LLVM  7.0.0svn
CoverageMapping.cpp
Go to the documentation of this file.
1 //===- CoverageMapping.cpp - Code coverage mapping support ----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for clang's and llvm's instrumentation based
11 // code coverage.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "llvm/ADT/ArrayRef.h"
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/ADT/None.h"
19 #include "llvm/ADT/Optional.h"
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/ADT/StringRef.h"
25 #include "llvm/Support/Debug.h"
26 #include "llvm/Support/Errc.h"
27 #include "llvm/Support/Error.h"
32 #include <algorithm>
33 #include <cassert>
34 #include <cstdint>
35 #include <iterator>
36 #include <map>
37 #include <memory>
38 #include <string>
39 #include <system_error>
40 #include <utility>
41 #include <vector>
42 
43 using namespace llvm;
44 using namespace coverage;
45 
46 #define DEBUG_TYPE "coverage-mapping"
47 
48 Counter CounterExpressionBuilder::get(const CounterExpression &E) {
49  auto It = ExpressionIndices.find(E);
50  if (It != ExpressionIndices.end())
51  return Counter::getExpression(It->second);
52  unsigned I = Expressions.size();
53  Expressions.push_back(E);
54  ExpressionIndices[E] = I;
55  return Counter::getExpression(I);
56 }
57 
58 void CounterExpressionBuilder::extractTerms(Counter C, int Factor,
59  SmallVectorImpl<Term> &Terms) {
60  switch (C.getKind()) {
61  case Counter::Zero:
62  break;
64  Terms.emplace_back(C.getCounterID(), Factor);
65  break;
67  const auto &E = Expressions[C.getExpressionID()];
68  extractTerms(E.LHS, Factor, Terms);
69  extractTerms(
70  E.RHS, E.Kind == CounterExpression::Subtract ? -Factor : Factor, Terms);
71  break;
72  }
73 }
74 
75 Counter CounterExpressionBuilder::simplify(Counter ExpressionTree) {
76  // Gather constant terms.
78  extractTerms(ExpressionTree, +1, Terms);
79 
80  // If there are no terms, this is just a zero. The algorithm below assumes at
81  // least one term.
82  if (Terms.size() == 0)
83  return Counter::getZero();
84 
85  // Group the terms by counter ID.
86  std::sort(Terms.begin(), Terms.end(), [](const Term &LHS, const Term &RHS) {
87  return LHS.CounterID < RHS.CounterID;
88  });
89 
90  // Combine terms by counter ID to eliminate counters that sum to zero.
91  auto Prev = Terms.begin();
92  for (auto I = Prev + 1, E = Terms.end(); I != E; ++I) {
93  if (I->CounterID == Prev->CounterID) {
94  Prev->Factor += I->Factor;
95  continue;
96  }
97  ++Prev;
98  *Prev = *I;
99  }
100  Terms.erase(++Prev, Terms.end());
101 
102  Counter C;
103  // Create additions. We do this before subtractions to avoid constructs like
104  // ((0 - X) + Y), as opposed to (Y - X).
105  for (auto T : Terms) {
106  if (T.Factor <= 0)
107  continue;
108  for (int I = 0; I < T.Factor; ++I)
109  if (C.isZero())
110  C = Counter::getCounter(T.CounterID);
111  else
113  Counter::getCounter(T.CounterID)));
114  }
115 
116  // Create subtractions.
117  for (auto T : Terms) {
118  if (T.Factor >= 0)
119  continue;
120  for (int I = 0; I < -T.Factor; ++I)
122  Counter::getCounter(T.CounterID)));
123  }
124  return C;
125 }
126 
128  return simplify(get(CounterExpression(CounterExpression::Add, LHS, RHS)));
129 }
130 
132  return simplify(
134 }
135 
137  switch (C.getKind()) {
138  case Counter::Zero:
139  OS << '0';
140  return;
142  OS << '#' << C.getCounterID();
143  break;
144  case Counter::Expression: {
145  if (C.getExpressionID() >= Expressions.size())
146  return;
147  const auto &E = Expressions[C.getExpressionID()];
148  OS << '(';
149  dump(E.LHS, OS);
150  OS << (E.Kind == CounterExpression::Subtract ? " - " : " + ");
151  dump(E.RHS, OS);
152  OS << ')';
153  break;
154  }
155  }
156  if (CounterValues.empty())
157  return;
158  Expected<int64_t> Value = evaluate(C);
159  if (auto E = Value.takeError()) {
160  consumeError(std::move(E));
161  return;
162  }
163  OS << '[' << *Value << ']';
164 }
165 
167  switch (C.getKind()) {
168  case Counter::Zero:
169  return 0;
171  if (C.getCounterID() >= CounterValues.size())
173  return CounterValues[C.getCounterID()];
174  case Counter::Expression: {
175  if (C.getExpressionID() >= Expressions.size())
177  const auto &E = Expressions[C.getExpressionID()];
178  Expected<int64_t> LHS = evaluate(E.LHS);
179  if (!LHS)
180  return LHS;
181  Expected<int64_t> RHS = evaluate(E.RHS);
182  if (!RHS)
183  return RHS;
184  return E.Kind == CounterExpression::Subtract ? *LHS - *RHS : *LHS + *RHS;
185  }
186  }
187  llvm_unreachable("Unhandled CounterKind");
188 }
189 
190 void FunctionRecordIterator::skipOtherFiles() {
191  while (Current != Records.end() && !Filename.empty() &&
192  Filename != Current->Filenames[0])
193  ++Current;
194  if (Current == Records.end())
195  *this = FunctionRecordIterator();
196 }
197 
198 Error CoverageMapping::loadFunctionRecord(
200  IndexedInstrProfReader &ProfileReader) {
201  StringRef OrigFuncName = Record.FunctionName;
202  if (OrigFuncName.empty())
203  return make_error<CoverageMapError>(coveragemap_error::malformed);
204 
205  if (Record.Filenames.empty())
206  OrigFuncName = getFuncNameWithoutPrefix(OrigFuncName);
207  else
208  OrigFuncName = getFuncNameWithoutPrefix(OrigFuncName, Record.Filenames[0]);
209 
210  // Don't load records for functions we've already seen.
211  if (!FunctionNames.insert(OrigFuncName).second)
212  return Error::success();
213 
215 
216  std::vector<uint64_t> Counts;
217  if (Error E = ProfileReader.getFunctionCounts(Record.FunctionName,
218  Record.FunctionHash, Counts)) {
219  instrprof_error IPE = InstrProfError::take(std::move(E));
220  if (IPE == instrprof_error::hash_mismatch) {
221  FuncHashMismatches.emplace_back(Record.FunctionName, Record.FunctionHash);
222  return Error::success();
223  } else if (IPE != instrprof_error::unknown_function)
224  return make_error<InstrProfError>(IPE);
225  Counts.assign(Record.MappingRegions.size(), 0);
226  }
227  Ctx.setCounts(Counts);
228 
229  assert(!Record.MappingRegions.empty() && "Function has no regions");
230 
231  FunctionRecord Function(OrigFuncName, Record.Filenames);
232  for (const auto &Region : Record.MappingRegions) {
233  Expected<int64_t> ExecutionCount = Ctx.evaluate(Region.Count);
234  if (auto E = ExecutionCount.takeError()) {
235  consumeError(std::move(E));
236  return Error::success();
237  }
238  Function.pushRegion(Region, *ExecutionCount);
239  }
240  if (Function.CountedRegions.size() != Record.MappingRegions.size()) {
241  FuncCounterMismatches.emplace_back(Record.FunctionName,
242  Function.CountedRegions.size());
243  return Error::success();
244  }
245 
246  Functions.push_back(std::move(Function));
247  return Error::success();
248 }
249 
251  ArrayRef<std::unique_ptr<CoverageMappingReader>> CoverageReaders,
252  IndexedInstrProfReader &ProfileReader) {
253  auto Coverage = std::unique_ptr<CoverageMapping>(new CoverageMapping());
254 
255  for (const auto &CoverageReader : CoverageReaders) {
256  for (auto RecordOrErr : *CoverageReader) {
257  if (Error E = RecordOrErr.takeError())
258  return std::move(E);
259  const auto &Record = *RecordOrErr;
260  if (Error E = Coverage->loadFunctionRecord(Record, ProfileReader))
261  return std::move(E);
262  }
263  }
264 
265  return std::move(Coverage);
266 }
267 
270  StringRef ProfileFilename, ArrayRef<StringRef> Arches) {
271  auto ProfileReaderOrErr = IndexedInstrProfReader::create(ProfileFilename);
272  if (Error E = ProfileReaderOrErr.takeError())
273  return std::move(E);
274  auto ProfileReader = std::move(ProfileReaderOrErr.get());
275 
278  for (const auto &File : llvm::enumerate(ObjectFilenames)) {
279  auto CovMappingBufOrErr = MemoryBuffer::getFileOrSTDIN(File.value());
280  if (std::error_code EC = CovMappingBufOrErr.getError())
281  return errorCodeToError(EC);
282  StringRef Arch = Arches.empty() ? StringRef() : Arches[File.index()];
283  auto CoverageReaderOrErr =
284  BinaryCoverageReader::create(CovMappingBufOrErr.get(), Arch);
285  if (Error E = CoverageReaderOrErr.takeError())
286  return std::move(E);
287  Readers.push_back(std::move(CoverageReaderOrErr.get()));
288  Buffers.push_back(std::move(CovMappingBufOrErr.get()));
289  }
290  return load(Readers, *ProfileReader);
291 }
292 
293 namespace {
294 
295 /// \brief Distributes functions into instantiation sets.
296 ///
297 /// An instantiation set is a collection of functions that have the same source
298 /// code, ie, template functions specializations.
299 class FunctionInstantiationSetCollector {
300  using MapT = std::map<LineColPair, std::vector<const FunctionRecord *>>;
301  MapT InstantiatedFunctions;
302 
303 public:
304  void insert(const FunctionRecord &Function, unsigned FileID) {
305  auto I = Function.CountedRegions.begin(), E = Function.CountedRegions.end();
306  while (I != E && I->FileID != FileID)
307  ++I;
308  assert(I != E && "function does not cover the given file");
309  auto &Functions = InstantiatedFunctions[I->startLoc()];
310  Functions.push_back(&Function);
311  }
312 
313  MapT::iterator begin() { return InstantiatedFunctions.begin(); }
314  MapT::iterator end() { return InstantiatedFunctions.end(); }
315 };
316 
317 class SegmentBuilder {
318  std::vector<CoverageSegment> &Segments;
320 
321  SegmentBuilder(std::vector<CoverageSegment> &Segments) : Segments(Segments) {}
322 
323  /// Emit a segment with the count from \p Region starting at \p StartLoc.
324  //
325  /// \p IsRegionEntry: The segment is at the start of a new non-gap region.
326  /// \p EmitSkippedRegion: The segment must be emitted as a skipped region.
327  void startSegment(const CountedRegion &Region, LineColPair StartLoc,
328  bool IsRegionEntry, bool EmitSkippedRegion = false) {
329  bool HasCount = !EmitSkippedRegion &&
331 
332  // If the new segment wouldn't affect coverage rendering, skip it.
333  if (!Segments.empty() && !IsRegionEntry && !EmitSkippedRegion) {
334  const auto &Last = Segments.back();
335  if (Last.HasCount == HasCount && Last.Count == Region.ExecutionCount &&
336  !Last.IsRegionEntry)
337  return;
338  }
339 
340  if (HasCount)
341  Segments.emplace_back(StartLoc.first, StartLoc.second,
342  Region.ExecutionCount, IsRegionEntry,
344  else
345  Segments.emplace_back(StartLoc.first, StartLoc.second, IsRegionEntry);
346 
347  DEBUG({
348  const auto &Last = Segments.back();
349  dbgs() << "Segment at " << Last.Line << ":" << Last.Col
350  << " (count = " << Last.Count << ")"
351  << (Last.IsRegionEntry ? ", RegionEntry" : "")
352  << (!Last.HasCount ? ", Skipped" : "")
353  << (Last.IsGapRegion ? ", Gap" : "") << "\n";
354  });
355  }
356 
357  /// Emit segments for active regions which end before \p Loc.
358  ///
359  /// \p Loc: The start location of the next region. If None, all active
360  /// regions are completed.
361  /// \p FirstCompletedRegion: Index of the first completed region.
362  void completeRegionsUntil(Optional<LineColPair> Loc,
363  unsigned FirstCompletedRegion) {
364  // Sort the completed regions by end location. This makes it simple to
365  // emit closing segments in sorted order.
366  auto CompletedRegionsIt = ActiveRegions.begin() + FirstCompletedRegion;
367  std::stable_sort(CompletedRegionsIt, ActiveRegions.end(),
368  [](const CountedRegion *L, const CountedRegion *R) {
369  return L->endLoc() < R->endLoc();
370  });
371 
372  // Emit segments for all completed regions.
373  for (unsigned I = FirstCompletedRegion + 1, E = ActiveRegions.size(); I < E;
374  ++I) {
375  const auto *CompletedRegion = ActiveRegions[I];
376  assert((!Loc || CompletedRegion->endLoc() <= *Loc) &&
377  "Completed region ends after start of new region");
378 
379  const auto *PrevCompletedRegion = ActiveRegions[I - 1];
380  auto CompletedSegmentLoc = PrevCompletedRegion->endLoc();
381 
382  // Don't emit any more segments if they start where the new region begins.
383  if (Loc && CompletedSegmentLoc == *Loc)
384  break;
385 
386  // Don't emit a segment if the next completed region ends at the same
387  // location as this one.
388  if (CompletedSegmentLoc == CompletedRegion->endLoc())
389  continue;
390 
391  // Use the count from the last completed region which ends at this loc.
392  for (unsigned J = I + 1; J < E; ++J)
393  if (CompletedRegion->endLoc() == ActiveRegions[J]->endLoc())
394  CompletedRegion = ActiveRegions[J];
395 
396  startSegment(*CompletedRegion, CompletedSegmentLoc, false);
397  }
398 
399  auto Last = ActiveRegions.back();
400  if (FirstCompletedRegion && Last->endLoc() != *Loc) {
401  // If there's a gap after the end of the last completed region and the
402  // start of the new region, use the last active region to fill the gap.
403  startSegment(*ActiveRegions[FirstCompletedRegion - 1], Last->endLoc(),
404  false);
405  } else if (!FirstCompletedRegion && (!Loc || *Loc != Last->endLoc())) {
406  // Emit a skipped segment if there are no more active regions. This
407  // ensures that gaps between functions are marked correctly.
408  startSegment(*Last, Last->endLoc(), false, true);
409  }
410 
411  // Pop the completed regions.
412  ActiveRegions.erase(CompletedRegionsIt, ActiveRegions.end());
413  }
414 
415  void buildSegmentsImpl(ArrayRef<CountedRegion> Regions) {
416  for (const auto &CR : enumerate(Regions)) {
417  auto CurStartLoc = CR.value().startLoc();
418 
419  // Active regions which end before the current region need to be popped.
420  auto CompletedRegions =
421  std::stable_partition(ActiveRegions.begin(), ActiveRegions.end(),
422  [&](const CountedRegion *Region) {
423  return !(Region->endLoc() <= CurStartLoc);
424  });
425  if (CompletedRegions != ActiveRegions.end()) {
426  unsigned FirstCompletedRegion =
427  std::distance(ActiveRegions.begin(), CompletedRegions);
428  completeRegionsUntil(CurStartLoc, FirstCompletedRegion);
429  }
430 
431  bool GapRegion = CR.value().Kind == CounterMappingRegion::GapRegion;
432 
433  // Try to emit a segment for the current region.
434  if (CurStartLoc == CR.value().endLoc()) {
435  // Avoid making zero-length regions active. If it's the last region,
436  // emit a skipped segment. Otherwise use its predecessor's count.
437  const bool Skipped = (CR.index() + 1) == Regions.size();
438  startSegment(ActiveRegions.empty() ? CR.value() : *ActiveRegions.back(),
439  CurStartLoc, !GapRegion, Skipped);
440  continue;
441  }
442  if (CR.index() + 1 == Regions.size() ||
443  CurStartLoc != Regions[CR.index() + 1].startLoc()) {
444  // Emit a segment if the next region doesn't start at the same location
445  // as this one.
446  startSegment(CR.value(), CurStartLoc, !GapRegion);
447  }
448 
449  // This region is active (i.e not completed).
450  ActiveRegions.push_back(&CR.value());
451  }
452 
453  // Complete any remaining active regions.
454  if (!ActiveRegions.empty())
455  completeRegionsUntil(None, 0);
456  }
457 
458  /// Sort a nested sequence of regions from a single file.
459  static void sortNestedRegions(MutableArrayRef<CountedRegion> Regions) {
460  std::sort(Regions.begin(), Regions.end(), [](const CountedRegion &LHS,
461  const CountedRegion &RHS) {
462  if (LHS.startLoc() != RHS.startLoc())
463  return LHS.startLoc() < RHS.startLoc();
464  if (LHS.endLoc() != RHS.endLoc())
465  // When LHS completely contains RHS, we sort LHS first.
466  return RHS.endLoc() < LHS.endLoc();
467  // If LHS and RHS cover the same area, we need to sort them according
468  // to their kinds so that the most suitable region will become "active"
469  // in combineRegions(). Because we accumulate counter values only from
470  // regions of the same kind as the first region of the area, prefer
471  // CodeRegion to ExpansionRegion and ExpansionRegion to SkippedRegion.
472  static_assert(CounterMappingRegion::CodeRegion <
476  "Unexpected order of region kind values");
477  return LHS.Kind < RHS.Kind;
478  });
479  }
480 
481  /// Combine counts of regions which cover the same area.
483  combineRegions(MutableArrayRef<CountedRegion> Regions) {
484  if (Regions.empty())
485  return Regions;
486  auto Active = Regions.begin();
487  auto End = Regions.end();
488  for (auto I = Regions.begin() + 1; I != End; ++I) {
489  if (Active->startLoc() != I->startLoc() ||
490  Active->endLoc() != I->endLoc()) {
491  // Shift to the next region.
492  ++Active;
493  if (Active != I)
494  *Active = *I;
495  continue;
496  }
497  // Merge duplicate region.
498  // If CodeRegions and ExpansionRegions cover the same area, it's probably
499  // a macro which is fully expanded to another macro. In that case, we need
500  // to accumulate counts only from CodeRegions, or else the area will be
501  // counted twice.
502  // On the other hand, a macro may have a nested macro in its body. If the
503  // outer macro is used several times, the ExpansionRegion for the nested
504  // macro will also be added several times. These ExpansionRegions cover
505  // the same source locations and have to be combined to reach the correct
506  // value for that area.
507  // We add counts of the regions of the same kind as the active region
508  // to handle the both situations.
509  if (I->Kind == Active->Kind)
510  Active->ExecutionCount += I->ExecutionCount;
511  }
512  return Regions.drop_back(std::distance(++Active, End));
513  }
514 
515 public:
516  /// Build a sorted list of CoverageSegments from a list of Regions.
517  static std::vector<CoverageSegment>
518  buildSegments(MutableArrayRef<CountedRegion> Regions) {
519  std::vector<CoverageSegment> Segments;
520  SegmentBuilder Builder(Segments);
521 
522  sortNestedRegions(Regions);
523  ArrayRef<CountedRegion> CombinedRegions = combineRegions(Regions);
524 
525  DEBUG({
526  dbgs() << "Combined regions:\n";
527  for (const auto &CR : CombinedRegions)
528  dbgs() << " " << CR.LineStart << ":" << CR.ColumnStart << " -> "
529  << CR.LineEnd << ":" << CR.ColumnEnd
530  << " (count=" << CR.ExecutionCount << ")\n";
531  });
532 
533  Builder.buildSegmentsImpl(CombinedRegions);
534 
535 #ifndef NDEBUG
536  for (unsigned I = 1, E = Segments.size(); I < E; ++I) {
537  const auto &L = Segments[I - 1];
538  const auto &R = Segments[I];
539  if (!(L.Line < R.Line) && !(L.Line == R.Line && L.Col < R.Col)) {
540  DEBUG(dbgs() << " ! Segment " << L.Line << ":" << L.Col
541  << " followed by " << R.Line << ":" << R.Col << "\n");
542  assert(false && "Coverage segments not unique or sorted");
543  }
544  }
545 #endif
546 
547  return Segments;
548  }
549 };
550 
551 } // end anonymous namespace
552 
553 std::vector<StringRef> CoverageMapping::getUniqueSourceFiles() const {
554  std::vector<StringRef> Filenames;
555  for (const auto &Function : getCoveredFunctions())
556  Filenames.insert(Filenames.end(), Function.Filenames.begin(),
557  Function.Filenames.end());
558  std::sort(Filenames.begin(), Filenames.end());
559  auto Last = std::unique(Filenames.begin(), Filenames.end());
560  Filenames.erase(Last, Filenames.end());
561  return Filenames;
562 }
563 
565  const FunctionRecord &Function) {
566  SmallBitVector FilenameEquivalence(Function.Filenames.size(), false);
567  for (unsigned I = 0, E = Function.Filenames.size(); I < E; ++I)
568  if (SourceFile == Function.Filenames[I])
569  FilenameEquivalence[I] = true;
570  return FilenameEquivalence;
571 }
572 
573 /// Return the ID of the file where the definition of the function is located.
575  SmallBitVector IsNotExpandedFile(Function.Filenames.size(), true);
576  for (const auto &CR : Function.CountedRegions)
578  IsNotExpandedFile[CR.ExpandedFileID] = false;
579  int I = IsNotExpandedFile.find_first();
580  if (I == -1)
581  return None;
582  return I;
583 }
584 
585 /// Check if SourceFile is the file that contains the definition of
586 /// the Function. Return the ID of the file in that case or None otherwise.
588  const FunctionRecord &Function) {
590  if (I && SourceFile == Function.Filenames[*I])
591  return I;
592  return None;
593 }
594 
595 static bool isExpansion(const CountedRegion &R, unsigned FileID) {
596  return R.Kind == CounterMappingRegion::ExpansionRegion && R.FileID == FileID;
597 }
598 
600  CoverageData FileCoverage(Filename);
601  std::vector<CountedRegion> Regions;
602 
603  for (const auto &Function : Functions) {
604  auto MainFileID = findMainViewFileID(Filename, Function);
605  auto FileIDs = gatherFileIDs(Filename, Function);
606  for (const auto &CR : Function.CountedRegions)
607  if (FileIDs.test(CR.FileID)) {
608  Regions.push_back(CR);
609  if (MainFileID && isExpansion(CR, *MainFileID))
610  FileCoverage.Expansions.emplace_back(CR, Function);
611  }
612  }
613 
614  DEBUG(dbgs() << "Emitting segments for file: " << Filename << "\n");
615  FileCoverage.Segments = SegmentBuilder::buildSegments(Regions);
616 
617  return FileCoverage;
618 }
619 
620 std::vector<InstantiationGroup>
622  FunctionInstantiationSetCollector InstantiationSetCollector;
623  for (const auto &Function : Functions) {
624  auto MainFileID = findMainViewFileID(Filename, Function);
625  if (!MainFileID)
626  continue;
627  InstantiationSetCollector.insert(Function, *MainFileID);
628  }
629 
630  std::vector<InstantiationGroup> Result;
631  for (auto &InstantiationSet : InstantiationSetCollector) {
632  InstantiationGroup IG{InstantiationSet.first.first,
633  InstantiationSet.first.second,
634  std::move(InstantiationSet.second)};
635  Result.emplace_back(std::move(IG));
636  }
637  return Result;
638 }
639 
642  auto MainFileID = findMainViewFileID(Function);
643  if (!MainFileID)
644  return CoverageData();
645 
646  CoverageData FunctionCoverage(Function.Filenames[*MainFileID]);
647  std::vector<CountedRegion> Regions;
648  for (const auto &CR : Function.CountedRegions)
649  if (CR.FileID == *MainFileID) {
650  Regions.push_back(CR);
651  if (isExpansion(CR, *MainFileID))
652  FunctionCoverage.Expansions.emplace_back(CR, Function);
653  }
654 
655  DEBUG(dbgs() << "Emitting segments for function: " << Function.Name << "\n");
656  FunctionCoverage.Segments = SegmentBuilder::buildSegments(Regions);
657 
658  return FunctionCoverage;
659 }
660 
662  const ExpansionRecord &Expansion) const {
663  CoverageData ExpansionCoverage(
664  Expansion.Function.Filenames[Expansion.FileID]);
665  std::vector<CountedRegion> Regions;
666  for (const auto &CR : Expansion.Function.CountedRegions)
667  if (CR.FileID == Expansion.FileID) {
668  Regions.push_back(CR);
669  if (isExpansion(CR, Expansion.FileID))
670  ExpansionCoverage.Expansions.emplace_back(CR, Expansion.Function);
671  }
672 
673  DEBUG(dbgs() << "Emitting segments for expansion of file " << Expansion.FileID
674  << "\n");
675  ExpansionCoverage.Segments = SegmentBuilder::buildSegments(Regions);
676 
677  return ExpansionCoverage;
678 }
679 
680 LineCoverageStats::LineCoverageStats(
682  const CoverageSegment *WrappedSegment, unsigned Line)
683  : ExecutionCount(0), HasMultipleRegions(false), Mapped(false), Line(Line),
684  LineSegments(LineSegments), WrappedSegment(WrappedSegment) {
685  // Find the minimum number of regions which start in this line.
686  unsigned MinRegionCount = 0;
687  auto isStartOfRegion = [](const CoverageSegment *S) {
688  return !S->IsGapRegion && S->HasCount && S->IsRegionEntry;
689  };
690  for (unsigned I = 0; I < LineSegments.size() && MinRegionCount < 2; ++I)
691  if (isStartOfRegion(LineSegments[I]))
692  ++MinRegionCount;
693 
694  bool StartOfSkippedRegion = !LineSegments.empty() &&
695  !LineSegments.front()->HasCount &&
696  LineSegments.front()->IsRegionEntry;
697 
698  HasMultipleRegions = MinRegionCount > 1;
699  Mapped =
700  !StartOfSkippedRegion &&
701  ((WrappedSegment && WrappedSegment->HasCount) || (MinRegionCount > 0));
702 
703  if (!Mapped)
704  return;
705 
706  // Pick the max count from the non-gap, region entry segments and the
707  // wrapped count.
708  if (WrappedSegment)
709  ExecutionCount = WrappedSegment->Count;
710  if (!MinRegionCount)
711  return;
712  for (const auto *LS : LineSegments)
713  if (isStartOfRegion(LS))
714  ExecutionCount = std::max(ExecutionCount, LS->Count);
715 }
716 
718  if (Next == CD.end()) {
720  Ended = true;
721  return *this;
722  }
723  if (Segments.size())
724  WrappedSegment = Segments.back();
725  Segments.clear();
726  while (Next != CD.end() && Next->Line == Line)
727  Segments.push_back(&*Next++);
728  Stats = LineCoverageStats(Segments, WrappedSegment, Line);
729  ++Line;
730  return *this;
731 }
732 
734  switch (Err) {
736  return "Success";
738  return "End of File";
740  return "No coverage data found";
742  return "Unsupported coverage format version";
744  return "Truncated coverage data";
746  return "Malformed coverage data";
747  }
748  llvm_unreachable("A value of coveragemap_error has no message.");
749 }
750 
751 namespace {
752 
753 // FIXME: This class is only here to support the transition to llvm::Error. It
754 // will be removed once this transition is complete. Clients should prefer to
755 // deal with the Error value directly, rather than converting to error_code.
756 class CoverageMappingErrorCategoryType : public std::error_category {
757  const char *name() const noexcept override { return "llvm.coveragemap"; }
758  std::string message(int IE) const override {
759  return getCoverageMapErrString(static_cast<coveragemap_error>(IE));
760  }
761 };
762 
763 } // end anonymous namespace
764 
765 std::string CoverageMapError::message() const {
766  return getCoverageMapErrString(Err);
767 }
768 
770 
772  return *ErrorCategory;
773 }
774 
775 char CoverageMapError::ID = 0;
const T & front() const
front - Get the first element.
Definition: ArrayRef.h:152
const NoneType None
Definition: None.h:24
uint64_t CallInst * C
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:245
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:236
This is a &#39;bitvector&#39; (really, a variable-sized bit array), optimized for the case when the array is ...
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
static Counter getZero()
Return the counter that represents the number zero.
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:136
iterator end()
Definition: Function.h:636
void setCounts(ArrayRef< uint64_t > Counts)
static instrprof_error take(Error E)
Consume an Error and return the raw enum value contained within it.
Definition: InstrProf.h:324
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
static SmallBitVector gatherFileIDs(StringRef SourceFile, const FunctionRecord &Function)
A Counter expression is a value that represents an arithmetic operation with two counters.
Error takeError()
Take ownership of the stored error.
Definition: Error.h:537
ArrayRef< CounterMappingRegion > MappingRegions
CoverageData getCoverageForFile(StringRef Filename) const
Get the coverage for a particular file.
Iterator over Functions, optionally filtered to a single file.
A GapRegion is like a CodeRegion, but its count is only set as the line execution count when its the ...
ArrayRef< CounterExpression > Expressions
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
An iterator over the LineCoverageStats objects for lines described by a CoverageData instance...
friend const_iterator begin(StringRef path, Style style)
Get begin iterator over path.
Definition: Path.cpp:236
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
block placement Basic Block Placement Stats
StringRef getFuncNameWithoutPrefix(StringRef PGOFuncName, StringRef FileName="<unknown>")
Given a PGO function name, remove the filename prefix and return the original (static) function name...
Definition: InstrProf.cpp:275
std::pair< unsigned, unsigned > LineColPair
void dump(const Counter &C, raw_ostream &OS) const
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
Coverage information to be processed or displayed.
static Expected< std::unique_ptr< CoverageMapping > > load(ArrayRef< std::unique_ptr< CoverageMappingReader >> CoverageReaders, IndexedInstrProfReader &ProfileReader)
Load the coverage mapping using the given readers.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
Counter add(Counter LHS, Counter RHS)
Return a counter that represents the expression that adds LHS and RHS.
iterator begin()
Definition: Function.h:634
const std::error_category & coveragemap_category()
The execution count information starting at a point in a file.
friend const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:245
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:291
Coverage mapping information for a single function.
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:78
An instantiation group contains a FunctionRecord list, such that each record corresponds to a distinc...
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:116
A CodeRegion associates some code with a counter.
A Counter mapping context is used to connect the counters, expressions and the obtained counter value...
bool IsRegionEntry
Whether this enters a new region or returns to a previous count.
static ManagedStatic< _object_error_category > error_category
Definition: Error.cpp:74
static const unsigned End
static ManagedStatic< CoverageMappingErrorCategoryType > ErrorCategory
Associates a source range with an execution count.
iterator erase(const_iterator CI)
Definition: SmallVector.h:447
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:962
MutableArrayRef< T > drop_back(size_t N=1) const
Definition: ArrayRef.h:367
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Counter subtract(Counter LHS, Counter RHS)
Return a counter that represents the expression that subtracts RHS from LHS.
CoverageData getCoverageForFunction(const FunctionRecord &Function) const
Get the coverage for a particular function.
Code coverage information for a single function.
static ErrorSuccess success()
Create a success value.
Definition: Error.h:313
static std::string getCoverageMapErrString(coveragemap_error Err)
Coverage statistics for a single line.
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:862
static bool isExpansion(const CountedRegion &R, unsigned FileID)
uint64_t Count
The execution count, or zero if no count was recorded.
bool HasCount
When false, the segment was uninstrumented or skipped.
static Expected< std::unique_ptr< BinaryCoverageReader > > create(std::unique_ptr< MemoryBuffer > &ObjectBuffer, StringRef Arch)
An ExpansionRegion represents a file expansion region that associates a source range with the expansi...
A SkippedRegion represents a source range with code that was skipped by a preprocessor or similar mea...
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
iterator begin() const
Definition: ArrayRef.h:331
The mapping of profile information to coverage data.
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileOrSTDIN(const Twine &Filename, int64_t FileSize=-1, bool RequiresNullTerminator=true)
Open the specified file as a MemoryBuffer, or open stdin if the Filename is "-".
std::vector< InstantiationGroup > getInstantiationGroups(StringRef Filename) const
Get the list of function instantiation groups in a particular file.
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:120
std::string message() const override
Return the error message as a string.
void emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:654
unsigned getExpressionID() const
CounterKind getKind() const
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:61
instrprof_error
Definition: InstrProf.h:280
#define I(x, y, z)
Definition: MD5.cpp:58
static Optional< unsigned > findMainViewFileID(const FunctionRecord &Function)
Return the ID of the file where the definition of the function is located.
Expected< int64_t > evaluate(const Counter &C) const
Return the number of times that a region of code associated with this counter was executed...
std::vector< CountedRegion > CountedRegions
Regions in the function along with their counts.
std::string Name
Raw function name.
unsigned FileID
The abstract file this expansion covers.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool IsGapRegion
Whether this enters a gap region.
unsigned getCounterID() const
LLVM Value Representation.
Definition: Value.h:73
static const char * name
std::vector< std::string > Filenames
Associated files.
static Expected< std::unique_ptr< IndexedInstrProfReader > > create(const Twine &Path)
Factory method to create an indexed reader.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
iterator end() const
Definition: ArrayRef.h:332
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
#define DEBUG(X)
Definition: Debug.h:118
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Reader for the indexed binary instrprof format.
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:61
void sort(Policy policy, RandomAccessIterator Start, RandomAccessIterator End, const Comparator &Comp=Comparator())
Definition: Parallel.h:199
static Counter getExpression(unsigned ExpressionId)
Return the counter that corresponds to a specific addition counter expression.
CoverageData getCoverageForExpansion(const ExpansionRecord &Expansion) const
Get the coverage for an expansion within a coverage set.
A Counter is an abstract value that describes how to compute the execution count for a region of code...
static Counter getCounter(unsigned CounterId)
Return the counter that corresponds to a specific profile counter.
const FunctionRecord & Function
Coverage for the expansion.
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:144
std::vector< StringRef > getUniqueSourceFiles() const
Returns a lexicographically sorted, unique list of files that are covered.
detail::enumerator< R > enumerate(R &&TheRange)
Given an input range, returns a new range whose values are are pair (A,B) such that A is the 0-based ...
Definition: STLExtras.h:1118
Error getFunctionCounts(StringRef FuncName, uint64_t FuncHash, std::vector< uint64_t > &Counts)
Fill Counts with the profile data for the given function name.
Coverage information for a macro expansion or #included file.