llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

   1 //===- CoverageMappingReader.cpp - Code coverage mapping reader -----------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file contains support for reading coverage mapping data for
  10 // instrumentation based coverage.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/ProfileData/Coverage/CoverageMappingReader.h"
  15 #include "llvm/ADT/ArrayRef.h"
  16 #include "llvm/ADT/DenseMap.h"
  17 #include "llvm/ADT/STLExtras.h"
  18 #include "llvm/ADT/SmallVector.h"
  19 #include "llvm/ADT/Statistic.h"
  20 #include "llvm/ADT/StringRef.h"
  21 #include "llvm/ADT/Triple.h"
  22 #include "llvm/Object/Binary.h"
  23 #include "llvm/Object/COFF.h"
  24 #include "llvm/Object/Error.h"
  25 #include "llvm/Object/MachOUniversal.h"
  26 #include "llvm/Object/ObjectFile.h"
  27 #include "llvm/ProfileData/InstrProf.h"
  28 #include "llvm/Support/Casting.h"
  29 #include "llvm/Support/Compression.h"
  30 #include "llvm/Support/Debug.h"
  31 #include "llvm/Support/Endian.h"
  32 #include "llvm/Support/Error.h"
  33 #include "llvm/Support/ErrorHandling.h"
  34 #include "llvm/Support/LEB128.h"
  35 #include "llvm/Support/MathExtras.h"
  36 #include "llvm/Support/Path.h"
  37 #include "llvm/Support/raw_ostream.h"
  38 #include <vector>
  39
  40 using namespace llvm;
  41 using namespace coverage;
  42 using namespace object;
  43
  44 #define DEBUG_TYPE "coverage-mapping"
  45
  46 STATISTIC(CovMapNumRecords, "The # of coverage function records");
  47 STATISTIC(CovMapNumUsedRecords, "The # of used coverage function records");
  48
  49 void CoverageMappingIterator::increment() {
  50   if (ReadErr != coveragemap_error::success)
  51     return;
  52
  53   // Check if all the records were read or if an error occurred while reading
  54   // the next record.
  55   if (auto E = Reader->readNextRecord(Record))
  56     handleAllErrors(std::move(E), [&](const CoverageMapError &CME) {
  57       if (CME.get() == coveragemap_error::eof)
  58         *this = CoverageMappingIterator();
  59       else
  60         ReadErr = CME.get();
  61     });
  62 }
  63
  64 Error RawCoverageReader::readULEB128(uint64_t &Result) {
  65   if (Data.empty())
  66     return make_error<CoverageMapError>(coveragemap_error::truncated);
  67   unsigned N = 0;
  68   Result = decodeULEB128(Data.bytes_begin(), &N);
  69   if (N > Data.size())
  70     return make_error<CoverageMapError>(coveragemap_error::malformed);
  71   Data = Data.substr(N);
  72   return Error::success();
  73 }
  74
  75 Error RawCoverageReader::readIntMax(uint64_t &Result, uint64_t MaxPlus1) {
  76   if (auto Err = readULEB128(Result))
  77     return Err;
  78   if (Result >= MaxPlus1)
  79     return make_error<CoverageMapError>(coveragemap_error::malformed);
  80   return Error::success();
  81 }
  82
  83 Error RawCoverageReader::readSize(uint64_t &Result) {
  84   if (auto Err = readULEB128(Result))
  85     return Err;
  86   // Sanity check the number.
  87   if (Result > Data.size())
  88     return make_error<CoverageMapError>(coveragemap_error::malformed);
  89   return Error::success();
  90 }
  91
  92 Error RawCoverageReader::readString(StringRef &Result) {
  93   uint64_t Length;
  94   if (auto Err = readSize(Length))
  95     return Err;
  96   Result = Data.substr(0, Length);
  97   Data = Data.substr(Length);
  98   return Error::success();
  99 }
 100
 101 Error RawCoverageFilenamesReader::read(CovMapVersion Version) {
 102   uint64_t NumFilenames;
 103   if (auto Err = readSize(NumFilenames))
 104     return Err;
 105   if (!NumFilenames)
 106     return make_error<CoverageMapError>(coveragemap_error::malformed);
 107
 108   if (Version < CovMapVersion::Version4)
 109     return readUncompressed(Version, NumFilenames);
 110
 111   // The uncompressed length may exceed the size of the encoded filenames.
 112   // Skip size validation.
 113   uint64_t UncompressedLen;
 114   if (auto Err = readULEB128(UncompressedLen))
 115     return Err;
 116
 117   uint64_t CompressedLen;
 118   if (auto Err = readSize(CompressedLen))
 119     return Err;
 120
 121   if (CompressedLen > 0) {
 122     if (!zlib::isAvailable())
 123       return make_error<CoverageMapError>(
 124           coveragemap_error::decompression_failed);
 125
 126     // Allocate memory for the decompressed filenames.
 127     SmallVector<char, 0> StorageBuf;
 128
 129     // Read compressed filenames.
 130     StringRef CompressedFilenames = Data.substr(0, CompressedLen);
 131     Data = Data.substr(CompressedLen);
 132     auto Err =
 133         zlib::uncompress(CompressedFilenames, StorageBuf, UncompressedLen);
 134     if (Err) {
 135       consumeError(std::move(Err));
 136       return make_error<CoverageMapError>(
 137           coveragemap_error::decompression_failed);
 138     }
 139
 140     StringRef UncompressedFilenames(StorageBuf.data(), StorageBuf.size());
 141     RawCoverageFilenamesReader Delegate(UncompressedFilenames, Filenames,
 142                                         CompilationDir);
 143     return Delegate.readUncompressed(Version, NumFilenames);
 144   }
 145
 146   return readUncompressed(Version, NumFilenames);
 147 }
 148
 149 Error RawCoverageFilenamesReader::readUncompressed(CovMapVersion Version,
 150                                                    uint64_t NumFilenames) {
 151   // Read uncompressed filenames.
 152   if (Version < CovMapVersion::Version6) {
 153     for (size_t I = 0; I < NumFilenames; ++I) {
 154       StringRef Filename;
 155       if (auto Err = readString(Filename))
 156         return Err;
 157       Filenames.push_back(Filename.str());
 158     }
 159   } else {
 160     StringRef CWD;
 161     if (auto Err = readString(CWD))
 162       return Err;
 163     Filenames.push_back(CWD.str());
 164
 165     for (size_t I = 1; I < NumFilenames; ++I) {
 166       StringRef Filename;
 167       if (auto Err = readString(Filename))
 168         return Err;
 169       if (sys::path::is_absolute(Filename)) {
 170         Filenames.push_back(Filename.str());
 171       } else {
 172         SmallString<256> P;
 173         if (!CompilationDir.empty())
 174           P.assign(CompilationDir);
 175         else
 176           P.assign(CWD);
 177         llvm::sys::path::append(P, Filename);
 178         Filenames.push_back(static_cast<std::string>(P));
 179       }
 180     }
 181   }
 182   return Error::success();
 183 }
 184
 185 Error RawCoverageMappingReader::decodeCounter(unsigned Value, Counter &C) {
 186   auto Tag = Value & Counter::EncodingTagMask;
 187   switch (Tag) {
 188   case Counter::Zero:
 189     C = Counter::getZero();
 190     return Error::success();
 191   case Counter::CounterValueReference:
 192     C = Counter::getCounter(Value >> Counter::EncodingTagBits);
 193     return Error::success();
 194   default:
 195     break;
 196   }
 197   Tag -= Counter::Expression;
 198   switch (Tag) {
 199   case CounterExpression::Subtract:
 200   case CounterExpression::Add: {
 201     auto ID = Value >> Counter::EncodingTagBits;
 202     if (ID >= Expressions.size())
 203       return make_error<CoverageMapError>(coveragemap_error::malformed);
 204     Expressions[ID].Kind = CounterExpression::ExprKind(Tag);
 205     C = Counter::getExpression(ID);
 206     break;
 207   }
 208   default:
 209     return make_error<CoverageMapError>(coveragemap_error::malformed);
 210   }
 211   return Error::success();
 212 }
 213
 214 Error RawCoverageMappingReader::readCounter(Counter &C) {
 215   uint64_t EncodedCounter;
 216   if (auto Err =
 217           readIntMax(EncodedCounter, std::numeric_limits<unsigned>::max()))
 218     return Err;
 219   if (auto Err = decodeCounter(EncodedCounter, C))
 220     return Err;
 221   return Error::success();
 222 }
 223
 224 static const unsigned EncodingExpansionRegionBit = 1
 225                                                    << Counter::EncodingTagBits;
 226
 227 /// Read the sub-array of regions for the given inferred file id.
 228 /// \param NumFileIDs the number of file ids that are defined for this
 229 /// function.
 230 Error RawCoverageMappingReader::readMappingRegionsSubArray(
 231     std::vector<CounterMappingRegion> &MappingRegions, unsigned InferredFileID,
 232     size_t NumFileIDs) {
 233   uint64_t NumRegions;
 234   if (auto Err = readSize(NumRegions))
 235     return Err;
 236   unsigned LineStart = 0;
 237   for (size_t I = 0; I < NumRegions; ++I) {
 238     Counter C, C2;
 239     CounterMappingRegion::RegionKind Kind = CounterMappingRegion::CodeRegion;
 240
 241     // Read the combined counter + region kind.
 242     uint64_t EncodedCounterAndRegion;
 243     if (auto Err = readIntMax(EncodedCounterAndRegion,
 244                               std::numeric_limits<unsigned>::max()))
 245       return Err;
 246     unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask;
 247     uint64_t ExpandedFileID = 0;
 248
 249     // If Tag does not represent a ZeroCounter, then it is understood to refer
 250     // to a counter or counter expression with region kind assumed to be
 251     // "CodeRegion". In that case, EncodedCounterAndRegion actually encodes the
 252     // referenced counter or counter expression (and nothing else).
 253     //
 254     // If Tag represents a ZeroCounter and EncodingExpansionRegionBit is set,
 255     // then EncodedCounterAndRegion is interpreted to represent an
 256     // ExpansionRegion. In all other cases, EncodedCounterAndRegion is
 257     // interpreted to refer to a specific region kind, after which additional
 258     // fields may be read (e.g. BranchRegions have two encoded counters that
 259     // follow an encoded region kind value).
 260     if (Tag != Counter::Zero) {
 261       if (auto Err = decodeCounter(EncodedCounterAndRegion, C))
 262         return Err;
 263     } else {
 264       // Is it an expansion region?
 265       if (EncodedCounterAndRegion & EncodingExpansionRegionBit) {
 266         Kind = CounterMappingRegion::ExpansionRegion;
 267         ExpandedFileID = EncodedCounterAndRegion >>
 268                          Counter::EncodingCounterTagAndExpansionRegionTagBits;
 269         if (ExpandedFileID >= NumFileIDs)
 270           return make_error<CoverageMapError>(coveragemap_error::malformed);
 271       } else {
 272         switch (EncodedCounterAndRegion >>
 273                 Counter::EncodingCounterTagAndExpansionRegionTagBits) {
 274         case CounterMappingRegion::CodeRegion:
 275           // Don't do anything when we have a code region with a zero counter.
 276           break;
 277         case CounterMappingRegion::SkippedRegion:
 278           Kind = CounterMappingRegion::SkippedRegion;
 279           break;
 280         case CounterMappingRegion::BranchRegion:
 281           // For a Branch Region, read two successive counters.
 282           Kind = CounterMappingRegion::BranchRegion;
 283           if (auto Err = readCounter(C))
 284             return Err;
 285           if (auto Err = readCounter(C2))
 286             return Err;
 287           break;
 288         default:
 289           return make_error<CoverageMapError>(coveragemap_error::malformed);
 290         }
 291       }
 292     }
 293
 294     // Read the source range.
 295     uint64_t LineStartDelta, ColumnStart, NumLines, ColumnEnd;
 296     if (auto Err =
 297             readIntMax(LineStartDelta, std::numeric_limits<unsigned>::max()))
 298       return Err;
 299     if (auto Err = readULEB128(ColumnStart))
 300       return Err;
 301     if (ColumnStart > std::numeric_limits<unsigned>::max())
 302       return make_error<CoverageMapError>(coveragemap_error::malformed);
 303     if (auto Err = readIntMax(NumLines, std::numeric_limits<unsigned>::max()))
 304       return Err;
 305     if (auto Err = readIntMax(ColumnEnd, std::numeric_limits<unsigned>::max()))
 306       return Err;
 307     LineStart += LineStartDelta;
 308
 309     // If the high bit of ColumnEnd is set, this is a gap region.
 310     if (ColumnEnd & (1U << 31)) {
 311       Kind = CounterMappingRegion::GapRegion;
 312       ColumnEnd &= ~(1U << 31);
 313     }
 314
 315     // Adjust the column locations for the empty regions that are supposed to
 316     // cover whole lines. Those regions should be encoded with the
 317     // column range (1 -> std::numeric_limits<unsigned>::max()), but because
 318     // the encoded std::numeric_limits<unsigned>::max() is several bytes long,
 319     // we set the column range to (0 -> 0) to ensure that the column start and
 320     // column end take up one byte each.
 321     // The std::numeric_limits<unsigned>::max() is used to represent a column
 322     // position at the end of the line without knowing the length of that line.
 323     if (ColumnStart == 0 && ColumnEnd == 0) {
 324       ColumnStart = 1;
 325       ColumnEnd = std::numeric_limits<unsigned>::max();
 326     }
 327
 328     LLVM_DEBUG({
 329       dbgs() << "Counter in file " << InferredFileID << " " << LineStart << ":"
 330              << ColumnStart << " -> " << (LineStart + NumLines) << ":"
 331              << ColumnEnd << ", ";
 332       if (Kind == CounterMappingRegion::ExpansionRegion)
 333         dbgs() << "Expands to file " << ExpandedFileID;
 334       else
 335         CounterMappingContext(Expressions).dump(C, dbgs());
 336       dbgs() << "\n";
 337     });
 338
 339     auto CMR = CounterMappingRegion(C, C2, InferredFileID, ExpandedFileID,
 340                                     LineStart, ColumnStart,
 341                                     LineStart + NumLines, ColumnEnd, Kind);
 342     if (CMR.startLoc() > CMR.endLoc())
 343       return make_error<CoverageMapError>(coveragemap_error::malformed);
 344     MappingRegions.push_back(CMR);
 345   }
 346   return Error::success();
 347 }
 348
 349 Error RawCoverageMappingReader::read() {
 350   // Read the virtual file mapping.
 351   SmallVector<unsigned, 8> VirtualFileMapping;
 352   uint64_t NumFileMappings;
 353   if (auto Err = readSize(NumFileMappings))
 354     return Err;
 355   for (size_t I = 0; I < NumFileMappings; ++I) {
 356     uint64_t FilenameIndex;
 357     if (auto Err = readIntMax(FilenameIndex, TranslationUnitFilenames.size()))
 358       return Err;
 359     VirtualFileMapping.push_back(FilenameIndex);
 360   }
 361
 362   // Construct the files using unique filenames and virtual file mapping.
 363   for (auto I : VirtualFileMapping) {
 364     Filenames.push_back(TranslationUnitFilenames[I]);
 365   }
 366
 367   // Read the expressions.
 368   uint64_t NumExpressions;
 369   if (auto Err = readSize(NumExpressions))
 370     return Err;
 371   // Create an array of dummy expressions that get the proper counters
 372   // when the expressions are read, and the proper kinds when the counters
 373   // are decoded.
 374   Expressions.resize(
 375       NumExpressions,
 376       CounterExpression(CounterExpression::Subtract, Counter(), Counter()));
 377   for (size_t I = 0; I < NumExpressions; ++I) {
 378     if (auto Err = readCounter(Expressions[I].LHS))
 379       return Err;
 380     if (auto Err = readCounter(Expressions[I].RHS))
 381       return Err;
 382   }
 383
 384   // Read the mapping regions sub-arrays.
 385   for (unsigned InferredFileID = 0, S = VirtualFileMapping.size();
 386        InferredFileID < S; ++InferredFileID) {
 387     if (auto Err = readMappingRegionsSubArray(MappingRegions, InferredFileID,
 388                                               VirtualFileMapping.size()))
 389       return Err;
 390   }
 391
 392   // Set the counters for the expansion regions.
 393   // i.e. Counter of expansion region = counter of the first region
 394   // from the expanded file.
 395   // Perform multiple passes to correctly propagate the counters through
 396   // all the nested expansion regions.
 397   SmallVector<CounterMappingRegion *, 8> FileIDExpansionRegionMapping;
 398   FileIDExpansionRegionMapping.resize(VirtualFileMapping.size(), nullptr);
 399   for (unsigned Pass = 1, S = VirtualFileMapping.size(); Pass < S; ++Pass) {
 400     for (auto &R : MappingRegions) {
 401       if (R.Kind != CounterMappingRegion::ExpansionRegion)
 402         continue;
 403       assert(!FileIDExpansionRegionMapping[R.ExpandedFileID]);
 404       FileIDExpansionRegionMapping[R.ExpandedFileID] = &R;
 405     }
 406     for (auto &R : MappingRegions) {
 407       if (FileIDExpansionRegionMapping[R.FileID]) {
 408         FileIDExpansionRegionMapping[R.FileID]->Count = R.Count;
 409         FileIDExpansionRegionMapping[R.FileID] = nullptr;
 410       }
 411     }
 412   }
 413
 414   return Error::success();
 415 }
 416
 417 Expected<bool> RawCoverageMappingDummyChecker::isDummy() {
 418   // A dummy coverage mapping data consists of just one region with zero count.
 419   uint64_t NumFileMappings;
 420   if (Error Err = readSize(NumFileMappings))
 421     return std::move(Err);
 422   if (NumFileMappings != 1)
 423     return false;
 424   // We don't expect any specific value for the filename index, just skip it.
 425   uint64_t FilenameIndex;
 426   if (Error Err =
 427           readIntMax(FilenameIndex, std::numeric_limits<unsigned>::max()))
 428     return std::move(Err);
 429   uint64_t NumExpressions;
 430   if (Error Err = readSize(NumExpressions))
 431     return std::move(Err);
 432   if (NumExpressions != 0)
 433     return false;
 434   uint64_t NumRegions;
 435   if (Error Err = readSize(NumRegions))
 436     return std::move(Err);
 437   if (NumRegions != 1)
 438     return false;
 439   uint64_t EncodedCounterAndRegion;
 440   if (Error Err = readIntMax(EncodedCounterAndRegion,
 441                              std::numeric_limits<unsigned>::max()))
 442     return std::move(Err);
 443   unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask;
 444   return Tag == Counter::Zero;
 445 }
 446
 447 Error InstrProfSymtab::create(SectionRef &Section) {
 448   Expected<StringRef> DataOrErr = Section.getContents();
 449   if (!DataOrErr)
 450     return DataOrErr.takeError();
 451   Data = *DataOrErr;
 452   Address = Section.getAddress();
 453
 454   // If this is a linked PE/COFF file, then we have to skip over the null byte
 455   // that is allocated in the .lprfn$A section in the LLVM profiling runtime.
 456   const ObjectFile *Obj = Section.getObject();
 457   if (isa<COFFObjectFile>(Obj) && !Obj->isRelocatableObject())
 458     Data = Data.drop_front(1);
 459
 460   return Error::success();
 461 }
 462
 463 StringRef InstrProfSymtab::getFuncName(uint64_t Pointer, size_t Size) {
 464   if (Pointer < Address)
 465     return StringRef();
 466   auto Offset = Pointer - Address;
 467   if (Offset + Size > Data.size())
 468     return StringRef();
 469   return Data.substr(Pointer - Address, Size);
 470 }
 471
 472 // Check if the mapping data is a dummy, i.e. is emitted for an unused function.
 473 static Expected<bool> isCoverageMappingDummy(uint64_t Hash, StringRef Mapping) {
 474   // The hash value of dummy mapping records is always zero.
 475   if (Hash)
 476     return false;
 477   return RawCoverageMappingDummyChecker(Mapping).isDummy();
 478 }
 479
 480 /// A range of filename indices. Used to specify the location of a batch of
 481 /// filenames in a vector-like container.
 482 struct FilenameRange {
 483   unsigned StartingIndex;
 484   unsigned Length;
 485
 486   FilenameRange(unsigned StartingIndex, unsigned Length)
 487       : StartingIndex(StartingIndex), Length(Length) {}
 488
 489   void markInvalid() { Length = 0; }
 490   bool isInvalid() const { return Length == 0; }
 491 };
 492
 493 namespace {
 494
 495 /// The interface to read coverage mapping function records for a module.
 496 struct CovMapFuncRecordReader {
 497   virtual ~CovMapFuncRecordReader() = default;
 498
 499   // Read a coverage header.
 500   //
 501   // \p CovBuf points to the buffer containing the \c CovHeader of the coverage
 502   // mapping data associated with the module.
 503   //
 504   // Returns a pointer to the next \c CovHeader if it exists, or to an address
 505   // greater than \p CovEnd if not.
 506   virtual Expected<const char *> readCoverageHeader(const char *CovBuf,
 507                                                     const char *CovBufEnd) = 0;
 508
 509   // Read function records.
 510   //
 511   // \p FuncRecBuf points to the buffer containing a batch of function records.
 512   // \p FuncRecBufEnd points past the end of the batch of records.
 513   //
 514   // Prior to Version4, \p OutOfLineFileRange points to a sequence of filenames
 515   // associated with the function records. It is unused in Version4.
 516   //
 517   // Prior to Version4, \p OutOfLineMappingBuf points to a sequence of coverage
 518   // mappings associated with the function records. It is unused in Version4.
 519   virtual Error readFunctionRecords(const char *FuncRecBuf,
 520                                     const char *FuncRecBufEnd,
 521                                     Optional<FilenameRange> OutOfLineFileRange,
 522                                     const char *OutOfLineMappingBuf,
 523                                     const char *OutOfLineMappingBufEnd) = 0;
 524
 525   template <class IntPtrT, support::endianness Endian>
 526   static Expected<std::unique_ptr<CovMapFuncRecordReader>>
 527   get(CovMapVersion Version, InstrProfSymtab &P,
 528       std::vector<BinaryCoverageReader::ProfileMappingRecord> &R, StringRef D,
 529       std::vector<std::string> &F);
 530 };
 531
 532 // A class for reading coverage mapping function records for a module.
 533 template <CovMapVersion Version, class IntPtrT, support::endianness Endian>
 534 class VersionedCovMapFuncRecordReader : public CovMapFuncRecordReader {
 535   using FuncRecordType =
 536       typename CovMapTraits<Version, IntPtrT>::CovMapFuncRecordType;
 537   using NameRefType = typename CovMapTraits<Version, IntPtrT>::NameRefType;
 538
 539   // Maps function's name references to the indexes of their records
 540   // in \c Records.
 541   DenseMap<NameRefType, size_t> FunctionRecords;
 542   InstrProfSymtab &ProfileNames;
 543   StringRef CompilationDir;
 544   std::vector<std::string> &Filenames;
 545   std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records;
 546
 547   // Maps a hash of the filenames in a TU to a \c FileRange. The range
 548   // specifies the location of the hashed filenames in \c Filenames.
 549   DenseMap<uint64_t, FilenameRange> FileRangeMap;
 550
 551   // Add the record to the collection if we don't already have a record that
 552   // points to the same function name. This is useful to ignore the redundant
 553   // records for the functions with ODR linkage.
 554   // In addition, prefer records with real coverage mapping data to dummy
 555   // records, which were emitted for inline functions which were seen but
 556   // not used in the corresponding translation unit.
 557   Error insertFunctionRecordIfNeeded(const FuncRecordType *CFR,
 558                                      StringRef Mapping,
 559                                      FilenameRange FileRange) {
 560     ++CovMapNumRecords;
 561     uint64_t FuncHash = CFR->template getFuncHash<Endian>();
 562     NameRefType NameRef = CFR->template getFuncNameRef<Endian>();
 563     auto InsertResult =
 564         FunctionRecords.insert(std::make_pair(NameRef, Records.size()));
 565     if (InsertResult.second) {
 566       StringRef FuncName;
 567       if (Error Err = CFR->template getFuncName<Endian>(ProfileNames, FuncName))
 568         return Err;
 569       if (FuncName.empty())
 570         return make_error<InstrProfError>(instrprof_error::malformed);
 571       ++CovMapNumUsedRecords;
 572       Records.emplace_back(Version, FuncName, FuncHash, Mapping,
 573                            FileRange.StartingIndex, FileRange.Length);
 574       return Error::success();
 575     }
 576     // Update the existing record if it's a dummy and the new record is real.
 577     size_t OldRecordIndex = InsertResult.first->second;
 578     BinaryCoverageReader::ProfileMappingRecord &OldRecord =
 579         Records[OldRecordIndex];
 580     Expected<bool> OldIsDummyExpected = isCoverageMappingDummy(
 581         OldRecord.FunctionHash, OldRecord.CoverageMapping);
 582     if (Error Err = OldIsDummyExpected.takeError())
 583       return Err;
 584     if (!*OldIsDummyExpected)
 585       return Error::success();
 586     Expected<bool> NewIsDummyExpected =
 587         isCoverageMappingDummy(FuncHash, Mapping);
 588     if (Error Err = NewIsDummyExpected.takeError())
 589       return Err;
 590     if (*NewIsDummyExpected)
 591       return Error::success();
 592     ++CovMapNumUsedRecords;
 593     OldRecord.FunctionHash = FuncHash;
 594     OldRecord.CoverageMapping = Mapping;
 595     OldRecord.FilenamesBegin = FileRange.StartingIndex;
 596     OldRecord.FilenamesSize = FileRange.Length;
 597     return Error::success();
 598   }
 599
 600 public:
 601   VersionedCovMapFuncRecordReader(
 602       InstrProfSymtab &P,
 603       std::vector<BinaryCoverageReader::ProfileMappingRecord> &R, StringRef D,
 604       std::vector<std::string> &F)
 605       : ProfileNames(P), CompilationDir(D), Filenames(F), Records(R) {}
 606
 607   ~VersionedCovMapFuncRecordReader() override = default;
 608
 609   Expected<const char *> readCoverageHeader(const char *CovBuf,
 610                                             const char *CovBufEnd) override {
 611     using namespace support;
 612
 613     if (CovBuf + sizeof(CovMapHeader) > CovBufEnd)
 614       return make_error<CoverageMapError>(coveragemap_error::malformed);
 615     auto CovHeader = reinterpret_cast<const CovMapHeader *>(CovBuf);
 616     uint32_t NRecords = CovHeader->getNRecords<Endian>();
 617     uint32_t FilenamesSize = CovHeader->getFilenamesSize<Endian>();
 618     uint32_t CoverageSize = CovHeader->getCoverageSize<Endian>();
 619     assert((CovMapVersion)CovHeader->getVersion<Endian>() == Version);
 620     CovBuf = reinterpret_cast<const char *>(CovHeader + 1);
 621
 622     // Skip past the function records, saving the start and end for later.
 623     // This is a no-op in Version4 (function records are read after all headers
 624     // are read).
 625     const char *FuncRecBuf = nullptr;
 626     const char *FuncRecBufEnd = nullptr;
 627     if (Version < CovMapVersion::Version4)
 628       FuncRecBuf = CovBuf;
 629     CovBuf += NRecords * sizeof(FuncRecordType);
 630     if (Version < CovMapVersion::Version4)
 631       FuncRecBufEnd = CovBuf;
 632
 633     // Get the filenames.
 634     if (CovBuf + FilenamesSize > CovBufEnd)
 635       return make_error<CoverageMapError>(coveragemap_error::malformed);
 636     size_t FilenamesBegin = Filenames.size();
 637     StringRef FilenameRegion(CovBuf, FilenamesSize);
 638     RawCoverageFilenamesReader Reader(FilenameRegion, Filenames,
 639                                       CompilationDir);
 640     if (auto Err = Reader.read(Version))
 641       return std::move(Err);
 642     CovBuf += FilenamesSize;
 643     FilenameRange FileRange(FilenamesBegin, Filenames.size() - FilenamesBegin);
 644
 645     if (Version >= CovMapVersion::Version4) {
 646       // Map a hash of the filenames region to the filename range associated
 647       // with this coverage header.
 648       int64_t FilenamesRef =
 649           llvm::IndexedInstrProf::ComputeHash(FilenameRegion);
 650       auto Insert =
 651           FileRangeMap.insert(std::make_pair(FilenamesRef, FileRange));
 652       if (!Insert.second) {
 653         // The same filenames ref was encountered twice. It's possible that
 654         // the associated filenames are the same.
 655         auto It = Filenames.begin();
 656         FilenameRange &OrigRange = Insert.first->getSecond();
 657         if (std::equal(It + OrigRange.StartingIndex,
 658                        It + OrigRange.StartingIndex + OrigRange.Length,
 659                        It + FileRange.StartingIndex,
 660                        It + FileRange.StartingIndex + FileRange.Length))
 661           // Map the new range to the original one.
 662           FileRange = OrigRange;
 663         else
 664           // This is a hash collision. Mark the filenames ref invalid.
 665           OrigRange.markInvalid();
 666       }
 667     }
 668
 669     // We'll read the coverage mapping records in the loop below.
 670     // This is a no-op in Version4 (coverage mappings are not affixed to the
 671     // coverage header).
 672     const char *MappingBuf = CovBuf;
 673     if (Version >= CovMapVersion::Version4 && CoverageSize != 0)
 674       return make_error<CoverageMapError>(coveragemap_error::malformed);
 675     CovBuf += CoverageSize;
 676     const char *MappingEnd = CovBuf;
 677
 678     if (CovBuf > CovBufEnd)
 679       return make_error<CoverageMapError>(coveragemap_error::malformed);
 680
 681     if (Version < CovMapVersion::Version4) {
 682       // Read each function record.
 683       if (Error E = readFunctionRecords(FuncRecBuf, FuncRecBufEnd, FileRange,
 684                                         MappingBuf, MappingEnd))
 685         return std::move(E);
 686     }
 687
 688     // Each coverage map has an alignment of 8, so we need to adjust alignment
 689     // before reading the next map.
 690     CovBuf += offsetToAlignedAddr(CovBuf, Align(8));
 691
 692     return CovBuf;
 693   }
 694
 695   Error readFunctionRecords(const char *FuncRecBuf, const char *FuncRecBufEnd,
 696                             Optional<FilenameRange> OutOfLineFileRange,
 697                             const char *OutOfLineMappingBuf,
 698                             const char *OutOfLineMappingBufEnd) override {
 699     auto CFR = reinterpret_cast<const FuncRecordType *>(FuncRecBuf);
 700     while ((const char *)CFR < FuncRecBufEnd) {
 701       // Validate the length of the coverage mapping for this function.
 702       const char *NextMappingBuf;
 703       const FuncRecordType *NextCFR;
 704       std::tie(NextMappingBuf, NextCFR) =
 705           CFR->template advanceByOne<Endian>(OutOfLineMappingBuf);
 706       if (Version < CovMapVersion::Version4)
 707         if (NextMappingBuf > OutOfLineMappingBufEnd)
 708           return make_error<CoverageMapError>(coveragemap_error::malformed);
 709
 710       // Look up the set of filenames associated with this function record.
 711       Optional<FilenameRange> FileRange;
 712       if (Version < CovMapVersion::Version4) {
 713         FileRange = OutOfLineFileRange;
 714       } else {
 715         uint64_t FilenamesRef = CFR->template getFilenamesRef<Endian>();
 716         auto It = FileRangeMap.find(FilenamesRef);
 717         if (It == FileRangeMap.end())
 718           return make_error<CoverageMapError>(coveragemap_error::malformed);
 719         else
 720           FileRange = It->getSecond();
 721       }
 722
 723       // Now, read the coverage data.
 724       if (FileRange && !FileRange->isInvalid()) {
 725         StringRef Mapping =
 726             CFR->template getCoverageMapping<Endian>(OutOfLineMappingBuf);
 727         if (Version >= CovMapVersion::Version4 &&
 728             Mapping.data() + Mapping.size() > FuncRecBufEnd)
 729           return make_error<CoverageMapError>(coveragemap_error::malformed);
 730         if (Error Err = insertFunctionRecordIfNeeded(CFR, Mapping, *FileRange))
 731           return Err;
 732       }
 733
 734       std::tie(OutOfLineMappingBuf, CFR) = std::tie(NextMappingBuf, NextCFR);
 735     }
 736     return Error::success();
 737   }
 738 };
 739
 740 } // end anonymous namespace
 741
 742 template <class IntPtrT, support::endianness Endian>
 743 Expected<std::unique_ptr<CovMapFuncRecordReader>> CovMapFuncRecordReader::get(
 744     CovMapVersion Version, InstrProfSymtab &P,
 745     std::vector<BinaryCoverageReader::ProfileMappingRecord> &R, StringRef D,
 746     std::vector<std::string> &F) {
 747   using namespace coverage;
 748
 749   switch (Version) {
 750   case CovMapVersion::Version1:
 751     return std::make_unique<VersionedCovMapFuncRecordReader<
 752         CovMapVersion::Version1, IntPtrT, Endian>>(P, R, D, F);
 753   case CovMapVersion::Version2:
 754   case CovMapVersion::Version3:
 755   case CovMapVersion::Version4:
 756   case CovMapVersion::Version5:
 757   case CovMapVersion::Version6:
 758     // Decompress the name data.
 759     if (Error E = P.create(P.getNameData()))
 760       return std::move(E);
 761     if (Version == CovMapVersion::Version2)
 762       return std::make_unique<VersionedCovMapFuncRecordReader<
 763           CovMapVersion::Version2, IntPtrT, Endian>>(P, R, D, F);
 764     else if (Version == CovMapVersion::Version3)
 765       return std::make_unique<VersionedCovMapFuncRecordReader<
 766           CovMapVersion::Version3, IntPtrT, Endian>>(P, R, D, F);
 767     else if (Version == CovMapVersion::Version4)
 768       return std::make_unique<VersionedCovMapFuncRecordReader<
 769           CovMapVersion::Version4, IntPtrT, Endian>>(P, R, D, F);
 770     else if (Version == CovMapVersion::Version5)
 771       return std::make_unique<VersionedCovMapFuncRecordReader<
 772           CovMapVersion::Version5, IntPtrT, Endian>>(P, R, D, F);
 773     else if (Version == CovMapVersion::Version6)
 774       return std::make_unique<VersionedCovMapFuncRecordReader<
 775           CovMapVersion::Version6, IntPtrT, Endian>>(P, R, D, F);
 776   }
 777   llvm_unreachable("Unsupported version");
 778 }
 779
 780 template <typename T, support::endianness Endian>
 781 static Error readCoverageMappingData(
 782     InstrProfSymtab &ProfileNames, StringRef CovMap, StringRef FuncRecords,
 783     std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records,
 784     StringRef CompilationDir, std::vector<std::string> &Filenames) {
 785   using namespace coverage;
 786
 787   // Read the records in the coverage data section.
 788   auto CovHeader =
 789       reinterpret_cast<const CovMapHeader *>(CovMap.data());
 790   CovMapVersion Version = (CovMapVersion)CovHeader->getVersion<Endian>();
 791   if (Version > CovMapVersion::CurrentVersion)
 792     return make_error<CoverageMapError>(coveragemap_error::unsupported_version);
 793   Expected<std::unique_ptr<CovMapFuncRecordReader>> ReaderExpected =
 794       CovMapFuncRecordReader::get<T, Endian>(Version, ProfileNames, Records,
 795                                              CompilationDir, Filenames);
 796   if (Error E = ReaderExpected.takeError())
 797     return E;
 798   auto Reader = std::move(ReaderExpected.get());
 799   const char *CovBuf = CovMap.data();
 800   const char *CovBufEnd = CovBuf + CovMap.size();
 801   const char *FuncRecBuf = FuncRecords.data();
 802   const char *FuncRecBufEnd = FuncRecords.data() + FuncRecords.size();
 803   while (CovBuf < CovBufEnd) {
 804     // Read the current coverage header & filename data.
 805     //
 806     // Prior to Version4, this also reads all function records affixed to the
 807     // header.
 808     //
 809     // Return a pointer to the next coverage header.
 810     auto NextOrErr = Reader->readCoverageHeader(CovBuf, CovBufEnd);
 811     if (auto E = NextOrErr.takeError())
 812       return E;
 813     CovBuf = NextOrErr.get();
 814   }
 815   // In Version4, function records are not affixed to coverage headers. Read
 816   // the records from their dedicated section.
 817   if (Version >= CovMapVersion::Version4)
 818     return Reader->readFunctionRecords(FuncRecBuf, FuncRecBufEnd, None, nullptr,
 819                                        nullptr);
 820   return Error::success();
 821 }
 822
 823 static const char *TestingFormatMagic = "llvmcovmtestdata";
 824
 825 Expected<std::unique_ptr<BinaryCoverageReader>>
 826 BinaryCoverageReader::createCoverageReaderFromBuffer(
 827     StringRef Coverage, FuncRecordsStorage &&FuncRecords,
 828     InstrProfSymtab &&ProfileNames, uint8_t BytesInAddress,
 829     support::endianness Endian, StringRef CompilationDir) {
 830   std::unique_ptr<BinaryCoverageReader> Reader(
 831       new BinaryCoverageReader(std::move(FuncRecords)));
 832   Reader->ProfileNames = std::move(ProfileNames);
 833   StringRef FuncRecordsRef = Reader->FuncRecords->getBuffer();
 834   if (BytesInAddress == 4 && Endian == support::endianness::little) {
 835     if (Error E =
 836             readCoverageMappingData<uint32_t, support::endianness::little>(
 837                 Reader->ProfileNames, Coverage, FuncRecordsRef,
 838                 Reader->MappingRecords, CompilationDir, Reader->Filenames))
 839       return std::move(E);
 840   } else if (BytesInAddress == 4 && Endian == support::endianness::big) {
 841     if (Error E = readCoverageMappingData<uint32_t, support::endianness::big>(
 842             Reader->ProfileNames, Coverage, FuncRecordsRef,
 843             Reader->MappingRecords, CompilationDir, Reader->Filenames))
 844       return std::move(E);
 845   } else if (BytesInAddress == 8 && Endian == support::endianness::little) {
 846     if (Error E =
 847             readCoverageMappingData<uint64_t, support::endianness::little>(
 848                 Reader->ProfileNames, Coverage, FuncRecordsRef,
 849                 Reader->MappingRecords, CompilationDir, Reader->Filenames))
 850       return std::move(E);
 851   } else if (BytesInAddress == 8 && Endian == support::endianness::big) {
 852     if (Error E = readCoverageMappingData<uint64_t, support::endianness::big>(
 853             Reader->ProfileNames, Coverage, FuncRecordsRef,
 854             Reader->MappingRecords, CompilationDir, Reader->Filenames))
 855       return std::move(E);
 856   } else
 857     return make_error<CoverageMapError>(coveragemap_error::malformed);
 858   return std::move(Reader);
 859 }
 860
 861 static Expected<std::unique_ptr<BinaryCoverageReader>>
 862 loadTestingFormat(StringRef Data, StringRef CompilationDir) {
 863   uint8_t BytesInAddress = 8;
 864   support::endianness Endian = support::endianness::little;
 865
 866   Data = Data.substr(StringRef(TestingFormatMagic).size());
 867   if (Data.empty())
 868     return make_error<CoverageMapError>(coveragemap_error::truncated);
 869   unsigned N = 0;
 870   uint64_t ProfileNamesSize = decodeULEB128(Data.bytes_begin(), &N);
 871   if (N > Data.size())
 872     return make_error<CoverageMapError>(coveragemap_error::malformed);
 873   Data = Data.substr(N);
 874   if (Data.empty())
 875     return make_error<CoverageMapError>(coveragemap_error::truncated);
 876   N = 0;
 877   uint64_t Address = decodeULEB128(Data.bytes_begin(), &N);
 878   if (N > Data.size())
 879     return make_error<CoverageMapError>(coveragemap_error::malformed);
 880   Data = Data.substr(N);
 881   if (Data.size() < ProfileNamesSize)
 882     return make_error<CoverageMapError>(coveragemap_error::malformed);
 883   InstrProfSymtab ProfileNames;
 884   if (Error E = ProfileNames.create(Data.substr(0, ProfileNamesSize), Address))
 885     return std::move(E);
 886   Data = Data.substr(ProfileNamesSize);
 887   // Skip the padding bytes because coverage map data has an alignment of 8.
 888   size_t Pad = offsetToAlignedAddr(Data.data(), Align(8));
 889   if (Data.size() < Pad)
 890     return make_error<CoverageMapError>(coveragemap_error::malformed);
 891   Data = Data.substr(Pad);
 892   if (Data.size() < sizeof(CovMapHeader))
 893     return make_error<CoverageMapError>(coveragemap_error::malformed);
 894   auto const *CovHeader = reinterpret_cast<const CovMapHeader *>(
 895       Data.substr(0, sizeof(CovMapHeader)).data());
 896   CovMapVersion Version =
 897       (CovMapVersion)CovHeader->getVersion<support::endianness::little>();
 898   StringRef CoverageMapping;
 899   BinaryCoverageReader::FuncRecordsStorage CoverageRecords;
 900   if (Version < CovMapVersion::Version4) {
 901     CoverageMapping = Data;
 902     if (CoverageMapping.empty())
 903       return make_error<CoverageMapError>(coveragemap_error::truncated);
 904     CoverageRecords = MemoryBuffer::getMemBuffer("");
 905   } else {
 906     uint32_t FilenamesSize =
 907         CovHeader->getFilenamesSize<support::endianness::little>();
 908     uint32_t CoverageMappingSize = sizeof(CovMapHeader) + FilenamesSize;
 909     CoverageMapping = Data.substr(0, CoverageMappingSize);
 910     if (CoverageMapping.empty())
 911       return make_error<CoverageMapError>(coveragemap_error::truncated);
 912     Data = Data.substr(CoverageMappingSize);
 913     // Skip the padding bytes because coverage records data has an alignment
 914     // of 8.
 915     Pad = offsetToAlignedAddr(Data.data(), Align(8));
 916     if (Data.size() < Pad)
 917       return make_error<CoverageMapError>(coveragemap_error::malformed);
 918     CoverageRecords = MemoryBuffer::getMemBuffer(Data.substr(Pad));
 919     if (CoverageRecords->getBufferSize() == 0)
 920       return make_error<CoverageMapError>(coveragemap_error::truncated);
 921   }
 922   return BinaryCoverageReader::createCoverageReaderFromBuffer(
 923       CoverageMapping, std::move(CoverageRecords), std::move(ProfileNames),
 924       BytesInAddress, Endian, CompilationDir);
 925 }
 926
 927 /// Find all sections that match \p Name. There may be more than one if comdats
 928 /// are in use, e.g. for the __llvm_covfun section on ELF.
 929 static Expected<std::vector<SectionRef>> lookupSections(ObjectFile &OF,
 930                                                         StringRef Name) {
 931   // On COFF, the object file section name may end in "$M". This tells the
 932   // linker to sort these sections between "$A" and "$Z". The linker removes the
 933   // dollar and everything after it in the final binary. Do the same to match.
 934   bool IsCOFF = isa<COFFObjectFile>(OF);
 935   auto stripSuffix = [IsCOFF](StringRef N) {
 936     return IsCOFF ? N.split('$').first : N;
 937   };
 938   Name = stripSuffix(Name);
 939
 940   std::vector<SectionRef> Sections;
 941   for (const auto &Section : OF.sections()) {
 942     Expected<StringRef> NameOrErr = Section.getName();
 943     if (!NameOrErr)
 944       return NameOrErr.takeError();
 945     if (stripSuffix(*NameOrErr) == Name)
 946       Sections.push_back(Section);
 947   }
 948   if (Sections.empty())
 949     return make_error<CoverageMapError>(coveragemap_error::no_data_found);
 950   return Sections;
 951 }
 952
 953 static Expected<std::unique_ptr<BinaryCoverageReader>>
 954 loadBinaryFormat(std::unique_ptr<Binary> Bin, StringRef Arch,
 955                  StringRef CompilationDir = "") {
 956   std::unique_ptr<ObjectFile> OF;
 957   if (auto *Universal = dyn_cast<MachOUniversalBinary>(Bin.get())) {
 958     // If we have a universal binary, try to look up the object for the
 959     // appropriate architecture.
 960     auto ObjectFileOrErr = Universal->getMachOObjectForArch(Arch);
 961     if (!ObjectFileOrErr)
 962       return ObjectFileOrErr.takeError();
 963     OF = std::move(ObjectFileOrErr.get());
 964   } else if (isa<ObjectFile>(Bin.get())) {
 965     // For any other object file, upcast and take ownership.
 966     OF.reset(cast<ObjectFile>(Bin.release()));
 967     // If we've asked for a particular arch, make sure they match.
 968     if (!Arch.empty() && OF->getArch() != Triple(Arch).getArch())
 969       return errorCodeToError(object_error::arch_not_found);
 970   } else
 971     // We can only handle object files.
 972     return make_error<CoverageMapError>(coveragemap_error::malformed);
 973
 974   // The coverage uses native pointer sizes for the object it's written in.
 975   uint8_t BytesInAddress = OF->getBytesInAddress();
 976   support::endianness Endian = OF->isLittleEndian()
 977                                    ? support::endianness::little
 978                                    : support::endianness::big;
 979
 980   // Look for the sections that we are interested in.
 981   auto ObjFormat = OF->getTripleObjectFormat();
 982   auto NamesSection =
 983       lookupSections(*OF, getInstrProfSectionName(IPSK_name, ObjFormat,
 984                                                  /*AddSegmentInfo=*/false));
 985   if (auto E = NamesSection.takeError())
 986     return std::move(E);
 987   auto CoverageSection =
 988       lookupSections(*OF, getInstrProfSectionName(IPSK_covmap, ObjFormat,
 989                                                   /*AddSegmentInfo=*/false));
 990   if (auto E = CoverageSection.takeError())
 991     return std::move(E);
 992   std::vector<SectionRef> CoverageSectionRefs = *CoverageSection;
 993   if (CoverageSectionRefs.size() != 1)
 994     return make_error<CoverageMapError>(coveragemap_error::malformed);
 995   auto CoverageMappingOrErr = CoverageSectionRefs.back().getContents();
 996   if (!CoverageMappingOrErr)
 997     return CoverageMappingOrErr.takeError();
 998   StringRef CoverageMapping = CoverageMappingOrErr.get();
 999
1000   InstrProfSymtab ProfileNames;
1001   std::vector<SectionRef> NamesSectionRefs = *NamesSection;
1002   if (NamesSectionRefs.size() != 1)
1003     return make_error<CoverageMapError>(coveragemap_error::malformed);
1004   if (Error E = ProfileNames.create(NamesSectionRefs.back()))
1005     return std::move(E);
1006
1007   // Look for the coverage records section (Version4 only).
1008   auto CoverageRecordsSections =
1009       lookupSections(*OF, getInstrProfSectionName(IPSK_covfun, ObjFormat,
1010                                                   /*AddSegmentInfo=*/false));
1011
1012   BinaryCoverageReader::FuncRecordsStorage FuncRecords;
1013   if (auto E = CoverageRecordsSections.takeError()) {
1014     consumeError(std::move(E));
1015     FuncRecords = MemoryBuffer::getMemBuffer("");
1016   } else {
1017     // Compute the FuncRecordsBuffer of the buffer, taking into account the
1018     // padding between each record, and making sure the first block is aligned
1019     // in memory to maintain consistency between buffer address and size
1020     // alignment.
1021     const Align RecordAlignment(8);
1022     uint64_t FuncRecordsSize = 0;
1023     for (SectionRef Section : *CoverageRecordsSections) {
1024       auto CoverageRecordsOrErr = Section.getContents();
1025       if (!CoverageRecordsOrErr)
1026         return CoverageRecordsOrErr.takeError();
1027       FuncRecordsSize += alignTo(CoverageRecordsOrErr->size(), RecordAlignment);
1028     }
1029     auto WritableBuffer =
1030         WritableMemoryBuffer::getNewUninitMemBuffer(FuncRecordsSize);
1031     char *FuncRecordsBuffer = WritableBuffer->getBufferStart();
1032     assert(isAddrAligned(RecordAlignment, FuncRecordsBuffer) &&
1033            "Allocated memory is correctly aligned");
1034
1035     for (SectionRef Section : *CoverageRecordsSections) {
1036       auto CoverageRecordsOrErr = Section.getContents();
1037       if (!CoverageRecordsOrErr)
1038         return CoverageRecordsOrErr.takeError();
1039       const auto &CoverageRecords = CoverageRecordsOrErr.get();
1040       FuncRecordsBuffer = std::copy(CoverageRecords.begin(),
1041                                     CoverageRecords.end(), FuncRecordsBuffer);
1042       FuncRecordsBuffer =
1043           std::fill_n(FuncRecordsBuffer,
1044                       alignAddr(FuncRecordsBuffer, RecordAlignment) -
1045                           (uintptr_t)FuncRecordsBuffer,
1046                       '\0');
1047     }
1048     assert(FuncRecordsBuffer == WritableBuffer->getBufferEnd() &&
1049            "consistent init");
1050     FuncRecords = std::move(WritableBuffer);
1051   }
1052
1053   return BinaryCoverageReader::createCoverageReaderFromBuffer(
1054       CoverageMapping, std::move(FuncRecords), std::move(ProfileNames),
1055       BytesInAddress, Endian, CompilationDir);
1056 }
1057
1058 /// Determine whether \p Arch is invalid or empty, given \p Bin.
1059 static bool isArchSpecifierInvalidOrMissing(Binary *Bin, StringRef Arch) {
1060   // If we have a universal binary and Arch doesn't identify any of its slices,
1061   // it's user error.
1062   if (auto *Universal = dyn_cast<MachOUniversalBinary>(Bin)) {
1063     for (auto &ObjForArch : Universal->objects())
1064       if (Arch == ObjForArch.getArchFlagName())
1065         return false;
1066     return true;
1067   }
1068   return false;
1069 }
1070
1071 Expected<std::vector<std::unique_ptr<BinaryCoverageReader>>>
1072 BinaryCoverageReader::create(
1073     MemoryBufferRef ObjectBuffer, StringRef Arch,
1074     SmallVectorImpl<std::unique_ptr<MemoryBuffer>> &ObjectFileBuffers,
1075     StringRef CompilationDir) {
1076   std::vector<std::unique_ptr<BinaryCoverageReader>> Readers;
1077
1078   if (ObjectBuffer.getBuffer().startswith(TestingFormatMagic)) {
1079     // This is a special format used for testing.
1080     auto ReaderOrErr =
1081         loadTestingFormat(ObjectBuffer.getBuffer(), CompilationDir);
1082     if (!ReaderOrErr)
1083       return ReaderOrErr.takeError();
1084     Readers.push_back(std::move(ReaderOrErr.get()));
1085     return std::move(Readers);
1086   }
1087
1088   auto BinOrErr = createBinary(ObjectBuffer);
1089   if (!BinOrErr)
1090     return BinOrErr.takeError();
1091   std::unique_ptr<Binary> Bin = std::move(BinOrErr.get());
1092
1093   if (isArchSpecifierInvalidOrMissing(Bin.get(), Arch))
1094     return make_error<CoverageMapError>(
1095         coveragemap_error::invalid_or_missing_arch_specifier);
1096
1097   // MachO universal binaries which contain archives need to be treated as
1098   // archives, not as regular binaries.
1099   if (auto *Universal = dyn_cast<MachOUniversalBinary>(Bin.get())) {
1100     for (auto &ObjForArch : Universal->objects()) {
1101       // Skip slices within the universal binary which target the wrong arch.
1102       std::string ObjArch = ObjForArch.getArchFlagName();
1103       if (Arch != ObjArch)
1104         continue;
1105
1106       auto ArchiveOrErr = ObjForArch.getAsArchive();
1107       if (!ArchiveOrErr) {
1108         // If this is not an archive, try treating it as a regular object.
1109         consumeError(ArchiveOrErr.takeError());
1110         break;
1111       }
1112
1113       return BinaryCoverageReader::create(
1114           ArchiveOrErr.get()->getMemoryBufferRef(), Arch, ObjectFileBuffers,
1115           CompilationDir);
1116     }
1117   }
1118
1119   // Load coverage out of archive members.
1120   if (auto *Ar = dyn_cast<Archive>(Bin.get())) {
1121     Error Err = Error::success();
1122     for (auto &Child : Ar->children(Err)) {
1123       Expected<MemoryBufferRef> ChildBufOrErr = Child.getMemoryBufferRef();
1124       if (!ChildBufOrErr)
1125         return ChildBufOrErr.takeError();
1126
1127       auto ChildReadersOrErr = BinaryCoverageReader::create(
1128           ChildBufOrErr.get(), Arch, ObjectFileBuffers, CompilationDir);
1129       if (!ChildReadersOrErr)
1130         return ChildReadersOrErr.takeError();
1131       for (auto &Reader : ChildReadersOrErr.get())
1132         Readers.push_back(std::move(Reader));
1133     }
1134     if (Err)
1135       return std::move(Err);
1136
1137     // Thin archives reference object files outside of the archive file, i.e.
1138     // files which reside in memory not owned by the caller. Transfer ownership
1139     // to the caller.
1140     if (Ar->isThin())
1141       for (auto &Buffer : Ar->takeThinBuffers())
1142         ObjectFileBuffers.push_back(std::move(Buffer));
1143
1144     return std::move(Readers);
1145   }
1146
1147   auto ReaderOrErr = loadBinaryFormat(std::move(Bin), Arch, CompilationDir);
1148   if (!ReaderOrErr)
1149     return ReaderOrErr.takeError();
1150   Readers.push_back(std::move(ReaderOrErr.get()));
1151   return std::move(Readers);
1152 }
1153
1154 Error BinaryCoverageReader::readNextRecord(CoverageMappingRecord &Record) {
1155   if (CurrentRecord >= MappingRecords.size())
1156     return make_error<CoverageMapError>(coveragemap_error::eof);
1157
1158   FunctionsFilenames.clear();
1159   Expressions.clear();
1160   MappingRegions.clear();
1161   auto &R = MappingRecords[CurrentRecord];
1162   auto F = makeArrayRef(Filenames).slice(R.FilenamesBegin, R.FilenamesSize);
1163   RawCoverageMappingReader Reader(R.CoverageMapping, F, FunctionsFilenames,
1164                                   Expressions, MappingRegions);
1165   if (auto Err = Reader.read())
1166     return Err;
1167
1168   Record.FunctionName = R.FunctionName;
1169   Record.FunctionHash = R.FunctionHash;
1170   Record.Filenames = FunctionsFilenames;
1171   Record.Expressions = Expressions;
1172   Record.MappingRegions = MappingRegions;
1173
1174   ++CurrentRecord;
1175   return Error::success();
1176 }