head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.7 netbsd-11-0-RC3:1.1.1.7 netbsd-11-0-RC2:1.1.1.7 netbsd-11-0-RC1:1.1.1.7 perseant-exfatfs-base-20250801:1.1.1.7 netbsd-11:1.1.1.7.0.10 netbsd-11-base:1.1.1.7 netbsd-10-1-RELEASE:1.1.1.7 perseant-exfatfs-base-20240630:1.1.1.7 perseant-exfatfs:1.1.1.7.0.8 perseant-exfatfs-base:1.1.1.7 netbsd-8-3-RELEASE:1.1.1.4 netbsd-9-4-RELEASE:1.1.1.6 netbsd-10-0-RELEASE:1.1.1.7 netbsd-10-0-RC6:1.1.1.7 netbsd-10-0-RC5:1.1.1.7 netbsd-10-0-RC4:1.1.1.7 netbsd-10-0-RC3:1.1.1.7 netbsd-10-0-RC2:1.1.1.7 netbsd-10-0-RC1:1.1.1.7 netbsd-10:1.1.1.7.0.6 netbsd-10-base:1.1.1.7 netbsd-9-3-RELEASE:1.1.1.6 cjep_sun2x:1.1.1.7.0.4 cjep_sun2x-base:1.1.1.7 cjep_staticlib_x-base1:1.1.1.7 netbsd-9-2-RELEASE:1.1.1.6 cjep_staticlib_x:1.1.1.7.0.2 cjep_staticlib_x-base:1.1.1.7 netbsd-9-1-RELEASE:1.1.1.6 phil-wifi-20200421:1.1.1.7 phil-wifi-20200411:1.1.1.7 phil-wifi-20200406:1.1.1.7 netbsd-8-2-RELEASE:1.1.1.4 netbsd-9-0-RELEASE:1.1.1.6 netbsd-9-0-RC2:1.1.1.6 netbsd-9-0-RC1:1.1.1.6 netbsd-9:1.1.1.6.0.2 netbsd-9-base:1.1.1.6 phil-wifi-20190609:1.1.1.6 netbsd-8-1-RELEASE:1.1.1.4 netbsd-8-1-RC1:1.1.1.4 pgoyette-compat-merge-20190127:1.1.1.5.2.1 pgoyette-compat-20190127:1.1.1.6 pgoyette-compat-20190118:1.1.1.6 pgoyette-compat-1226:1.1.1.6 pgoyette-compat-1126:1.1.1.6 pgoyette-compat-1020:1.1.1.6 pgoyette-compat-0930:1.1.1.6 pgoyette-compat-0906:1.1.1.6 netbsd-7-2-RELEASE:1.1.1.1.2.1 pgoyette-compat-0728:1.1.1.6 clang-337282:1.1.1.6 netbsd-8-0-RELEASE:1.1.1.4 phil-wifi:1.1.1.5.0.4 phil-wifi-base:1.1.1.5 pgoyette-compat-0625:1.1.1.5 netbsd-8-0-RC2:1.1.1.4 pgoyette-compat-0521:1.1.1.5 pgoyette-compat-0502:1.1.1.5 pgoyette-compat-0422:1.1.1.5 netbsd-8-0-RC1:1.1.1.4 pgoyette-compat-0415:1.1.1.5 pgoyette-compat-0407:1.1.1.5 pgoyette-compat-0330:1.1.1.5 pgoyette-compat-0322:1.1.1.5 pgoyette-compat-0315:1.1.1.5 netbsd-7-1-2-RELEASE:1.1.1.1.2.1 pgoyette-compat:1.1.1.5.0.2 pgoyette-compat-base:1.1.1.5 netbsd-7-1-1-RELEASE:1.1.1.1.2.1 clang-319952:1.1.1.5 matt-nb8-mediatek:1.1.1.4.0.10 matt-nb8-mediatek-base:1.1.1.4 clang-309604:1.1.1.5 perseant-stdc-iso10646:1.1.1.4.0.8 perseant-stdc-iso10646-base:1.1.1.4 netbsd-8:1.1.1.4.0.6 netbsd-8-base:1.1.1.4 prg-localcount2-base3:1.1.1.4 prg-localcount2-base2:1.1.1.4 prg-localcount2-base1:1.1.1.4 prg-localcount2:1.1.1.4.0.4 prg-localcount2-base:1.1.1.4 pgoyette-localcount-20170426:1.1.1.4 bouyer-socketcan-base1:1.1.1.4 pgoyette-localcount-20170320:1.1.1.4 netbsd-7-1:1.1.1.1.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.1.2.1 netbsd-7-1-RC2:1.1.1.1.2.1 clang-294123:1.1.1.4 netbsd-7-nhusb-base-20170116:1.1.1.1.2.1 bouyer-socketcan:1.1.1.4.0.2 bouyer-socketcan-base:1.1.1.4 clang-291444:1.1.1.4 pgoyette-localcount-20170107:1.1.1.3 netbsd-7-1-RC1:1.1.1.1.2.1 pgoyette-localcount-20161104:1.1.1.3 netbsd-7-0-2-RELEASE:1.1.1.1.2.1 localcount-20160914:1.1.1.3 netbsd-7-nhusb:1.1.1.1.2.1.0.4 netbsd-7-nhusb-base:1.1.1.1.2.1 clang-280599:1.1.1.3 pgoyette-localcount-20160806:1.1.1.3 pgoyette-localcount-20160726:1.1.1.3 pgoyette-localcount:1.1.1.3.0.2 pgoyette-localcount-base:1.1.1.3 netbsd-7-0-1-RELEASE:1.1.1.1.2.1 clang-261930:1.1.1.3 netbsd-7-0:1.1.1.1.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.1.2.1 netbsd-7-0-RC3:1.1.1.1.2.1 netbsd-7-0-RC2:1.1.1.1.2.1 netbsd-7-0-RC1:1.1.1.1.2.1 clang-237755:1.1.1.2 clang-232565:1.1.1.2 clang-227398:1.1.1.2 tls-maxphys-base:1.1.1.1 tls-maxphys:1.1.1.1.0.4 netbsd-7:1.1.1.1.0.2 netbsd-7-base:1.1.1.1 clang-215315:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2014.08.10.17.08.36; author joerg; state Exp; branches 1.1.1.1; next ; commitid N85tXAN6Ex9VZPLx; 1.1.1.1 date 2014.08.10.17.08.36; author joerg; state Exp; branches 1.1.1.1.2.1 1.1.1.1.4.1; next 1.1.1.2; commitid N85tXAN6Ex9VZPLx; 1.1.1.2 date 2015.01.29.19.57.31; author joerg; state Exp; branches; next 1.1.1.3; commitid mlISSizlPKvepX7y; 1.1.1.3 date 2016.02.27.22.12.08; author joerg; state Exp; branches 1.1.1.3.2.1; next 1.1.1.4; commitid tIimz3oDlh1NpBWy; 1.1.1.4 date 2017.01.11.10.33.18; author joerg; state Exp; branches; next 1.1.1.5; commitid CNnUNfII1jgNmxBz; 1.1.1.5 date 2017.08.01.19.35.19; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid pMuDy65V0VicSx1A; 1.1.1.6 date 2018.07.17.18.31.01; author joerg; state Exp; branches; next 1.1.1.7; commitid wDzL46ALjrCZgwKA; 1.1.1.7 date 2019.11.13.22.19.21; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.1.2.1 date 2015.06.04.20.04.28; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.1.4.1 date 2014.08.10.17.08.36; author tls; state dead; branches; next 1.1.1.1.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.1.4.2 date 2014.08.19.23.47.27; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.3.2.1 date 2017.03.20.06.52.37; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.5.2.1 date 2018.07.28.04.33.18; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.5.4.1 date 2019.06.10.21.45.22; author christos; state Exp; branches; next 1.1.1.5.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.5.4.2 date 2020.04.13.07.46.32; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- CoverageMappingGen.cpp - Coverage mapping generation ---*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Instrumentation-based code coverage mapping generator // //===----------------------------------------------------------------------===// #include "CoverageMappingGen.h" #include "CodeGenFunction.h" #include "clang/AST/StmtVisitor.h" #include "clang/Lex/Lexer.h" #include "llvm/ProfileData/InstrProfReader.h" #include "llvm/ProfileData/CoverageMapping.h" #include "llvm/ProfileData/CoverageMappingWriter.h" #include "llvm/ProfileData/CoverageMappingReader.h" #include "llvm/Support/FileSystem.h" using namespace clang; using namespace CodeGen; using namespace llvm::coverage; void CoverageSourceInfo::SourceRangeSkipped(SourceRange Range) { SkippedRanges.push_back(Range); } namespace { /// \brief A region of source code that can be mapped to a counter. struct SourceMappingRegion { enum RegionFlags { /// \brief This region won't be emitted if it wasn't extended. /// This is useful so that we won't emit source ranges for single tokens /// that we don't really care that much about, like: /// the '(' token in #define MACRO ( IgnoreIfNotExtended = 0x0001, }; FileID File, MacroArgumentFile; Counter Count; /// \brief A statement that initiated the count of Zero. /// /// This initiator statement is useful to prevent merging of unreachable /// regions with different statements that caused the counter to become /// unreachable. const Stmt *UnreachableInitiator; /// \brief A statement that separates certain mapping regions into groups. /// /// The group statement is sometimes useful when we are emitting the source /// regions not in their correct lexical order, e.g. the regions for the /// incrementation expression in the 'for' construct. By marking the regions /// in the incrementation expression with the group statement, we avoid the /// merging of the regions from the incrementation expression and the loop's /// body. const Stmt *Group; /// \brief The region's starting location. SourceLocation LocStart; /// \brief The region's ending location. SourceLocation LocEnd, AlternativeLocEnd; unsigned Flags; CounterMappingRegion::RegionKind Kind; SourceMappingRegion(FileID File, FileID MacroArgumentFile, Counter Count, const Stmt *UnreachableInitiator, const Stmt *Group, SourceLocation LocStart, SourceLocation LocEnd, unsigned Flags = 0, CounterMappingRegion::RegionKind Kind = CounterMappingRegion::CodeRegion) : File(File), MacroArgumentFile(MacroArgumentFile), Count(Count), UnreachableInitiator(UnreachableInitiator), Group(Group), LocStart(LocStart), LocEnd(LocEnd), AlternativeLocEnd(LocStart), Flags(Flags), Kind(Kind) {} bool hasFlag(RegionFlags Flag) const { return (Flags & Flag) != 0; } void setFlag(RegionFlags Flag) { Flags |= Flag; } void clearFlag(RegionFlags Flag) { Flags &= ~Flag; } /// \brief Return true if two regions can be merged together. bool isMergeable(SourceMappingRegion &R) { return File == R.File && MacroArgumentFile == R.MacroArgumentFile && Count == R.Count && UnreachableInitiator == R.UnreachableInitiator && Group == R.Group && Kind == R.Kind; } /// \brief Merge two regions by extending the 'this' region to cover the /// given region. void mergeByExtendingTo(SourceMappingRegion &R) { LocEnd = R.LocEnd; AlternativeLocEnd = R.LocStart; if (hasFlag(IgnoreIfNotExtended)) clearFlag(IgnoreIfNotExtended); } }; /// \brief The state of the coverage mapping builder. struct SourceMappingState { Counter CurrentRegionCount; const Stmt *CurrentSourceGroup; const Stmt *CurrentUnreachableRegionInitiator; SourceMappingState(Counter CurrentRegionCount, const Stmt *CurrentSourceGroup, const Stmt *CurrentUnreachableRegionInitiator) : CurrentRegionCount(CurrentRegionCount), CurrentSourceGroup(CurrentSourceGroup), CurrentUnreachableRegionInitiator(CurrentUnreachableRegionInitiator) {} }; /// \brief Provides the common functionality for the different /// coverage mapping region builders. class CoverageMappingBuilder { public: CoverageMappingModuleGen &CVM; SourceManager &SM; const LangOptions &LangOpts; private: struct FileInfo { /// \brief The file id that will be used by the coverage mapping system. unsigned CovMappingFileID; const FileEntry *Entry; FileInfo(unsigned CovMappingFileID, const FileEntry *Entry) : CovMappingFileID(CovMappingFileID), Entry(Entry) {} }; /// \brief This mapping maps clang's FileIDs to file ids used /// by the coverage mapping system and clang's file entries. llvm::SmallDenseMap FileIDMapping; public: /// \brief The statement that corresponds to the current source group. const Stmt *CurrentSourceGroup; /// \brief The statement the initiated the current unreachable region. const Stmt *CurrentUnreachableRegionInitiator; /// \brief The coverage mapping regions for this function llvm::SmallVector MappingRegions; /// \brief The source mapping regions for this function. llvm::SmallVector SourceRegions; CoverageMappingBuilder(CoverageMappingModuleGen &CVM, SourceManager &SM, const LangOptions &LangOpts) : CVM(CVM), SM(SM), LangOpts(LangOpts), CurrentSourceGroup(nullptr), CurrentUnreachableRegionInitiator(nullptr) {} /// \brief Return the precise end location for the given token. SourceLocation getPreciseTokenLocEnd(SourceLocation Loc) { return Lexer::getLocForEndOfToken(SM.getSpellingLoc(Loc), 0, SM, LangOpts); } /// \brief Create the mapping that maps from the function's file ids to /// the indices for the translation unit's filenames. void createFileIDMapping(SmallVectorImpl &Mapping) { Mapping.resize(FileIDMapping.size(), 0); for (const auto &I : FileIDMapping) Mapping[I.second.CovMappingFileID] = CVM.getFileID(I.second.Entry); } /// \brief Get the coverage mapping file id that corresponds to the given /// clang file id. If such file id doesn't exist, it gets added to the /// mapping that maps from clang's file ids to coverage mapping file ids. /// Return true if there was an error getting the coverage mapping file id. /// An example of an when this function fails is when the region tries /// to get a coverage file id for a location in a built-in macro. bool getCoverageFileID(SourceLocation LocStart, FileID File, FileID SpellingFile, unsigned &Result) { auto Mapping = FileIDMapping.find(File); if (Mapping != FileIDMapping.end()) { Result = Mapping->second.CovMappingFileID; return false; } auto Entry = SM.getFileEntryForID(SpellingFile); if (!Entry) return true; Result = FileIDMapping.size(); FileIDMapping.insert(std::make_pair(File, FileInfo(Result, Entry))); createFileExpansionRegion(LocStart, File); return false; } /// \brief Get the coverage mapping file id that corresponds to the given /// clang file id. /// Return true if there was an error getting the coverage mapping file id. bool getExistingCoverageFileID(FileID File, unsigned &Result) { // Make sure that the file is valid. if (File.isInvalid()) return true; auto Mapping = FileIDMapping.find(File); if (Mapping != FileIDMapping.end()) { Result = Mapping->second.CovMappingFileID; return false; } return true; } /// \brief Return true if the given clang's file id has a corresponding /// coverage file id. bool hasExistingCoverageFileID(FileID File) const { return FileIDMapping.count(File); } /// \brief Gather all the regions that were skipped by the preprocessor /// using the constructs like #if. void gatherSkippedRegions() { /// An array of the minimum lineStarts and the maximum lineEnds /// for mapping regions from the appropriate source files. llvm::SmallVector, 8> FileLineRanges; FileLineRanges.resize( FileIDMapping.size(), std::make_pair(std::numeric_limits::max(), 0)); for (const auto &R : MappingRegions) { FileLineRanges[R.FileID].first = std::min(FileLineRanges[R.FileID].first, R.LineStart); FileLineRanges[R.FileID].second = std::max(FileLineRanges[R.FileID].second, R.LineEnd); } auto SkippedRanges = CVM.getSourceInfo().getSkippedRanges(); for (const auto &I : SkippedRanges) { auto LocStart = I.getBegin(); auto LocEnd = I.getEnd(); auto FileStart = SM.getFileID(LocStart); if (!hasExistingCoverageFileID(FileStart)) continue; auto ActualFileStart = SM.getDecomposedSpellingLoc(LocStart).first; if (ActualFileStart != SM.getDecomposedSpellingLoc(LocEnd).first) // Ignore regions that span across multiple files. continue; unsigned CovFileID; if (getCoverageFileID(LocStart, FileStart, ActualFileStart, CovFileID)) continue; unsigned LineStart = SM.getSpellingLineNumber(LocStart); unsigned ColumnStart = SM.getSpellingColumnNumber(LocStart); unsigned LineEnd = SM.getSpellingLineNumber(LocEnd); unsigned ColumnEnd = SM.getSpellingColumnNumber(LocEnd); CounterMappingRegion Region(Counter(), CovFileID, LineStart, ColumnStart, LineEnd, ColumnEnd, false, CounterMappingRegion::SkippedRegion); // Make sure that we only collect the regions that are inside // the souce code of this function. if (Region.LineStart >= FileLineRanges[CovFileID].first && Region.LineEnd <= FileLineRanges[CovFileID].second) MappingRegions.push_back(Region); } } /// \brief Create a mapping region that correponds to an expansion of /// a macro or an embedded include. void createFileExpansionRegion(SourceLocation Loc, FileID ExpandedFile) { SourceLocation LocStart; if (Loc.isMacroID()) LocStart = SM.getImmediateExpansionRange(Loc).first; else { LocStart = SM.getIncludeLoc(ExpandedFile); if (LocStart.isInvalid()) return; // This file has no expansion region. } auto File = SM.getFileID(LocStart); auto SpellingFile = SM.getDecomposedSpellingLoc(LocStart).first; unsigned CovFileID, ExpandedFileID; if (getExistingCoverageFileID(ExpandedFile, ExpandedFileID)) return; if (getCoverageFileID(LocStart, File, SpellingFile, CovFileID)) return; unsigned LineStart = SM.getSpellingLineNumber(LocStart); unsigned ColumnStart = SM.getSpellingColumnNumber(LocStart); unsigned LineEnd = LineStart; // Compute the end column manually as Lexer::getLocForEndOfToken doesn't // give the correct result in all cases. unsigned ColumnEnd = ColumnStart + Lexer::MeasureTokenLength(SM.getSpellingLoc(LocStart), SM, LangOpts); MappingRegions.push_back(CounterMappingRegion( Counter(), CovFileID, LineStart, ColumnStart, LineEnd, ColumnEnd, false, CounterMappingRegion::ExpansionRegion)); MappingRegions.back().ExpandedFileID = ExpandedFileID; } /// \brief Enter a source region group that is identified by the given /// statement. /// It's not possible to enter a group when there is already /// another group present. void beginSourceRegionGroup(const Stmt *Group) { assert(!CurrentSourceGroup); CurrentSourceGroup = Group; } /// \brief Exit the current source region group. void endSourceRegionGroup() { CurrentSourceGroup = nullptr; } /// \brief Brings a region that has the same counter and file to the back /// of the source regions array. void bringSimilarRegionBack(Counter Count, FileID File, FileID MacroArgumentFile, const Stmt *UnreachableInitiator, const Stmt *SourceGroup) { for (size_t I = SourceRegions.size(); I != 0;) { --I; if (SourceRegions[I].Count == Count && SourceRegions[I].File == File && SourceRegions[I].MacroArgumentFile == MacroArgumentFile && SourceRegions[I].UnreachableInitiator == UnreachableInitiator && SourceRegions[I].Group == SourceGroup) { if (I != SourceRegions.size() - 1) std::swap(SourceRegions[I], SourceRegions.back()); return; } } } /// \brief Associate a counter with a given source code range. void mapSourceCodeRange(SourceLocation LocStart, SourceLocation LocEnd, Counter Count, const Stmt *UnreachableInitiator, const Stmt *SourceGroup, unsigned Flags = 0, FileID MacroArgumentFile = FileID()) { if (SM.isMacroArgExpansion(LocStart)) { // Map the code range with the macro argument's value. mapSourceCodeRange(SM.getImmediateSpellingLoc(LocStart), SM.getImmediateSpellingLoc(LocEnd), Count, UnreachableInitiator, SourceGroup, Flags, SM.getFileID(LocStart)); // Map the code range where the macro argument is referenced. SourceLocation RefLocStart(SM.getImmediateExpansionRange(LocStart).first); SourceLocation RefLocEnd(RefLocStart); if (SM.isMacroArgExpansion(RefLocStart)) mapSourceCodeRange(RefLocStart, RefLocEnd, Count, UnreachableInitiator, SourceGroup, 0, SM.getFileID(RefLocStart)); else mapSourceCodeRange(RefLocStart, RefLocEnd, Count, UnreachableInitiator, SourceGroup); return; } auto File = SM.getFileID(LocStart); // Make sure that the file id is valid. if (File.isInvalid()) return; bringSimilarRegionBack(Count, File, MacroArgumentFile, UnreachableInitiator, SourceGroup); SourceMappingRegion R(File, MacroArgumentFile, Count, UnreachableInitiator, SourceGroup, LocStart, LocEnd, Flags); if (SourceRegions.empty() || !SourceRegions.back().isMergeable(R)) { SourceRegions.push_back(R); return; } SourceRegions.back().mergeByExtendingTo(R); } void mapSourceCodeRange(SourceLocation LocStart, SourceLocation LocEnd, Counter Count, unsigned Flags = 0) { mapSourceCodeRange(LocStart, LocEnd, Count, CurrentUnreachableRegionInitiator, CurrentSourceGroup, Flags); } void mapSourceCodeRange(const SourceMappingState &State, SourceLocation LocStart, SourceLocation LocEnd, unsigned Flags = 0) { mapSourceCodeRange(LocStart, LocEnd, State.CurrentRegionCount, State.CurrentUnreachableRegionInitiator, State.CurrentSourceGroup, Flags); } /// \brief Generate the coverage counter mapping regions from collected /// source regions. void emitSourceRegions() { for (const auto &R : SourceRegions) { SourceLocation LocStart = R.LocStart; SourceLocation LocEnd = R.LocEnd; if (SM.getFileID(LocEnd) != R.File) LocEnd = R.AlternativeLocEnd; if (R.hasFlag(SourceMappingRegion::IgnoreIfNotExtended) && LocStart == LocEnd) continue; LocEnd = getPreciseTokenLocEnd(LocEnd); unsigned LineStart = SM.getSpellingLineNumber(LocStart); unsigned ColumnStart = SM.getSpellingColumnNumber(LocStart); unsigned LineEnd = SM.getSpellingLineNumber(LocEnd); unsigned ColumnEnd = SM.getSpellingColumnNumber(LocEnd); auto SpellingFile = SM.getDecomposedSpellingLoc(R.LocStart).first; unsigned CovFileID; if (getCoverageFileID(R.LocStart, R.File, SpellingFile, CovFileID)) continue; assert(LineStart <= LineEnd); MappingRegions.push_back(CounterMappingRegion( R.Count, CovFileID, LineStart, ColumnStart, LineEnd, ColumnEnd, false, CounterMappingRegion::CodeRegion)); } } }; /// \brief Creates unreachable coverage regions for the functions that /// are not emitted. struct EmptyCoverageMappingBuilder : public CoverageMappingBuilder { EmptyCoverageMappingBuilder(CoverageMappingModuleGen &CVM, SourceManager &SM, const LangOptions &LangOpts) : CoverageMappingBuilder(CVM, SM, LangOpts) {} void VisitDecl(const Decl *D) { if (!D->hasBody()) return; auto Body = D->getBody(); mapSourceCodeRange(Body->getLocStart(), Body->getLocEnd(), Counter()); } /// \brief Write the mapping data to the output stream void write(llvm::raw_ostream &OS) { emitSourceRegions(); SmallVector FileIDMapping; createFileIDMapping(FileIDMapping); CoverageMappingWriter Writer( FileIDMapping, ArrayRef(), MappingRegions); Writer.write(OS); } }; /// \brief A StmtVisitor that creates coverage mapping regions which map /// from the source code locations to the PGO counters. struct CounterCoverageMappingBuilder : public CoverageMappingBuilder, public ConstStmtVisitor { /// \brief The map of statements to count values. llvm::DenseMap &CounterMap; Counter CurrentRegionCount; CounterExpressionBuilder Builder; /// \brief Return a counter that represents the /// expression that subracts rhs from lhs. Counter subtractCounters(Counter LHS, Counter RHS) { return Builder.subtract(LHS, RHS); } /// \brief Return a counter that represents the /// the exression that adds lhs and rhs. Counter addCounters(Counter LHS, Counter RHS) { return Builder.add(LHS, RHS); } /// \brief Return the region counter for the given statement. /// This should only be called on statements that have a dedicated counter. unsigned getRegionCounter(const Stmt *S) { return CounterMap[S]; } /// \brief Return the region count for the counter at the given index. Counter getRegionCount(unsigned CounterId) { return Counter::getCounter(CounterId); } /// \brief Return the counter value of the current region. Counter getCurrentRegionCount() { return CurrentRegionCount; } /// \brief Set the counter value for the current region. /// This is used to keep track of changes to the most recent counter /// from control flow and non-local exits. void setCurrentRegionCount(Counter Count) { CurrentRegionCount = Count; CurrentUnreachableRegionInitiator = nullptr; } /// \brief Indicate that the current region is never reached, /// and thus should have a counter value of zero. /// This is important so that subsequent regions can correctly track /// their parent counts. void setCurrentRegionUnreachable(const Stmt *Initiator) { CurrentRegionCount = Counter::getZero(); CurrentUnreachableRegionInitiator = Initiator; } /// \brief A counter for a particular region. /// This is the primary interface through /// which the coverage mapping builder manages counters and their values. class RegionMapper { CounterCoverageMappingBuilder &Mapping; Counter Count; Counter ParentCount; Counter RegionCount; Counter Adjust; public: RegionMapper(CounterCoverageMappingBuilder *Mapper, const Stmt *S) : Mapping(*Mapper), Count(Mapper->getRegionCount(Mapper->getRegionCounter(S))), ParentCount(Mapper->getCurrentRegionCount()) {} /// Get the value of the counter. In most cases this is the number of times /// the region of the counter was entered, but for switch labels it's the /// number of direct jumps to that label. Counter getCount() const { return Count; } /// Get the value of the counter with adjustments applied. Adjustments occur /// when control enters or leaves the region abnormally; i.e., if there is a /// jump to a label within the region, or if the function can return from /// within the region. The adjusted count, then, is the value of the counter /// at the end of the region. Counter getAdjustedCount() const { return Mapping.addCounters(Count, Adjust); } /// Get the value of the counter in this region's parent, i.e., the region /// that was active when this region began. This is useful for deriving /// counts in implicitly counted regions, like the false case of a condition /// or the normal exits of a loop. Counter getParentCount() const { return ParentCount; } /// Activate the counter by emitting an increment and starting to track /// adjustments. If AddIncomingFallThrough is true, the current region count /// will be added to the counter for the purposes of tracking the region. void beginRegion(bool AddIncomingFallThrough = false) { RegionCount = Count; if (AddIncomingFallThrough) RegionCount = Mapping.addCounters(RegionCount, Mapping.getCurrentRegionCount()); Mapping.setCurrentRegionCount(RegionCount); } /// For counters on boolean branches, begins tracking adjustments for the /// uncounted path. void beginElseRegion() { RegionCount = Mapping.subtractCounters(ParentCount, Count); Mapping.setCurrentRegionCount(RegionCount); } /// Reset the current region count. void setCurrentRegionCount(Counter CurrentCount) { RegionCount = CurrentCount; Mapping.setCurrentRegionCount(RegionCount); } /// Adjust for non-local control flow after emitting a subexpression or /// substatement. This must be called to account for constructs such as /// gotos, /// labels, and returns, so that we can ensure that our region's count is /// correct in the code that follows. void adjustForControlFlow() { Adjust = Mapping.addCounters( Adjust, Mapping.subtractCounters(Mapping.getCurrentRegionCount(), RegionCount)); // Reset the region count in case this is called again later. RegionCount = Mapping.getCurrentRegionCount(); } /// Commit all adjustments to the current region. If the region is a loop, /// the LoopAdjust value should be the count of all the breaks and continues /// from the loop, to compensate for those counts being deducted from the /// adjustments for the body of the loop. void applyAdjustmentsToRegion() { Mapping.setCurrentRegionCount(Mapping.addCounters(ParentCount, Adjust)); } void applyAdjustmentsToRegion(Counter LoopAdjust) { Mapping.setCurrentRegionCount(Mapping.addCounters( Mapping.addCounters(ParentCount, Adjust), LoopAdjust)); } }; /// \brief Keep counts of breaks and continues inside loops. struct BreakContinue { Counter BreakCount; Counter ContinueCount; }; SmallVector BreakContinueStack; CounterCoverageMappingBuilder( CoverageMappingModuleGen &CVM, llvm::DenseMap &CounterMap, unsigned NumRegionCounters, SourceManager &SM, const LangOptions &LangOpts) : CoverageMappingBuilder(CVM, SM, LangOpts), CounterMap(CounterMap), Builder(NumRegionCounters) {} /// \brief Write the mapping data to the output stream void write(llvm::raw_ostream &OS) { emitSourceRegions(); llvm::SmallVector VirtualFileMapping; createFileIDMapping(VirtualFileMapping); gatherSkippedRegions(); CoverageMappingWriter Writer( VirtualFileMapping, Builder.getExpressions(), MappingRegions); Writer.write(OS); } /// \brief Return the current source mapping state. SourceMappingState getCurrentState() const { return SourceMappingState(CurrentRegionCount, CurrentSourceGroup, CurrentUnreachableRegionInitiator); } /// \brief Associate the source code range with the current region count. void mapSourceCodeRange(SourceLocation LocStart, SourceLocation LocEnd, unsigned Flags = 0) { CoverageMappingBuilder::mapSourceCodeRange(LocStart, LocEnd, CurrentRegionCount, Flags); } void mapSourceCodeRange(SourceLocation LocStart) { CoverageMappingBuilder::mapSourceCodeRange(LocStart, LocStart, CurrentRegionCount); } /// \brief Associate the source range of a token with the current region /// count. /// Ignore the source range for this token if it produces a distinct /// mapping region with no other source ranges. void mapToken(SourceLocation LocStart) { CoverageMappingBuilder::mapSourceCodeRange( LocStart, LocStart, CurrentRegionCount, SourceMappingRegion::IgnoreIfNotExtended); } void mapToken(const SourceMappingState &State, SourceLocation LocStart) { CoverageMappingBuilder::mapSourceCodeRange( State, LocStart, LocStart, SourceMappingRegion::IgnoreIfNotExtended); } void VisitStmt(const Stmt *S) { mapSourceCodeRange(S->getLocStart()); for (Stmt::const_child_range I = S->children(); I; ++I) { if (*I) this->Visit(*I); } } /// \brief If the given statement is a compound statement, /// map '}' with the same count as '{'. void VisitSubStmtRBraceState(const Stmt *S) { if (!isa(S)) return Visit(S); const auto *CS = cast(S); auto State = getCurrentState(); mapSourceCodeRange(CS->getLBracLoc()); for (Stmt::const_child_range I = S->children(); I; ++I) { if (*I) this->Visit(*I); } CoverageMappingBuilder::mapSourceCodeRange(State, CS->getRBracLoc(), CS->getRBracLoc()); } void VisitDecl(const Decl *D) { if (!D->hasBody()) return; // Counter tracks entry to the function body. auto Body = D->getBody(); RegionMapper Cnt(this, Body); Cnt.beginRegion(); VisitSubStmtRBraceState(Body); } void VisitDeclStmt(const DeclStmt *S) { mapSourceCodeRange(S->getLocStart()); for (Stmt::const_child_range I = static_cast(S)->children(); I; ++I) { if (*I) this->Visit(*I); } } void VisitCompoundStmt(const CompoundStmt *S) { mapSourceCodeRange(S->getLBracLoc()); for (Stmt::const_child_range I = S->children(); I; ++I) { if (*I) this->Visit(*I); } mapSourceCodeRange(S->getRBracLoc(), S->getRBracLoc()); } void VisitReturnStmt(const ReturnStmt *S) { mapSourceCodeRange(S->getLocStart()); if (S->getRetValue()) Visit(S->getRetValue()); setCurrentRegionUnreachable(S); } void VisitGotoStmt(const GotoStmt *S) { mapSourceCodeRange(S->getLocStart()); mapToken(S->getLabelLoc()); setCurrentRegionUnreachable(S); } void VisitLabelStmt(const LabelStmt *S) { // Counter tracks the block following the label. RegionMapper Cnt(this, S); Cnt.beginRegion(); mapSourceCodeRange(S->getLocStart()); // Can't map the ':' token as its location isn't known. Visit(S->getSubStmt()); } void VisitBreakStmt(const BreakStmt *S) { mapSourceCodeRange(S->getLocStart()); assert(!BreakContinueStack.empty() && "break not in a loop or switch!"); BreakContinueStack.back().BreakCount = addCounters( BreakContinueStack.back().BreakCount, getCurrentRegionCount()); setCurrentRegionUnreachable(S); } void VisitContinueStmt(const ContinueStmt *S) { mapSourceCodeRange(S->getLocStart()); assert(!BreakContinueStack.empty() && "continue stmt not in a loop!"); BreakContinueStack.back().ContinueCount = addCounters( BreakContinueStack.back().ContinueCount, getCurrentRegionCount()); setCurrentRegionUnreachable(S); } void VisitWhileStmt(const WhileStmt *S) { mapSourceCodeRange(S->getLocStart()); // Counter tracks the body of the loop. RegionMapper Cnt(this, S); BreakContinueStack.push_back(BreakContinue()); // Visit the body region first so the break/continue adjustments can be // included when visiting the condition. Cnt.beginRegion(); VisitSubStmtRBraceState(S->getBody()); Cnt.adjustForControlFlow(); // ...then go back and propagate counts through the condition. The count // at the start of the condition is the sum of the incoming edges, // the backedge from the end of the loop body, and the edges from // continue statements. BreakContinue BC = BreakContinueStack.pop_back_val(); Cnt.setCurrentRegionCount( addCounters(Cnt.getParentCount(), addCounters(Cnt.getAdjustedCount(), BC.ContinueCount))); beginSourceRegionGroup(S->getCond()); Visit(S->getCond()); endSourceRegionGroup(); Cnt.adjustForControlFlow(); Cnt.applyAdjustmentsToRegion(addCounters(BC.BreakCount, BC.ContinueCount)); } void VisitDoStmt(const DoStmt *S) { mapSourceCodeRange(S->getLocStart()); // Counter tracks the body of the loop. RegionMapper Cnt(this, S); BreakContinueStack.push_back(BreakContinue()); Cnt.beginRegion(/*AddIncomingFallThrough=*/true); VisitSubStmtRBraceState(S->getBody()); Cnt.adjustForControlFlow(); BreakContinue BC = BreakContinueStack.pop_back_val(); // The count at the start of the condition is equal to the count at the // end of the body. The adjusted count does not include either the // fall-through count coming into the loop or the continue count, so add // both of those separately. This is coincidentally the same equation as // with while loops but for different reasons. Cnt.setCurrentRegionCount( addCounters(Cnt.getParentCount(), addCounters(Cnt.getAdjustedCount(), BC.ContinueCount))); Visit(S->getCond()); Cnt.adjustForControlFlow(); Cnt.applyAdjustmentsToRegion(addCounters(BC.BreakCount, BC.ContinueCount)); } void VisitForStmt(const ForStmt *S) { mapSourceCodeRange(S->getLocStart()); if (S->getInit()) Visit(S->getInit()); // Counter tracks the body of the loop. RegionMapper Cnt(this, S); BreakContinueStack.push_back(BreakContinue()); // Visit the body region first. (This is basically the same as a while // loop; see further comments in VisitWhileStmt.) Cnt.beginRegion(); VisitSubStmtRBraceState(S->getBody()); Cnt.adjustForControlFlow(); // The increment is essentially part of the body but it needs to include // the count for all the continue statements. if (S->getInc()) { Cnt.setCurrentRegionCount(addCounters( getCurrentRegionCount(), BreakContinueStack.back().ContinueCount)); beginSourceRegionGroup(S->getInc()); Visit(S->getInc()); endSourceRegionGroup(); Cnt.adjustForControlFlow(); } BreakContinue BC = BreakContinueStack.pop_back_val(); // ...then go back and propagate counts through the condition. if (S->getCond()) { Cnt.setCurrentRegionCount( addCounters(addCounters(Cnt.getParentCount(), Cnt.getAdjustedCount()), BC.ContinueCount)); beginSourceRegionGroup(S->getCond()); Visit(S->getCond()); endSourceRegionGroup(); Cnt.adjustForControlFlow(); } Cnt.applyAdjustmentsToRegion(addCounters(BC.BreakCount, BC.ContinueCount)); } void VisitCXXForRangeStmt(const CXXForRangeStmt *S) { mapSourceCodeRange(S->getLocStart()); Visit(S->getRangeStmt()); Visit(S->getBeginEndStmt()); // Counter tracks the body of the loop. RegionMapper Cnt(this, S); BreakContinueStack.push_back(BreakContinue()); // Visit the body region first. (This is basically the same as a while // loop; see further comments in VisitWhileStmt.) Cnt.beginRegion(); VisitSubStmtRBraceState(S->getBody()); Cnt.adjustForControlFlow(); BreakContinue BC = BreakContinueStack.pop_back_val(); Cnt.applyAdjustmentsToRegion(addCounters(BC.BreakCount, BC.ContinueCount)); } void VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) { mapSourceCodeRange(S->getLocStart()); Visit(S->getElement()); // Counter tracks the body of the loop. RegionMapper Cnt(this, S); BreakContinueStack.push_back(BreakContinue()); VisitSubStmtRBraceState(S->getBody()); BreakContinue BC = BreakContinueStack.pop_back_val(); Cnt.adjustForControlFlow(); Cnt.applyAdjustmentsToRegion(addCounters(BC.BreakCount, BC.ContinueCount)); } void VisitSwitchStmt(const SwitchStmt *S) { mapSourceCodeRange(S->getLocStart()); Visit(S->getCond()); BreakContinueStack.push_back(BreakContinue()); // Map the '}' for the body to have the same count as the regions after // the switch. SourceLocation RBracLoc; if (const auto *CS = dyn_cast(S->getBody())) { mapSourceCodeRange(CS->getLBracLoc()); setCurrentRegionUnreachable(S); for (Stmt::const_child_range I = CS->children(); I; ++I) { if (*I) this->Visit(*I); } RBracLoc = CS->getRBracLoc(); } else { setCurrentRegionUnreachable(S); Visit(S->getBody()); } // If the switch is inside a loop, add the continue counts. BreakContinue BC = BreakContinueStack.pop_back_val(); if (!BreakContinueStack.empty()) BreakContinueStack.back().ContinueCount = addCounters( BreakContinueStack.back().ContinueCount, BC.ContinueCount); // Counter tracks the exit block of the switch. RegionMapper ExitCnt(this, S); ExitCnt.beginRegion(); if (RBracLoc.isValid()) mapSourceCodeRange(RBracLoc); } void VisitCaseStmt(const CaseStmt *S) { // Counter for this particular case. This counts only jumps from the // switch header and does not include fallthrough from the case before // this one. RegionMapper Cnt(this, S); Cnt.beginRegion(/*AddIncomingFallThrough=*/true); mapSourceCodeRange(S->getLocStart()); mapToken(S->getColonLoc()); Visit(S->getSubStmt()); } void VisitDefaultStmt(const DefaultStmt *S) { // Counter for this default case. This does not include fallthrough from // the previous case. RegionMapper Cnt(this, S); Cnt.beginRegion(/*AddIncomingFallThrough=*/true); mapSourceCodeRange(S->getLocStart()); mapToken(S->getColonLoc()); Visit(S->getSubStmt()); } void VisitIfStmt(const IfStmt *S) { mapSourceCodeRange(S->getLocStart()); Visit(S->getCond()); mapToken(S->getElseLoc()); // Counter tracks the "then" part of an if statement. The count for // the "else" part, if it exists, will be calculated from this counter. RegionMapper Cnt(this, S); Cnt.beginRegion(); VisitSubStmtRBraceState(S->getThen()); Cnt.adjustForControlFlow(); if (S->getElse()) { Cnt.beginElseRegion(); VisitSubStmtRBraceState(S->getElse()); Cnt.adjustForControlFlow(); } Cnt.applyAdjustmentsToRegion(); } void VisitCXXTryStmt(const CXXTryStmt *S) { mapSourceCodeRange(S->getLocStart()); Visit(S->getTryBlock()); for (unsigned I = 0, E = S->getNumHandlers(); I < E; ++I) Visit(S->getHandler(I)); // Counter tracks the continuation block of the try statement. RegionMapper Cnt(this, S); Cnt.beginRegion(); } void VisitCXXCatchStmt(const CXXCatchStmt *S) { mapSourceCodeRange(S->getLocStart()); // Counter tracks the catch statement's handler block. RegionMapper Cnt(this, S); Cnt.beginRegion(); VisitSubStmtRBraceState(S->getHandlerBlock()); } void VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { Visit(E->getCond()); mapToken(E->getQuestionLoc()); auto State = getCurrentState(); // Counter tracks the "true" part of a conditional operator. The // count in the "false" part will be calculated from this counter. RegionMapper Cnt(this, E); Cnt.beginRegion(); Visit(E->getTrueExpr()); Cnt.adjustForControlFlow(); mapToken(State, E->getColonLoc()); Cnt.beginElseRegion(); Visit(E->getFalseExpr()); Cnt.adjustForControlFlow(); Cnt.applyAdjustmentsToRegion(); } void VisitBinLAnd(const BinaryOperator *E) { Visit(E->getLHS()); mapToken(E->getOperatorLoc()); // Counter tracks the right hand side of a logical and operator. RegionMapper Cnt(this, E); Cnt.beginRegion(); Visit(E->getRHS()); Cnt.adjustForControlFlow(); Cnt.applyAdjustmentsToRegion(); } void VisitBinLOr(const BinaryOperator *E) { Visit(E->getLHS()); mapToken(E->getOperatorLoc()); // Counter tracks the right hand side of a logical or operator. RegionMapper Cnt(this, E); Cnt.beginRegion(); Visit(E->getRHS()); Cnt.adjustForControlFlow(); Cnt.applyAdjustmentsToRegion(); } void VisitParenExpr(const ParenExpr *E) { mapToken(E->getLParen()); Visit(E->getSubExpr()); mapToken(E->getRParen()); } void VisitBinaryOperator(const BinaryOperator *E) { Visit(E->getLHS()); mapToken(E->getOperatorLoc()); Visit(E->getRHS()); } void VisitUnaryOperator(const UnaryOperator *E) { bool Postfix = E->isPostfix(); if (!Postfix) mapToken(E->getOperatorLoc()); Visit(E->getSubExpr()); if (Postfix) mapToken(E->getOperatorLoc()); } void VisitMemberExpr(const MemberExpr *E) { Visit(E->getBase()); mapToken(E->getMemberLoc()); } void VisitCallExpr(const CallExpr *E) { Visit(E->getCallee()); for (const auto &Arg : E->arguments()) Visit(Arg); mapToken(E->getRParenLoc()); } void VisitArraySubscriptExpr(const ArraySubscriptExpr *E) { Visit(E->getLHS()); Visit(E->getRHS()); mapToken(E->getRBracketLoc()); } void VisitCStyleCastExpr(const CStyleCastExpr *E) { mapToken(E->getLParenLoc()); mapToken(E->getRParenLoc()); Visit(E->getSubExpr()); } // Map literals as tokens so that the macros like #define PI 3.14 // won't generate coverage mapping regions. void VisitIntegerLiteral(const IntegerLiteral *E) { mapToken(E->getLocStart()); } void VisitFloatingLiteral(const FloatingLiteral *E) { mapToken(E->getLocStart()); } void VisitCharacterLiteral(const CharacterLiteral *E) { mapToken(E->getLocStart()); } void VisitStringLiteral(const StringLiteral *E) { mapToken(E->getLocStart()); } void VisitImaginaryLiteral(const ImaginaryLiteral *E) { mapToken(E->getLocStart()); } }; } static bool isMachO(const CodeGenModule &CGM) { return CGM.getTarget().getTriple().isOSBinFormatMachO(); } static StringRef getCoverageSection(const CodeGenModule &CGM) { return isMachO(CGM) ? "__DATA,__llvm_covmap" : "__llvm_covmap"; } static void dump(llvm::raw_ostream &OS, const CoverageMappingRecord &Function) { OS << Function.FunctionName << ":\n"; CounterMappingContext Ctx(Function.Expressions); for (const auto &R : Function.MappingRegions) { OS.indent(2); switch (R.Kind) { case CounterMappingRegion::CodeRegion: break; case CounterMappingRegion::ExpansionRegion: OS << "Expansion,"; break; case CounterMappingRegion::SkippedRegion: OS << "Skipped,"; break; } OS << "File " << R.FileID << ", " << R.LineStart << ":" << R.ColumnStart << " -> " << R.LineEnd << ":" << R.ColumnEnd << " = "; Ctx.dump(R.Count); OS << " (HasCodeBefore = " << R.HasCodeBefore; if (R.Kind == CounterMappingRegion::ExpansionRegion) OS << ", Expanded file = " << R.ExpandedFileID; OS << ")\n"; } } void CoverageMappingModuleGen::addFunctionMappingRecord( llvm::GlobalVariable *FunctionName, StringRef FunctionNameValue, const std::string &CoverageMapping) { llvm::LLVMContext &Ctx = CGM.getLLVMContext(); auto *Int32Ty = llvm::Type::getInt32Ty(Ctx); auto *Int8PtrTy = llvm::Type::getInt8PtrTy(Ctx); if (!FunctionRecordTy) { llvm::Type *FunctionRecordTypes[] = {Int8PtrTy, Int32Ty, Int32Ty}; FunctionRecordTy = llvm::StructType::get(Ctx, makeArrayRef(FunctionRecordTypes)); } llvm::Constant *FunctionRecordVals[] = { llvm::ConstantExpr::getBitCast(FunctionName, Int8PtrTy), llvm::ConstantInt::get(Int32Ty, FunctionNameValue.size()), llvm::ConstantInt::get(Int32Ty, CoverageMapping.size())}; FunctionRecords.push_back(llvm::ConstantStruct::get( FunctionRecordTy, makeArrayRef(FunctionRecordVals))); CoverageMappings += CoverageMapping; if (CGM.getCodeGenOpts().DumpCoverageMapping) { // Dump the coverage mapping data for this function by decoding the // encoded data. This allows us to dump the mapping regions which were // also processed by the CoverageMappingWriter which performs // additional minimization operations such as reducing the number of // expressions. std::vector Filenames; std::vector Expressions; std::vector Regions; llvm::SmallVector FilenameRefs; FilenameRefs.resize(FileEntries.size()); for (const auto &Entry : FileEntries) FilenameRefs[Entry.second] = Entry.first->getName(); RawCoverageMappingReader Reader(FunctionNameValue, CoverageMapping, FilenameRefs, Filenames, Expressions, Regions); CoverageMappingRecord FunctionRecord; if (Reader.read(FunctionRecord)) return; dump(llvm::outs(), FunctionRecord); } } void CoverageMappingModuleGen::emit() { if (FunctionRecords.empty()) return; llvm::LLVMContext &Ctx = CGM.getLLVMContext(); auto *Int32Ty = llvm::Type::getInt32Ty(Ctx); // Create the filenames and merge them with coverage mappings llvm::SmallVector FilenameStrs; llvm::SmallVector FilenameRefs; FilenameStrs.resize(FileEntries.size()); FilenameRefs.resize(FileEntries.size()); for (const auto &Entry : FileEntries) { llvm::SmallString<256> Path(Entry.first->getName()); llvm::sys::fs::make_absolute(Path); auto I = Entry.second; FilenameStrs[I] = std::move(std::string(Path.begin(), Path.end())); FilenameRefs[I] = FilenameStrs[I]; } std::string FilenamesAndCoverageMappings; llvm::raw_string_ostream OS(FilenamesAndCoverageMappings); CoverageFilenamesSectionWriter(FilenameRefs).write(OS); OS << CoverageMappings; size_t CoverageMappingSize = CoverageMappings.size(); size_t FilenamesSize = OS.str().size() - CoverageMappingSize; // Append extra zeroes if necessary to ensure that the size of the filenames // and coverage mappings is a multiple of 8. if (size_t Rem = OS.str().size() % 8) { CoverageMappingSize += 8 - Rem; for (size_t I = 0, S = 8 - Rem; I < S; ++I) OS << '\0'; } auto *FilenamesAndMappingsVal = llvm::ConstantDataArray::getString(Ctx, OS.str(), false); // Create the deferred function records array auto RecordsTy = llvm::ArrayType::get(FunctionRecordTy, FunctionRecords.size()); auto RecordsVal = llvm::ConstantArray::get(RecordsTy, FunctionRecords); // Create the coverage data record llvm::Type *CovDataTypes[] = {Int32Ty, Int32Ty, Int32Ty, Int32Ty, RecordsTy, FilenamesAndMappingsVal->getType()}; auto CovDataTy = llvm::StructType::get(Ctx, makeArrayRef(CovDataTypes)); llvm::Constant *TUDataVals[] = { llvm::ConstantInt::get(Int32Ty, FunctionRecords.size()), llvm::ConstantInt::get(Int32Ty, FilenamesSize), llvm::ConstantInt::get(Int32Ty, CoverageMappingSize), llvm::ConstantInt::get(Int32Ty, /*Version=*/CoverageMappingVersion1), RecordsVal, FilenamesAndMappingsVal}; auto CovDataVal = llvm::ConstantStruct::get(CovDataTy, makeArrayRef(TUDataVals)); auto CovData = new llvm::GlobalVariable(CGM.getModule(), CovDataTy, true, llvm::GlobalValue::InternalLinkage, CovDataVal, "__llvm_coverage_mapping"); CovData->setSection(getCoverageSection(CGM)); CovData->setAlignment(8); // Make sure the data doesn't get deleted. CGM.addUsedGlobal(CovData); } unsigned CoverageMappingModuleGen::getFileID(const FileEntry *File) { auto It = FileEntries.find(File); if (It != FileEntries.end()) return It->second; unsigned FileID = FileEntries.size(); FileEntries.insert(std::make_pair(File, FileID)); return FileID; } void CoverageMappingGen::emitCounterMapping(const Decl *D, llvm::raw_ostream &OS) { assert(CounterMap); CounterCoverageMappingBuilder Walker(CVM, *CounterMap, NumRegionCounters, SM, LangOpts); Walker.VisitDecl(D); Walker.write(OS); } void CoverageMappingGen::emitEmptyMapping(const Decl *D, llvm::raw_ostream &OS) { EmptyCoverageMappingBuilder Walker(CVM, SM, LangOpts); Walker.VisitDecl(D); Walker.write(OS); } @ 1.1.1.1 log @Import clang 3.6svn r215315. @ text @@ 1.1.1.1.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d18 1 d20 1 a21 2 #include "llvm/ProfileData/CoverageMappingWriter.h" #include "llvm/ProfileData/InstrProfReader.h" d35 1 a35 2 class SourceMappingRegion { public: a43 1 private: d71 1 a72 1 public: d76 3 a78 1 unsigned Flags = 0) d82 1 a82 13 Flags(Flags) {} const FileID &getFile() const { return File; } const Counter &getCounter() const { return Count; } const SourceLocation &getStartLoc() const { return LocStart; } const SourceLocation &getEndLoc(const SourceManager &SM) const { if (SM.getFileID(LocEnd) != File) return AlternativeLocEnd; return LocEnd; } a91 1 // FIXME: We allow merging regions with a gap in between them. Should we? d94 1 a94 1 Group == R.Group; d97 7 a103 7 /// \brief A comparison that sorts such that mergeable regions are adjacent. friend bool operator<(const SourceMappingRegion &LHS, const SourceMappingRegion &RHS) { return std::tie(LHS.File, LHS.MacroArgumentFile, LHS.Count, LHS.UnreachableInitiator, LHS.Group) < std::tie(RHS.File, RHS.MacroArgumentFile, RHS.Count, RHS.UnreachableInitiator, RHS.Group); d107 13 d152 1 a152 1 std::vector SourceRegions; d310 19 d355 9 a363 3 SourceRegions.emplace_back(File, MacroArgumentFile, Count, UnreachableInitiator, SourceGroup, LocStart, LocEnd, Flags); d373 8 d384 5 a388 1 std::sort(SourceRegions.begin(), SourceRegions.end()); d390 2 a391 15 for (auto I = SourceRegions.begin(), E = SourceRegions.end(); I != E; ++I) { // Keep the original start location of this region. SourceLocation LocStart = I->getStartLoc(); SourceLocation LocEnd = I->getEndLoc(SM); bool Ignore = I->hasFlag(SourceMappingRegion::IgnoreIfNotExtended); // We need to handle mergeable regions together. for (auto Next = I + 1; Next != E && Next->isMergeable(*I); ++Next) { ++I; LocStart = std::min(LocStart, I->getStartLoc()); LocEnd = std::max(LocEnd, I->getEndLoc(SM)); // FIXME: Should we && together the Ignore flag of multiple regions? Ignore = false; } if (Ignore) a393 1 // Find the spilling locations for the mapping region. d400 1 a400 1 auto SpellingFile = SM.getDecomposedSpellingLoc(LocStart).first; d402 1 a402 1 if (getCoverageFileID(LocStart, I->getFile(), SpellingFile, CovFileID)) d407 2 a408 2 I->getCounter(), CovFileID, LineStart, ColumnStart, LineEnd, ColumnEnd, false, CounterMappingRegion::CodeRegion)); d433 2 a434 1 CoverageMappingWriter Writer(FileIDMapping, None, MappingRegions); d587 2 a588 1 llvm::DenseMap &CounterMap, SourceManager &SM, d590 2 a591 1 : CoverageMappingBuilder(CVM, SM, LangOpts), CounterMap(CounterMap) {} d605 6 d633 5 d646 16 d669 1 a669 1 Visit(Body); a682 1 mapSourceCodeRange(S->getRBracLoc()); d687 1 d736 1 a736 1 Visit(S->getBody()); d760 1 a760 1 Visit(S->getBody()); d788 1 a788 1 Visit(S->getBody()); d827 1 a827 1 Visit(S->getBody()); d839 1 a839 2 Cnt.beginRegion(); Visit(S->getBody()); d906 1 a906 1 Visit(S->getThen()); d911 1 a911 1 Visit(S->getElse()); d932 1 a932 1 Visit(S->getHandlerBlock()); d938 1 a938 1 mapToken(E->getColonLoc()); d947 2 a1044 10 void VisitObjCMessageExpr(const ObjCMessageExpr *E) { mapToken(E->getLeftLoc()); for (Stmt::const_child_range I = static_cast(E)->children(); I; ++I) { if (*I) this->Visit(*I); } mapToken(E->getRightLoc()); } d1086 1 a1086 1 uint64_t FunctionHash, const std::string &CoverageMapping) { a1088 1 auto *Int64Ty = llvm::Type::getInt64Ty(Ctx); d1091 1 a1091 1 llvm::Type *FunctionRecordTypes[] = {Int8PtrTy, Int32Ty, Int32Ty, Int64Ty}; d1099 1 a1099 2 llvm::ConstantInt::get(Int32Ty, CoverageMapping.size()), llvm::ConstantInt::get(Int64Ty, FunctionHash)}; d1206 2 a1207 1 CounterCoverageMappingBuilder Walker(CVM, *CounterMap, SM, LangOpts); @ 1.1.1.2 log @Import Clang 3.6RC1 r227398. @ text @d18 1 d20 1 a21 2 #include "llvm/ProfileData/CoverageMappingWriter.h" #include "llvm/ProfileData/InstrProfReader.h" d35 1 a35 2 class SourceMappingRegion { public: a43 1 private: d71 1 a72 1 public: d76 3 a78 1 unsigned Flags = 0) d82 1 a82 13 Flags(Flags) {} const FileID &getFile() const { return File; } const Counter &getCounter() const { return Count; } const SourceLocation &getStartLoc() const { return LocStart; } const SourceLocation &getEndLoc(const SourceManager &SM) const { if (SM.getFileID(LocEnd) != File) return AlternativeLocEnd; return LocEnd; } a91 1 // FIXME: We allow merging regions with a gap in between them. Should we? d94 1 a94 1 Group == R.Group; d97 7 a103 7 /// \brief A comparison that sorts such that mergeable regions are adjacent. friend bool operator<(const SourceMappingRegion &LHS, const SourceMappingRegion &RHS) { return std::tie(LHS.File, LHS.MacroArgumentFile, LHS.Count, LHS.UnreachableInitiator, LHS.Group) < std::tie(RHS.File, RHS.MacroArgumentFile, RHS.Count, RHS.UnreachableInitiator, RHS.Group); d107 13 d152 1 a152 1 std::vector SourceRegions; d310 19 d355 9 a363 3 SourceRegions.emplace_back(File, MacroArgumentFile, Count, UnreachableInitiator, SourceGroup, LocStart, LocEnd, Flags); d373 8 d384 5 a388 1 std::sort(SourceRegions.begin(), SourceRegions.end()); d390 2 a391 15 for (auto I = SourceRegions.begin(), E = SourceRegions.end(); I != E; ++I) { // Keep the original start location of this region. SourceLocation LocStart = I->getStartLoc(); SourceLocation LocEnd = I->getEndLoc(SM); bool Ignore = I->hasFlag(SourceMappingRegion::IgnoreIfNotExtended); // We need to handle mergeable regions together. for (auto Next = I + 1; Next != E && Next->isMergeable(*I); ++Next) { ++I; LocStart = std::min(LocStart, I->getStartLoc()); LocEnd = std::max(LocEnd, I->getEndLoc(SM)); // FIXME: Should we && together the Ignore flag of multiple regions? Ignore = false; } if (Ignore) a393 1 // Find the spilling locations for the mapping region. d400 1 a400 1 auto SpellingFile = SM.getDecomposedSpellingLoc(LocStart).first; d402 1 a402 1 if (getCoverageFileID(LocStart, I->getFile(), SpellingFile, CovFileID)) d407 2 a408 2 I->getCounter(), CovFileID, LineStart, ColumnStart, LineEnd, ColumnEnd, false, CounterMappingRegion::CodeRegion)); d433 2 a434 1 CoverageMappingWriter Writer(FileIDMapping, None, MappingRegions); d587 2 a588 1 llvm::DenseMap &CounterMap, SourceManager &SM, d590 2 a591 1 : CoverageMappingBuilder(CVM, SM, LangOpts), CounterMap(CounterMap) {} d605 6 d633 5 d646 16 d669 1 a669 1 Visit(Body); a682 1 mapSourceCodeRange(S->getRBracLoc()); d687 1 d736 1 a736 1 Visit(S->getBody()); d760 1 a760 1 Visit(S->getBody()); d788 1 a788 1 Visit(S->getBody()); d827 1 a827 1 Visit(S->getBody()); d839 1 a839 2 Cnt.beginRegion(); Visit(S->getBody()); d906 1 a906 1 Visit(S->getThen()); d911 1 a911 1 Visit(S->getElse()); d932 1 a932 1 Visit(S->getHandlerBlock()); d938 1 a938 1 mapToken(E->getColonLoc()); d947 2 a1044 10 void VisitObjCMessageExpr(const ObjCMessageExpr *E) { mapToken(E->getLeftLoc()); for (Stmt::const_child_range I = static_cast(E)->children(); I; ++I) { if (*I) this->Visit(*I); } mapToken(E->getRightLoc()); } d1086 1 a1086 1 uint64_t FunctionHash, const std::string &CoverageMapping) { a1088 1 auto *Int64Ty = llvm::Type::getInt64Ty(Ctx); d1091 1 a1091 1 llvm::Type *FunctionRecordTypes[] = {Int8PtrTy, Int32Ty, Int32Ty, Int64Ty}; d1099 1 a1099 2 llvm::ConstantInt::get(Int32Ty, CoverageMapping.size()), llvm::ConstantInt::get(Int64Ty, FunctionHash)}; d1206 2 a1207 1 CounterCoverageMappingBuilder Walker(CVM, *CounterMap, SM, LangOpts); @ 1.1.1.3 log @Import Clang 3.8.0rc3 r261930. @ text @a17 1 #include "llvm/ADT/Optional.h" d36 12 d50 17 d68 1 a68 1 Optional LocStart; d71 2 a72 1 Optional LocEnd; d75 10 a84 3 SourceMappingRegion(Counter Count, Optional LocStart, Optional LocEnd) : Count(Count), LocStart(LocStart), LocEnd(LocEnd) {} d88 1 a88 1 void setCounter(Counter C) { Count = C; } d90 5 a94 1 bool hasStartLoc() const { return LocStart.hasValue(); } d96 1 a96 1 void setStartLoc(SourceLocation Loc) { LocStart = Loc; } d98 1 a98 4 SourceLocation getStartLoc() const { assert(LocStart && "Region has no start location"); return *LocStart; } d100 1 a100 1 bool hasEndLoc() const { return LocEnd.hasValue(); } d102 7 a108 1 void setEndLoc(SourceLocation Loc) { LocEnd = Loc; } d110 7 a116 3 SourceLocation getEndLoc() const { assert(LocEnd && "Region has no end location"); return *LocEnd; d129 12 a140 3 /// \brief Map of clang's FileIDs to IDs used for coverage mapping. llvm::SmallDenseMap, 8> FileIDMapping; d143 6 d156 3 a158 1 : CVM(CVM), SM(SM), LangOpts(LangOpts) {} d162 1 a162 5 // We avoid getLocForEndOfToken here, because it doesn't do what we want for // macro locations, which we just treat as expanded files. unsigned TokLen = Lexer::MeasureTokenLength(SM.getSpellingLoc(Loc), SM, LangOpts); return Loc.getLocWithOffset(TokLen); d165 21 a185 14 /// \brief Return the start location of an included file or expanded macro. SourceLocation getStartOfFileOrMacro(SourceLocation Loc) { if (Loc.isMacroID()) return Loc.getLocWithOffset(-SM.getFileOffset(Loc)); return SM.getLocForStartOfFile(SM.getFileID(Loc)); } /// \brief Return the end location of an included file or expanded macro. SourceLocation getEndOfFileOrMacro(SourceLocation Loc) { if (Loc.isMacroID()) return Loc.getLocWithOffset(SM.getFileIDSize(SM.getFileID(Loc)) - SM.getFileOffset(Loc)); return SM.getLocForEndOfFile(SM.getFileID(Loc)); } d187 21 a207 61 /// \brief Find out where the current file is included or macro is expanded. SourceLocation getIncludeOrExpansionLoc(SourceLocation Loc) { return Loc.isMacroID() ? SM.getImmediateExpansionRange(Loc).first : SM.getIncludeLoc(SM.getFileID(Loc)); } /// \brief Return true if \c Loc is a location in a built-in macro. bool isInBuiltin(SourceLocation Loc) { return strcmp(SM.getBufferName(SM.getSpellingLoc(Loc)), "") == 0; } /// \brief Get the start of \c S ignoring macro arguments and builtin macros. SourceLocation getStart(const Stmt *S) { SourceLocation Loc = S->getLocStart(); while (SM.isMacroArgExpansion(Loc) || isInBuiltin(Loc)) Loc = SM.getImmediateExpansionRange(Loc).first; return Loc; } /// \brief Get the end of \c S ignoring macro arguments and builtin macros. SourceLocation getEnd(const Stmt *S) { SourceLocation Loc = S->getLocEnd(); while (SM.isMacroArgExpansion(Loc) || isInBuiltin(Loc)) Loc = SM.getImmediateExpansionRange(Loc).first; return getPreciseTokenLocEnd(Loc); } /// \brief Find the set of files we have regions for and assign IDs /// /// Fills \c Mapping with the virtual file mapping needed to write out /// coverage and collects the necessary file information to emit source and /// expansion regions. void gatherFileIDs(SmallVectorImpl &Mapping) { FileIDMapping.clear(); SmallVector Visited; SmallVector, 8> FileLocs; for (const auto &Region : SourceRegions) { SourceLocation Loc = Region.getStartLoc(); FileID File = SM.getFileID(Loc); if (std::find(Visited.begin(), Visited.end(), File) != Visited.end()) continue; Visited.push_back(File); unsigned Depth = 0; for (SourceLocation Parent = getIncludeOrExpansionLoc(Loc); Parent.isValid(); Parent = getIncludeOrExpansionLoc(Parent)) ++Depth; FileLocs.push_back(std::make_pair(Loc, Depth)); } std::stable_sort(FileLocs.begin(), FileLocs.end(), llvm::less_second()); for (const auto &FL : FileLocs) { SourceLocation Loc = FL.first; FileID SpellingFile = SM.getDecomposedSpellingLoc(Loc).first; auto Entry = SM.getFileEntryForID(SpellingFile); if (!Entry) continue; FileIDMapping[SM.getFileID(Loc)] = std::make_pair(Mapping.size(), Loc); Mapping.push_back(CVM.getFileID(Entry)); d209 1 a209 10 } /// \brief Get the coverage mapping file ID for \c Loc. /// /// If such file id doesn't exist, return None. Optional getCoverageFileID(SourceLocation Loc) { auto Mapping = FileIDMapping.find(SM.getFileID(Loc)); if (Mapping != FileIDMapping.end()) return Mapping->second.first; return None; d238 7 a244 2 assert(SM.isWrittenInSameFile(LocStart, LocEnd) && "region spans multiple files"); d246 2 a247 2 auto CovFileID = getCoverageFileID(LocStart); if (!CovFileID) d253 3 a255 2 auto Region = CounterMappingRegion::makeSkipped( *CovFileID, LineStart, ColumnStart, LineEnd, ColumnEnd); d258 2 a259 2 if (Region.LineStart >= FileLineRanges[*CovFileID].first && Region.LineEnd <= FileLineRanges[*CovFileID].second) d264 84 d351 1 a351 2 for (const auto &Region : SourceRegions) { assert(Region.hasEndLoc() && "incomplete region"); d353 15 a367 6 SourceLocation LocStart = Region.getStartLoc(); assert(SM.getFileID(LocStart).isValid() && "region in invalid file"); auto CovFileID = getCoverageFileID(LocStart); // Ignore regions that don't have a file, such as builtin macros. if (!CovFileID) a369 4 SourceLocation LocEnd = Region.getEndLoc(); assert(SM.isWrittenInSameFile(LocStart, LocEnd) && "region spans multiple files"); d371 1 d377 3 a379 13 assert(LineStart <= LineEnd && "region start and end out of order"); MappingRegions.push_back(CounterMappingRegion::makeRegion( Region.getCounter(), *CovFileID, LineStart, ColumnStart, LineEnd, ColumnEnd)); } } /// \brief Generate expansion regions for each virtual file we've seen. void emitExpansionRegions() { for (const auto &FM : FileIDMapping) { SourceLocation ExpandedLoc = FM.second.second; SourceLocation ParentLoc = getIncludeOrExpansionLoc(ExpandedLoc); if (ParentLoc.isInvalid()) d382 4 a385 18 auto ParentFileID = getCoverageFileID(ParentLoc); if (!ParentFileID) continue; auto ExpandedFileID = getCoverageFileID(ExpandedLoc); assert(ExpandedFileID && "expansion in uncovered file"); SourceLocation LocEnd = getPreciseTokenLocEnd(ParentLoc); assert(SM.isWrittenInSameFile(ParentLoc, LocEnd) && "region spans multiple files"); unsigned LineStart = SM.getSpellingLineNumber(ParentLoc); unsigned ColumnStart = SM.getSpellingColumnNumber(ParentLoc); unsigned LineEnd = SM.getSpellingLineNumber(LocEnd); unsigned ColumnEnd = SM.getSpellingColumnNumber(LocEnd); MappingRegions.push_back(CounterMappingRegion::makeExpansion( *ParentFileID, *ExpandedFileID, LineStart, ColumnStart, LineEnd, ColumnEnd)); d401 1 a401 1 SourceRegions.emplace_back(Counter(), getStart(Body), getEnd(Body)); d406 1 d408 1 a408 2 gatherFileIDs(FileIDMapping); emitSourceRegions(); d423 1 a423 2 /// \brief A stack of currently live regions. std::vector RegionStack; d427 2 a428 7 /// \brief A location in the most recently visited file or macro. /// /// This is used to adjust the active source regions appropriately when /// expressions cross file or macro boundaries. SourceLocation MostRecentLocation; /// \brief Return a counter for the subtraction of \c RHS from \c LHS d433 2 a434 1 /// \brief Return a counter for the sum of \c LHS and \c RHS. a438 8 Counter addCounters(Counter C1, Counter C2, Counter C3) { return addCounters(addCounters(C1, C2), C3); } Counter addCounters(Counter C1, Counter C2, Counter C3, Counter C4) { return addCounters(addCounters(C1, C2, C3), C4); } a439 1 /// d441 1 a441 3 Counter getRegionCounter(const Stmt *S) { return Counter::getCounter(CounterMap[S]); } d443 54 a496 9 /// \brief Push a region onto the stack. /// /// Returns the index on the stack where the region was pushed. This can be /// used with popRegions to exit a "scope", ending the region that was pushed. size_t pushRegion(Counter Count, Optional StartLoc = None, Optional EndLoc = None) { if (StartLoc) MostRecentLocation = *StartLoc; RegionStack.emplace_back(Count, StartLoc, EndLoc); d498 16 a513 2 return RegionStack.size() - 1; } d515 6 a520 33 /// \brief Pop regions from the stack into the function's list of regions. /// /// Adds all regions from \c ParentIndex to the top of the stack to the /// function's \c SourceRegions. void popRegions(size_t ParentIndex) { assert(RegionStack.size() >= ParentIndex && "parent not in stack"); while (RegionStack.size() > ParentIndex) { SourceMappingRegion &Region = RegionStack.back(); if (Region.hasStartLoc()) { SourceLocation StartLoc = Region.getStartLoc(); SourceLocation EndLoc = Region.hasEndLoc() ? Region.getEndLoc() : RegionStack[ParentIndex].getEndLoc(); while (!SM.isWrittenInSameFile(StartLoc, EndLoc)) { // The region ends in a nested file or macro expansion. Create a // separate region for each expansion. SourceLocation NestedLoc = getStartOfFileOrMacro(EndLoc); assert(SM.isWrittenInSameFile(NestedLoc, EndLoc)); SourceRegions.emplace_back(Region.getCounter(), NestedLoc, EndLoc); EndLoc = getPreciseTokenLocEnd(getIncludeOrExpansionLoc(EndLoc)); if (EndLoc.isInvalid()) llvm::report_fatal_error("File exit not handled before popRegions"); } Region.setEndLoc(EndLoc); MostRecentLocation = EndLoc; // If this region happens to span an entire expansion, we need to make // sure we don't overlap the parent region with it. if (StartLoc == getStartOfFileOrMacro(StartLoc) && EndLoc == getEndOfFileOrMacro(EndLoc)) MostRecentLocation = getIncludeOrExpansionLoc(EndLoc); d522 4 a525 4 assert(SM.isWrittenInSameFile(Region.getStartLoc(), EndLoc)); SourceRegions.push_back(Region); } RegionStack.pop_back(); a526 1 } d528 11 a538 60 /// \brief Return the currently active region. SourceMappingRegion &getRegion() { assert(!RegionStack.empty() && "statement has no region"); return RegionStack.back(); } /// \brief Propagate counts through the children of \c S. Counter propagateCounts(Counter TopCount, const Stmt *S) { size_t Index = pushRegion(TopCount, getStart(S), getEnd(S)); Visit(S); Counter ExitCount = getRegion().getCounter(); popRegions(Index); return ExitCount; } /// \brief Adjust the most recently visited location to \c EndLoc. /// /// This should be used after visiting any statements in non-source order. void adjustForOutOfOrderTraversal(SourceLocation EndLoc) { MostRecentLocation = EndLoc; // Avoid adding duplicate regions if we have a completed region on the top // of the stack and are adjusting to the end of a virtual file. if (getRegion().hasEndLoc() && MostRecentLocation == getEndOfFileOrMacro(MostRecentLocation)) MostRecentLocation = getIncludeOrExpansionLoc(MostRecentLocation); } /// \brief Check whether \c Loc is included or expanded from \c Parent. bool isNestedIn(SourceLocation Loc, FileID Parent) { do { Loc = getIncludeOrExpansionLoc(Loc); if (Loc.isInvalid()) return false; } while (!SM.isInFileID(Loc, Parent)); return true; } /// \brief Adjust regions and state when \c NewLoc exits a file. /// /// If moving from our most recently tracked location to \c NewLoc exits any /// files, this adjusts our current region stack and creates the file regions /// for the exited file. void handleFileExit(SourceLocation NewLoc) { if (NewLoc.isInvalid() || SM.isWrittenInSameFile(MostRecentLocation, NewLoc)) return; // If NewLoc is not in a file that contains MostRecentLocation, walk up to // find the common ancestor. SourceLocation LCA = NewLoc; FileID ParentFile = SM.getFileID(LCA); while (!isNestedIn(MostRecentLocation, ParentFile)) { LCA = getIncludeOrExpansionLoc(LCA); if (LCA.isInvalid() || SM.isWrittenInSameFile(LCA, MostRecentLocation)) { // Since there isn't a common ancestor, no file was exited. We just need // to adjust our location to the new file. MostRecentLocation = NewLoc; return; } ParentFile = SM.getFileID(LCA); d541 6 a546 21 llvm::SmallSet StartLocs; Optional ParentCounter; for (SourceMappingRegion &I : llvm::reverse(RegionStack)) { if (!I.hasStartLoc()) continue; SourceLocation Loc = I.getStartLoc(); if (!isNestedIn(Loc, ParentFile)) { ParentCounter = I.getCounter(); break; } while (!SM.isInFileID(Loc, ParentFile)) { // The most nested region for each start location is the one with the // correct count. We avoid creating redundant regions by stopping once // we've seen this region. if (StartLocs.insert(Loc).second) SourceRegions.emplace_back(I.getCounter(), Loc, getEndOfFileOrMacro(Loc)); Loc = getIncludeOrExpansionLoc(Loc); } I.setStartLoc(getPreciseTokenLocEnd(Loc)); d548 3 a550 13 if (ParentCounter) { // If the file is contained completely by another region and doesn't // immediately start its own region, the whole file gets a region // corresponding to the parent. SourceLocation Loc = MostRecentLocation; while (isNestedIn(Loc, ParentFile)) { SourceLocation FileStart = getStartOfFileOrMacro(Loc); if (StartLocs.insert(FileStart).second) SourceRegions.emplace_back(*ParentCounter, FileStart, getEndOfFileOrMacro(Loc)); Loc = getIncludeOrExpansionLoc(Loc); } d552 1 a552 22 MostRecentLocation = NewLoc; } /// \brief Ensure that \c S is included in the current region. void extendRegion(const Stmt *S) { SourceMappingRegion &Region = getRegion(); SourceLocation StartLoc = getStart(S); handleFileExit(StartLoc); if (!Region.hasStartLoc()) Region.setStartLoc(StartLoc); } /// \brief Mark \c S as a terminator, starting a zero region. void terminateRegion(const Stmt *S) { extendRegion(S); SourceMappingRegion &Region = getRegion(); if (!Region.hasEndLoc()) Region.setEndLoc(getEnd(S)); pushRegion(Counter::getZero()); } d569 1 d571 1 a571 3 gatherFileIDs(VirtualFileMapping); emitSourceRegions(); emitExpansionRegions(); d574 2 a575 2 CoverageMappingWriter Writer(VirtualFileMapping, Builder.getExpressions(), MappingRegions); d579 22 d602 5 a606 6 if (S->getLocStart().isValid()) extendRegion(S); for (const Stmt *Child : S->children()) if (Child) this->Visit(Child); handleFileExit(getEnd(S)); d610 25 a634 2 Stmt *Body = D->getBody(); propagateCounts(getRegionCounter(Body), Body); d638 1 a638 1 extendRegion(S); d641 1 a641 1 terminateRegion(S); d644 4 a647 5 void VisitCXXThrowExpr(const CXXThrowExpr *E) { extendRegion(E); if (E->getSubExpr()) Visit(E->getSubExpr()); terminateRegion(E); a649 2 void VisitGotoStmt(const GotoStmt *S) { terminateRegion(S); } d651 5 a655 4 SourceLocation Start = getStart(S); // We can't extendRegion here or we risk overlapping with our new region. handleFileExit(Start); pushRegion(getRegionCounter(S), Start); d660 1 d663 2 a664 2 BreakContinueStack.back().BreakCount, getRegion().getCounter()); terminateRegion(S); d668 1 d671 2 a672 2 BreakContinueStack.back().ContinueCount, getRegion().getCounter()); terminateRegion(S); d676 3 a678 6 extendRegion(S); Counter ParentCount = getRegion().getCounter(); Counter BodyCount = getRegionCounter(S); // Handle the body first so that we can get the backedge count. d680 10 a689 2 extendRegion(S->getBody()); Counter BackedgeCount = propagateCounts(BodyCount, S->getBody()); d691 8 a698 11 // Go back to handle the condition. Counter CondCount = addCounters(ParentCount, BackedgeCount, BC.ContinueCount); propagateCounts(CondCount, S->getCond()); adjustForOutOfOrderTraversal(getEnd(S)); Counter OutCount = addCounters(BC.BreakCount, subtractCounters(CondCount, BodyCount)); if (OutCount != ParentCount) pushRegion(OutCount); d702 7 a708 1 extendRegion(S); a709 7 Counter ParentCount = getRegion().getCounter(); Counter BodyCount = getRegionCounter(S); BreakContinueStack.push_back(BreakContinue()); extendRegion(S->getBody()); Counter BackedgeCount = propagateCounts(addCounters(ParentCount, BodyCount), S->getBody()); d711 11 a721 8 Counter CondCount = addCounters(BackedgeCount, BC.ContinueCount); propagateCounts(CondCount, S->getCond()); Counter OutCount = addCounters(BC.BreakCount, subtractCounters(CondCount, BodyCount)); if (OutCount != ParentCount) pushRegion(OutCount); d725 1 a725 1 extendRegion(S); d729 2 a730 4 Counter ParentCount = getRegion().getCounter(); Counter BodyCount = getRegionCounter(S); // Handle the body first so that we can get the backedge count. d732 5 a736 3 extendRegion(S->getBody()); Counter BackedgeCount = propagateCounts(BodyCount, S->getBody()); BreakContinue BC = BreakContinueStack.pop_back_val(); d740 10 a749 2 if (const Stmt *Inc = S->getInc()) propagateCounts(addCounters(BackedgeCount, BC.ContinueCount), Inc); d751 9 a759 6 // Go back to handle the condition. Counter CondCount = addCounters(ParentCount, BackedgeCount, BC.ContinueCount); if (const Expr *Cond = S->getCond()) { propagateCounts(CondCount, Cond); adjustForOutOfOrderTraversal(getEnd(S)); d761 1 a761 5 Counter OutCount = addCounters(BC.BreakCount, subtractCounters(CondCount, BodyCount)); if (OutCount != ParentCount) pushRegion(OutCount); d765 1 a765 2 extendRegion(S); Visit(S->getLoopVarStmt()); d767 3 a769 4 Counter ParentCount = getRegion().getCounter(); Counter BodyCount = getRegionCounter(S); d771 5 a775 2 extendRegion(S->getBody()); Counter BackedgeCount = propagateCounts(BodyCount, S->getBody()); d777 1 a777 7 Counter LoopCount = addCounters(ParentCount, BackedgeCount, BC.ContinueCount); Counter OutCount = addCounters(BC.BreakCount, subtractCounters(LoopCount, BodyCount)); if (OutCount != ParentCount) pushRegion(OutCount); d781 1 a781 1 extendRegion(S); d783 2 a784 4 Counter ParentCount = getRegion().getCounter(); Counter BodyCount = getRegionCounter(S); d786 2 a787 2 extendRegion(S->getBody()); Counter BackedgeCount = propagateCounts(BodyCount, S->getBody()); d789 2 a790 7 Counter LoopCount = addCounters(ParentCount, BackedgeCount, BC.ContinueCount); Counter OutCount = addCounters(BC.BreakCount, subtractCounters(LoopCount, BodyCount)); if (OutCount != ParentCount) pushRegion(OutCount); d794 1 a794 1 extendRegion(S); a795 1 d797 9 a805 15 const Stmt *Body = S->getBody(); extendRegion(Body); if (const auto *CS = dyn_cast(Body)) { if (!CS->body_empty()) { // The body of the switch needs a zero region so that fallthrough counts // behave correctly, but it would be misleading to include the braces of // the compound statement in the zeroed area, so we need to handle this // specially. size_t Index = pushRegion(Counter::getZero(), getStart(CS->body_front()), getEnd(CS->body_back())); for (const auto *Child : CS->children()) Visit(Child); popRegions(Index); d807 6 a812 2 } else propagateCounts(Counter::getZero(), Body); a813 1 d817 6 d824 9 a832 2 Counter ExitCount = getRegionCounter(S); pushRegion(ExitCount); d835 7 a841 18 void VisitSwitchCase(const SwitchCase *S) { extendRegion(S); SourceMappingRegion &Parent = getRegion(); Counter Count = addCounters(Parent.getCounter(), getRegionCounter(S)); // Reuse the existing region if it starts at our label. This is typical of // the first case in a switch. if (Parent.hasStartLoc() && Parent.getStartLoc() == getStart(S)) Parent.setCounter(Count); else pushRegion(Count, getStart(S)); if (const auto *CS = dyn_cast(S)) { Visit(CS->getLHS()); if (const Expr *RHS = CS->getRHS()) Visit(RHS); } d846 3 a848 21 extendRegion(S); // Extend into the condition before we propagate through it below - this is // needed to handle macros that generate the "if" but not the condition. extendRegion(S->getCond()); Counter ParentCount = getRegion().getCounter(); Counter ThenCount = getRegionCounter(S); // Emitting a counter for the condition makes it easier to interpret the // counter for the body when looking at the coverage. propagateCounts(ParentCount, S->getCond()); extendRegion(S->getThen()); Counter OutCount = propagateCounts(ThenCount, S->getThen()); Counter ElseCount = subtractCounters(ParentCount, ThenCount); if (const Stmt *Else = S->getElse()) { extendRegion(S->getElse()); OutCount = addCounters(OutCount, propagateCounts(ElseCount, Else)); } else OutCount = addCounters(OutCount, ElseCount); d850 13 a862 2 if (OutCount != ParentCount) pushRegion(OutCount); d866 1 a866 1 extendRegion(S); d870 3 a872 3 Counter ExitCount = getRegionCounter(S); pushRegion(ExitCount); d876 5 a880 1 propagateCounts(getRegionCounter(S), S->getHandlerBlock()); d884 3 a886 1 extendRegion(E); d888 10 a897 2 Counter ParentCount = getRegion().getCounter(); Counter TrueCount = getRegionCounter(E); d899 13 a911 1 Visit(E->getCond()); d913 15 a927 7 if (!isa(E)) { extendRegion(E->getTrueExpr()); propagateCounts(TrueCount, E->getTrueExpr()); } extendRegion(E->getFalseExpr()); propagateCounts(subtractCounters(ParentCount, TrueCount), E->getFalseExpr()); d930 1 a930 2 void VisitBinLAnd(const BinaryOperator *E) { extendRegion(E); d932 12 d945 3 a947 2 extendRegion(E->getRHS()); propagateCounts(getRegionCounter(E), E->getRHS()); d950 8 a957 2 void VisitBinLOr(const BinaryOperator *E) { extendRegion(E); d959 28 d988 2 a989 2 extendRegion(E->getRHS()); propagateCounts(getRegionCounter(E), E->getRHS()); d992 8 a999 3 void VisitLambdaExpr(const LambdaExpr *LE) { // Lambdas are treated as their own functions for now, so we shouldn't // propagate counts into them. d1009 1 a1009 1 return llvm::getInstrProfCoverageSectionName(isMachO(CGM)); d1012 4 a1015 6 static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef Expressions, ArrayRef Regions) { OS << FunctionName << ":\n"; CounterMappingContext Ctx(Expressions); for (const auto &R : Regions) { d1028 5 a1032 3 OS << "File " << R.FileID << ", " << R.LineStart << ":" << R.ColumnStart << " -> " << R.LineEnd << ":" << R.ColumnEnd << " = "; Ctx.dump(R.Count, OS); d1034 3 a1036 2 OS << " (Expanded file = " << R.ExpandedFileID << ")"; OS << "\n"; d1041 2 a1042 2 llvm::GlobalVariable *NamePtr, StringRef NameValue, uint64_t FuncHash, const std::string &CoverageMapping, bool isUsed) { d1044 3 d1048 1 a1048 4 #define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) LLVMType, llvm::Type *FunctionRecordTypes[] = { #include "llvm/ProfileData/InstrProfData.inc" }; d1050 1 a1050 2 llvm::StructType::get(Ctx, makeArrayRef(FunctionRecordTypes), /*isPacked=*/true); a1052 1 #define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) Init, d1054 4 a1057 2 #include "llvm/ProfileData/InstrProfData.inc" }; a1059 3 if (!isUsed) FunctionNames.push_back( llvm::ConstantExpr::getBitCast(NamePtr, llvm::Type::getInt8PtrTy(Ctx))); d1075 5 a1079 3 RawCoverageMappingReader Reader(CoverageMapping, FilenameRefs, Filenames, Expressions, Regions); if (Reader.read()) d1081 1 a1081 1 dump(llvm::outs(), NameValue, Expressions, Regions); d1101 1 a1101 1 FilenameStrs[I] = std::string(Path.begin(), Path.end()); a1125 13 llvm::Type *CovDataHeaderTypes[] = { #define COVMAP_HEADER(Type, LLVMType, Name, Init) LLVMType, #include "llvm/ProfileData/InstrProfData.inc" }; auto CovDataHeaderTy = llvm::StructType::get(Ctx, makeArrayRef(CovDataHeaderTypes)); llvm::Constant *CovDataHeaderVals[] = { #define COVMAP_HEADER(Type, LLVMType, Name, Init) Init, #include "llvm/ProfileData/InstrProfData.inc" }; auto CovDataHeaderVal = llvm::ConstantStruct::get( CovDataHeaderTy, makeArrayRef(CovDataHeaderVals)); d1127 3 a1129 2 llvm::Type *CovDataTypes[] = {CovDataHeaderTy, RecordsTy, FilenamesAndMappingsVal->getType()}; d1131 7 a1137 2 llvm::Constant *TUDataVals[] = {CovDataHeaderVal, RecordsVal, FilenamesAndMappingsVal}; d1140 4 a1143 3 auto CovData = new llvm::GlobalVariable( CGM.getModule(), CovDataTy, true, llvm::GlobalValue::InternalLinkage, CovDataVal, llvm::getCoverageMappingVarName()); a1149 11 // Create the deferred function records array if (!FunctionNames.empty()) { auto NamesArrTy = llvm::ArrayType::get(llvm::Type::getInt8PtrTy(Ctx), FunctionNames.size()); auto NamesArrVal = llvm::ConstantArray::get(NamesArrTy, FunctionNames); // This variable will *NOT* be emitted to the object file. It is used // to pass the list of names referenced to codegen. new llvm::GlobalVariable(CGM.getModule(), NamesArrTy, true, llvm::GlobalValue::InternalLinkage, NamesArrVal, llvm::getCoverageNamesVarName()); } @ 1.1.1.3.2.1 log @Sync with HEAD @ text @a17 2 #include "llvm/ADT/SmallSet.h" #include "llvm/ADT/StringExtras.h" d19 3 a21 3 #include "llvm/ProfileData/Coverage/CoverageMapping.h" #include "llvm/ProfileData/Coverage/CoverageMappingReader.h" #include "llvm/ProfileData/Coverage/CoverageMappingWriter.h" a23 1 #include "llvm/Support/Path.h" a91 8 /// \brief A set of regions which can be used as a filter. /// /// It is produced by emitExpansionRegions() and is used in /// emitSourceRegions() to suppress producing code regions if /// the same area is covered by expansion regions. typedef llvm::SmallSet, 8> SourceRegionFilter; d128 1 a128 11 return SM.getBufferName(SM.getSpellingLoc(Loc)) == ""; } /// \brief Check whether \c Loc is included or expanded from \c Parent. bool isNestedIn(SourceLocation Loc, FileID Parent) { do { Loc = getIncludeOrExpansionLoc(Loc); if (Loc.isInvalid()) return false; } while (!SM.isInFileID(Loc, Parent)); return true; d155 1 a155 1 llvm::SmallSet Visited; d160 1 a160 5 if (!Visited.insert(File).second) continue; // Do not map FileID's associated with system headers. if (SM.isInSystemHeader(SM.getSpellingLoc(Loc))) d162 1 d194 6 d242 1 a242 1 void emitSourceRegions(const SourceRegionFilter &Filter) { a248 4 // Ignore regions from system headers. if (SM.isInSystemHeader(SM.getSpellingLoc(LocStart))) continue; a257 7 // Don't add code regions for the area covered by expansion regions. // This not only suppresses redundant regions, but sometimes prevents // creating regions with wrong counters if, for example, a statement's // body ends at the end of a nested macro. if (Filter.count(std::make_pair(LocStart, LocEnd))) continue; d272 1 a272 2 SourceRegionFilter emitExpansionRegions() { SourceRegionFilter Filter; a287 1 Filter.insert(std::make_pair(ParentLoc, LocEnd)); a297 1 return Filter; d312 1 a312 21 SourceLocation Start = getStart(Body); SourceLocation End = getEnd(Body); if (!SM.isWrittenInSameFile(Start, End)) { // Walk up to find the common ancestor. // Correct the locations accordingly. FileID StartFileID = SM.getFileID(Start); FileID EndFileID = SM.getFileID(End); while (StartFileID != EndFileID && !isNestedIn(End, StartFileID)) { Start = getIncludeOrExpansionLoc(Start); assert(Start.isValid() && "Declaration start location not nested within a known region"); StartFileID = SM.getFileID(Start); } while (StartFileID != EndFileID) { End = getPreciseTokenLocEnd(getIncludeOrExpansionLoc(End)); assert(End.isValid() && "Declaration end location not nested within a known region"); EndFileID = SM.getFileID(End); } } SourceRegions.emplace_back(Counter(), Start, End); d319 1 a319 4 emitSourceRegions(SourceRegionFilter()); if (MappingRegions.empty()) return; d359 4 d402 1 a402 2 if (!isRegionAlreadyAdded(NestedLoc, EndLoc)) SourceRegions.emplace_back(Region.getCounter(), NestedLoc, EndLoc); a435 6 // The statement may be spanned by an expansion. Make sure we handle a file // exit out of this expansion before moving to the next statement. if (SM.isBeforeInTranslationUnit(getStart(S), S->getLocStart())) MostRecentLocation = getEnd(S); a438 11 /// \brief Check whether a region with bounds \c StartLoc and \c EndLoc /// is already added to \c SourceRegions. bool isRegionAlreadyAdded(SourceLocation StartLoc, SourceLocation EndLoc) { return SourceRegions.rend() != std::find_if(SourceRegions.rbegin(), SourceRegions.rend(), [&](const SourceMappingRegion &Region) { return Region.getStartLoc() == StartLoc && Region.getEndLoc() == EndLoc; }); } d444 2 a445 5 // The code region for a whole macro is created in handleFileExit() when // it detects exiting of the virtual file of that macro. If we visited // statements in non-source order, we might already have such a region // added, for example, if a body of a loop is divided among multiple // macros. Avoid adding duplicate regions in such case. d447 1 a447 3 MostRecentLocation == getEndOfFileOrMacro(MostRecentLocation) && isRegionAlreadyAdded(getStartOfFileOrMacro(MostRecentLocation), MostRecentLocation)) d451 10 d562 2 a563 2 SourceRegionFilter Filter = emitExpansionRegions(); emitSourceRegions(Filter); a565 3 if (MappingRegions.empty()) return; a581 5 // Do not propagate region counts into system headers. if (Body && SM.isInSystemHeader(SM.getSpellingLoc(getStart(Body)))) return; a743 2 if (S->getInit()) Visit(S->getInit()); a771 1 SourceLocation ExitLoc = getEnd(S); a772 5 // Ensure that handleFileExit recognizes when the end location is located // in a different file. MostRecentLocation = getStart(S); handleFileExit(ExitLoc); a797 3 if (S->getInit()) Visit(S->getInit()); d825 1 a825 6 // Handle macros that generate the "try" but not the rest. extendRegion(S->getTryBlock()); Counter ParentCount = getRegion().getCounter(); propagateCounts(ParentCount, S->getTryBlock()); d875 1 d877 1 a877 1 bool isMachO(const CodeGenModule &CGM) { d881 1 a881 1 StringRef getCoverageSection(const CodeGenModule &CGM) { a884 9 std::string normalizeFilename(StringRef Filename) { llvm::SmallString<256> Path(Filename); llvm::sys::fs::make_absolute(Path); llvm::sys::path::remove_dots(Path, /*remove_dot_dots=*/true); return Path.str().str(); } } // end anonymous namespace d914 1 a914 1 const std::string &CoverageMapping, bool IsUsed) { d932 1 a932 1 if (!IsUsed) d935 1 a935 1 CoverageMappings.push_back(CoverageMapping); a945 1 llvm::SmallVector FilenameStrs; a946 1 FilenameStrs.resize(FileEntries.size()); d948 2 a949 5 for (const auto &Entry : FileEntries) { auto I = Entry.second; FilenameStrs[I] = normalizeFilename(Entry.first->getName()); FilenameRefs[I] = FilenameStrs[I]; } d970 3 d974 1 a974 1 FilenameStrs[I] = normalizeFilename(Entry.first->getName()); d981 2 a982 4 std::string RawCoverageMappings = llvm::join(CoverageMappings.begin(), CoverageMappings.end(), ""); OS << RawCoverageMappings; size_t CoverageMappingSize = RawCoverageMappings.size(); d1038 1 a1038 1 llvm::getCoverageUnusedNamesVarName()); @ 1.1.1.4 log @Import Clang pre-4.0.0 r291444. @ text @a17 2 #include "llvm/ADT/SmallSet.h" #include "llvm/ADT/StringExtras.h" d19 3 a21 3 #include "llvm/ProfileData/Coverage/CoverageMapping.h" #include "llvm/ProfileData/Coverage/CoverageMappingReader.h" #include "llvm/ProfileData/Coverage/CoverageMappingWriter.h" a23 1 #include "llvm/Support/Path.h" a91 8 /// \brief A set of regions which can be used as a filter. /// /// It is produced by emitExpansionRegions() and is used in /// emitSourceRegions() to suppress producing code regions if /// the same area is covered by expansion regions. typedef llvm::SmallSet, 8> SourceRegionFilter; d128 1 a128 11 return SM.getBufferName(SM.getSpellingLoc(Loc)) == ""; } /// \brief Check whether \c Loc is included or expanded from \c Parent. bool isNestedIn(SourceLocation Loc, FileID Parent) { do { Loc = getIncludeOrExpansionLoc(Loc); if (Loc.isInvalid()) return false; } while (!SM.isInFileID(Loc, Parent)); return true; d155 1 a155 1 llvm::SmallSet Visited; d160 1 a160 5 if (!Visited.insert(File).second) continue; // Do not map FileID's associated with system headers. if (SM.isInSystemHeader(SM.getSpellingLoc(Loc))) d162 1 d194 6 d242 1 a242 1 void emitSourceRegions(const SourceRegionFilter &Filter) { a248 4 // Ignore regions from system headers. if (SM.isInSystemHeader(SM.getSpellingLoc(LocStart))) continue; a257 7 // Don't add code regions for the area covered by expansion regions. // This not only suppresses redundant regions, but sometimes prevents // creating regions with wrong counters if, for example, a statement's // body ends at the end of a nested macro. if (Filter.count(std::make_pair(LocStart, LocEnd))) continue; d272 1 a272 2 SourceRegionFilter emitExpansionRegions() { SourceRegionFilter Filter; a287 1 Filter.insert(std::make_pair(ParentLoc, LocEnd)); a297 1 return Filter; d312 1 a312 21 SourceLocation Start = getStart(Body); SourceLocation End = getEnd(Body); if (!SM.isWrittenInSameFile(Start, End)) { // Walk up to find the common ancestor. // Correct the locations accordingly. FileID StartFileID = SM.getFileID(Start); FileID EndFileID = SM.getFileID(End); while (StartFileID != EndFileID && !isNestedIn(End, StartFileID)) { Start = getIncludeOrExpansionLoc(Start); assert(Start.isValid() && "Declaration start location not nested within a known region"); StartFileID = SM.getFileID(Start); } while (StartFileID != EndFileID) { End = getPreciseTokenLocEnd(getIncludeOrExpansionLoc(End)); assert(End.isValid() && "Declaration end location not nested within a known region"); EndFileID = SM.getFileID(End); } } SourceRegions.emplace_back(Counter(), Start, End); d319 1 a319 4 emitSourceRegions(SourceRegionFilter()); if (MappingRegions.empty()) return; d359 4 d402 1 a402 2 if (!isRegionAlreadyAdded(NestedLoc, EndLoc)) SourceRegions.emplace_back(Region.getCounter(), NestedLoc, EndLoc); a435 6 // The statement may be spanned by an expansion. Make sure we handle a file // exit out of this expansion before moving to the next statement. if (SM.isBeforeInTranslationUnit(getStart(S), S->getLocStart())) MostRecentLocation = getEnd(S); a438 11 /// \brief Check whether a region with bounds \c StartLoc and \c EndLoc /// is already added to \c SourceRegions. bool isRegionAlreadyAdded(SourceLocation StartLoc, SourceLocation EndLoc) { return SourceRegions.rend() != std::find_if(SourceRegions.rbegin(), SourceRegions.rend(), [&](const SourceMappingRegion &Region) { return Region.getStartLoc() == StartLoc && Region.getEndLoc() == EndLoc; }); } d444 2 a445 5 // The code region for a whole macro is created in handleFileExit() when // it detects exiting of the virtual file of that macro. If we visited // statements in non-source order, we might already have such a region // added, for example, if a body of a loop is divided among multiple // macros. Avoid adding duplicate regions in such case. d447 1 a447 3 MostRecentLocation == getEndOfFileOrMacro(MostRecentLocation) && isRegionAlreadyAdded(getStartOfFileOrMacro(MostRecentLocation), MostRecentLocation)) d451 10 d562 2 a563 2 SourceRegionFilter Filter = emitExpansionRegions(); emitSourceRegions(Filter); a565 3 if (MappingRegions.empty()) return; a581 5 // Do not propagate region counts into system headers. if (Body && SM.isInSystemHeader(SM.getSpellingLoc(getStart(Body)))) return; a743 2 if (S->getInit()) Visit(S->getInit()); a771 1 SourceLocation ExitLoc = getEnd(S); a772 5 // Ensure that handleFileExit recognizes when the end location is located // in a different file. MostRecentLocation = getStart(S); handleFileExit(ExitLoc); a797 3 if (S->getInit()) Visit(S->getInit()); d825 1 a825 6 // Handle macros that generate the "try" but not the rest. extendRegion(S->getTryBlock()); Counter ParentCount = getRegion().getCounter(); propagateCounts(ParentCount, S->getTryBlock()); d875 1 d877 1 a877 1 bool isMachO(const CodeGenModule &CGM) { d881 1 a881 1 StringRef getCoverageSection(const CodeGenModule &CGM) { a884 9 std::string normalizeFilename(StringRef Filename) { llvm::SmallString<256> Path(Filename); llvm::sys::fs::make_absolute(Path); llvm::sys::path::remove_dots(Path, /*remove_dot_dots=*/true); return Path.str().str(); } } // end anonymous namespace d914 1 a914 1 const std::string &CoverageMapping, bool IsUsed) { d932 1 a932 1 if (!IsUsed) d935 1 a935 1 CoverageMappings.push_back(CoverageMapping); a945 1 llvm::SmallVector FilenameStrs; a946 1 FilenameStrs.resize(FileEntries.size()); d948 2 a949 5 for (const auto &Entry : FileEntries) { auto I = Entry.second; FilenameStrs[I] = normalizeFilename(Entry.first->getName()); FilenameRefs[I] = FilenameStrs[I]; } d970 3 d974 1 a974 1 FilenameStrs[I] = normalizeFilename(Entry.first->getName()); d981 2 a982 4 std::string RawCoverageMappings = llvm::join(CoverageMappings.begin(), CoverageMappings.end(), ""); OS << RawCoverageMappings; size_t CoverageMappingSize = RawCoverageMappings.size(); d1038 1 a1038 1 llvm::getCoverageUnusedNamesVarName()); @ 1.1.1.5 log @Import clang r309604 from branches/release_50 @ text @d964 6 a969 4 std::string getCoverageSection(const CodeGenModule &CGM) { return llvm::getInstrProfSectionName( llvm::IPSK_covmap, CGM.getContext().getTargetInfo().getTriple().getObjectFormat()); @ 1.1.1.5.4.1 log @Sync with HEAD @ text @d32 1 a32 1 void CoverageSourceInfo::SourceRangeSkipped(SourceRange Range, SourceLocation) { d38 1 a38 1 /// A region of source code that can be mapped to a counter. d42 1 a42 1 /// The region's starting location. d45 1 a45 1 /// The region's ending location. a47 7 /// Whether this region should be emitted after its parent is emitted. bool DeferRegion; /// Whether this region is a gap region. The count from a gap region is set /// as the line execution count if there are no other regions on the line. bool GapRegion; d50 2 a51 4 Optional LocEnd, bool DeferRegion = false, bool GapRegion = false) : Count(Count), LocStart(LocStart), LocEnd(LocEnd), DeferRegion(DeferRegion), GapRegion(GapRegion) {} d68 1 a68 4 void setEndLoc(SourceLocation Loc) { assert(Loc.isValid() && "Setting an invalid end location"); LocEnd = Loc; } a73 41 bool isDeferred() const { return DeferRegion; } void setDeferred(bool Deferred) { DeferRegion = Deferred; } bool isGap() const { return GapRegion; } void setGap(bool Gap) { GapRegion = Gap; } }; /// Spelling locations for the start and end of a source region. struct SpellingRegion { /// The line where the region starts. unsigned LineStart; /// The column where the region starts. unsigned ColumnStart; /// The line where the region ends. unsigned LineEnd; /// The column where the region ends. unsigned ColumnEnd; SpellingRegion(SourceManager &SM, SourceLocation LocStart, SourceLocation LocEnd) { LineStart = SM.getSpellingLineNumber(LocStart); ColumnStart = SM.getSpellingColumnNumber(LocStart); LineEnd = SM.getSpellingLineNumber(LocEnd); ColumnEnd = SM.getSpellingColumnNumber(LocEnd); } SpellingRegion(SourceManager &SM, SourceMappingRegion &R) : SpellingRegion(SM, R.getStartLoc(), R.getEndLoc()) {} /// Check if the start and end locations appear in source order, i.e /// top->bottom, left->right. bool isInSourceOrder() const { return (LineStart < LineEnd) || (LineStart == LineEnd && ColumnStart <= ColumnEnd); } d76 1 a76 1 /// Provides the common functionality for the different d85 1 a85 1 /// Map of clang's FileIDs to IDs used for coverage mapping. d90 1 a90 1 /// The coverage mapping regions for this function d92 1 a92 1 /// The source mapping regions for this function. d95 1 a95 1 /// A set of regions which can be used as a filter. d107 1 a107 1 /// Return the precise end location for the given token. d116 1 a116 1 /// Return the start location of an included file or expanded macro. d123 1 a123 1 /// Return the end location of an included file or expanded macro. d131 1 a131 1 /// Find out where the current file is included or macro is expanded. d133 1 a133 1 return Loc.isMacroID() ? SM.getImmediateExpansionRange(Loc).getBegin() d137 1 a137 1 /// Return true if \c Loc is a location in a built-in macro. d142 1 a142 1 /// Check whether \c Loc is included or expanded from \c Parent. d152 1 a152 1 /// Get the start of \c S ignoring macro arguments and builtin macros. d156 1 a156 1 Loc = SM.getImmediateExpansionRange(Loc).getBegin(); d160 1 a160 1 /// Get the end of \c S ignoring macro arguments and builtin macros. d164 1 a164 1 Loc = SM.getImmediateExpansionRange(Loc).getBegin(); d168 1 a168 1 /// Find the set of files we have regions for and assign IDs d208 1 a208 1 /// Get the coverage mapping file ID for \c Loc. d218 1 a218 1 /// Gather all the regions that were skipped by the preprocessor d244 4 a247 1 SpellingRegion SR{SM, LocStart, LocEnd}; d249 1 a249 1 *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd); d251 1 a251 1 // the source code of this function. d258 1 a258 1 /// Generate the coverage counter mapping regions from collected d287 10 a296 13 // Find the spelling locations for the mapping region. SpellingRegion SR{SM, LocStart, LocEnd}; assert(SR.isInSourceOrder() && "region start and end out of order"); if (Region.isGap()) { MappingRegions.push_back(CounterMappingRegion::makeGapRegion( Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd)); } else { MappingRegions.push_back(CounterMappingRegion::makeRegion( Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd)); } d300 1 a300 1 /// Generate expansion regions for each virtual file we've seen. d320 5 a324 2 SpellingRegion SR{SM, ParentLoc, LocEnd}; assert(SR.isInSourceOrder() && "region start and end out of order"); d326 2 a327 2 *ParentFileID, *ExpandedFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd)); d333 1 a333 1 /// Creates unreachable coverage regions for the functions that d367 1 a367 1 /// Write the mapping data to the output stream d381 1 a381 1 /// A StmtVisitor that creates coverage mapping regions which map d386 1 a386 1 /// The map of statements to count values. d389 1 a389 1 /// A stack of currently live regions. a391 4 /// The currently deferred region: its end location and count can be set once /// its parent has been popped from the region stack. Optional DeferredRegion; d394 1 a394 1 /// A location in the most recently visited file or macro. d400 1 a400 4 /// Location of the last terminated region. Optional> LastTerminatedRegion; /// Return a counter for the subtraction of \c RHS from \c LHS d405 1 a405 1 /// Return a counter for the sum of \c LHS and \c RHS. d414 1 a414 1 /// Return the region counter for the given statement. d421 1 a421 1 /// Push a region onto the stack. d427 1 a427 1 if (StartLoc) { a428 2 completeDeferred(Count, MostRecentLocation); } d434 1 a434 63 /// Complete any pending deferred region by setting its end location and /// count, and then pushing it onto the region stack. size_t completeDeferred(Counter Count, SourceLocation DeferredEndLoc) { size_t Index = RegionStack.size(); if (!DeferredRegion) return Index; // Consume the pending region. SourceMappingRegion DR = DeferredRegion.getValue(); DeferredRegion = None; // If the region ends in an expansion, find the expansion site. FileID StartFile = SM.getFileID(DR.getStartLoc()); if (SM.getFileID(DeferredEndLoc) != StartFile) { if (isNestedIn(DeferredEndLoc, StartFile)) { do { DeferredEndLoc = getIncludeOrExpansionLoc(DeferredEndLoc); } while (StartFile != SM.getFileID(DeferredEndLoc)); } else { return Index; } } // The parent of this deferred region ends where the containing decl ends, // so the region isn't useful. if (DR.getStartLoc() == DeferredEndLoc) return Index; // If we're visiting statements in non-source order (e.g switch cases or // a loop condition) we can't construct a sensible deferred region. if (!SpellingRegion(SM, DR.getStartLoc(), DeferredEndLoc).isInSourceOrder()) return Index; DR.setGap(true); DR.setCounter(Count); DR.setEndLoc(DeferredEndLoc); handleFileExit(DeferredEndLoc); RegionStack.push_back(DR); return Index; } /// Complete a deferred region created after a terminated region at the /// top-level. void completeTopLevelDeferredRegion(Counter Count, SourceLocation DeferredEndLoc) { if (DeferredRegion || !LastTerminatedRegion) return; if (LastTerminatedRegion->second != RegionStack.size()) return; SourceLocation Start = LastTerminatedRegion->first; if (SM.getFileID(Start) != SM.getMainFileID()) return; SourceMappingRegion DR = RegionStack.back(); DR.setStartLoc(Start); DR.setDeferred(false); DeferredRegion = DR; completeDeferred(Count, DeferredEndLoc); } /// Pop regions from the stack into the function's list of regions. a439 1 bool ParentOfDeferredRegion = false; a469 1 assert(SpellingRegion(SM, Region).isInSourceOrder()); a470 16 if (ParentOfDeferredRegion) { ParentOfDeferredRegion = false; // If there's an existing deferred region, keep the old one, because // it means there are two consecutive returns (or a similar pattern). if (!DeferredRegion.hasValue() && // File IDs aren't gathered within macro expansions, so it isn't // useful to try and create a deferred region inside of one. !EndLoc.isMacroID()) DeferredRegion = SourceMappingRegion(Counter::getZero(), EndLoc, None); } } else if (Region.isDeferred()) { assert(!ParentOfDeferredRegion && "Consecutive deferred regions"); ParentOfDeferredRegion = true; a472 6 // If the zero region pushed after the last terminated region no longer // exists, clear its cached information. if (LastTerminatedRegion && RegionStack.size() < LastTerminatedRegion->second) LastTerminatedRegion = None; a473 1 assert(!ParentOfDeferredRegion && "Deferred region with no parent"); d476 1 a476 1 /// Return the currently active region. d482 1 a482 1 /// Propagate counts through the children of \c S. d484 1 a484 3 SourceLocation StartLoc = getStart(S); SourceLocation EndLoc = getEnd(S); size_t Index = pushRegion(TopCount, StartLoc, EndLoc); d491 2 a492 2 if (SM.isBeforeInTranslationUnit(StartLoc, S->getLocStart())) MostRecentLocation = EndLoc; d497 1 a497 1 /// Check whether a region with bounds \c StartLoc and \c EndLoc d508 1 a508 1 /// Adjust the most recently visited location to \c EndLoc. d525 1 a525 1 /// Adjust regions and state when \c NewLoc exits a file. d580 1 a580 1 if (StartLocs.insert(FileStart).second) { a582 2 assert(SpellingRegion(SM, SourceRegions.back()).isInSourceOrder()); } d590 1 a590 1 /// Ensure that \c S is included in the current region. a597 2 completeDeferred(Region.getCounter(), StartLoc); d600 1 a600 1 /// Mark \c S as a terminator, starting a zero region. a603 1 SourceLocation EndLoc = getEnd(S); d605 1 a605 1 Region.setEndLoc(EndLoc); a606 35 auto &ZeroRegion = getRegion(); ZeroRegion.setDeferred(true); LastTerminatedRegion = {EndLoc, RegionStack.size()}; } /// Find a valid gap range between \p AfterLoc and \p BeforeLoc. Optional findGapAreaBetween(SourceLocation AfterLoc, SourceLocation BeforeLoc) { // If the start and end locations of the gap are both within the same macro // file, the range may not be in source order. if (AfterLoc.isMacroID() || BeforeLoc.isMacroID()) return None; if (!SM.isWrittenInSameFile(AfterLoc, BeforeLoc)) return None; return {{AfterLoc, BeforeLoc}}; } /// Find the source range after \p AfterStmt and before \p BeforeStmt. Optional findGapAreaBetween(const Stmt *AfterStmt, const Stmt *BeforeStmt) { return findGapAreaBetween(getPreciseTokenLocEnd(getEnd(AfterStmt)), getStart(BeforeStmt)); } /// Emit a gap region between \p StartLoc and \p EndLoc with the given count. void fillGapAreaWithCount(SourceLocation StartLoc, SourceLocation EndLoc, Counter Count) { if (StartLoc == EndLoc) return; assert(SpellingRegion(SM, StartLoc, EndLoc).isInSourceOrder()); handleFileExit(StartLoc); size_t Index = pushRegion(Count, StartLoc, EndLoc); getRegion().setGap(true); handleFileExit(EndLoc); popRegions(Index); d609 1 a609 1 /// Keep counts of breaks and continues inside loops. d620 1 a620 2 : CoverageMappingBuilder(CVM, SM, LangOpts), CounterMap(CounterMap), DeferredRegion(None) {} d622 1 a622 1 /// Write the mapping data to the output stream a626 1 assert(!DeferredRegion && "Deferred region never completed"); a647 2 assert(!DeferredRegion && "Deferred region never completed"); a654 6 assert(RegionStack.empty() && "Regions entered but never exited"); // Discard the last uncompleted deferred region in a decl, if one exists. // This prevents lines at the end of a function containing only whitespace // or closing braces from being marked as uncovered. DeferredRegion = None; a673 1 Counter LabelCount = getRegionCounter(S); a674 2 completeTopLevelDeferredRegion(LabelCount, Start); completeDeferred(LabelCount, Start); d677 1 a677 1 pushRegion(LabelCount, Start); a684 2 // FIXME: a break in a switch should terminate regions for all preceding // case statements, not just the most recent one. a694 10 void VisitCallExpr(const CallExpr *E) { VisitStmt(E); // Terminate the region when we hit a noreturn function. // (This is helpful dealing with switch statements.) QualType CalleeType = E->getCallee()->getType(); if (getFunctionExtInfo(*CalleeType).getNoReturn()) terminateRegion(E); } a712 5 // The body count applies to the area immediately after the increment. auto Gap = findGapAreaBetween(S->getCond(), S->getBody()); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount); a747 4 // The loop increment may contain a break or continue. if (S->getInc()) BreakContinueStack.emplace_back(); d749 1 a749 1 BreakContinueStack.emplace_back(); d752 1 a752 1 BreakContinue BodyBC = BreakContinueStack.pop_back_val(); d756 2 a757 5 BreakContinue IncrementBC; if (const Stmt *Inc = S->getInc()) { propagateCounts(addCounters(BackedgeCount, BodyBC.ContinueCount), Inc); IncrementBC = BreakContinueStack.pop_back_val(); } d760 2 a761 3 Counter CondCount = addCounters( addCounters(ParentCount, BackedgeCount, BodyBC.ContinueCount), IncrementBC.ContinueCount); d767 2 a768 8 // The body count applies to the area immediately after the increment. auto Gap = findGapAreaBetween(getPreciseTokenLocEnd(S->getRParenLoc()), getStart(S->getBody())); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount); Counter OutCount = addCounters(BodyBC.BreakCount, IncrementBC.BreakCount, subtractCounters(CondCount, BodyCount)); a785 6 // The body count applies to the area immediately after the range. auto Gap = findGapAreaBetween(getPreciseTokenLocEnd(S->getRParenLoc()), getStart(S->getBody())); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount); a805 6 // The body count applies to the area immediately after the collection. auto Gap = findGapAreaBetween(getPreciseTokenLocEnd(S->getRParenLoc()), getStart(S->getBody())); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount); d826 4 a829 3 // Make a region for the body of the switch. If the body starts with // a case, that case will reuse this region; otherwise, this covers // the unreachable code at the beginning of the switch body. d831 2 a832 1 pushRegion(Counter::getZero(), getStart(CS->body_front())); a834 7 // Set the end for the body of the switch, if it isn't already set. for (size_t i = RegionStack.size(); i != Index; --i) { if (!RegionStack[i - 1].hasEndLoc()) RegionStack[i - 1].setEndLoc(getEnd(CS->body_back())); } a891 5 // The 'then' count applies to the area immediately after the condition. auto Gap = findGapAreaBetween(S->getCond(), S->getThen()); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), ThenCount); d897 1 a897 5 // The 'else' count applies to the area immediately after the 'then'. Gap = findGapAreaBetween(S->getThen(), Else); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), ElseCount); extendRegion(Else); a933 6 // The 'then' count applies to the area immediately after the condition. auto Gap = findGapAreaBetween(E->getQuestionLoc(), getStart(E->getTrueExpr())); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), TrueCount); a936 1 d943 2 a944 3 extendRegion(E->getLHS()); propagateCounts(getRegion().getCounter(), E->getLHS()); handleFileExit(getEnd(E->getLHS())); d951 2 a952 3 extendRegion(E->getLHS()); propagateCounts(getRegion().getCounter(), E->getLHS()); handleFileExit(getEnd(E->getLHS())); a994 3 case CounterMappingRegion::GapRegion: OS << "Gap,"; break; d1086 2 a1087 1 OS.write_zeros(8 - Rem); @ 1.1.1.5.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.5.2.1 log @Sync with HEAD @ text @d32 1 a32 1 void CoverageSourceInfo::SourceRangeSkipped(SourceRange Range, SourceLocation) { d38 1 a38 1 /// A region of source code that can be mapped to a counter. d42 1 a42 1 /// The region's starting location. d45 1 a45 1 /// The region's ending location. a47 7 /// Whether this region should be emitted after its parent is emitted. bool DeferRegion; /// Whether this region is a gap region. The count from a gap region is set /// as the line execution count if there are no other regions on the line. bool GapRegion; d50 2 a51 4 Optional LocEnd, bool DeferRegion = false, bool GapRegion = false) : Count(Count), LocStart(LocStart), LocEnd(LocEnd), DeferRegion(DeferRegion), GapRegion(GapRegion) {} d68 1 a68 4 void setEndLoc(SourceLocation Loc) { assert(Loc.isValid() && "Setting an invalid end location"); LocEnd = Loc; } a73 41 bool isDeferred() const { return DeferRegion; } void setDeferred(bool Deferred) { DeferRegion = Deferred; } bool isGap() const { return GapRegion; } void setGap(bool Gap) { GapRegion = Gap; } }; /// Spelling locations for the start and end of a source region. struct SpellingRegion { /// The line where the region starts. unsigned LineStart; /// The column where the region starts. unsigned ColumnStart; /// The line where the region ends. unsigned LineEnd; /// The column where the region ends. unsigned ColumnEnd; SpellingRegion(SourceManager &SM, SourceLocation LocStart, SourceLocation LocEnd) { LineStart = SM.getSpellingLineNumber(LocStart); ColumnStart = SM.getSpellingColumnNumber(LocStart); LineEnd = SM.getSpellingLineNumber(LocEnd); ColumnEnd = SM.getSpellingColumnNumber(LocEnd); } SpellingRegion(SourceManager &SM, SourceMappingRegion &R) : SpellingRegion(SM, R.getStartLoc(), R.getEndLoc()) {} /// Check if the start and end locations appear in source order, i.e /// top->bottom, left->right. bool isInSourceOrder() const { return (LineStart < LineEnd) || (LineStart == LineEnd && ColumnStart <= ColumnEnd); } d76 1 a76 1 /// Provides the common functionality for the different d85 1 a85 1 /// Map of clang's FileIDs to IDs used for coverage mapping. d90 1 a90 1 /// The coverage mapping regions for this function d92 1 a92 1 /// The source mapping regions for this function. d95 1 a95 1 /// A set of regions which can be used as a filter. d107 1 a107 1 /// Return the precise end location for the given token. d116 1 a116 1 /// Return the start location of an included file or expanded macro. d123 1 a123 1 /// Return the end location of an included file or expanded macro. d131 1 a131 1 /// Find out where the current file is included or macro is expanded. d133 1 a133 1 return Loc.isMacroID() ? SM.getImmediateExpansionRange(Loc).getBegin() d137 1 a137 1 /// Return true if \c Loc is a location in a built-in macro. d142 1 a142 1 /// Check whether \c Loc is included or expanded from \c Parent. d152 1 a152 1 /// Get the start of \c S ignoring macro arguments and builtin macros. d156 1 a156 1 Loc = SM.getImmediateExpansionRange(Loc).getBegin(); d160 1 a160 1 /// Get the end of \c S ignoring macro arguments and builtin macros. d164 1 a164 1 Loc = SM.getImmediateExpansionRange(Loc).getBegin(); d168 1 a168 1 /// Find the set of files we have regions for and assign IDs d208 1 a208 1 /// Get the coverage mapping file ID for \c Loc. d218 1 a218 1 /// Gather all the regions that were skipped by the preprocessor d244 4 a247 1 SpellingRegion SR{SM, LocStart, LocEnd}; d249 1 a249 1 *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd); d251 1 a251 1 // the source code of this function. d258 1 a258 1 /// Generate the coverage counter mapping regions from collected d287 10 a296 13 // Find the spelling locations for the mapping region. SpellingRegion SR{SM, LocStart, LocEnd}; assert(SR.isInSourceOrder() && "region start and end out of order"); if (Region.isGap()) { MappingRegions.push_back(CounterMappingRegion::makeGapRegion( Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd)); } else { MappingRegions.push_back(CounterMappingRegion::makeRegion( Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd)); } d300 1 a300 1 /// Generate expansion regions for each virtual file we've seen. d320 5 a324 2 SpellingRegion SR{SM, ParentLoc, LocEnd}; assert(SR.isInSourceOrder() && "region start and end out of order"); d326 2 a327 2 *ParentFileID, *ExpandedFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd)); d333 1 a333 1 /// Creates unreachable coverage regions for the functions that d367 1 a367 1 /// Write the mapping data to the output stream d381 1 a381 1 /// A StmtVisitor that creates coverage mapping regions which map d386 1 a386 1 /// The map of statements to count values. d389 1 a389 1 /// A stack of currently live regions. a391 4 /// The currently deferred region: its end location and count can be set once /// its parent has been popped from the region stack. Optional DeferredRegion; d394 1 a394 1 /// A location in the most recently visited file or macro. d400 1 a400 4 /// Location of the last terminated region. Optional> LastTerminatedRegion; /// Return a counter for the subtraction of \c RHS from \c LHS d405 1 a405 1 /// Return a counter for the sum of \c LHS and \c RHS. d414 1 a414 1 /// Return the region counter for the given statement. d421 1 a421 1 /// Push a region onto the stack. d427 1 a427 1 if (StartLoc) { a428 2 completeDeferred(Count, MostRecentLocation); } d434 1 a434 63 /// Complete any pending deferred region by setting its end location and /// count, and then pushing it onto the region stack. size_t completeDeferred(Counter Count, SourceLocation DeferredEndLoc) { size_t Index = RegionStack.size(); if (!DeferredRegion) return Index; // Consume the pending region. SourceMappingRegion DR = DeferredRegion.getValue(); DeferredRegion = None; // If the region ends in an expansion, find the expansion site. FileID StartFile = SM.getFileID(DR.getStartLoc()); if (SM.getFileID(DeferredEndLoc) != StartFile) { if (isNestedIn(DeferredEndLoc, StartFile)) { do { DeferredEndLoc = getIncludeOrExpansionLoc(DeferredEndLoc); } while (StartFile != SM.getFileID(DeferredEndLoc)); } else { return Index; } } // The parent of this deferred region ends where the containing decl ends, // so the region isn't useful. if (DR.getStartLoc() == DeferredEndLoc) return Index; // If we're visiting statements in non-source order (e.g switch cases or // a loop condition) we can't construct a sensible deferred region. if (!SpellingRegion(SM, DR.getStartLoc(), DeferredEndLoc).isInSourceOrder()) return Index; DR.setGap(true); DR.setCounter(Count); DR.setEndLoc(DeferredEndLoc); handleFileExit(DeferredEndLoc); RegionStack.push_back(DR); return Index; } /// Complete a deferred region created after a terminated region at the /// top-level. void completeTopLevelDeferredRegion(Counter Count, SourceLocation DeferredEndLoc) { if (DeferredRegion || !LastTerminatedRegion) return; if (LastTerminatedRegion->second != RegionStack.size()) return; SourceLocation Start = LastTerminatedRegion->first; if (SM.getFileID(Start) != SM.getMainFileID()) return; SourceMappingRegion DR = RegionStack.back(); DR.setStartLoc(Start); DR.setDeferred(false); DeferredRegion = DR; completeDeferred(Count, DeferredEndLoc); } /// Pop regions from the stack into the function's list of regions. a439 1 bool ParentOfDeferredRegion = false; a469 1 assert(SpellingRegion(SM, Region).isInSourceOrder()); a470 16 if (ParentOfDeferredRegion) { ParentOfDeferredRegion = false; // If there's an existing deferred region, keep the old one, because // it means there are two consecutive returns (or a similar pattern). if (!DeferredRegion.hasValue() && // File IDs aren't gathered within macro expansions, so it isn't // useful to try and create a deferred region inside of one. !EndLoc.isMacroID()) DeferredRegion = SourceMappingRegion(Counter::getZero(), EndLoc, None); } } else if (Region.isDeferred()) { assert(!ParentOfDeferredRegion && "Consecutive deferred regions"); ParentOfDeferredRegion = true; a472 6 // If the zero region pushed after the last terminated region no longer // exists, clear its cached information. if (LastTerminatedRegion && RegionStack.size() < LastTerminatedRegion->second) LastTerminatedRegion = None; a473 1 assert(!ParentOfDeferredRegion && "Deferred region with no parent"); d476 1 a476 1 /// Return the currently active region. d482 1 a482 1 /// Propagate counts through the children of \c S. d484 1 a484 3 SourceLocation StartLoc = getStart(S); SourceLocation EndLoc = getEnd(S); size_t Index = pushRegion(TopCount, StartLoc, EndLoc); d491 2 a492 2 if (SM.isBeforeInTranslationUnit(StartLoc, S->getLocStart())) MostRecentLocation = EndLoc; d497 1 a497 1 /// Check whether a region with bounds \c StartLoc and \c EndLoc d508 1 a508 1 /// Adjust the most recently visited location to \c EndLoc. d525 1 a525 1 /// Adjust regions and state when \c NewLoc exits a file. d580 1 a580 1 if (StartLocs.insert(FileStart).second) { a582 2 assert(SpellingRegion(SM, SourceRegions.back()).isInSourceOrder()); } d590 1 a590 1 /// Ensure that \c S is included in the current region. a597 2 completeDeferred(Region.getCounter(), StartLoc); d600 1 a600 1 /// Mark \c S as a terminator, starting a zero region. a603 1 SourceLocation EndLoc = getEnd(S); d605 1 a605 1 Region.setEndLoc(EndLoc); a606 35 auto &ZeroRegion = getRegion(); ZeroRegion.setDeferred(true); LastTerminatedRegion = {EndLoc, RegionStack.size()}; } /// Find a valid gap range between \p AfterLoc and \p BeforeLoc. Optional findGapAreaBetween(SourceLocation AfterLoc, SourceLocation BeforeLoc) { // If the start and end locations of the gap are both within the same macro // file, the range may not be in source order. if (AfterLoc.isMacroID() || BeforeLoc.isMacroID()) return None; if (!SM.isWrittenInSameFile(AfterLoc, BeforeLoc)) return None; return {{AfterLoc, BeforeLoc}}; } /// Find the source range after \p AfterStmt and before \p BeforeStmt. Optional findGapAreaBetween(const Stmt *AfterStmt, const Stmt *BeforeStmt) { return findGapAreaBetween(getPreciseTokenLocEnd(getEnd(AfterStmt)), getStart(BeforeStmt)); } /// Emit a gap region between \p StartLoc and \p EndLoc with the given count. void fillGapAreaWithCount(SourceLocation StartLoc, SourceLocation EndLoc, Counter Count) { if (StartLoc == EndLoc) return; assert(SpellingRegion(SM, StartLoc, EndLoc).isInSourceOrder()); handleFileExit(StartLoc); size_t Index = pushRegion(Count, StartLoc, EndLoc); getRegion().setGap(true); handleFileExit(EndLoc); popRegions(Index); d609 1 a609 1 /// Keep counts of breaks and continues inside loops. d620 1 a620 2 : CoverageMappingBuilder(CVM, SM, LangOpts), CounterMap(CounterMap), DeferredRegion(None) {} d622 1 a622 1 /// Write the mapping data to the output stream a626 1 assert(!DeferredRegion && "Deferred region never completed"); a647 2 assert(!DeferredRegion && "Deferred region never completed"); a654 6 assert(RegionStack.empty() && "Regions entered but never exited"); // Discard the last uncompleted deferred region in a decl, if one exists. // This prevents lines at the end of a function containing only whitespace // or closing braces from being marked as uncovered. DeferredRegion = None; a673 1 Counter LabelCount = getRegionCounter(S); a674 2 completeTopLevelDeferredRegion(LabelCount, Start); completeDeferred(LabelCount, Start); d677 1 a677 1 pushRegion(LabelCount, Start); a684 2 // FIXME: a break in a switch should terminate regions for all preceding // case statements, not just the most recent one. a694 10 void VisitCallExpr(const CallExpr *E) { VisitStmt(E); // Terminate the region when we hit a noreturn function. // (This is helpful dealing with switch statements.) QualType CalleeType = E->getCallee()->getType(); if (getFunctionExtInfo(*CalleeType).getNoReturn()) terminateRegion(E); } a712 5 // The body count applies to the area immediately after the increment. auto Gap = findGapAreaBetween(S->getCond(), S->getBody()); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount); a747 4 // The loop increment may contain a break or continue. if (S->getInc()) BreakContinueStack.emplace_back(); d749 1 a749 1 BreakContinueStack.emplace_back(); d752 1 a752 1 BreakContinue BodyBC = BreakContinueStack.pop_back_val(); d756 2 a757 5 BreakContinue IncrementBC; if (const Stmt *Inc = S->getInc()) { propagateCounts(addCounters(BackedgeCount, BodyBC.ContinueCount), Inc); IncrementBC = BreakContinueStack.pop_back_val(); } d760 2 a761 3 Counter CondCount = addCounters( addCounters(ParentCount, BackedgeCount, BodyBC.ContinueCount), IncrementBC.ContinueCount); d767 2 a768 8 // The body count applies to the area immediately after the increment. auto Gap = findGapAreaBetween(getPreciseTokenLocEnd(S->getRParenLoc()), getStart(S->getBody())); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount); Counter OutCount = addCounters(BodyBC.BreakCount, IncrementBC.BreakCount, subtractCounters(CondCount, BodyCount)); a785 6 // The body count applies to the area immediately after the range. auto Gap = findGapAreaBetween(getPreciseTokenLocEnd(S->getRParenLoc()), getStart(S->getBody())); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount); a805 6 // The body count applies to the area immediately after the collection. auto Gap = findGapAreaBetween(getPreciseTokenLocEnd(S->getRParenLoc()), getStart(S->getBody())); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount); d826 4 a829 3 // Make a region for the body of the switch. If the body starts with // a case, that case will reuse this region; otherwise, this covers // the unreachable code at the beginning of the switch body. d831 2 a832 1 pushRegion(Counter::getZero(), getStart(CS->body_front())); a834 7 // Set the end for the body of the switch, if it isn't already set. for (size_t i = RegionStack.size(); i != Index; --i) { if (!RegionStack[i - 1].hasEndLoc()) RegionStack[i - 1].setEndLoc(getEnd(CS->body_back())); } a891 5 // The 'then' count applies to the area immediately after the condition. auto Gap = findGapAreaBetween(S->getCond(), S->getThen()); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), ThenCount); d897 1 a897 5 // The 'else' count applies to the area immediately after the 'then'. Gap = findGapAreaBetween(S->getThen(), Else); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), ElseCount); extendRegion(Else); a933 6 // The 'then' count applies to the area immediately after the condition. auto Gap = findGapAreaBetween(E->getQuestionLoc(), getStart(E->getTrueExpr())); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), TrueCount); a936 1 d943 2 a944 3 extendRegion(E->getLHS()); propagateCounts(getRegion().getCounter(), E->getLHS()); handleFileExit(getEnd(E->getLHS())); d951 2 a952 3 extendRegion(E->getLHS()); propagateCounts(getRegion().getCounter(), E->getLHS()); handleFileExit(getEnd(E->getLHS())); a994 3 case CounterMappingRegion::GapRegion: OS << "Gap,"; break; d1086 2 a1087 1 OS.write_zeros(8 - Rem); @ 1.1.1.6 log @Import clang r337282 from trunk @ text @d32 1 a32 1 void CoverageSourceInfo::SourceRangeSkipped(SourceRange Range, SourceLocation) { d38 1 a38 1 /// A region of source code that can be mapped to a counter. d42 1 a42 1 /// The region's starting location. d45 1 a45 1 /// The region's ending location. a47 7 /// Whether this region should be emitted after its parent is emitted. bool DeferRegion; /// Whether this region is a gap region. The count from a gap region is set /// as the line execution count if there are no other regions on the line. bool GapRegion; d50 2 a51 4 Optional LocEnd, bool DeferRegion = false, bool GapRegion = false) : Count(Count), LocStart(LocStart), LocEnd(LocEnd), DeferRegion(DeferRegion), GapRegion(GapRegion) {} d68 1 a68 4 void setEndLoc(SourceLocation Loc) { assert(Loc.isValid() && "Setting an invalid end location"); LocEnd = Loc; } a73 41 bool isDeferred() const { return DeferRegion; } void setDeferred(bool Deferred) { DeferRegion = Deferred; } bool isGap() const { return GapRegion; } void setGap(bool Gap) { GapRegion = Gap; } }; /// Spelling locations for the start and end of a source region. struct SpellingRegion { /// The line where the region starts. unsigned LineStart; /// The column where the region starts. unsigned ColumnStart; /// The line where the region ends. unsigned LineEnd; /// The column where the region ends. unsigned ColumnEnd; SpellingRegion(SourceManager &SM, SourceLocation LocStart, SourceLocation LocEnd) { LineStart = SM.getSpellingLineNumber(LocStart); ColumnStart = SM.getSpellingColumnNumber(LocStart); LineEnd = SM.getSpellingLineNumber(LocEnd); ColumnEnd = SM.getSpellingColumnNumber(LocEnd); } SpellingRegion(SourceManager &SM, SourceMappingRegion &R) : SpellingRegion(SM, R.getStartLoc(), R.getEndLoc()) {} /// Check if the start and end locations appear in source order, i.e /// top->bottom, left->right. bool isInSourceOrder() const { return (LineStart < LineEnd) || (LineStart == LineEnd && ColumnStart <= ColumnEnd); } d76 1 a76 1 /// Provides the common functionality for the different d85 1 a85 1 /// Map of clang's FileIDs to IDs used for coverage mapping. d90 1 a90 1 /// The coverage mapping regions for this function d92 1 a92 1 /// The source mapping regions for this function. d95 1 a95 1 /// A set of regions which can be used as a filter. d107 1 a107 1 /// Return the precise end location for the given token. d116 1 a116 1 /// Return the start location of an included file or expanded macro. d123 1 a123 1 /// Return the end location of an included file or expanded macro. d131 1 a131 1 /// Find out where the current file is included or macro is expanded. d133 1 a133 1 return Loc.isMacroID() ? SM.getImmediateExpansionRange(Loc).getBegin() d137 1 a137 1 /// Return true if \c Loc is a location in a built-in macro. d142 1 a142 1 /// Check whether \c Loc is included or expanded from \c Parent. d152 1 a152 1 /// Get the start of \c S ignoring macro arguments and builtin macros. d156 1 a156 1 Loc = SM.getImmediateExpansionRange(Loc).getBegin(); d160 1 a160 1 /// Get the end of \c S ignoring macro arguments and builtin macros. d164 1 a164 1 Loc = SM.getImmediateExpansionRange(Loc).getBegin(); d168 1 a168 1 /// Find the set of files we have regions for and assign IDs d208 1 a208 1 /// Get the coverage mapping file ID for \c Loc. d218 1 a218 1 /// Gather all the regions that were skipped by the preprocessor d244 4 a247 1 SpellingRegion SR{SM, LocStart, LocEnd}; d249 1 a249 1 *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd); d251 1 a251 1 // the source code of this function. d258 1 a258 1 /// Generate the coverage counter mapping regions from collected d287 10 a296 13 // Find the spelling locations for the mapping region. SpellingRegion SR{SM, LocStart, LocEnd}; assert(SR.isInSourceOrder() && "region start and end out of order"); if (Region.isGap()) { MappingRegions.push_back(CounterMappingRegion::makeGapRegion( Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd)); } else { MappingRegions.push_back(CounterMappingRegion::makeRegion( Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd)); } d300 1 a300 1 /// Generate expansion regions for each virtual file we've seen. d320 5 a324 2 SpellingRegion SR{SM, ParentLoc, LocEnd}; assert(SR.isInSourceOrder() && "region start and end out of order"); d326 2 a327 2 *ParentFileID, *ExpandedFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd)); d333 1 a333 1 /// Creates unreachable coverage regions for the functions that d367 1 a367 1 /// Write the mapping data to the output stream d381 1 a381 1 /// A StmtVisitor that creates coverage mapping regions which map d386 1 a386 1 /// The map of statements to count values. d389 1 a389 1 /// A stack of currently live regions. a391 4 /// The currently deferred region: its end location and count can be set once /// its parent has been popped from the region stack. Optional DeferredRegion; d394 1 a394 1 /// A location in the most recently visited file or macro. d400 1 a400 4 /// Location of the last terminated region. Optional> LastTerminatedRegion; /// Return a counter for the subtraction of \c RHS from \c LHS d405 1 a405 1 /// Return a counter for the sum of \c LHS and \c RHS. d414 1 a414 1 /// Return the region counter for the given statement. d421 1 a421 1 /// Push a region onto the stack. d427 1 a427 1 if (StartLoc) { a428 2 completeDeferred(Count, MostRecentLocation); } d434 1 a434 63 /// Complete any pending deferred region by setting its end location and /// count, and then pushing it onto the region stack. size_t completeDeferred(Counter Count, SourceLocation DeferredEndLoc) { size_t Index = RegionStack.size(); if (!DeferredRegion) return Index; // Consume the pending region. SourceMappingRegion DR = DeferredRegion.getValue(); DeferredRegion = None; // If the region ends in an expansion, find the expansion site. FileID StartFile = SM.getFileID(DR.getStartLoc()); if (SM.getFileID(DeferredEndLoc) != StartFile) { if (isNestedIn(DeferredEndLoc, StartFile)) { do { DeferredEndLoc = getIncludeOrExpansionLoc(DeferredEndLoc); } while (StartFile != SM.getFileID(DeferredEndLoc)); } else { return Index; } } // The parent of this deferred region ends where the containing decl ends, // so the region isn't useful. if (DR.getStartLoc() == DeferredEndLoc) return Index; // If we're visiting statements in non-source order (e.g switch cases or // a loop condition) we can't construct a sensible deferred region. if (!SpellingRegion(SM, DR.getStartLoc(), DeferredEndLoc).isInSourceOrder()) return Index; DR.setGap(true); DR.setCounter(Count); DR.setEndLoc(DeferredEndLoc); handleFileExit(DeferredEndLoc); RegionStack.push_back(DR); return Index; } /// Complete a deferred region created after a terminated region at the /// top-level. void completeTopLevelDeferredRegion(Counter Count, SourceLocation DeferredEndLoc) { if (DeferredRegion || !LastTerminatedRegion) return; if (LastTerminatedRegion->second != RegionStack.size()) return; SourceLocation Start = LastTerminatedRegion->first; if (SM.getFileID(Start) != SM.getMainFileID()) return; SourceMappingRegion DR = RegionStack.back(); DR.setStartLoc(Start); DR.setDeferred(false); DeferredRegion = DR; completeDeferred(Count, DeferredEndLoc); } /// Pop regions from the stack into the function's list of regions. a439 1 bool ParentOfDeferredRegion = false; a469 1 assert(SpellingRegion(SM, Region).isInSourceOrder()); a470 16 if (ParentOfDeferredRegion) { ParentOfDeferredRegion = false; // If there's an existing deferred region, keep the old one, because // it means there are two consecutive returns (or a similar pattern). if (!DeferredRegion.hasValue() && // File IDs aren't gathered within macro expansions, so it isn't // useful to try and create a deferred region inside of one. !EndLoc.isMacroID()) DeferredRegion = SourceMappingRegion(Counter::getZero(), EndLoc, None); } } else if (Region.isDeferred()) { assert(!ParentOfDeferredRegion && "Consecutive deferred regions"); ParentOfDeferredRegion = true; a472 6 // If the zero region pushed after the last terminated region no longer // exists, clear its cached information. if (LastTerminatedRegion && RegionStack.size() < LastTerminatedRegion->second) LastTerminatedRegion = None; a473 1 assert(!ParentOfDeferredRegion && "Deferred region with no parent"); d476 1 a476 1 /// Return the currently active region. d482 1 a482 1 /// Propagate counts through the children of \c S. d484 1 a484 3 SourceLocation StartLoc = getStart(S); SourceLocation EndLoc = getEnd(S); size_t Index = pushRegion(TopCount, StartLoc, EndLoc); d491 2 a492 2 if (SM.isBeforeInTranslationUnit(StartLoc, S->getLocStart())) MostRecentLocation = EndLoc; d497 1 a497 1 /// Check whether a region with bounds \c StartLoc and \c EndLoc d508 1 a508 1 /// Adjust the most recently visited location to \c EndLoc. d525 1 a525 1 /// Adjust regions and state when \c NewLoc exits a file. d580 1 a580 1 if (StartLocs.insert(FileStart).second) { a582 2 assert(SpellingRegion(SM, SourceRegions.back()).isInSourceOrder()); } d590 1 a590 1 /// Ensure that \c S is included in the current region. a597 2 completeDeferred(Region.getCounter(), StartLoc); d600 1 a600 1 /// Mark \c S as a terminator, starting a zero region. a603 1 SourceLocation EndLoc = getEnd(S); d605 1 a605 1 Region.setEndLoc(EndLoc); a606 35 auto &ZeroRegion = getRegion(); ZeroRegion.setDeferred(true); LastTerminatedRegion = {EndLoc, RegionStack.size()}; } /// Find a valid gap range between \p AfterLoc and \p BeforeLoc. Optional findGapAreaBetween(SourceLocation AfterLoc, SourceLocation BeforeLoc) { // If the start and end locations of the gap are both within the same macro // file, the range may not be in source order. if (AfterLoc.isMacroID() || BeforeLoc.isMacroID()) return None; if (!SM.isWrittenInSameFile(AfterLoc, BeforeLoc)) return None; return {{AfterLoc, BeforeLoc}}; } /// Find the source range after \p AfterStmt and before \p BeforeStmt. Optional findGapAreaBetween(const Stmt *AfterStmt, const Stmt *BeforeStmt) { return findGapAreaBetween(getPreciseTokenLocEnd(getEnd(AfterStmt)), getStart(BeforeStmt)); } /// Emit a gap region between \p StartLoc and \p EndLoc with the given count. void fillGapAreaWithCount(SourceLocation StartLoc, SourceLocation EndLoc, Counter Count) { if (StartLoc == EndLoc) return; assert(SpellingRegion(SM, StartLoc, EndLoc).isInSourceOrder()); handleFileExit(StartLoc); size_t Index = pushRegion(Count, StartLoc, EndLoc); getRegion().setGap(true); handleFileExit(EndLoc); popRegions(Index); d609 1 a609 1 /// Keep counts of breaks and continues inside loops. d620 1 a620 2 : CoverageMappingBuilder(CVM, SM, LangOpts), CounterMap(CounterMap), DeferredRegion(None) {} d622 1 a622 1 /// Write the mapping data to the output stream a626 1 assert(!DeferredRegion && "Deferred region never completed"); a647 2 assert(!DeferredRegion && "Deferred region never completed"); a654 6 assert(RegionStack.empty() && "Regions entered but never exited"); // Discard the last uncompleted deferred region in a decl, if one exists. // This prevents lines at the end of a function containing only whitespace // or closing braces from being marked as uncovered. DeferredRegion = None; a673 1 Counter LabelCount = getRegionCounter(S); a674 2 completeTopLevelDeferredRegion(LabelCount, Start); completeDeferred(LabelCount, Start); d677 1 a677 1 pushRegion(LabelCount, Start); a684 2 // FIXME: a break in a switch should terminate regions for all preceding // case statements, not just the most recent one. a694 10 void VisitCallExpr(const CallExpr *E) { VisitStmt(E); // Terminate the region when we hit a noreturn function. // (This is helpful dealing with switch statements.) QualType CalleeType = E->getCallee()->getType(); if (getFunctionExtInfo(*CalleeType).getNoReturn()) terminateRegion(E); } a712 5 // The body count applies to the area immediately after the increment. auto Gap = findGapAreaBetween(S->getCond(), S->getBody()); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount); a747 4 // The loop increment may contain a break or continue. if (S->getInc()) BreakContinueStack.emplace_back(); d749 1 a749 1 BreakContinueStack.emplace_back(); d752 1 a752 1 BreakContinue BodyBC = BreakContinueStack.pop_back_val(); d756 2 a757 5 BreakContinue IncrementBC; if (const Stmt *Inc = S->getInc()) { propagateCounts(addCounters(BackedgeCount, BodyBC.ContinueCount), Inc); IncrementBC = BreakContinueStack.pop_back_val(); } d760 2 a761 3 Counter CondCount = addCounters( addCounters(ParentCount, BackedgeCount, BodyBC.ContinueCount), IncrementBC.ContinueCount); d767 2 a768 8 // The body count applies to the area immediately after the increment. auto Gap = findGapAreaBetween(getPreciseTokenLocEnd(S->getRParenLoc()), getStart(S->getBody())); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount); Counter OutCount = addCounters(BodyBC.BreakCount, IncrementBC.BreakCount, subtractCounters(CondCount, BodyCount)); a785 6 // The body count applies to the area immediately after the range. auto Gap = findGapAreaBetween(getPreciseTokenLocEnd(S->getRParenLoc()), getStart(S->getBody())); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount); a805 6 // The body count applies to the area immediately after the collection. auto Gap = findGapAreaBetween(getPreciseTokenLocEnd(S->getRParenLoc()), getStart(S->getBody())); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount); d826 4 a829 3 // Make a region for the body of the switch. If the body starts with // a case, that case will reuse this region; otherwise, this covers // the unreachable code at the beginning of the switch body. d831 2 a832 1 pushRegion(Counter::getZero(), getStart(CS->body_front())); a834 7 // Set the end for the body of the switch, if it isn't already set. for (size_t i = RegionStack.size(); i != Index; --i) { if (!RegionStack[i - 1].hasEndLoc()) RegionStack[i - 1].setEndLoc(getEnd(CS->body_back())); } a891 5 // The 'then' count applies to the area immediately after the condition. auto Gap = findGapAreaBetween(S->getCond(), S->getThen()); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), ThenCount); d897 1 a897 5 // The 'else' count applies to the area immediately after the 'then'. Gap = findGapAreaBetween(S->getThen(), Else); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), ElseCount); extendRegion(Else); a933 6 // The 'then' count applies to the area immediately after the condition. auto Gap = findGapAreaBetween(E->getQuestionLoc(), getStart(E->getTrueExpr())); if (Gap) fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), TrueCount); a936 1 d943 2 a944 3 extendRegion(E->getLHS()); propagateCounts(getRegion().getCounter(), E->getLHS()); handleFileExit(getEnd(E->getLHS())); d951 2 a952 3 extendRegion(E->getLHS()); propagateCounts(getRegion().getCounter(), E->getLHS()); handleFileExit(getEnd(E->getLHS())); a994 3 case CounterMappingRegion::GapRegion: OS << "Gap,"; break; d1086 2 a1087 1 OS.write_zeros(8 - Rem); @ 1.1.1.7 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.1.4.1 log @file CoverageMappingGen.cpp was added on branch tls-maxphys on 2014-08-19 23:47:27 +0000 @ text @d1 1217 @ 1.1.1.1.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 1217 //===--- CoverageMappingGen.cpp - Coverage mapping generation ---*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Instrumentation-based code coverage mapping generator // //===----------------------------------------------------------------------===// #include "CoverageMappingGen.h" #include "CodeGenFunction.h" #include "clang/AST/StmtVisitor.h" #include "clang/Lex/Lexer.h" #include "llvm/ProfileData/InstrProfReader.h" #include "llvm/ProfileData/CoverageMapping.h" #include "llvm/ProfileData/CoverageMappingWriter.h" #include "llvm/ProfileData/CoverageMappingReader.h" #include "llvm/Support/FileSystem.h" using namespace clang; using namespace CodeGen; using namespace llvm::coverage; void CoverageSourceInfo::SourceRangeSkipped(SourceRange Range) { SkippedRanges.push_back(Range); } namespace { /// \brief A region of source code that can be mapped to a counter. struct SourceMappingRegion { enum RegionFlags { /// \brief This region won't be emitted if it wasn't extended. /// This is useful so that we won't emit source ranges for single tokens /// that we don't really care that much about, like: /// the '(' token in #define MACRO ( IgnoreIfNotExtended = 0x0001, }; FileID File, MacroArgumentFile; Counter Count; /// \brief A statement that initiated the count of Zero. /// /// This initiator statement is useful to prevent merging of unreachable /// regions with different statements that caused the counter to become /// unreachable. const Stmt *UnreachableInitiator; /// \brief A statement that separates certain mapping regions into groups. /// /// The group statement is sometimes useful when we are emitting the source /// regions not in their correct lexical order, e.g. the regions for the /// incrementation expression in the 'for' construct. By marking the regions /// in the incrementation expression with the group statement, we avoid the /// merging of the regions from the incrementation expression and the loop's /// body. const Stmt *Group; /// \brief The region's starting location. SourceLocation LocStart; /// \brief The region's ending location. SourceLocation LocEnd, AlternativeLocEnd; unsigned Flags; CounterMappingRegion::RegionKind Kind; SourceMappingRegion(FileID File, FileID MacroArgumentFile, Counter Count, const Stmt *UnreachableInitiator, const Stmt *Group, SourceLocation LocStart, SourceLocation LocEnd, unsigned Flags = 0, CounterMappingRegion::RegionKind Kind = CounterMappingRegion::CodeRegion) : File(File), MacroArgumentFile(MacroArgumentFile), Count(Count), UnreachableInitiator(UnreachableInitiator), Group(Group), LocStart(LocStart), LocEnd(LocEnd), AlternativeLocEnd(LocStart), Flags(Flags), Kind(Kind) {} bool hasFlag(RegionFlags Flag) const { return (Flags & Flag) != 0; } void setFlag(RegionFlags Flag) { Flags |= Flag; } void clearFlag(RegionFlags Flag) { Flags &= ~Flag; } /// \brief Return true if two regions can be merged together. bool isMergeable(SourceMappingRegion &R) { return File == R.File && MacroArgumentFile == R.MacroArgumentFile && Count == R.Count && UnreachableInitiator == R.UnreachableInitiator && Group == R.Group && Kind == R.Kind; } /// \brief Merge two regions by extending the 'this' region to cover the /// given region. void mergeByExtendingTo(SourceMappingRegion &R) { LocEnd = R.LocEnd; AlternativeLocEnd = R.LocStart; if (hasFlag(IgnoreIfNotExtended)) clearFlag(IgnoreIfNotExtended); } }; /// \brief The state of the coverage mapping builder. struct SourceMappingState { Counter CurrentRegionCount; const Stmt *CurrentSourceGroup; const Stmt *CurrentUnreachableRegionInitiator; SourceMappingState(Counter CurrentRegionCount, const Stmt *CurrentSourceGroup, const Stmt *CurrentUnreachableRegionInitiator) : CurrentRegionCount(CurrentRegionCount), CurrentSourceGroup(CurrentSourceGroup), CurrentUnreachableRegionInitiator(CurrentUnreachableRegionInitiator) {} }; /// \brief Provides the common functionality for the different /// coverage mapping region builders. class CoverageMappingBuilder { public: CoverageMappingModuleGen &CVM; SourceManager &SM; const LangOptions &LangOpts; private: struct FileInfo { /// \brief The file id that will be used by the coverage mapping system. unsigned CovMappingFileID; const FileEntry *Entry; FileInfo(unsigned CovMappingFileID, const FileEntry *Entry) : CovMappingFileID(CovMappingFileID), Entry(Entry) {} }; /// \brief This mapping maps clang's FileIDs to file ids used /// by the coverage mapping system and clang's file entries. llvm::SmallDenseMap FileIDMapping; public: /// \brief The statement that corresponds to the current source group. const Stmt *CurrentSourceGroup; /// \brief The statement the initiated the current unreachable region. const Stmt *CurrentUnreachableRegionInitiator; /// \brief The coverage mapping regions for this function llvm::SmallVector MappingRegions; /// \brief The source mapping regions for this function. llvm::SmallVector SourceRegions; CoverageMappingBuilder(CoverageMappingModuleGen &CVM, SourceManager &SM, const LangOptions &LangOpts) : CVM(CVM), SM(SM), LangOpts(LangOpts), CurrentSourceGroup(nullptr), CurrentUnreachableRegionInitiator(nullptr) {} /// \brief Return the precise end location for the given token. SourceLocation getPreciseTokenLocEnd(SourceLocation Loc) { return Lexer::getLocForEndOfToken(SM.getSpellingLoc(Loc), 0, SM, LangOpts); } /// \brief Create the mapping that maps from the function's file ids to /// the indices for the translation unit's filenames. void createFileIDMapping(SmallVectorImpl &Mapping) { Mapping.resize(FileIDMapping.size(), 0); for (const auto &I : FileIDMapping) Mapping[I.second.CovMappingFileID] = CVM.getFileID(I.second.Entry); } /// \brief Get the coverage mapping file id that corresponds to the given /// clang file id. If such file id doesn't exist, it gets added to the /// mapping that maps from clang's file ids to coverage mapping file ids. /// Return true if there was an error getting the coverage mapping file id. /// An example of an when this function fails is when the region tries /// to get a coverage file id for a location in a built-in macro. bool getCoverageFileID(SourceLocation LocStart, FileID File, FileID SpellingFile, unsigned &Result) { auto Mapping = FileIDMapping.find(File); if (Mapping != FileIDMapping.end()) { Result = Mapping->second.CovMappingFileID; return false; } auto Entry = SM.getFileEntryForID(SpellingFile); if (!Entry) return true; Result = FileIDMapping.size(); FileIDMapping.insert(std::make_pair(File, FileInfo(Result, Entry))); createFileExpansionRegion(LocStart, File); return false; } /// \brief Get the coverage mapping file id that corresponds to the given /// clang file id. /// Return true if there was an error getting the coverage mapping file id. bool getExistingCoverageFileID(FileID File, unsigned &Result) { // Make sure that the file is valid. if (File.isInvalid()) return true; auto Mapping = FileIDMapping.find(File); if (Mapping != FileIDMapping.end()) { Result = Mapping->second.CovMappingFileID; return false; } return true; } /// \brief Return true if the given clang's file id has a corresponding /// coverage file id. bool hasExistingCoverageFileID(FileID File) const { return FileIDMapping.count(File); } /// \brief Gather all the regions that were skipped by the preprocessor /// using the constructs like #if. void gatherSkippedRegions() { /// An array of the minimum lineStarts and the maximum lineEnds /// for mapping regions from the appropriate source files. llvm::SmallVector, 8> FileLineRanges; FileLineRanges.resize( FileIDMapping.size(), std::make_pair(std::numeric_limits::max(), 0)); for (const auto &R : MappingRegions) { FileLineRanges[R.FileID].first = std::min(FileLineRanges[R.FileID].first, R.LineStart); FileLineRanges[R.FileID].second = std::max(FileLineRanges[R.FileID].second, R.LineEnd); } auto SkippedRanges = CVM.getSourceInfo().getSkippedRanges(); for (const auto &I : SkippedRanges) { auto LocStart = I.getBegin(); auto LocEnd = I.getEnd(); auto FileStart = SM.getFileID(LocStart); if (!hasExistingCoverageFileID(FileStart)) continue; auto ActualFileStart = SM.getDecomposedSpellingLoc(LocStart).first; if (ActualFileStart != SM.getDecomposedSpellingLoc(LocEnd).first) // Ignore regions that span across multiple files. continue; unsigned CovFileID; if (getCoverageFileID(LocStart, FileStart, ActualFileStart, CovFileID)) continue; unsigned LineStart = SM.getSpellingLineNumber(LocStart); unsigned ColumnStart = SM.getSpellingColumnNumber(LocStart); unsigned LineEnd = SM.getSpellingLineNumber(LocEnd); unsigned ColumnEnd = SM.getSpellingColumnNumber(LocEnd); CounterMappingRegion Region(Counter(), CovFileID, LineStart, ColumnStart, LineEnd, ColumnEnd, false, CounterMappingRegion::SkippedRegion); // Make sure that we only collect the regions that are inside // the souce code of this function. if (Region.LineStart >= FileLineRanges[CovFileID].first && Region.LineEnd <= FileLineRanges[CovFileID].second) MappingRegions.push_back(Region); } } /// \brief Create a mapping region that correponds to an expansion of /// a macro or an embedded include. void createFileExpansionRegion(SourceLocation Loc, FileID ExpandedFile) { SourceLocation LocStart; if (Loc.isMacroID()) LocStart = SM.getImmediateExpansionRange(Loc).first; else { LocStart = SM.getIncludeLoc(ExpandedFile); if (LocStart.isInvalid()) return; // This file has no expansion region. } auto File = SM.getFileID(LocStart); auto SpellingFile = SM.getDecomposedSpellingLoc(LocStart).first; unsigned CovFileID, ExpandedFileID; if (getExistingCoverageFileID(ExpandedFile, ExpandedFileID)) return; if (getCoverageFileID(LocStart, File, SpellingFile, CovFileID)) return; unsigned LineStart = SM.getSpellingLineNumber(LocStart); unsigned ColumnStart = SM.getSpellingColumnNumber(LocStart); unsigned LineEnd = LineStart; // Compute the end column manually as Lexer::getLocForEndOfToken doesn't // give the correct result in all cases. unsigned ColumnEnd = ColumnStart + Lexer::MeasureTokenLength(SM.getSpellingLoc(LocStart), SM, LangOpts); MappingRegions.push_back(CounterMappingRegion( Counter(), CovFileID, LineStart, ColumnStart, LineEnd, ColumnEnd, false, CounterMappingRegion::ExpansionRegion)); MappingRegions.back().ExpandedFileID = ExpandedFileID; } /// \brief Enter a source region group that is identified by the given /// statement. /// It's not possible to enter a group when there is already /// another group present. void beginSourceRegionGroup(const Stmt *Group) { assert(!CurrentSourceGroup); CurrentSourceGroup = Group; } /// \brief Exit the current source region group. void endSourceRegionGroup() { CurrentSourceGroup = nullptr; } /// \brief Brings a region that has the same counter and file to the back /// of the source regions array. void bringSimilarRegionBack(Counter Count, FileID File, FileID MacroArgumentFile, const Stmt *UnreachableInitiator, const Stmt *SourceGroup) { for (size_t I = SourceRegions.size(); I != 0;) { --I; if (SourceRegions[I].Count == Count && SourceRegions[I].File == File && SourceRegions[I].MacroArgumentFile == MacroArgumentFile && SourceRegions[I].UnreachableInitiator == UnreachableInitiator && SourceRegions[I].Group == SourceGroup) { if (I != SourceRegions.size() - 1) std::swap(SourceRegions[I], SourceRegions.back()); return; } } } /// \brief Associate a counter with a given source code range. void mapSourceCodeRange(SourceLocation LocStart, SourceLocation LocEnd, Counter Count, const Stmt *UnreachableInitiator, const Stmt *SourceGroup, unsigned Flags = 0, FileID MacroArgumentFile = FileID()) { if (SM.isMacroArgExpansion(LocStart)) { // Map the code range with the macro argument's value. mapSourceCodeRange(SM.getImmediateSpellingLoc(LocStart), SM.getImmediateSpellingLoc(LocEnd), Count, UnreachableInitiator, SourceGroup, Flags, SM.getFileID(LocStart)); // Map the code range where the macro argument is referenced. SourceLocation RefLocStart(SM.getImmediateExpansionRange(LocStart).first); SourceLocation RefLocEnd(RefLocStart); if (SM.isMacroArgExpansion(RefLocStart)) mapSourceCodeRange(RefLocStart, RefLocEnd, Count, UnreachableInitiator, SourceGroup, 0, SM.getFileID(RefLocStart)); else mapSourceCodeRange(RefLocStart, RefLocEnd, Count, UnreachableInitiator, SourceGroup); return; } auto File = SM.getFileID(LocStart); // Make sure that the file id is valid. if (File.isInvalid()) return; bringSimilarRegionBack(Count, File, MacroArgumentFile, UnreachableInitiator, SourceGroup); SourceMappingRegion R(File, MacroArgumentFile, Count, UnreachableInitiator, SourceGroup, LocStart, LocEnd, Flags); if (SourceRegions.empty() || !SourceRegions.back().isMergeable(R)) { SourceRegions.push_back(R); return; } SourceRegions.back().mergeByExtendingTo(R); } void mapSourceCodeRange(SourceLocation LocStart, SourceLocation LocEnd, Counter Count, unsigned Flags = 0) { mapSourceCodeRange(LocStart, LocEnd, Count, CurrentUnreachableRegionInitiator, CurrentSourceGroup, Flags); } void mapSourceCodeRange(const SourceMappingState &State, SourceLocation LocStart, SourceLocation LocEnd, unsigned Flags = 0) { mapSourceCodeRange(LocStart, LocEnd, State.CurrentRegionCount, State.CurrentUnreachableRegionInitiator, State.CurrentSourceGroup, Flags); } /// \brief Generate the coverage counter mapping regions from collected /// source regions. void emitSourceRegions() { for (const auto &R : SourceRegions) { SourceLocation LocStart = R.LocStart; SourceLocation LocEnd = R.LocEnd; if (SM.getFileID(LocEnd) != R.File) LocEnd = R.AlternativeLocEnd; if (R.hasFlag(SourceMappingRegion::IgnoreIfNotExtended) && LocStart == LocEnd) continue; LocEnd = getPreciseTokenLocEnd(LocEnd); unsigned LineStart = SM.getSpellingLineNumber(LocStart); unsigned ColumnStart = SM.getSpellingColumnNumber(LocStart); unsigned LineEnd = SM.getSpellingLineNumber(LocEnd); unsigned ColumnEnd = SM.getSpellingColumnNumber(LocEnd); auto SpellingFile = SM.getDecomposedSpellingLoc(R.LocStart).first; unsigned CovFileID; if (getCoverageFileID(R.LocStart, R.File, SpellingFile, CovFileID)) continue; assert(LineStart <= LineEnd); MappingRegions.push_back(CounterMappingRegion( R.Count, CovFileID, LineStart, ColumnStart, LineEnd, ColumnEnd, false, CounterMappingRegion::CodeRegion)); } } }; /// \brief Creates unreachable coverage regions for the functions that /// are not emitted. struct EmptyCoverageMappingBuilder : public CoverageMappingBuilder { EmptyCoverageMappingBuilder(CoverageMappingModuleGen &CVM, SourceManager &SM, const LangOptions &LangOpts) : CoverageMappingBuilder(CVM, SM, LangOpts) {} void VisitDecl(const Decl *D) { if (!D->hasBody()) return; auto Body = D->getBody(); mapSourceCodeRange(Body->getLocStart(), Body->getLocEnd(), Counter()); } /// \brief Write the mapping data to the output stream void write(llvm::raw_ostream &OS) { emitSourceRegions(); SmallVector FileIDMapping; createFileIDMapping(FileIDMapping); CoverageMappingWriter Writer( FileIDMapping, ArrayRef(), MappingRegions); Writer.write(OS); } }; /// \brief A StmtVisitor that creates coverage mapping regions which map /// from the source code locations to the PGO counters. struct CounterCoverageMappingBuilder : public CoverageMappingBuilder, public ConstStmtVisitor { /// \brief The map of statements to count values. llvm::DenseMap &CounterMap; Counter CurrentRegionCount; CounterExpressionBuilder Builder; /// \brief Return a counter that represents the /// expression that subracts rhs from lhs. Counter subtractCounters(Counter LHS, Counter RHS) { return Builder.subtract(LHS, RHS); } /// \brief Return a counter that represents the /// the exression that adds lhs and rhs. Counter addCounters(Counter LHS, Counter RHS) { return Builder.add(LHS, RHS); } /// \brief Return the region counter for the given statement. /// This should only be called on statements that have a dedicated counter. unsigned getRegionCounter(const Stmt *S) { return CounterMap[S]; } /// \brief Return the region count for the counter at the given index. Counter getRegionCount(unsigned CounterId) { return Counter::getCounter(CounterId); } /// \brief Return the counter value of the current region. Counter getCurrentRegionCount() { return CurrentRegionCount; } /// \brief Set the counter value for the current region. /// This is used to keep track of changes to the most recent counter /// from control flow and non-local exits. void setCurrentRegionCount(Counter Count) { CurrentRegionCount = Count; CurrentUnreachableRegionInitiator = nullptr; } /// \brief Indicate that the current region is never reached, /// and thus should have a counter value of zero. /// This is important so that subsequent regions can correctly track /// their parent counts. void setCurrentRegionUnreachable(const Stmt *Initiator) { CurrentRegionCount = Counter::getZero(); CurrentUnreachableRegionInitiator = Initiator; } /// \brief A counter for a particular region. /// This is the primary interface through /// which the coverage mapping builder manages counters and their values. class RegionMapper { CounterCoverageMappingBuilder &Mapping; Counter Count; Counter ParentCount; Counter RegionCount; Counter Adjust; public: RegionMapper(CounterCoverageMappingBuilder *Mapper, const Stmt *S) : Mapping(*Mapper), Count(Mapper->getRegionCount(Mapper->getRegionCounter(S))), ParentCount(Mapper->getCurrentRegionCount()) {} /// Get the value of the counter. In most cases this is the number of times /// the region of the counter was entered, but for switch labels it's the /// number of direct jumps to that label. Counter getCount() const { return Count; } /// Get the value of the counter with adjustments applied. Adjustments occur /// when control enters or leaves the region abnormally; i.e., if there is a /// jump to a label within the region, or if the function can return from /// within the region. The adjusted count, then, is the value of the counter /// at the end of the region. Counter getAdjustedCount() const { return Mapping.addCounters(Count, Adjust); } /// Get the value of the counter in this region's parent, i.e., the region /// that was active when this region began. This is useful for deriving /// counts in implicitly counted regions, like the false case of a condition /// or the normal exits of a loop. Counter getParentCount() const { return ParentCount; } /// Activate the counter by emitting an increment and starting to track /// adjustments. If AddIncomingFallThrough is true, the current region count /// will be added to the counter for the purposes of tracking the region. void beginRegion(bool AddIncomingFallThrough = false) { RegionCount = Count; if (AddIncomingFallThrough) RegionCount = Mapping.addCounters(RegionCount, Mapping.getCurrentRegionCount()); Mapping.setCurrentRegionCount(RegionCount); } /// For counters on boolean branches, begins tracking adjustments for the /// uncounted path. void beginElseRegion() { RegionCount = Mapping.subtractCounters(ParentCount, Count); Mapping.setCurrentRegionCount(RegionCount); } /// Reset the current region count. void setCurrentRegionCount(Counter CurrentCount) { RegionCount = CurrentCount; Mapping.setCurrentRegionCount(RegionCount); } /// Adjust for non-local control flow after emitting a subexpression or /// substatement. This must be called to account for constructs such as /// gotos, /// labels, and returns, so that we can ensure that our region's count is /// correct in the code that follows. void adjustForControlFlow() { Adjust = Mapping.addCounters( Adjust, Mapping.subtractCounters(Mapping.getCurrentRegionCount(), RegionCount)); // Reset the region count in case this is called again later. RegionCount = Mapping.getCurrentRegionCount(); } /// Commit all adjustments to the current region. If the region is a loop, /// the LoopAdjust value should be the count of all the breaks and continues /// from the loop, to compensate for those counts being deducted from the /// adjustments for the body of the loop. void applyAdjustmentsToRegion() { Mapping.setCurrentRegionCount(Mapping.addCounters(ParentCount, Adjust)); } void applyAdjustmentsToRegion(Counter LoopAdjust) { Mapping.setCurrentRegionCount(Mapping.addCounters( Mapping.addCounters(ParentCount, Adjust), LoopAdjust)); } }; /// \brief Keep counts of breaks and continues inside loops. struct BreakContinue { Counter BreakCount; Counter ContinueCount; }; SmallVector BreakContinueStack; CounterCoverageMappingBuilder( CoverageMappingModuleGen &CVM, llvm::DenseMap &CounterMap, unsigned NumRegionCounters, SourceManager &SM, const LangOptions &LangOpts) : CoverageMappingBuilder(CVM, SM, LangOpts), CounterMap(CounterMap), Builder(NumRegionCounters) {} /// \brief Write the mapping data to the output stream void write(llvm::raw_ostream &OS) { emitSourceRegions(); llvm::SmallVector VirtualFileMapping; createFileIDMapping(VirtualFileMapping); gatherSkippedRegions(); CoverageMappingWriter Writer( VirtualFileMapping, Builder.getExpressions(), MappingRegions); Writer.write(OS); } /// \brief Return the current source mapping state. SourceMappingState getCurrentState() const { return SourceMappingState(CurrentRegionCount, CurrentSourceGroup, CurrentUnreachableRegionInitiator); } /// \brief Associate the source code range with the current region count. void mapSourceCodeRange(SourceLocation LocStart, SourceLocation LocEnd, unsigned Flags = 0) { CoverageMappingBuilder::mapSourceCodeRange(LocStart, LocEnd, CurrentRegionCount, Flags); } void mapSourceCodeRange(SourceLocation LocStart) { CoverageMappingBuilder::mapSourceCodeRange(LocStart, LocStart, CurrentRegionCount); } /// \brief Associate the source range of a token with the current region /// count. /// Ignore the source range for this token if it produces a distinct /// mapping region with no other source ranges. void mapToken(SourceLocation LocStart) { CoverageMappingBuilder::mapSourceCodeRange( LocStart, LocStart, CurrentRegionCount, SourceMappingRegion::IgnoreIfNotExtended); } void mapToken(const SourceMappingState &State, SourceLocation LocStart) { CoverageMappingBuilder::mapSourceCodeRange( State, LocStart, LocStart, SourceMappingRegion::IgnoreIfNotExtended); } void VisitStmt(const Stmt *S) { mapSourceCodeRange(S->getLocStart()); for (Stmt::const_child_range I = S->children(); I; ++I) { if (*I) this->Visit(*I); } } /// \brief If the given statement is a compound statement, /// map '}' with the same count as '{'. void VisitSubStmtRBraceState(const Stmt *S) { if (!isa(S)) return Visit(S); const auto *CS = cast(S); auto State = getCurrentState(); mapSourceCodeRange(CS->getLBracLoc()); for (Stmt::const_child_range I = S->children(); I; ++I) { if (*I) this->Visit(*I); } CoverageMappingBuilder::mapSourceCodeRange(State, CS->getRBracLoc(), CS->getRBracLoc()); } void VisitDecl(const Decl *D) { if (!D->hasBody()) return; // Counter tracks entry to the function body. auto Body = D->getBody(); RegionMapper Cnt(this, Body); Cnt.beginRegion(); VisitSubStmtRBraceState(Body); } void VisitDeclStmt(const DeclStmt *S) { mapSourceCodeRange(S->getLocStart()); for (Stmt::const_child_range I = static_cast(S)->children(); I; ++I) { if (*I) this->Visit(*I); } } void VisitCompoundStmt(const CompoundStmt *S) { mapSourceCodeRange(S->getLBracLoc()); for (Stmt::const_child_range I = S->children(); I; ++I) { if (*I) this->Visit(*I); } mapSourceCodeRange(S->getRBracLoc(), S->getRBracLoc()); } void VisitReturnStmt(const ReturnStmt *S) { mapSourceCodeRange(S->getLocStart()); if (S->getRetValue()) Visit(S->getRetValue()); setCurrentRegionUnreachable(S); } void VisitGotoStmt(const GotoStmt *S) { mapSourceCodeRange(S->getLocStart()); mapToken(S->getLabelLoc()); setCurrentRegionUnreachable(S); } void VisitLabelStmt(const LabelStmt *S) { // Counter tracks the block following the label. RegionMapper Cnt(this, S); Cnt.beginRegion(); mapSourceCodeRange(S->getLocStart()); // Can't map the ':' token as its location isn't known. Visit(S->getSubStmt()); } void VisitBreakStmt(const BreakStmt *S) { mapSourceCodeRange(S->getLocStart()); assert(!BreakContinueStack.empty() && "break not in a loop or switch!"); BreakContinueStack.back().BreakCount = addCounters( BreakContinueStack.back().BreakCount, getCurrentRegionCount()); setCurrentRegionUnreachable(S); } void VisitContinueStmt(const ContinueStmt *S) { mapSourceCodeRange(S->getLocStart()); assert(!BreakContinueStack.empty() && "continue stmt not in a loop!"); BreakContinueStack.back().ContinueCount = addCounters( BreakContinueStack.back().ContinueCount, getCurrentRegionCount()); setCurrentRegionUnreachable(S); } void VisitWhileStmt(const WhileStmt *S) { mapSourceCodeRange(S->getLocStart()); // Counter tracks the body of the loop. RegionMapper Cnt(this, S); BreakContinueStack.push_back(BreakContinue()); // Visit the body region first so the break/continue adjustments can be // included when visiting the condition. Cnt.beginRegion(); VisitSubStmtRBraceState(S->getBody()); Cnt.adjustForControlFlow(); // ...then go back and propagate counts through the condition. The count // at the start of the condition is the sum of the incoming edges, // the backedge from the end of the loop body, and the edges from // continue statements. BreakContinue BC = BreakContinueStack.pop_back_val(); Cnt.setCurrentRegionCount( addCounters(Cnt.getParentCount(), addCounters(Cnt.getAdjustedCount(), BC.ContinueCount))); beginSourceRegionGroup(S->getCond()); Visit(S->getCond()); endSourceRegionGroup(); Cnt.adjustForControlFlow(); Cnt.applyAdjustmentsToRegion(addCounters(BC.BreakCount, BC.ContinueCount)); } void VisitDoStmt(const DoStmt *S) { mapSourceCodeRange(S->getLocStart()); // Counter tracks the body of the loop. RegionMapper Cnt(this, S); BreakContinueStack.push_back(BreakContinue()); Cnt.beginRegion(/*AddIncomingFallThrough=*/true); VisitSubStmtRBraceState(S->getBody()); Cnt.adjustForControlFlow(); BreakContinue BC = BreakContinueStack.pop_back_val(); // The count at the start of the condition is equal to the count at the // end of the body. The adjusted count does not include either the // fall-through count coming into the loop or the continue count, so add // both of those separately. This is coincidentally the same equation as // with while loops but for different reasons. Cnt.setCurrentRegionCount( addCounters(Cnt.getParentCount(), addCounters(Cnt.getAdjustedCount(), BC.ContinueCount))); Visit(S->getCond()); Cnt.adjustForControlFlow(); Cnt.applyAdjustmentsToRegion(addCounters(BC.BreakCount, BC.ContinueCount)); } void VisitForStmt(const ForStmt *S) { mapSourceCodeRange(S->getLocStart()); if (S->getInit()) Visit(S->getInit()); // Counter tracks the body of the loop. RegionMapper Cnt(this, S); BreakContinueStack.push_back(BreakContinue()); // Visit the body region first. (This is basically the same as a while // loop; see further comments in VisitWhileStmt.) Cnt.beginRegion(); VisitSubStmtRBraceState(S->getBody()); Cnt.adjustForControlFlow(); // The increment is essentially part of the body but it needs to include // the count for all the continue statements. if (S->getInc()) { Cnt.setCurrentRegionCount(addCounters( getCurrentRegionCount(), BreakContinueStack.back().ContinueCount)); beginSourceRegionGroup(S->getInc()); Visit(S->getInc()); endSourceRegionGroup(); Cnt.adjustForControlFlow(); } BreakContinue BC = BreakContinueStack.pop_back_val(); // ...then go back and propagate counts through the condition. if (S->getCond()) { Cnt.setCurrentRegionCount( addCounters(addCounters(Cnt.getParentCount(), Cnt.getAdjustedCount()), BC.ContinueCount)); beginSourceRegionGroup(S->getCond()); Visit(S->getCond()); endSourceRegionGroup(); Cnt.adjustForControlFlow(); } Cnt.applyAdjustmentsToRegion(addCounters(BC.BreakCount, BC.ContinueCount)); } void VisitCXXForRangeStmt(const CXXForRangeStmt *S) { mapSourceCodeRange(S->getLocStart()); Visit(S->getRangeStmt()); Visit(S->getBeginEndStmt()); // Counter tracks the body of the loop. RegionMapper Cnt(this, S); BreakContinueStack.push_back(BreakContinue()); // Visit the body region first. (This is basically the same as a while // loop; see further comments in VisitWhileStmt.) Cnt.beginRegion(); VisitSubStmtRBraceState(S->getBody()); Cnt.adjustForControlFlow(); BreakContinue BC = BreakContinueStack.pop_back_val(); Cnt.applyAdjustmentsToRegion(addCounters(BC.BreakCount, BC.ContinueCount)); } void VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) { mapSourceCodeRange(S->getLocStart()); Visit(S->getElement()); // Counter tracks the body of the loop. RegionMapper Cnt(this, S); BreakContinueStack.push_back(BreakContinue()); VisitSubStmtRBraceState(S->getBody()); BreakContinue BC = BreakContinueStack.pop_back_val(); Cnt.adjustForControlFlow(); Cnt.applyAdjustmentsToRegion(addCounters(BC.BreakCount, BC.ContinueCount)); } void VisitSwitchStmt(const SwitchStmt *S) { mapSourceCodeRange(S->getLocStart()); Visit(S->getCond()); BreakContinueStack.push_back(BreakContinue()); // Map the '}' for the body to have the same count as the regions after // the switch. SourceLocation RBracLoc; if (const auto *CS = dyn_cast(S->getBody())) { mapSourceCodeRange(CS->getLBracLoc()); setCurrentRegionUnreachable(S); for (Stmt::const_child_range I = CS->children(); I; ++I) { if (*I) this->Visit(*I); } RBracLoc = CS->getRBracLoc(); } else { setCurrentRegionUnreachable(S); Visit(S->getBody()); } // If the switch is inside a loop, add the continue counts. BreakContinue BC = BreakContinueStack.pop_back_val(); if (!BreakContinueStack.empty()) BreakContinueStack.back().ContinueCount = addCounters( BreakContinueStack.back().ContinueCount, BC.ContinueCount); // Counter tracks the exit block of the switch. RegionMapper ExitCnt(this, S); ExitCnt.beginRegion(); if (RBracLoc.isValid()) mapSourceCodeRange(RBracLoc); } void VisitCaseStmt(const CaseStmt *S) { // Counter for this particular case. This counts only jumps from the // switch header and does not include fallthrough from the case before // this one. RegionMapper Cnt(this, S); Cnt.beginRegion(/*AddIncomingFallThrough=*/true); mapSourceCodeRange(S->getLocStart()); mapToken(S->getColonLoc()); Visit(S->getSubStmt()); } void VisitDefaultStmt(const DefaultStmt *S) { // Counter for this default case. This does not include fallthrough from // the previous case. RegionMapper Cnt(this, S); Cnt.beginRegion(/*AddIncomingFallThrough=*/true); mapSourceCodeRange(S->getLocStart()); mapToken(S->getColonLoc()); Visit(S->getSubStmt()); } void VisitIfStmt(const IfStmt *S) { mapSourceCodeRange(S->getLocStart()); Visit(S->getCond()); mapToken(S->getElseLoc()); // Counter tracks the "then" part of an if statement. The count for // the "else" part, if it exists, will be calculated from this counter. RegionMapper Cnt(this, S); Cnt.beginRegion(); VisitSubStmtRBraceState(S->getThen()); Cnt.adjustForControlFlow(); if (S->getElse()) { Cnt.beginElseRegion(); VisitSubStmtRBraceState(S->getElse()); Cnt.adjustForControlFlow(); } Cnt.applyAdjustmentsToRegion(); } void VisitCXXTryStmt(const CXXTryStmt *S) { mapSourceCodeRange(S->getLocStart()); Visit(S->getTryBlock()); for (unsigned I = 0, E = S->getNumHandlers(); I < E; ++I) Visit(S->getHandler(I)); // Counter tracks the continuation block of the try statement. RegionMapper Cnt(this, S); Cnt.beginRegion(); } void VisitCXXCatchStmt(const CXXCatchStmt *S) { mapSourceCodeRange(S->getLocStart()); // Counter tracks the catch statement's handler block. RegionMapper Cnt(this, S); Cnt.beginRegion(); VisitSubStmtRBraceState(S->getHandlerBlock()); } void VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { Visit(E->getCond()); mapToken(E->getQuestionLoc()); auto State = getCurrentState(); // Counter tracks the "true" part of a conditional operator. The // count in the "false" part will be calculated from this counter. RegionMapper Cnt(this, E); Cnt.beginRegion(); Visit(E->getTrueExpr()); Cnt.adjustForControlFlow(); mapToken(State, E->getColonLoc()); Cnt.beginElseRegion(); Visit(E->getFalseExpr()); Cnt.adjustForControlFlow(); Cnt.applyAdjustmentsToRegion(); } void VisitBinLAnd(const BinaryOperator *E) { Visit(E->getLHS()); mapToken(E->getOperatorLoc()); // Counter tracks the right hand side of a logical and operator. RegionMapper Cnt(this, E); Cnt.beginRegion(); Visit(E->getRHS()); Cnt.adjustForControlFlow(); Cnt.applyAdjustmentsToRegion(); } void VisitBinLOr(const BinaryOperator *E) { Visit(E->getLHS()); mapToken(E->getOperatorLoc()); // Counter tracks the right hand side of a logical or operator. RegionMapper Cnt(this, E); Cnt.beginRegion(); Visit(E->getRHS()); Cnt.adjustForControlFlow(); Cnt.applyAdjustmentsToRegion(); } void VisitParenExpr(const ParenExpr *E) { mapToken(E->getLParen()); Visit(E->getSubExpr()); mapToken(E->getRParen()); } void VisitBinaryOperator(const BinaryOperator *E) { Visit(E->getLHS()); mapToken(E->getOperatorLoc()); Visit(E->getRHS()); } void VisitUnaryOperator(const UnaryOperator *E) { bool Postfix = E->isPostfix(); if (!Postfix) mapToken(E->getOperatorLoc()); Visit(E->getSubExpr()); if (Postfix) mapToken(E->getOperatorLoc()); } void VisitMemberExpr(const MemberExpr *E) { Visit(E->getBase()); mapToken(E->getMemberLoc()); } void VisitCallExpr(const CallExpr *E) { Visit(E->getCallee()); for (const auto &Arg : E->arguments()) Visit(Arg); mapToken(E->getRParenLoc()); } void VisitArraySubscriptExpr(const ArraySubscriptExpr *E) { Visit(E->getLHS()); Visit(E->getRHS()); mapToken(E->getRBracketLoc()); } void VisitCStyleCastExpr(const CStyleCastExpr *E) { mapToken(E->getLParenLoc()); mapToken(E->getRParenLoc()); Visit(E->getSubExpr()); } // Map literals as tokens so that the macros like #define PI 3.14 // won't generate coverage mapping regions. void VisitIntegerLiteral(const IntegerLiteral *E) { mapToken(E->getLocStart()); } void VisitFloatingLiteral(const FloatingLiteral *E) { mapToken(E->getLocStart()); } void VisitCharacterLiteral(const CharacterLiteral *E) { mapToken(E->getLocStart()); } void VisitStringLiteral(const StringLiteral *E) { mapToken(E->getLocStart()); } void VisitImaginaryLiteral(const ImaginaryLiteral *E) { mapToken(E->getLocStart()); } }; } static bool isMachO(const CodeGenModule &CGM) { return CGM.getTarget().getTriple().isOSBinFormatMachO(); } static StringRef getCoverageSection(const CodeGenModule &CGM) { return isMachO(CGM) ? "__DATA,__llvm_covmap" : "__llvm_covmap"; } static void dump(llvm::raw_ostream &OS, const CoverageMappingRecord &Function) { OS << Function.FunctionName << ":\n"; CounterMappingContext Ctx(Function.Expressions); for (const auto &R : Function.MappingRegions) { OS.indent(2); switch (R.Kind) { case CounterMappingRegion::CodeRegion: break; case CounterMappingRegion::ExpansionRegion: OS << "Expansion,"; break; case CounterMappingRegion::SkippedRegion: OS << "Skipped,"; break; } OS << "File " << R.FileID << ", " << R.LineStart << ":" << R.ColumnStart << " -> " << R.LineEnd << ":" << R.ColumnEnd << " = "; Ctx.dump(R.Count); OS << " (HasCodeBefore = " << R.HasCodeBefore; if (R.Kind == CounterMappingRegion::ExpansionRegion) OS << ", Expanded file = " << R.ExpandedFileID; OS << ")\n"; } } void CoverageMappingModuleGen::addFunctionMappingRecord( llvm::GlobalVariable *FunctionName, StringRef FunctionNameValue, const std::string &CoverageMapping) { llvm::LLVMContext &Ctx = CGM.getLLVMContext(); auto *Int32Ty = llvm::Type::getInt32Ty(Ctx); auto *Int8PtrTy = llvm::Type::getInt8PtrTy(Ctx); if (!FunctionRecordTy) { llvm::Type *FunctionRecordTypes[] = {Int8PtrTy, Int32Ty, Int32Ty}; FunctionRecordTy = llvm::StructType::get(Ctx, makeArrayRef(FunctionRecordTypes)); } llvm::Constant *FunctionRecordVals[] = { llvm::ConstantExpr::getBitCast(FunctionName, Int8PtrTy), llvm::ConstantInt::get(Int32Ty, FunctionNameValue.size()), llvm::ConstantInt::get(Int32Ty, CoverageMapping.size())}; FunctionRecords.push_back(llvm::ConstantStruct::get( FunctionRecordTy, makeArrayRef(FunctionRecordVals))); CoverageMappings += CoverageMapping; if (CGM.getCodeGenOpts().DumpCoverageMapping) { // Dump the coverage mapping data for this function by decoding the // encoded data. This allows us to dump the mapping regions which were // also processed by the CoverageMappingWriter which performs // additional minimization operations such as reducing the number of // expressions. std::vector Filenames; std::vector Expressions; std::vector Regions; llvm::SmallVector FilenameRefs; FilenameRefs.resize(FileEntries.size()); for (const auto &Entry : FileEntries) FilenameRefs[Entry.second] = Entry.first->getName(); RawCoverageMappingReader Reader(FunctionNameValue, CoverageMapping, FilenameRefs, Filenames, Expressions, Regions); CoverageMappingRecord FunctionRecord; if (Reader.read(FunctionRecord)) return; dump(llvm::outs(), FunctionRecord); } } void CoverageMappingModuleGen::emit() { if (FunctionRecords.empty()) return; llvm::LLVMContext &Ctx = CGM.getLLVMContext(); auto *Int32Ty = llvm::Type::getInt32Ty(Ctx); // Create the filenames and merge them with coverage mappings llvm::SmallVector FilenameStrs; llvm::SmallVector FilenameRefs; FilenameStrs.resize(FileEntries.size()); FilenameRefs.resize(FileEntries.size()); for (const auto &Entry : FileEntries) { llvm::SmallString<256> Path(Entry.first->getName()); llvm::sys::fs::make_absolute(Path); auto I = Entry.second; FilenameStrs[I] = std::move(std::string(Path.begin(), Path.end())); FilenameRefs[I] = FilenameStrs[I]; } std::string FilenamesAndCoverageMappings; llvm::raw_string_ostream OS(FilenamesAndCoverageMappings); CoverageFilenamesSectionWriter(FilenameRefs).write(OS); OS << CoverageMappings; size_t CoverageMappingSize = CoverageMappings.size(); size_t FilenamesSize = OS.str().size() - CoverageMappingSize; // Append extra zeroes if necessary to ensure that the size of the filenames // and coverage mappings is a multiple of 8. if (size_t Rem = OS.str().size() % 8) { CoverageMappingSize += 8 - Rem; for (size_t I = 0, S = 8 - Rem; I < S; ++I) OS << '\0'; } auto *FilenamesAndMappingsVal = llvm::ConstantDataArray::getString(Ctx, OS.str(), false); // Create the deferred function records array auto RecordsTy = llvm::ArrayType::get(FunctionRecordTy, FunctionRecords.size()); auto RecordsVal = llvm::ConstantArray::get(RecordsTy, FunctionRecords); // Create the coverage data record llvm::Type *CovDataTypes[] = {Int32Ty, Int32Ty, Int32Ty, Int32Ty, RecordsTy, FilenamesAndMappingsVal->getType()}; auto CovDataTy = llvm::StructType::get(Ctx, makeArrayRef(CovDataTypes)); llvm::Constant *TUDataVals[] = { llvm::ConstantInt::get(Int32Ty, FunctionRecords.size()), llvm::ConstantInt::get(Int32Ty, FilenamesSize), llvm::ConstantInt::get(Int32Ty, CoverageMappingSize), llvm::ConstantInt::get(Int32Ty, /*Version=*/CoverageMappingVersion1), RecordsVal, FilenamesAndMappingsVal}; auto CovDataVal = llvm::ConstantStruct::get(CovDataTy, makeArrayRef(TUDataVals)); auto CovData = new llvm::GlobalVariable(CGM.getModule(), CovDataTy, true, llvm::GlobalValue::InternalLinkage, CovDataVal, "__llvm_coverage_mapping"); CovData->setSection(getCoverageSection(CGM)); CovData->setAlignment(8); // Make sure the data doesn't get deleted. CGM.addUsedGlobal(CovData); } unsigned CoverageMappingModuleGen::getFileID(const FileEntry *File) { auto It = FileEntries.find(File); if (It != FileEntries.end()) return It->second; unsigned FileID = FileEntries.size(); FileEntries.insert(std::make_pair(File, FileID)); return FileID; } void CoverageMappingGen::emitCounterMapping(const Decl *D, llvm::raw_ostream &OS) { assert(CounterMap); CounterCoverageMappingBuilder Walker(CVM, *CounterMap, NumRegionCounters, SM, LangOpts); Walker.VisitDecl(D); Walker.write(OS); } void CoverageMappingGen::emitEmptyMapping(const Decl *D, llvm::raw_ostream &OS) { EmptyCoverageMappingBuilder Walker(CVM, SM, LangOpts); Walker.VisitDecl(D); Walker.write(OS); } @