contrib/llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

   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
  15 #include "llvm/ProfileData/Coverage/CoverageMapping.h"
  16 #include "llvm/ADT/ArrayRef.h"
  17 #include "llvm/ADT/DenseMap.h"
  18 #include "llvm/ADT/None.h"
  19 #include "llvm/ADT/Optional.h"
  20 #include "llvm/ADT/SmallBitVector.h"
  21 #include "llvm/ADT/SmallVector.h"
  22 #include "llvm/ADT/StringRef.h"
  23 #include "llvm/ProfileData/Coverage/CoverageMappingReader.h"
  24 #include "llvm/ProfileData/InstrProfReader.h"
  25 #include "llvm/Support/Debug.h"
  26 #include "llvm/Support/Errc.h"
  27 #include "llvm/Support/Error.h"
  28 #include "llvm/Support/ErrorHandling.h"
  29 #include "llvm/Support/ManagedStatic.h"
  30 #include "llvm/Support/MemoryBuffer.h"
  31 #include "llvm/Support/raw_ostream.h"
  32 #include <algorithm>
  33 #include <cassert>
  34 #include <cstdint>
  35 #include <iterator>
  36 #include <memory>
  37 #include <string>
  38 #include <system_error>
  39 #include <utility>
  40 #include <vector>
  41
  42 using namespace llvm;
  43 using namespace coverage;
  44
  45 #define DEBUG_TYPE "coverage-mapping"
  46
  47 Counter CounterExpressionBuilder::get(const CounterExpression &E) {
  48   auto It = ExpressionIndices.find(E);
  49   if (It != ExpressionIndices.end())
  50     return Counter::getExpression(It->second);
  51   unsigned I = Expressions.size();
  52   Expressions.push_back(E);
  53   ExpressionIndices[E] = I;
  54   return Counter::getExpression(I);
  55 }
  56
  57 void CounterExpressionBuilder::extractTerms(Counter C, int Factor,
  58                                             SmallVectorImpl<Term> &Terms) {
  59   switch (C.getKind()) {
  60   case Counter::Zero:
  61     break;
  62   case Counter::CounterValueReference:
  63     Terms.emplace_back(C.getCounterID(), Factor);
  64     break;
  65   case Counter::Expression:
  66     const auto &E = Expressions[C.getExpressionID()];
  67     extractTerms(E.LHS, Factor, Terms);
  68     extractTerms(
  69         E.RHS, E.Kind == CounterExpression::Subtract ? -Factor : Factor, Terms);
  70     break;
  71   }
  72 }
  73
  74 Counter CounterExpressionBuilder::simplify(Counter ExpressionTree) {
  75   // Gather constant terms.
  76   SmallVector<Term, 32> Terms;
  77   extractTerms(ExpressionTree, +1, Terms);
  78
  79   // If there are no terms, this is just a zero. The algorithm below assumes at
  80   // least one term.
  81   if (Terms.size() == 0)
  82     return Counter::getZero();
  83
  84   // Group the terms by counter ID.
  85   std::sort(Terms.begin(), Terms.end(), [](const Term &LHS, const Term &RHS) {
  86     return LHS.CounterID < RHS.CounterID;
  87   });
  88
  89   // Combine terms by counter ID to eliminate counters that sum to zero.
  90   auto Prev = Terms.begin();
  91   for (auto I = Prev + 1, E = Terms.end(); I != E; ++I) {
  92     if (I->CounterID == Prev->CounterID) {
  93       Prev->Factor += I->Factor;
  94       continue;
  95     }
  96     ++Prev;
  97     *Prev = *I;
  98   }
  99   Terms.erase(++Prev, Terms.end());
 100
 101   Counter C;
 102   // Create additions. We do this before subtractions to avoid constructs like
 103   // ((0 - X) + Y), as opposed to (Y - X).
 104   for (auto T : Terms) {
 105     if (T.Factor <= 0)
 106       continue;
 107     for (int I = 0; I < T.Factor; ++I)
 108       if (C.isZero())
 109         C = Counter::getCounter(T.CounterID);
 110       else
 111         C = get(CounterExpression(CounterExpression::Add, C,
 112                                   Counter::getCounter(T.CounterID)));
 113   }
 114
 115   // Create subtractions.
 116   for (auto T : Terms) {
 117     if (T.Factor >= 0)
 118       continue;
 119     for (int I = 0; I < -T.Factor; ++I)
 120       C = get(CounterExpression(CounterExpression::Subtract, C,
 121                                 Counter::getCounter(T.CounterID)));
 122   }
 123   return C;
 124 }
 125
 126 Counter CounterExpressionBuilder::add(Counter LHS, Counter RHS) {
 127   return simplify(get(CounterExpression(CounterExpression::Add, LHS, RHS)));
 128 }
 129
 130 Counter CounterExpressionBuilder::subtract(Counter LHS, Counter RHS) {
 131   return simplify(
 132       get(CounterExpression(CounterExpression::Subtract, LHS, RHS)));
 133 }
 134
 135 void CounterMappingContext::dump(const Counter &C, raw_ostream &OS) const {
 136   switch (C.getKind()) {
 137   case Counter::Zero:
 138     OS << '0';
 139     return;
 140   case Counter::CounterValueReference:
 141     OS << '#' << C.getCounterID();
 142     break;
 143   case Counter::Expression: {
 144     if (C.getExpressionID() >= Expressions.size())
 145       return;
 146     const auto &E = Expressions[C.getExpressionID()];
 147     OS << '(';
 148     dump(E.LHS, OS);
 149     OS << (E.Kind == CounterExpression::Subtract ? " - " : " + ");
 150     dump(E.RHS, OS);
 151     OS << ')';
 152     break;
 153   }
 154   }
 155   if (CounterValues.empty())
 156     return;
 157   Expected<int64_t> Value = evaluate(C);
 158   if (auto E = Value.takeError()) {
 159     consumeError(std::move(E));
 160     return;
 161   }
 162   OS << '[' << *Value << ']';
 163 }
 164
 165 Expected<int64_t> CounterMappingContext::evaluate(const Counter &C) const {
 166   switch (C.getKind()) {
 167   case Counter::Zero:
 168     return 0;
 169   case Counter::CounterValueReference:
 170     if (C.getCounterID() >= CounterValues.size())
 171       return errorCodeToError(errc::argument_out_of_domain);
 172     return CounterValues[C.getCounterID()];
 173   case Counter::Expression: {
 174     if (C.getExpressionID() >= Expressions.size())
 175       return errorCodeToError(errc::argument_out_of_domain);
 176     const auto &E = Expressions[C.getExpressionID()];
 177     Expected<int64_t> LHS = evaluate(E.LHS);
 178     if (!LHS)
 179       return LHS;
 180     Expected<int64_t> RHS = evaluate(E.RHS);
 181     if (!RHS)
 182       return RHS;
 183     return E.Kind == CounterExpression::Subtract ? *LHS - *RHS : *LHS + *RHS;
 184   }
 185   }
 186   llvm_unreachable("Unhandled CounterKind");
 187 }
 188
 189 void FunctionRecordIterator::skipOtherFiles() {
 190   while (Current != Records.end() && !Filename.empty() &&
 191          Filename != Current->Filenames[0])
 192     ++Current;
 193   if (Current == Records.end())
 194     *this = FunctionRecordIterator();
 195 }
 196
 197 Error CoverageMapping::loadFunctionRecord(
 198     const CoverageMappingRecord &Record,
 199     IndexedInstrProfReader &ProfileReader) {
 200   StringRef OrigFuncName = Record.FunctionName;
 201   if (OrigFuncName.empty())
 202     return make_error<CoverageMapError>(coveragemap_error::malformed);
 203
 204   if (Record.Filenames.empty())
 205     OrigFuncName = getFuncNameWithoutPrefix(OrigFuncName);
 206   else
 207     OrigFuncName = getFuncNameWithoutPrefix(OrigFuncName, Record.Filenames[0]);
 208
 209   // Don't load records for functions we've already seen.
 210   if (!FunctionNames.insert(OrigFuncName).second)
 211     return Error::success();
 212
 213   CounterMappingContext Ctx(Record.Expressions);
 214
 215   std::vector<uint64_t> Counts;
 216   if (Error E = ProfileReader.getFunctionCounts(Record.FunctionName,
 217                                                 Record.FunctionHash, Counts)) {
 218     instrprof_error IPE = InstrProfError::take(std::move(E));
 219     if (IPE == instrprof_error::hash_mismatch) {
 220       MismatchedFunctionCount++;
 221       return Error::success();
 222     } else if (IPE != instrprof_error::unknown_function)
 223       return make_error<InstrProfError>(IPE);
 224     Counts.assign(Record.MappingRegions.size(), 0);
 225   }
 226   Ctx.setCounts(Counts);
 227
 228   assert(!Record.MappingRegions.empty() && "Function has no regions");
 229
 230   FunctionRecord Function(OrigFuncName, Record.Filenames);
 231   for (const auto &Region : Record.MappingRegions) {
 232     Expected<int64_t> ExecutionCount = Ctx.evaluate(Region.Count);
 233     if (auto E = ExecutionCount.takeError()) {
 234       consumeError(std::move(E));
 235       return Error::success();
 236     }
 237     Function.pushRegion(Region, *ExecutionCount);
 238   }
 239   if (Function.CountedRegions.size() != Record.MappingRegions.size()) {
 240     MismatchedFunctionCount++;
 241     return Error::success();
 242   }
 243
 244   Functions.push_back(std::move(Function));
 245   return Error::success();
 246 }
 247
 248 Expected<std::unique_ptr<CoverageMapping>> CoverageMapping::load(
 249     ArrayRef<std::unique_ptr<CoverageMappingReader>> CoverageReaders,
 250     IndexedInstrProfReader &ProfileReader) {
 251   auto Coverage = std::unique_ptr<CoverageMapping>(new CoverageMapping());
 252
 253   for (const auto &CoverageReader : CoverageReaders)
 254     for (const auto &Record : *CoverageReader)
 255       if (Error E = Coverage->loadFunctionRecord(Record, ProfileReader))
 256         return std::move(E);
 257
 258   return std::move(Coverage);
 259 }
 260
 261 Expected<std::unique_ptr<CoverageMapping>>
 262 CoverageMapping::load(ArrayRef<StringRef> ObjectFilenames,
 263                       StringRef ProfileFilename, StringRef Arch) {
 264   auto ProfileReaderOrErr = IndexedInstrProfReader::create(ProfileFilename);
 265   if (Error E = ProfileReaderOrErr.takeError())
 266     return std::move(E);
 267   auto ProfileReader = std::move(ProfileReaderOrErr.get());
 268
 269   SmallVector<std::unique_ptr<CoverageMappingReader>, 4> Readers;
 270   SmallVector<std::unique_ptr<MemoryBuffer>, 4> Buffers;
 271   for (StringRef ObjectFilename : ObjectFilenames) {
 272     auto CovMappingBufOrErr = MemoryBuffer::getFileOrSTDIN(ObjectFilename);
 273     if (std::error_code EC = CovMappingBufOrErr.getError())
 274       return errorCodeToError(EC);
 275     auto CoverageReaderOrErr =
 276         BinaryCoverageReader::create(CovMappingBufOrErr.get(), Arch);
 277     if (Error E = CoverageReaderOrErr.takeError())
 278       return std::move(E);
 279     Readers.push_back(std::move(CoverageReaderOrErr.get()));
 280     Buffers.push_back(std::move(CovMappingBufOrErr.get()));
 281   }
 282   return load(Readers, *ProfileReader);
 283 }
 284
 285 namespace {
 286
 287 /// \brief Distributes functions into instantiation sets.
 288 ///
 289 /// An instantiation set is a collection of functions that have the same source
 290 /// code, ie, template functions specializations.
 291 class FunctionInstantiationSetCollector {
 292   using MapT = DenseMap<std::pair<unsigned, unsigned>,
 293                         std::vector<const FunctionRecord *>>;
 294   MapT InstantiatedFunctions;
 295
 296 public:
 297   void insert(const FunctionRecord &Function, unsigned FileID) {
 298     auto I = Function.CountedRegions.begin(), E = Function.CountedRegions.end();
 299     while (I != E && I->FileID != FileID)
 300       ++I;
 301     assert(I != E && "function does not cover the given file");
 302     auto &Functions = InstantiatedFunctions[I->startLoc()];
 303     Functions.push_back(&Function);
 304   }
 305
 306   MapT::iterator begin() { return InstantiatedFunctions.begin(); }
 307   MapT::iterator end() { return InstantiatedFunctions.end(); }
 308 };
 309
 310 class SegmentBuilder {
 311   std::vector<CoverageSegment> &Segments;
 312   SmallVector<const CountedRegion *, 8> ActiveRegions;
 313
 314   SegmentBuilder(std::vector<CoverageSegment> &Segments) : Segments(Segments) {}
 315
 316   /// Start a segment with no count specified.
 317   void startSegment(unsigned Line, unsigned Col) {
 318     DEBUG(dbgs() << "Top level segment at " << Line << ":" << Col << "\n");
 319     Segments.emplace_back(Line, Col, /*IsRegionEntry=*/false);
 320   }
 321
 322   /// Start a segment with the given Region's count.
 323   void startSegment(unsigned Line, unsigned Col, bool IsRegionEntry,
 324                     const CountedRegion &Region) {
 325     // Avoid creating empty regions.
 326     if (!Segments.empty() && Segments.back().Line == Line &&
 327         Segments.back().Col == Col)
 328       Segments.pop_back();
 329     DEBUG(dbgs() << "Segment at " << Line << ":" << Col);
 330     // Set this region's count.
 331     if (Region.Kind != CounterMappingRegion::SkippedRegion) {
 332       DEBUG(dbgs() << " with count " << Region.ExecutionCount);
 333       Segments.emplace_back(Line, Col, Region.ExecutionCount, IsRegionEntry);
 334     } else
 335       Segments.emplace_back(Line, Col, IsRegionEntry);
 336     DEBUG(dbgs() << "\n");
 337   }
 338
 339   /// Start a segment for the given region.
 340   void startSegment(const CountedRegion &Region) {
 341     startSegment(Region.LineStart, Region.ColumnStart, true, Region);
 342   }
 343
 344   /// Pop the top region off of the active stack, starting a new segment with
 345   /// the containing Region's count.
 346   void popRegion() {
 347     const CountedRegion *Active = ActiveRegions.back();
 348     unsigned Line = Active->LineEnd, Col = Active->ColumnEnd;
 349     ActiveRegions.pop_back();
 350     if (ActiveRegions.empty())
 351       startSegment(Line, Col);
 352     else
 353       startSegment(Line, Col, false, *ActiveRegions.back());
 354   }
 355
 356   void buildSegmentsImpl(ArrayRef<CountedRegion> Regions) {
 357     for (const auto &Region : Regions) {
 358       // Pop any regions that end before this one starts.
 359       while (!ActiveRegions.empty() &&
 360              ActiveRegions.back()->endLoc() <= Region.startLoc())
 361         popRegion();
 362       // Add this region to the stack.
 363       ActiveRegions.push_back(&Region);
 364       startSegment(Region);
 365     }
 366     // Pop any regions that are left in the stack.
 367     while (!ActiveRegions.empty())
 368       popRegion();
 369   }
 370
 371   /// Sort a nested sequence of regions from a single file.
 372   static void sortNestedRegions(MutableArrayRef<CountedRegion> Regions) {
 373     std::sort(Regions.begin(), Regions.end(), [](const CountedRegion &LHS,
 374                                                  const CountedRegion &RHS) {
 375       if (LHS.startLoc() != RHS.startLoc())
 376         return LHS.startLoc() < RHS.startLoc();
 377       if (LHS.endLoc() != RHS.endLoc())
 378         // When LHS completely contains RHS, we sort LHS first.
 379         return RHS.endLoc() < LHS.endLoc();
 380       // If LHS and RHS cover the same area, we need to sort them according
 381       // to their kinds so that the most suitable region will become "active"
 382       // in combineRegions(). Because we accumulate counter values only from
 383       // regions of the same kind as the first region of the area, prefer
 384       // CodeRegion to ExpansionRegion and ExpansionRegion to SkippedRegion.
 385       static_assert(CounterMappingRegion::CodeRegion <
 386                             CounterMappingRegion::ExpansionRegion &&
 387                         CounterMappingRegion::ExpansionRegion <
 388                             CounterMappingRegion::SkippedRegion,
 389                     "Unexpected order of region kind values");
 390       return LHS.Kind < RHS.Kind;
 391     });
 392   }
 393
 394   /// Combine counts of regions which cover the same area.
 395   static ArrayRef<CountedRegion>
 396   combineRegions(MutableArrayRef<CountedRegion> Regions) {
 397     if (Regions.empty())
 398       return Regions;
 399     auto Active = Regions.begin();
 400     auto End = Regions.end();
 401     for (auto I = Regions.begin() + 1; I != End; ++I) {
 402       if (Active->startLoc() != I->startLoc() ||
 403           Active->endLoc() != I->endLoc()) {
 404         // Shift to the next region.
 405         ++Active;
 406         if (Active != I)
 407           *Active = *I;
 408         continue;
 409       }
 410       // Merge duplicate region.
 411       // If CodeRegions and ExpansionRegions cover the same area, it's probably
 412       // a macro which is fully expanded to another macro. In that case, we need
 413       // to accumulate counts only from CodeRegions, or else the area will be
 414       // counted twice.
 415       // On the other hand, a macro may have a nested macro in its body. If the
 416       // outer macro is used several times, the ExpansionRegion for the nested
 417       // macro will also be added several times. These ExpansionRegions cover
 418       // the same source locations and have to be combined to reach the correct
 419       // value for that area.
 420       // We add counts of the regions of the same kind as the active region
 421       // to handle the both situations.
 422       if (I->Kind == Active->Kind)
 423         Active->ExecutionCount += I->ExecutionCount;
 424     }
 425     return Regions.drop_back(std::distance(++Active, End));
 426   }
 427
 428 public:
 429   /// Build a list of CoverageSegments from a list of Regions.
 430   static std::vector<CoverageSegment>
 431   buildSegments(MutableArrayRef<CountedRegion> Regions) {
 432     std::vector<CoverageSegment> Segments;
 433     SegmentBuilder Builder(Segments);
 434
 435     sortNestedRegions(Regions);
 436     ArrayRef<CountedRegion> CombinedRegions = combineRegions(Regions);
 437
 438     Builder.buildSegmentsImpl(CombinedRegions);
 439     return Segments;
 440   }
 441 };
 442
 443 } // end anonymous namespace
 444
 445 std::vector<StringRef> CoverageMapping::getUniqueSourceFiles() const {
 446   std::vector<StringRef> Filenames;
 447   for (const auto &Function : getCoveredFunctions())
 448     Filenames.insert(Filenames.end(), Function.Filenames.begin(),
 449                      Function.Filenames.end());
 450   std::sort(Filenames.begin(), Filenames.end());
 451   auto Last = std::unique(Filenames.begin(), Filenames.end());
 452   Filenames.erase(Last, Filenames.end());
 453   return Filenames;
 454 }
 455
 456 static SmallBitVector gatherFileIDs(StringRef SourceFile,
 457                                     const FunctionRecord &Function) {
 458   SmallBitVector FilenameEquivalence(Function.Filenames.size(), false);
 459   for (unsigned I = 0, E = Function.Filenames.size(); I < E; ++I)
 460     if (SourceFile == Function.Filenames[I])
 461       FilenameEquivalence[I] = true;
 462   return FilenameEquivalence;
 463 }
 464
 465 /// Return the ID of the file where the definition of the function is located.
 466 static Optional<unsigned> findMainViewFileID(const FunctionRecord &Function) {
 467   SmallBitVector IsNotExpandedFile(Function.Filenames.size(), true);
 468   for (const auto &CR : Function.CountedRegions)
 469     if (CR.Kind == CounterMappingRegion::ExpansionRegion)
 470       IsNotExpandedFile[CR.ExpandedFileID] = false;
 471   int I = IsNotExpandedFile.find_first();
 472   if (I == -1)
 473     return None;
 474   return I;
 475 }
 476
 477 /// Check if SourceFile is the file that contains the definition of
 478 /// the Function. Return the ID of the file in that case or None otherwise.
 479 static Optional<unsigned> findMainViewFileID(StringRef SourceFile,
 480                                              const FunctionRecord &Function) {
 481   Optional<unsigned> I = findMainViewFileID(Function);
 482   if (I && SourceFile == Function.Filenames[*I])
 483     return I;
 484   return None;
 485 }
 486
 487 static bool isExpansion(const CountedRegion &R, unsigned FileID) {
 488   return R.Kind == CounterMappingRegion::ExpansionRegion && R.FileID == FileID;
 489 }
 490
 491 CoverageData CoverageMapping::getCoverageForFile(StringRef Filename) const {
 492   CoverageData FileCoverage(Filename);
 493   std::vector<CountedRegion> Regions;
 494
 495   for (const auto &Function : Functions) {
 496     auto MainFileID = findMainViewFileID(Filename, Function);
 497     auto FileIDs = gatherFileIDs(Filename, Function);
 498     for (const auto &CR : Function.CountedRegions)
 499       if (FileIDs.test(CR.FileID)) {
 500         Regions.push_back(CR);
 501         if (MainFileID && isExpansion(CR, *MainFileID))
 502           FileCoverage.Expansions.emplace_back(CR, Function);
 503       }
 504   }
 505
 506   DEBUG(dbgs() << "Emitting segments for file: " << Filename << "\n");
 507   FileCoverage.Segments = SegmentBuilder::buildSegments(Regions);
 508
 509   return FileCoverage;
 510 }
 511
 512 std::vector<const FunctionRecord *>
 513 CoverageMapping::getInstantiations(StringRef Filename) const {
 514   FunctionInstantiationSetCollector InstantiationSetCollector;
 515   for (const auto &Function : Functions) {
 516     auto MainFileID = findMainViewFileID(Filename, Function);
 517     if (!MainFileID)
 518       continue;
 519     InstantiationSetCollector.insert(Function, *MainFileID);
 520   }
 521
 522   std::vector<const FunctionRecord *> Result;
 523   for (const auto &InstantiationSet : InstantiationSetCollector) {
 524     if (InstantiationSet.second.size() < 2)
 525       continue;
 526     Result.insert(Result.end(), InstantiationSet.second.begin(),
 527                   InstantiationSet.second.end());
 528   }
 529   return Result;
 530 }
 531
 532 CoverageData
 533 CoverageMapping::getCoverageForFunction(const FunctionRecord &Function) const {
 534   auto MainFileID = findMainViewFileID(Function);
 535   if (!MainFileID)
 536     return CoverageData();
 537
 538   CoverageData FunctionCoverage(Function.Filenames[*MainFileID]);
 539   std::vector<CountedRegion> Regions;
 540   for (const auto &CR : Function.CountedRegions)
 541     if (CR.FileID == *MainFileID) {
 542       Regions.push_back(CR);
 543       if (isExpansion(CR, *MainFileID))
 544         FunctionCoverage.Expansions.emplace_back(CR, Function);
 545     }
 546
 547   DEBUG(dbgs() << "Emitting segments for function: " << Function.Name << "\n");
 548   FunctionCoverage.Segments = SegmentBuilder::buildSegments(Regions);
 549
 550   return FunctionCoverage;
 551 }
 552
 553 CoverageData CoverageMapping::getCoverageForExpansion(
 554     const ExpansionRecord &Expansion) const {
 555   CoverageData ExpansionCoverage(
 556       Expansion.Function.Filenames[Expansion.FileID]);
 557   std::vector<CountedRegion> Regions;
 558   for (const auto &CR : Expansion.Function.CountedRegions)
 559     if (CR.FileID == Expansion.FileID) {
 560       Regions.push_back(CR);
 561       if (isExpansion(CR, Expansion.FileID))
 562         ExpansionCoverage.Expansions.emplace_back(CR, Expansion.Function);
 563     }
 564
 565   DEBUG(dbgs() << "Emitting segments for expansion of file " << Expansion.FileID
 566                << "\n");
 567   ExpansionCoverage.Segments = SegmentBuilder::buildSegments(Regions);
 568
 569   return ExpansionCoverage;
 570 }
 571
 572 static std::string getCoverageMapErrString(coveragemap_error Err) {
 573   switch (Err) {
 574   case coveragemap_error::success:
 575     return "Success";
 576   case coveragemap_error::eof:
 577     return "End of File";
 578   case coveragemap_error::no_data_found:
 579     return "No coverage data found";
 580   case coveragemap_error::unsupported_version:
 581     return "Unsupported coverage format version";
 582   case coveragemap_error::truncated:
 583     return "Truncated coverage data";
 584   case coveragemap_error::malformed:
 585     return "Malformed coverage data";
 586   }
 587   llvm_unreachable("A value of coveragemap_error has no message.");
 588 }
 589
 590 namespace {
 591
 592 // FIXME: This class is only here to support the transition to llvm::Error. It
 593 // will be removed once this transition is complete. Clients should prefer to
 594 // deal with the Error value directly, rather than converting to error_code.
 595 class CoverageMappingErrorCategoryType : public std::error_category {
 596   const char *name() const noexcept override { return "llvm.coveragemap"; }
 597   std::string message(int IE) const override {
 598     return getCoverageMapErrString(static_cast<coveragemap_error>(IE));
 599   }
 600 };
 601
 602 } // end anonymous namespace
 603
 604 std::string CoverageMapError::message() const {
 605   return getCoverageMapErrString(Err);
 606 }
 607
 608 static ManagedStatic<CoverageMappingErrorCategoryType> ErrorCategory;
 609
 610 const std::error_category &llvm::coverage::coveragemap_category() {
 611   return *ErrorCategory;
 612 }
 613
 614 char CoverageMapError::ID = 0;