1 //===--- CoverageMappingGen.cpp - Coverage mapping generation ---*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Instrumentation-based code coverage mapping generator
12 //===----------------------------------------------------------------------===//
14 #include "CoverageMappingGen.h"
15 #include "CodeGenFunction.h"
16 #include "clang/AST/StmtVisitor.h"
17 #include "clang/Lex/Lexer.h"
18 #include "llvm/ADT/SmallSet.h"
19 #include "llvm/ADT/StringExtras.h"
20 #include "llvm/ADT/Optional.h"
21 #include "llvm/ProfileData/Coverage/CoverageMapping.h"
22 #include "llvm/ProfileData/Coverage/CoverageMappingReader.h"
23 #include "llvm/ProfileData/Coverage/CoverageMappingWriter.h"
24 #include "llvm/ProfileData/InstrProfReader.h"
25 #include "llvm/Support/FileSystem.h"
26 #include "llvm/Support/Path.h"
28 using namespace clang;
29 using namespace CodeGen;
30 using namespace llvm::coverage;
32 void CoverageSourceInfo::SourceRangeSkipped(SourceRange Range) {
33 SkippedRanges.push_back(Range);
38 /// \brief A region of source code that can be mapped to a counter.
39 class SourceMappingRegion {
42 /// \brief The region's starting location.
43 Optional<SourceLocation> LocStart;
45 /// \brief The region's ending location.
46 Optional<SourceLocation> LocEnd;
49 SourceMappingRegion(Counter Count, Optional<SourceLocation> LocStart,
50 Optional<SourceLocation> LocEnd)
51 : Count(Count), LocStart(LocStart), LocEnd(LocEnd) {}
53 const Counter &getCounter() const { return Count; }
55 void setCounter(Counter C) { Count = C; }
57 bool hasStartLoc() const { return LocStart.hasValue(); }
59 void setStartLoc(SourceLocation Loc) { LocStart = Loc; }
61 SourceLocation getStartLoc() const {
62 assert(LocStart && "Region has no start location");
66 bool hasEndLoc() const { return LocEnd.hasValue(); }
68 void setEndLoc(SourceLocation Loc) { LocEnd = Loc; }
70 SourceLocation getEndLoc() const {
71 assert(LocEnd && "Region has no end location");
76 /// \brief Provides the common functionality for the different
77 /// coverage mapping region builders.
78 class CoverageMappingBuilder {
80 CoverageMappingModuleGen &CVM;
82 const LangOptions &LangOpts;
85 /// \brief Map of clang's FileIDs to IDs used for coverage mapping.
86 llvm::SmallDenseMap<FileID, std::pair<unsigned, SourceLocation>, 8>
90 /// \brief The coverage mapping regions for this function
91 llvm::SmallVector<CounterMappingRegion, 32> MappingRegions;
92 /// \brief The source mapping regions for this function.
93 std::vector<SourceMappingRegion> SourceRegions;
95 /// \brief A set of regions which can be used as a filter.
97 /// It is produced by emitExpansionRegions() and is used in
98 /// emitSourceRegions() to suppress producing code regions if
99 /// the same area is covered by expansion regions.
100 typedef llvm::SmallSet<std::pair<SourceLocation, SourceLocation>, 8>
103 CoverageMappingBuilder(CoverageMappingModuleGen &CVM, SourceManager &SM,
104 const LangOptions &LangOpts)
105 : CVM(CVM), SM(SM), LangOpts(LangOpts) {}
107 /// \brief Return the precise end location for the given token.
108 SourceLocation getPreciseTokenLocEnd(SourceLocation Loc) {
109 // We avoid getLocForEndOfToken here, because it doesn't do what we want for
110 // macro locations, which we just treat as expanded files.
112 Lexer::MeasureTokenLength(SM.getSpellingLoc(Loc), SM, LangOpts);
113 return Loc.getLocWithOffset(TokLen);
116 /// \brief Return the start location of an included file or expanded macro.
117 SourceLocation getStartOfFileOrMacro(SourceLocation Loc) {
119 return Loc.getLocWithOffset(-SM.getFileOffset(Loc));
120 return SM.getLocForStartOfFile(SM.getFileID(Loc));
123 /// \brief Return the end location of an included file or expanded macro.
124 SourceLocation getEndOfFileOrMacro(SourceLocation Loc) {
126 return Loc.getLocWithOffset(SM.getFileIDSize(SM.getFileID(Loc)) -
127 SM.getFileOffset(Loc));
128 return SM.getLocForEndOfFile(SM.getFileID(Loc));
131 /// \brief Find out where the current file is included or macro is expanded.
132 SourceLocation getIncludeOrExpansionLoc(SourceLocation Loc) {
133 return Loc.isMacroID() ? SM.getImmediateExpansionRange(Loc).first
134 : SM.getIncludeLoc(SM.getFileID(Loc));
137 /// \brief Return true if \c Loc is a location in a built-in macro.
138 bool isInBuiltin(SourceLocation Loc) {
139 return SM.getBufferName(SM.getSpellingLoc(Loc)) == "<built-in>";
142 /// \brief Check whether \c Loc is included or expanded from \c Parent.
143 bool isNestedIn(SourceLocation Loc, FileID Parent) {
145 Loc = getIncludeOrExpansionLoc(Loc);
148 } while (!SM.isInFileID(Loc, Parent));
152 /// \brief Get the start of \c S ignoring macro arguments and builtin macros.
153 SourceLocation getStart(const Stmt *S) {
154 SourceLocation Loc = S->getLocStart();
155 while (SM.isMacroArgExpansion(Loc) || isInBuiltin(Loc))
156 Loc = SM.getImmediateExpansionRange(Loc).first;
160 /// \brief Get the end of \c S ignoring macro arguments and builtin macros.
161 SourceLocation getEnd(const Stmt *S) {
162 SourceLocation Loc = S->getLocEnd();
163 while (SM.isMacroArgExpansion(Loc) || isInBuiltin(Loc))
164 Loc = SM.getImmediateExpansionRange(Loc).first;
165 return getPreciseTokenLocEnd(Loc);
168 /// \brief Find the set of files we have regions for and assign IDs
170 /// Fills \c Mapping with the virtual file mapping needed to write out
171 /// coverage and collects the necessary file information to emit source and
172 /// expansion regions.
173 void gatherFileIDs(SmallVectorImpl<unsigned> &Mapping) {
174 FileIDMapping.clear();
176 llvm::SmallSet<FileID, 8> Visited;
177 SmallVector<std::pair<SourceLocation, unsigned>, 8> FileLocs;
178 for (const auto &Region : SourceRegions) {
179 SourceLocation Loc = Region.getStartLoc();
180 FileID File = SM.getFileID(Loc);
181 if (!Visited.insert(File).second)
184 // Do not map FileID's associated with system headers.
185 if (SM.isInSystemHeader(SM.getSpellingLoc(Loc)))
189 for (SourceLocation Parent = getIncludeOrExpansionLoc(Loc);
190 Parent.isValid(); Parent = getIncludeOrExpansionLoc(Parent))
192 FileLocs.push_back(std::make_pair(Loc, Depth));
194 std::stable_sort(FileLocs.begin(), FileLocs.end(), llvm::less_second());
196 for (const auto &FL : FileLocs) {
197 SourceLocation Loc = FL.first;
198 FileID SpellingFile = SM.getDecomposedSpellingLoc(Loc).first;
199 auto Entry = SM.getFileEntryForID(SpellingFile);
203 FileIDMapping[SM.getFileID(Loc)] = std::make_pair(Mapping.size(), Loc);
204 Mapping.push_back(CVM.getFileID(Entry));
208 /// \brief Get the coverage mapping file ID for \c Loc.
210 /// If such file id doesn't exist, return None.
211 Optional<unsigned> getCoverageFileID(SourceLocation Loc) {
212 auto Mapping = FileIDMapping.find(SM.getFileID(Loc));
213 if (Mapping != FileIDMapping.end())
214 return Mapping->second.first;
218 /// \brief Gather all the regions that were skipped by the preprocessor
219 /// using the constructs like #if.
220 void gatherSkippedRegions() {
221 /// An array of the minimum lineStarts and the maximum lineEnds
222 /// for mapping regions from the appropriate source files.
223 llvm::SmallVector<std::pair<unsigned, unsigned>, 8> FileLineRanges;
224 FileLineRanges.resize(
225 FileIDMapping.size(),
226 std::make_pair(std::numeric_limits<unsigned>::max(), 0));
227 for (const auto &R : MappingRegions) {
228 FileLineRanges[R.FileID].first =
229 std::min(FileLineRanges[R.FileID].first, R.LineStart);
230 FileLineRanges[R.FileID].second =
231 std::max(FileLineRanges[R.FileID].second, R.LineEnd);
234 auto SkippedRanges = CVM.getSourceInfo().getSkippedRanges();
235 for (const auto &I : SkippedRanges) {
236 auto LocStart = I.getBegin();
237 auto LocEnd = I.getEnd();
238 assert(SM.isWrittenInSameFile(LocStart, LocEnd) &&
239 "region spans multiple files");
241 auto CovFileID = getCoverageFileID(LocStart);
244 unsigned LineStart = SM.getSpellingLineNumber(LocStart);
245 unsigned ColumnStart = SM.getSpellingColumnNumber(LocStart);
246 unsigned LineEnd = SM.getSpellingLineNumber(LocEnd);
247 unsigned ColumnEnd = SM.getSpellingColumnNumber(LocEnd);
248 auto Region = CounterMappingRegion::makeSkipped(
249 *CovFileID, LineStart, ColumnStart, LineEnd, ColumnEnd);
250 // Make sure that we only collect the regions that are inside
251 // the souce code of this function.
252 if (Region.LineStart >= FileLineRanges[*CovFileID].first &&
253 Region.LineEnd <= FileLineRanges[*CovFileID].second)
254 MappingRegions.push_back(Region);
258 /// \brief Generate the coverage counter mapping regions from collected
260 void emitSourceRegions(const SourceRegionFilter &Filter) {
261 for (const auto &Region : SourceRegions) {
262 assert(Region.hasEndLoc() && "incomplete region");
264 SourceLocation LocStart = Region.getStartLoc();
265 assert(SM.getFileID(LocStart).isValid() && "region in invalid file");
267 // Ignore regions from system headers.
268 if (SM.isInSystemHeader(SM.getSpellingLoc(LocStart)))
271 auto CovFileID = getCoverageFileID(LocStart);
272 // Ignore regions that don't have a file, such as builtin macros.
276 SourceLocation LocEnd = Region.getEndLoc();
277 assert(SM.isWrittenInSameFile(LocStart, LocEnd) &&
278 "region spans multiple files");
280 // Don't add code regions for the area covered by expansion regions.
281 // This not only suppresses redundant regions, but sometimes prevents
282 // creating regions with wrong counters if, for example, a statement's
283 // body ends at the end of a nested macro.
284 if (Filter.count(std::make_pair(LocStart, LocEnd)))
287 // Find the spilling locations for the mapping region.
288 unsigned LineStart = SM.getSpellingLineNumber(LocStart);
289 unsigned ColumnStart = SM.getSpellingColumnNumber(LocStart);
290 unsigned LineEnd = SM.getSpellingLineNumber(LocEnd);
291 unsigned ColumnEnd = SM.getSpellingColumnNumber(LocEnd);
293 assert(LineStart <= LineEnd && "region start and end out of order");
294 MappingRegions.push_back(CounterMappingRegion::makeRegion(
295 Region.getCounter(), *CovFileID, LineStart, ColumnStart, LineEnd,
300 /// \brief Generate expansion regions for each virtual file we've seen.
301 SourceRegionFilter emitExpansionRegions() {
302 SourceRegionFilter Filter;
303 for (const auto &FM : FileIDMapping) {
304 SourceLocation ExpandedLoc = FM.second.second;
305 SourceLocation ParentLoc = getIncludeOrExpansionLoc(ExpandedLoc);
306 if (ParentLoc.isInvalid())
309 auto ParentFileID = getCoverageFileID(ParentLoc);
312 auto ExpandedFileID = getCoverageFileID(ExpandedLoc);
313 assert(ExpandedFileID && "expansion in uncovered file");
315 SourceLocation LocEnd = getPreciseTokenLocEnd(ParentLoc);
316 assert(SM.isWrittenInSameFile(ParentLoc, LocEnd) &&
317 "region spans multiple files");
318 Filter.insert(std::make_pair(ParentLoc, LocEnd));
320 unsigned LineStart = SM.getSpellingLineNumber(ParentLoc);
321 unsigned ColumnStart = SM.getSpellingColumnNumber(ParentLoc);
322 unsigned LineEnd = SM.getSpellingLineNumber(LocEnd);
323 unsigned ColumnEnd = SM.getSpellingColumnNumber(LocEnd);
325 MappingRegions.push_back(CounterMappingRegion::makeExpansion(
326 *ParentFileID, *ExpandedFileID, LineStart, ColumnStart, LineEnd,
333 /// \brief Creates unreachable coverage regions for the functions that
335 struct EmptyCoverageMappingBuilder : public CoverageMappingBuilder {
336 EmptyCoverageMappingBuilder(CoverageMappingModuleGen &CVM, SourceManager &SM,
337 const LangOptions &LangOpts)
338 : CoverageMappingBuilder(CVM, SM, LangOpts) {}
340 void VisitDecl(const Decl *D) {
343 auto Body = D->getBody();
344 SourceLocation Start = getStart(Body);
345 SourceLocation End = getEnd(Body);
346 if (!SM.isWrittenInSameFile(Start, End)) {
347 // Walk up to find the common ancestor.
348 // Correct the locations accordingly.
349 FileID StartFileID = SM.getFileID(Start);
350 FileID EndFileID = SM.getFileID(End);
351 while (StartFileID != EndFileID && !isNestedIn(End, StartFileID)) {
352 Start = getIncludeOrExpansionLoc(Start);
353 assert(Start.isValid() &&
354 "Declaration start location not nested within a known region");
355 StartFileID = SM.getFileID(Start);
357 while (StartFileID != EndFileID) {
358 End = getPreciseTokenLocEnd(getIncludeOrExpansionLoc(End));
359 assert(End.isValid() &&
360 "Declaration end location not nested within a known region");
361 EndFileID = SM.getFileID(End);
364 SourceRegions.emplace_back(Counter(), Start, End);
367 /// \brief Write the mapping data to the output stream
368 void write(llvm::raw_ostream &OS) {
369 SmallVector<unsigned, 16> FileIDMapping;
370 gatherFileIDs(FileIDMapping);
371 emitSourceRegions(SourceRegionFilter());
373 if (MappingRegions.empty())
376 CoverageMappingWriter Writer(FileIDMapping, None, MappingRegions);
381 /// \brief A StmtVisitor that creates coverage mapping regions which map
382 /// from the source code locations to the PGO counters.
383 struct CounterCoverageMappingBuilder
384 : public CoverageMappingBuilder,
385 public ConstStmtVisitor<CounterCoverageMappingBuilder> {
386 /// \brief The map of statements to count values.
387 llvm::DenseMap<const Stmt *, unsigned> &CounterMap;
389 /// \brief A stack of currently live regions.
390 std::vector<SourceMappingRegion> RegionStack;
392 CounterExpressionBuilder Builder;
394 /// \brief A location in the most recently visited file or macro.
396 /// This is used to adjust the active source regions appropriately when
397 /// expressions cross file or macro boundaries.
398 SourceLocation MostRecentLocation;
400 /// \brief Return a counter for the subtraction of \c RHS from \c LHS
401 Counter subtractCounters(Counter LHS, Counter RHS) {
402 return Builder.subtract(LHS, RHS);
405 /// \brief Return a counter for the sum of \c LHS and \c RHS.
406 Counter addCounters(Counter LHS, Counter RHS) {
407 return Builder.add(LHS, RHS);
410 Counter addCounters(Counter C1, Counter C2, Counter C3) {
411 return addCounters(addCounters(C1, C2), C3);
414 /// \brief Return the region counter for the given statement.
416 /// This should only be called on statements that have a dedicated counter.
417 Counter getRegionCounter(const Stmt *S) {
418 return Counter::getCounter(CounterMap[S]);
421 /// \brief Push a region onto the stack.
423 /// Returns the index on the stack where the region was pushed. This can be
424 /// used with popRegions to exit a "scope", ending the region that was pushed.
425 size_t pushRegion(Counter Count, Optional<SourceLocation> StartLoc = None,
426 Optional<SourceLocation> EndLoc = None) {
428 MostRecentLocation = *StartLoc;
429 RegionStack.emplace_back(Count, StartLoc, EndLoc);
431 return RegionStack.size() - 1;
434 /// \brief Pop regions from the stack into the function's list of regions.
436 /// Adds all regions from \c ParentIndex to the top of the stack to the
437 /// function's \c SourceRegions.
438 void popRegions(size_t ParentIndex) {
439 assert(RegionStack.size() >= ParentIndex && "parent not in stack");
440 while (RegionStack.size() > ParentIndex) {
441 SourceMappingRegion &Region = RegionStack.back();
442 if (Region.hasStartLoc()) {
443 SourceLocation StartLoc = Region.getStartLoc();
444 SourceLocation EndLoc = Region.hasEndLoc()
446 : RegionStack[ParentIndex].getEndLoc();
447 while (!SM.isWrittenInSameFile(StartLoc, EndLoc)) {
448 // The region ends in a nested file or macro expansion. Create a
449 // separate region for each expansion.
450 SourceLocation NestedLoc = getStartOfFileOrMacro(EndLoc);
451 assert(SM.isWrittenInSameFile(NestedLoc, EndLoc));
453 if (!isRegionAlreadyAdded(NestedLoc, EndLoc))
454 SourceRegions.emplace_back(Region.getCounter(), NestedLoc, EndLoc);
456 EndLoc = getPreciseTokenLocEnd(getIncludeOrExpansionLoc(EndLoc));
457 if (EndLoc.isInvalid())
458 llvm::report_fatal_error("File exit not handled before popRegions");
460 Region.setEndLoc(EndLoc);
462 MostRecentLocation = EndLoc;
463 // If this region happens to span an entire expansion, we need to make
464 // sure we don't overlap the parent region with it.
465 if (StartLoc == getStartOfFileOrMacro(StartLoc) &&
466 EndLoc == getEndOfFileOrMacro(EndLoc))
467 MostRecentLocation = getIncludeOrExpansionLoc(EndLoc);
469 assert(SM.isWrittenInSameFile(Region.getStartLoc(), EndLoc));
470 SourceRegions.push_back(Region);
472 RegionStack.pop_back();
476 /// \brief Return the currently active region.
477 SourceMappingRegion &getRegion() {
478 assert(!RegionStack.empty() && "statement has no region");
479 return RegionStack.back();
482 /// \brief Propagate counts through the children of \c S.
483 Counter propagateCounts(Counter TopCount, const Stmt *S) {
484 size_t Index = pushRegion(TopCount, getStart(S), getEnd(S));
486 Counter ExitCount = getRegion().getCounter();
489 // The statement may be spanned by an expansion. Make sure we handle a file
490 // exit out of this expansion before moving to the next statement.
491 if (SM.isBeforeInTranslationUnit(getStart(S), S->getLocStart()))
492 MostRecentLocation = getEnd(S);
497 /// \brief Check whether a region with bounds \c StartLoc and \c EndLoc
498 /// is already added to \c SourceRegions.
499 bool isRegionAlreadyAdded(SourceLocation StartLoc, SourceLocation EndLoc) {
500 return SourceRegions.rend() !=
501 std::find_if(SourceRegions.rbegin(), SourceRegions.rend(),
502 [&](const SourceMappingRegion &Region) {
503 return Region.getStartLoc() == StartLoc &&
504 Region.getEndLoc() == EndLoc;
508 /// \brief Adjust the most recently visited location to \c EndLoc.
510 /// This should be used after visiting any statements in non-source order.
511 void adjustForOutOfOrderTraversal(SourceLocation EndLoc) {
512 MostRecentLocation = EndLoc;
513 // The code region for a whole macro is created in handleFileExit() when
514 // it detects exiting of the virtual file of that macro. If we visited
515 // statements in non-source order, we might already have such a region
516 // added, for example, if a body of a loop is divided among multiple
517 // macros. Avoid adding duplicate regions in such case.
518 if (getRegion().hasEndLoc() &&
519 MostRecentLocation == getEndOfFileOrMacro(MostRecentLocation) &&
520 isRegionAlreadyAdded(getStartOfFileOrMacro(MostRecentLocation),
522 MostRecentLocation = getIncludeOrExpansionLoc(MostRecentLocation);
525 /// \brief Adjust regions and state when \c NewLoc exits a file.
527 /// If moving from our most recently tracked location to \c NewLoc exits any
528 /// files, this adjusts our current region stack and creates the file regions
529 /// for the exited file.
530 void handleFileExit(SourceLocation NewLoc) {
531 if (NewLoc.isInvalid() ||
532 SM.isWrittenInSameFile(MostRecentLocation, NewLoc))
535 // If NewLoc is not in a file that contains MostRecentLocation, walk up to
536 // find the common ancestor.
537 SourceLocation LCA = NewLoc;
538 FileID ParentFile = SM.getFileID(LCA);
539 while (!isNestedIn(MostRecentLocation, ParentFile)) {
540 LCA = getIncludeOrExpansionLoc(LCA);
541 if (LCA.isInvalid() || SM.isWrittenInSameFile(LCA, MostRecentLocation)) {
542 // Since there isn't a common ancestor, no file was exited. We just need
543 // to adjust our location to the new file.
544 MostRecentLocation = NewLoc;
547 ParentFile = SM.getFileID(LCA);
550 llvm::SmallSet<SourceLocation, 8> StartLocs;
551 Optional<Counter> ParentCounter;
552 for (SourceMappingRegion &I : llvm::reverse(RegionStack)) {
553 if (!I.hasStartLoc())
555 SourceLocation Loc = I.getStartLoc();
556 if (!isNestedIn(Loc, ParentFile)) {
557 ParentCounter = I.getCounter();
561 while (!SM.isInFileID(Loc, ParentFile)) {
562 // The most nested region for each start location is the one with the
563 // correct count. We avoid creating redundant regions by stopping once
564 // we've seen this region.
565 if (StartLocs.insert(Loc).second)
566 SourceRegions.emplace_back(I.getCounter(), Loc,
567 getEndOfFileOrMacro(Loc));
568 Loc = getIncludeOrExpansionLoc(Loc);
570 I.setStartLoc(getPreciseTokenLocEnd(Loc));
574 // If the file is contained completely by another region and doesn't
575 // immediately start its own region, the whole file gets a region
576 // corresponding to the parent.
577 SourceLocation Loc = MostRecentLocation;
578 while (isNestedIn(Loc, ParentFile)) {
579 SourceLocation FileStart = getStartOfFileOrMacro(Loc);
580 if (StartLocs.insert(FileStart).second)
581 SourceRegions.emplace_back(*ParentCounter, FileStart,
582 getEndOfFileOrMacro(Loc));
583 Loc = getIncludeOrExpansionLoc(Loc);
587 MostRecentLocation = NewLoc;
590 /// \brief Ensure that \c S is included in the current region.
591 void extendRegion(const Stmt *S) {
592 SourceMappingRegion &Region = getRegion();
593 SourceLocation StartLoc = getStart(S);
595 handleFileExit(StartLoc);
596 if (!Region.hasStartLoc())
597 Region.setStartLoc(StartLoc);
600 /// \brief Mark \c S as a terminator, starting a zero region.
601 void terminateRegion(const Stmt *S) {
603 SourceMappingRegion &Region = getRegion();
604 if (!Region.hasEndLoc())
605 Region.setEndLoc(getEnd(S));
606 pushRegion(Counter::getZero());
609 /// \brief Keep counts of breaks and continues inside loops.
610 struct BreakContinue {
612 Counter ContinueCount;
614 SmallVector<BreakContinue, 8> BreakContinueStack;
616 CounterCoverageMappingBuilder(
617 CoverageMappingModuleGen &CVM,
618 llvm::DenseMap<const Stmt *, unsigned> &CounterMap, SourceManager &SM,
619 const LangOptions &LangOpts)
620 : CoverageMappingBuilder(CVM, SM, LangOpts), CounterMap(CounterMap) {}
622 /// \brief Write the mapping data to the output stream
623 void write(llvm::raw_ostream &OS) {
624 llvm::SmallVector<unsigned, 8> VirtualFileMapping;
625 gatherFileIDs(VirtualFileMapping);
626 SourceRegionFilter Filter = emitExpansionRegions();
627 emitSourceRegions(Filter);
628 gatherSkippedRegions();
630 if (MappingRegions.empty())
633 CoverageMappingWriter Writer(VirtualFileMapping, Builder.getExpressions(),
638 void VisitStmt(const Stmt *S) {
639 if (S->getLocStart().isValid())
641 for (const Stmt *Child : S->children())
644 handleFileExit(getEnd(S));
647 void VisitDecl(const Decl *D) {
648 Stmt *Body = D->getBody();
650 // Do not propagate region counts into system headers.
651 if (Body && SM.isInSystemHeader(SM.getSpellingLoc(getStart(Body))))
654 propagateCounts(getRegionCounter(Body), Body);
657 void VisitReturnStmt(const ReturnStmt *S) {
659 if (S->getRetValue())
660 Visit(S->getRetValue());
664 void VisitCXXThrowExpr(const CXXThrowExpr *E) {
667 Visit(E->getSubExpr());
671 void VisitGotoStmt(const GotoStmt *S) { terminateRegion(S); }
673 void VisitLabelStmt(const LabelStmt *S) {
674 SourceLocation Start = getStart(S);
675 // We can't extendRegion here or we risk overlapping with our new region.
676 handleFileExit(Start);
677 pushRegion(getRegionCounter(S), Start);
678 Visit(S->getSubStmt());
681 void VisitBreakStmt(const BreakStmt *S) {
682 assert(!BreakContinueStack.empty() && "break not in a loop or switch!");
683 BreakContinueStack.back().BreakCount = addCounters(
684 BreakContinueStack.back().BreakCount, getRegion().getCounter());
688 void VisitContinueStmt(const ContinueStmt *S) {
689 assert(!BreakContinueStack.empty() && "continue stmt not in a loop!");
690 BreakContinueStack.back().ContinueCount = addCounters(
691 BreakContinueStack.back().ContinueCount, getRegion().getCounter());
695 void VisitWhileStmt(const WhileStmt *S) {
698 Counter ParentCount = getRegion().getCounter();
699 Counter BodyCount = getRegionCounter(S);
701 // Handle the body first so that we can get the backedge count.
702 BreakContinueStack.push_back(BreakContinue());
703 extendRegion(S->getBody());
704 Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());
705 BreakContinue BC = BreakContinueStack.pop_back_val();
707 // Go back to handle the condition.
709 addCounters(ParentCount, BackedgeCount, BC.ContinueCount);
710 propagateCounts(CondCount, S->getCond());
711 adjustForOutOfOrderTraversal(getEnd(S));
714 addCounters(BC.BreakCount, subtractCounters(CondCount, BodyCount));
715 if (OutCount != ParentCount)
716 pushRegion(OutCount);
719 void VisitDoStmt(const DoStmt *S) {
722 Counter ParentCount = getRegion().getCounter();
723 Counter BodyCount = getRegionCounter(S);
725 BreakContinueStack.push_back(BreakContinue());
726 extendRegion(S->getBody());
727 Counter BackedgeCount =
728 propagateCounts(addCounters(ParentCount, BodyCount), S->getBody());
729 BreakContinue BC = BreakContinueStack.pop_back_val();
731 Counter CondCount = addCounters(BackedgeCount, BC.ContinueCount);
732 propagateCounts(CondCount, S->getCond());
735 addCounters(BC.BreakCount, subtractCounters(CondCount, BodyCount));
736 if (OutCount != ParentCount)
737 pushRegion(OutCount);
740 void VisitForStmt(const ForStmt *S) {
745 Counter ParentCount = getRegion().getCounter();
746 Counter BodyCount = getRegionCounter(S);
748 // Handle the body first so that we can get the backedge count.
749 BreakContinueStack.push_back(BreakContinue());
750 extendRegion(S->getBody());
751 Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());
752 BreakContinue BC = BreakContinueStack.pop_back_val();
754 // The increment is essentially part of the body but it needs to include
755 // the count for all the continue statements.
756 if (const Stmt *Inc = S->getInc())
757 propagateCounts(addCounters(BackedgeCount, BC.ContinueCount), Inc);
759 // Go back to handle the condition.
761 addCounters(ParentCount, BackedgeCount, BC.ContinueCount);
762 if (const Expr *Cond = S->getCond()) {
763 propagateCounts(CondCount, Cond);
764 adjustForOutOfOrderTraversal(getEnd(S));
768 addCounters(BC.BreakCount, subtractCounters(CondCount, BodyCount));
769 if (OutCount != ParentCount)
770 pushRegion(OutCount);
773 void VisitCXXForRangeStmt(const CXXForRangeStmt *S) {
775 Visit(S->getLoopVarStmt());
776 Visit(S->getRangeStmt());
778 Counter ParentCount = getRegion().getCounter();
779 Counter BodyCount = getRegionCounter(S);
781 BreakContinueStack.push_back(BreakContinue());
782 extendRegion(S->getBody());
783 Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());
784 BreakContinue BC = BreakContinueStack.pop_back_val();
787 addCounters(ParentCount, BackedgeCount, BC.ContinueCount);
789 addCounters(BC.BreakCount, subtractCounters(LoopCount, BodyCount));
790 if (OutCount != ParentCount)
791 pushRegion(OutCount);
794 void VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) {
796 Visit(S->getElement());
798 Counter ParentCount = getRegion().getCounter();
799 Counter BodyCount = getRegionCounter(S);
801 BreakContinueStack.push_back(BreakContinue());
802 extendRegion(S->getBody());
803 Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());
804 BreakContinue BC = BreakContinueStack.pop_back_val();
807 addCounters(ParentCount, BackedgeCount, BC.ContinueCount);
809 addCounters(BC.BreakCount, subtractCounters(LoopCount, BodyCount));
810 if (OutCount != ParentCount)
811 pushRegion(OutCount);
814 void VisitSwitchStmt(const SwitchStmt *S) {
820 BreakContinueStack.push_back(BreakContinue());
822 const Stmt *Body = S->getBody();
824 if (const auto *CS = dyn_cast<CompoundStmt>(Body)) {
825 if (!CS->body_empty()) {
826 // The body of the switch needs a zero region so that fallthrough counts
827 // behave correctly, but it would be misleading to include the braces of
828 // the compound statement in the zeroed area, so we need to handle this
831 pushRegion(Counter::getZero(), getStart(CS->body_front()),
832 getEnd(CS->body_back()));
833 for (const auto *Child : CS->children())
838 propagateCounts(Counter::getZero(), Body);
839 BreakContinue BC = BreakContinueStack.pop_back_val();
841 if (!BreakContinueStack.empty())
842 BreakContinueStack.back().ContinueCount = addCounters(
843 BreakContinueStack.back().ContinueCount, BC.ContinueCount);
845 Counter ExitCount = getRegionCounter(S);
846 SourceLocation ExitLoc = getEnd(S);
847 pushRegion(ExitCount);
849 // Ensure that handleFileExit recognizes when the end location is located
850 // in a different file.
851 MostRecentLocation = getStart(S);
852 handleFileExit(ExitLoc);
855 void VisitSwitchCase(const SwitchCase *S) {
858 SourceMappingRegion &Parent = getRegion();
860 Counter Count = addCounters(Parent.getCounter(), getRegionCounter(S));
861 // Reuse the existing region if it starts at our label. This is typical of
862 // the first case in a switch.
863 if (Parent.hasStartLoc() && Parent.getStartLoc() == getStart(S))
864 Parent.setCounter(Count);
866 pushRegion(Count, getStart(S));
868 if (const auto *CS = dyn_cast<CaseStmt>(S)) {
870 if (const Expr *RHS = CS->getRHS())
873 Visit(S->getSubStmt());
876 void VisitIfStmt(const IfStmt *S) {
881 // Extend into the condition before we propagate through it below - this is
882 // needed to handle macros that generate the "if" but not the condition.
883 extendRegion(S->getCond());
885 Counter ParentCount = getRegion().getCounter();
886 Counter ThenCount = getRegionCounter(S);
888 // Emitting a counter for the condition makes it easier to interpret the
889 // counter for the body when looking at the coverage.
890 propagateCounts(ParentCount, S->getCond());
892 extendRegion(S->getThen());
893 Counter OutCount = propagateCounts(ThenCount, S->getThen());
895 Counter ElseCount = subtractCounters(ParentCount, ThenCount);
896 if (const Stmt *Else = S->getElse()) {
897 extendRegion(S->getElse());
898 OutCount = addCounters(OutCount, propagateCounts(ElseCount, Else));
900 OutCount = addCounters(OutCount, ElseCount);
902 if (OutCount != ParentCount)
903 pushRegion(OutCount);
906 void VisitCXXTryStmt(const CXXTryStmt *S) {
908 // Handle macros that generate the "try" but not the rest.
909 extendRegion(S->getTryBlock());
911 Counter ParentCount = getRegion().getCounter();
912 propagateCounts(ParentCount, S->getTryBlock());
914 for (unsigned I = 0, E = S->getNumHandlers(); I < E; ++I)
915 Visit(S->getHandler(I));
917 Counter ExitCount = getRegionCounter(S);
918 pushRegion(ExitCount);
921 void VisitCXXCatchStmt(const CXXCatchStmt *S) {
922 propagateCounts(getRegionCounter(S), S->getHandlerBlock());
925 void VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
928 Counter ParentCount = getRegion().getCounter();
929 Counter TrueCount = getRegionCounter(E);
933 if (!isa<BinaryConditionalOperator>(E)) {
934 extendRegion(E->getTrueExpr());
935 propagateCounts(TrueCount, E->getTrueExpr());
937 extendRegion(E->getFalseExpr());
938 propagateCounts(subtractCounters(ParentCount, TrueCount),
942 void VisitBinLAnd(const BinaryOperator *E) {
946 extendRegion(E->getRHS());
947 propagateCounts(getRegionCounter(E), E->getRHS());
950 void VisitBinLOr(const BinaryOperator *E) {
954 extendRegion(E->getRHS());
955 propagateCounts(getRegionCounter(E), E->getRHS());
958 void VisitLambdaExpr(const LambdaExpr *LE) {
959 // Lambdas are treated as their own functions for now, so we shouldn't
960 // propagate counts into them.
964 bool isMachO(const CodeGenModule &CGM) {
965 return CGM.getTarget().getTriple().isOSBinFormatMachO();
968 StringRef getCoverageSection(const CodeGenModule &CGM) {
969 return llvm::getInstrProfCoverageSectionName(isMachO(CGM));
972 std::string normalizeFilename(StringRef Filename) {
973 llvm::SmallString<256> Path(Filename);
974 llvm::sys::fs::make_absolute(Path);
975 llvm::sys::path::remove_dots(Path, /*remove_dot_dots=*/true);
976 return Path.str().str();
979 } // end anonymous namespace
981 static void dump(llvm::raw_ostream &OS, StringRef FunctionName,
982 ArrayRef<CounterExpression> Expressions,
983 ArrayRef<CounterMappingRegion> Regions) {
984 OS << FunctionName << ":\n";
985 CounterMappingContext Ctx(Expressions);
986 for (const auto &R : Regions) {
989 case CounterMappingRegion::CodeRegion:
991 case CounterMappingRegion::ExpansionRegion:
994 case CounterMappingRegion::SkippedRegion:
999 OS << "File " << R.FileID << ", " << R.LineStart << ":" << R.ColumnStart
1000 << " -> " << R.LineEnd << ":" << R.ColumnEnd << " = ";
1001 Ctx.dump(R.Count, OS);
1002 if (R.Kind == CounterMappingRegion::ExpansionRegion)
1003 OS << " (Expanded file = " << R.ExpandedFileID << ")";
1008 void CoverageMappingModuleGen::addFunctionMappingRecord(
1009 llvm::GlobalVariable *NamePtr, StringRef NameValue, uint64_t FuncHash,
1010 const std::string &CoverageMapping, bool IsUsed) {
1011 llvm::LLVMContext &Ctx = CGM.getLLVMContext();
1012 if (!FunctionRecordTy) {
1013 #define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) LLVMType,
1014 llvm::Type *FunctionRecordTypes[] = {
1015 #include "llvm/ProfileData/InstrProfData.inc"
1018 llvm::StructType::get(Ctx, makeArrayRef(FunctionRecordTypes),
1022 #define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) Init,
1023 llvm::Constant *FunctionRecordVals[] = {
1024 #include "llvm/ProfileData/InstrProfData.inc"
1026 FunctionRecords.push_back(llvm::ConstantStruct::get(
1027 FunctionRecordTy, makeArrayRef(FunctionRecordVals)));
1029 FunctionNames.push_back(
1030 llvm::ConstantExpr::getBitCast(NamePtr, llvm::Type::getInt8PtrTy(Ctx)));
1031 CoverageMappings.push_back(CoverageMapping);
1033 if (CGM.getCodeGenOpts().DumpCoverageMapping) {
1034 // Dump the coverage mapping data for this function by decoding the
1035 // encoded data. This allows us to dump the mapping regions which were
1036 // also processed by the CoverageMappingWriter which performs
1037 // additional minimization operations such as reducing the number of
1039 std::vector<StringRef> Filenames;
1040 std::vector<CounterExpression> Expressions;
1041 std::vector<CounterMappingRegion> Regions;
1042 llvm::SmallVector<std::string, 16> FilenameStrs;
1043 llvm::SmallVector<StringRef, 16> FilenameRefs;
1044 FilenameStrs.resize(FileEntries.size());
1045 FilenameRefs.resize(FileEntries.size());
1046 for (const auto &Entry : FileEntries) {
1047 auto I = Entry.second;
1048 FilenameStrs[I] = normalizeFilename(Entry.first->getName());
1049 FilenameRefs[I] = FilenameStrs[I];
1051 RawCoverageMappingReader Reader(CoverageMapping, FilenameRefs, Filenames,
1052 Expressions, Regions);
1055 dump(llvm::outs(), NameValue, Expressions, Regions);
1059 void CoverageMappingModuleGen::emit() {
1060 if (FunctionRecords.empty())
1062 llvm::LLVMContext &Ctx = CGM.getLLVMContext();
1063 auto *Int32Ty = llvm::Type::getInt32Ty(Ctx);
1065 // Create the filenames and merge them with coverage mappings
1066 llvm::SmallVector<std::string, 16> FilenameStrs;
1067 llvm::SmallVector<StringRef, 16> FilenameRefs;
1068 FilenameStrs.resize(FileEntries.size());
1069 FilenameRefs.resize(FileEntries.size());
1070 for (const auto &Entry : FileEntries) {
1071 auto I = Entry.second;
1072 FilenameStrs[I] = normalizeFilename(Entry.first->getName());
1073 FilenameRefs[I] = FilenameStrs[I];
1076 std::string FilenamesAndCoverageMappings;
1077 llvm::raw_string_ostream OS(FilenamesAndCoverageMappings);
1078 CoverageFilenamesSectionWriter(FilenameRefs).write(OS);
1079 std::string RawCoverageMappings =
1080 llvm::join(CoverageMappings.begin(), CoverageMappings.end(), "");
1081 OS << RawCoverageMappings;
1082 size_t CoverageMappingSize = RawCoverageMappings.size();
1083 size_t FilenamesSize = OS.str().size() - CoverageMappingSize;
1084 // Append extra zeroes if necessary to ensure that the size of the filenames
1085 // and coverage mappings is a multiple of 8.
1086 if (size_t Rem = OS.str().size() % 8) {
1087 CoverageMappingSize += 8 - Rem;
1088 for (size_t I = 0, S = 8 - Rem; I < S; ++I)
1091 auto *FilenamesAndMappingsVal =
1092 llvm::ConstantDataArray::getString(Ctx, OS.str(), false);
1094 // Create the deferred function records array
1096 llvm::ArrayType::get(FunctionRecordTy, FunctionRecords.size());
1097 auto RecordsVal = llvm::ConstantArray::get(RecordsTy, FunctionRecords);
1099 llvm::Type *CovDataHeaderTypes[] = {
1100 #define COVMAP_HEADER(Type, LLVMType, Name, Init) LLVMType,
1101 #include "llvm/ProfileData/InstrProfData.inc"
1103 auto CovDataHeaderTy =
1104 llvm::StructType::get(Ctx, makeArrayRef(CovDataHeaderTypes));
1105 llvm::Constant *CovDataHeaderVals[] = {
1106 #define COVMAP_HEADER(Type, LLVMType, Name, Init) Init,
1107 #include "llvm/ProfileData/InstrProfData.inc"
1109 auto CovDataHeaderVal = llvm::ConstantStruct::get(
1110 CovDataHeaderTy, makeArrayRef(CovDataHeaderVals));
1112 // Create the coverage data record
1113 llvm::Type *CovDataTypes[] = {CovDataHeaderTy, RecordsTy,
1114 FilenamesAndMappingsVal->getType()};
1115 auto CovDataTy = llvm::StructType::get(Ctx, makeArrayRef(CovDataTypes));
1116 llvm::Constant *TUDataVals[] = {CovDataHeaderVal, RecordsVal,
1117 FilenamesAndMappingsVal};
1119 llvm::ConstantStruct::get(CovDataTy, makeArrayRef(TUDataVals));
1120 auto CovData = new llvm::GlobalVariable(
1121 CGM.getModule(), CovDataTy, true, llvm::GlobalValue::InternalLinkage,
1122 CovDataVal, llvm::getCoverageMappingVarName());
1124 CovData->setSection(getCoverageSection(CGM));
1125 CovData->setAlignment(8);
1127 // Make sure the data doesn't get deleted.
1128 CGM.addUsedGlobal(CovData);
1129 // Create the deferred function records array
1130 if (!FunctionNames.empty()) {
1131 auto NamesArrTy = llvm::ArrayType::get(llvm::Type::getInt8PtrTy(Ctx),
1132 FunctionNames.size());
1133 auto NamesArrVal = llvm::ConstantArray::get(NamesArrTy, FunctionNames);
1134 // This variable will *NOT* be emitted to the object file. It is used
1135 // to pass the list of names referenced to codegen.
1136 new llvm::GlobalVariable(CGM.getModule(), NamesArrTy, true,
1137 llvm::GlobalValue::InternalLinkage, NamesArrVal,
1138 llvm::getCoverageUnusedNamesVarName());
1142 unsigned CoverageMappingModuleGen::getFileID(const FileEntry *File) {
1143 auto It = FileEntries.find(File);
1144 if (It != FileEntries.end())
1146 unsigned FileID = FileEntries.size();
1147 FileEntries.insert(std::make_pair(File, FileID));
1151 void CoverageMappingGen::emitCounterMapping(const Decl *D,
1152 llvm::raw_ostream &OS) {
1154 CounterCoverageMappingBuilder Walker(CVM, *CounterMap, SM, LangOpts);
1155 Walker.VisitDecl(D);
1159 void CoverageMappingGen::emitEmptyMapping(const Decl *D,
1160 llvm::raw_ostream &OS) {
1161 EmptyCoverageMappingBuilder Walker(CVM, SM, LangOpts);
1162 Walker.VisitDecl(D);