1//=-- CoverageMappingReader.cpp - Code coverage mapping reader ----*- C++ -*-=//
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 reading coverage mapping data for
11// instrumentation based coverage.
12//
13//===----------------------------------------------------------------------===//
14
15#include "llvm/ProfileData/Coverage/CoverageMappingReader.h"
16#include "llvm/ADT/DenseMap.h"
17#include "llvm/Object/MachOUniversal.h"
18#include "llvm/Object/ObjectFile.h"
19#include "llvm/Support/Debug.h"
20#include "llvm/Support/Endian.h"
21#include "llvm/Support/LEB128.h"
22#include "llvm/Support/MathExtras.h"
23#include "llvm/Support/raw_ostream.h"
24
25using namespace llvm;
26using namespace coverage;
27using namespace object;
28
29#define DEBUG_TYPE "coverage-mapping"
30
31void CoverageMappingIterator::increment() {
32  // Check if all the records were read or if an error occurred while reading
33  // the next record.
34  if (auto E = Reader->readNextRecord(Record)) {
35    handleAllErrors(std::move(E), [&](const CoverageMapError &CME) {
36      if (CME.get() == coveragemap_error::eof)
37        *this = CoverageMappingIterator();
38      else
39        llvm_unreachable("Unexpected error in coverage mapping iterator");
40    });
41  }
42}
43
44Error RawCoverageReader::readULEB128(uint64_t &Result) {
45  if (Data.size() < 1)
46    return make_error<CoverageMapError>(coveragemap_error::truncated);
47  unsigned N = 0;
48  Result = decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
49  if (N > Data.size())
50    return make_error<CoverageMapError>(coveragemap_error::malformed);
51  Data = Data.substr(N);
52  return Error::success();
53}
54
55Error RawCoverageReader::readIntMax(uint64_t &Result, uint64_t MaxPlus1) {
56  if (auto Err = readULEB128(Result))
57    return Err;
58  if (Result >= MaxPlus1)
59    return make_error<CoverageMapError>(coveragemap_error::malformed);
60  return Error::success();
61}
62
63Error RawCoverageReader::readSize(uint64_t &Result) {
64  if (auto Err = readULEB128(Result))
65    return Err;
66  // Sanity check the number.
67  if (Result > Data.size())
68    return make_error<CoverageMapError>(coveragemap_error::malformed);
69  return Error::success();
70}
71
72Error RawCoverageReader::readString(StringRef &Result) {
73  uint64_t Length;
74  if (auto Err = readSize(Length))
75    return Err;
76  Result = Data.substr(0, Length);
77  Data = Data.substr(Length);
78  return Error::success();
79}
80
81Error RawCoverageFilenamesReader::read() {
82  uint64_t NumFilenames;
83  if (auto Err = readSize(NumFilenames))
84    return Err;
85  for (size_t I = 0; I < NumFilenames; ++I) {
86    StringRef Filename;
87    if (auto Err = readString(Filename))
88      return Err;
89    Filenames.push_back(Filename);
90  }
91  return Error::success();
92}
93
94Error RawCoverageMappingReader::decodeCounter(unsigned Value, Counter &C) {
95  auto Tag = Value & Counter::EncodingTagMask;
96  switch (Tag) {
97  case Counter::Zero:
98    C = Counter::getZero();
99    return Error::success();
100  case Counter::CounterValueReference:
101    C = Counter::getCounter(Value >> Counter::EncodingTagBits);
102    return Error::success();
103  default:
104    break;
105  }
106  Tag -= Counter::Expression;
107  switch (Tag) {
108  case CounterExpression::Subtract:
109  case CounterExpression::Add: {
110    auto ID = Value >> Counter::EncodingTagBits;
111    if (ID >= Expressions.size())
112      return make_error<CoverageMapError>(coveragemap_error::malformed);
113    Expressions[ID].Kind = CounterExpression::ExprKind(Tag);
114    C = Counter::getExpression(ID);
115    break;
116  }
117  default:
118    return make_error<CoverageMapError>(coveragemap_error::malformed);
119  }
120  return Error::success();
121}
122
123Error RawCoverageMappingReader::readCounter(Counter &C) {
124  uint64_t EncodedCounter;
125  if (auto Err =
126          readIntMax(EncodedCounter, std::numeric_limits<unsigned>::max()))
127    return Err;
128  if (auto Err = decodeCounter(EncodedCounter, C))
129    return Err;
130  return Error::success();
131}
132
133static const unsigned EncodingExpansionRegionBit = 1
134                                                   << Counter::EncodingTagBits;
135
136/// \brief Read the sub-array of regions for the given inferred file id.
137/// \param NumFileIDs the number of file ids that are defined for this
138/// function.
139Error RawCoverageMappingReader::readMappingRegionsSubArray(
140    std::vector<CounterMappingRegion> &MappingRegions, unsigned InferredFileID,
141    size_t NumFileIDs) {
142  uint64_t NumRegions;
143  if (auto Err = readSize(NumRegions))
144    return Err;
145  unsigned LineStart = 0;
146  for (size_t I = 0; I < NumRegions; ++I) {
147    Counter C;
148    CounterMappingRegion::RegionKind Kind = CounterMappingRegion::CodeRegion;
149
150    // Read the combined counter + region kind.
151    uint64_t EncodedCounterAndRegion;
152    if (auto Err = readIntMax(EncodedCounterAndRegion,
153                              std::numeric_limits<unsigned>::max()))
154      return Err;
155    unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask;
156    uint64_t ExpandedFileID = 0;
157    if (Tag != Counter::Zero) {
158      if (auto Err = decodeCounter(EncodedCounterAndRegion, C))
159        return Err;
160    } else {
161      // Is it an expansion region?
162      if (EncodedCounterAndRegion & EncodingExpansionRegionBit) {
163        Kind = CounterMappingRegion::ExpansionRegion;
164        ExpandedFileID = EncodedCounterAndRegion >>
165                         Counter::EncodingCounterTagAndExpansionRegionTagBits;
166        if (ExpandedFileID >= NumFileIDs)
167          return make_error<CoverageMapError>(coveragemap_error::malformed);
168      } else {
169        switch (EncodedCounterAndRegion >>
170                Counter::EncodingCounterTagAndExpansionRegionTagBits) {
171        case CounterMappingRegion::CodeRegion:
172          // Don't do anything when we have a code region with a zero counter.
173          break;
174        case CounterMappingRegion::SkippedRegion:
175          Kind = CounterMappingRegion::SkippedRegion;
176          break;
177        default:
178          return make_error<CoverageMapError>(coveragemap_error::malformed);
179        }
180      }
181    }
182
183    // Read the source range.
184    uint64_t LineStartDelta, ColumnStart, NumLines, ColumnEnd;
185    if (auto Err =
186            readIntMax(LineStartDelta, std::numeric_limits<unsigned>::max()))
187      return Err;
188    if (auto Err = readULEB128(ColumnStart))
189      return Err;
190    if (ColumnStart > std::numeric_limits<unsigned>::max())
191      return make_error<CoverageMapError>(coveragemap_error::malformed);
192    if (auto Err = readIntMax(NumLines, std::numeric_limits<unsigned>::max()))
193      return Err;
194    if (auto Err = readIntMax(ColumnEnd, std::numeric_limits<unsigned>::max()))
195      return Err;
196    LineStart += LineStartDelta;
197    // Adjust the column locations for the empty regions that are supposed to
198    // cover whole lines. Those regions should be encoded with the
199    // column range (1 -> std::numeric_limits<unsigned>::max()), but because
200    // the encoded std::numeric_limits<unsigned>::max() is several bytes long,
201    // we set the column range to (0 -> 0) to ensure that the column start and
202    // column end take up one byte each.
203    // The std::numeric_limits<unsigned>::max() is used to represent a column
204    // position at the end of the line without knowing the length of that line.
205    if (ColumnStart == 0 && ColumnEnd == 0) {
206      ColumnStart = 1;
207      ColumnEnd = std::numeric_limits<unsigned>::max();
208    }
209
210    DEBUG({
211      dbgs() << "Counter in file " << InferredFileID << " " << LineStart << ":"
212             << ColumnStart << " -> " << (LineStart + NumLines) << ":"
213             << ColumnEnd << ", ";
214      if (Kind == CounterMappingRegion::ExpansionRegion)
215        dbgs() << "Expands to file " << ExpandedFileID;
216      else
217        CounterMappingContext(Expressions).dump(C, dbgs());
218      dbgs() << "\n";
219    });
220
221    MappingRegions.push_back(CounterMappingRegion(
222        C, InferredFileID, ExpandedFileID, LineStart, ColumnStart,
223        LineStart + NumLines, ColumnEnd, Kind));
224  }
225  return Error::success();
226}
227
228Error RawCoverageMappingReader::read() {
229
230  // Read the virtual file mapping.
231  llvm::SmallVector<unsigned, 8> VirtualFileMapping;
232  uint64_t NumFileMappings;
233  if (auto Err = readSize(NumFileMappings))
234    return Err;
235  for (size_t I = 0; I < NumFileMappings; ++I) {
236    uint64_t FilenameIndex;
237    if (auto Err = readIntMax(FilenameIndex, TranslationUnitFilenames.size()))
238      return Err;
239    VirtualFileMapping.push_back(FilenameIndex);
240  }
241
242  // Construct the files using unique filenames and virtual file mapping.
243  for (auto I : VirtualFileMapping) {
244    Filenames.push_back(TranslationUnitFilenames[I]);
245  }
246
247  // Read the expressions.
248  uint64_t NumExpressions;
249  if (auto Err = readSize(NumExpressions))
250    return Err;
251  // Create an array of dummy expressions that get the proper counters
252  // when the expressions are read, and the proper kinds when the counters
253  // are decoded.
254  Expressions.resize(
255      NumExpressions,
256      CounterExpression(CounterExpression::Subtract, Counter(), Counter()));
257  for (size_t I = 0; I < NumExpressions; ++I) {
258    if (auto Err = readCounter(Expressions[I].LHS))
259      return Err;
260    if (auto Err = readCounter(Expressions[I].RHS))
261      return Err;
262  }
263
264  // Read the mapping regions sub-arrays.
265  for (unsigned InferredFileID = 0, S = VirtualFileMapping.size();
266       InferredFileID < S; ++InferredFileID) {
267    if (auto Err = readMappingRegionsSubArray(MappingRegions, InferredFileID,
268                                              VirtualFileMapping.size()))
269      return Err;
270  }
271
272  // Set the counters for the expansion regions.
273  // i.e. Counter of expansion region = counter of the first region
274  // from the expanded file.
275  // Perform multiple passes to correctly propagate the counters through
276  // all the nested expansion regions.
277  SmallVector<CounterMappingRegion *, 8> FileIDExpansionRegionMapping;
278  FileIDExpansionRegionMapping.resize(VirtualFileMapping.size(), nullptr);
279  for (unsigned Pass = 1, S = VirtualFileMapping.size(); Pass < S; ++Pass) {
280    for (auto &R : MappingRegions) {
281      if (R.Kind != CounterMappingRegion::ExpansionRegion)
282        continue;
283      assert(!FileIDExpansionRegionMapping[R.ExpandedFileID]);
284      FileIDExpansionRegionMapping[R.ExpandedFileID] = &R;
285    }
286    for (auto &R : MappingRegions) {
287      if (FileIDExpansionRegionMapping[R.FileID]) {
288        FileIDExpansionRegionMapping[R.FileID]->Count = R.Count;
289        FileIDExpansionRegionMapping[R.FileID] = nullptr;
290      }
291    }
292  }
293
294  return Error::success();
295}
296
297Expected<bool> RawCoverageMappingDummyChecker::isDummy() {
298  // A dummy coverage mapping data consists of just one region with zero count.
299  uint64_t NumFileMappings;
300  if (Error Err = readSize(NumFileMappings))
301    return std::move(Err);
302  if (NumFileMappings != 1)
303    return false;
304  // We don't expect any specific value for the filename index, just skip it.
305  uint64_t FilenameIndex;
306  if (Error Err =
307          readIntMax(FilenameIndex, std::numeric_limits<unsigned>::max()))
308    return std::move(Err);
309  uint64_t NumExpressions;
310  if (Error Err = readSize(NumExpressions))
311    return std::move(Err);
312  if (NumExpressions != 0)
313    return false;
314  uint64_t NumRegions;
315  if (Error Err = readSize(NumRegions))
316    return std::move(Err);
317  if (NumRegions != 1)
318    return false;
319  uint64_t EncodedCounterAndRegion;
320  if (Error Err = readIntMax(EncodedCounterAndRegion,
321                             std::numeric_limits<unsigned>::max()))
322    return std::move(Err);
323  unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask;
324  return Tag == Counter::Zero;
325}
326
327Error InstrProfSymtab::create(SectionRef &Section) {
328  if (auto EC = Section.getContents(Data))
329    return errorCodeToError(EC);
330  Address = Section.getAddress();
331  return Error::success();
332}
333
334StringRef InstrProfSymtab::getFuncName(uint64_t Pointer, size_t Size) {
335  if (Pointer < Address)
336    return StringRef();
337  auto Offset = Pointer - Address;
338  if (Offset + Size > Data.size())
339    return StringRef();
340  return Data.substr(Pointer - Address, Size);
341}
342
343// Check if the mapping data is a dummy, i.e. is emitted for an unused function.
344static Expected<bool> isCoverageMappingDummy(uint64_t Hash, StringRef Mapping) {
345  // The hash value of dummy mapping records is always zero.
346  if (Hash)
347    return false;
348  return RawCoverageMappingDummyChecker(Mapping).isDummy();
349}
350
351namespace {
352struct CovMapFuncRecordReader {
353  // The interface to read coverage mapping function records for a module.
354  //
355  // \p Buf points to the buffer containing the \c CovHeader of the coverage
356  // mapping data associated with the module.
357  //
358  // Returns a pointer to the next \c CovHeader if it exists, or a pointer
359  // greater than \p End if not.
360  virtual Expected<const char *> readFunctionRecords(const char *Buf,
361                                                     const char *End) = 0;
362  virtual ~CovMapFuncRecordReader() {}
363  template <class IntPtrT, support::endianness Endian>
364  static Expected<std::unique_ptr<CovMapFuncRecordReader>>
365  get(coverage::CovMapVersion Version, InstrProfSymtab &P,
366      std::vector<BinaryCoverageReader::ProfileMappingRecord> &R,
367      std::vector<StringRef> &F);
368};
369
370// A class for reading coverage mapping function records for a module.
371template <coverage::CovMapVersion Version, class IntPtrT,
372          support::endianness Endian>
373class VersionedCovMapFuncRecordReader : public CovMapFuncRecordReader {
374  typedef typename coverage::CovMapTraits<
375      Version, IntPtrT>::CovMapFuncRecordType FuncRecordType;
376  typedef typename coverage::CovMapTraits<Version, IntPtrT>::NameRefType
377      NameRefType;
378
379  // Maps function's name references to the indexes of their records
380  // in \c Records.
381  llvm::DenseMap<NameRefType, size_t> FunctionRecords;
382  InstrProfSymtab &ProfileNames;
383  std::vector<StringRef> &Filenames;
384  std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records;
385
386  // Add the record to the collection if we don't already have a record that
387  // points to the same function name. This is useful to ignore the redundant
388  // records for the functions with ODR linkage.
389  // In addition, prefer records with real coverage mapping data to dummy
390  // records, which were emitted for inline functions which were seen but
391  // not used in the corresponding translation unit.
392  Error insertFunctionRecordIfNeeded(const FuncRecordType *CFR,
393                                     StringRef Mapping, size_t FilenamesBegin) {
394    uint64_t FuncHash = CFR->template getFuncHash<Endian>();
395    NameRefType NameRef = CFR->template getFuncNameRef<Endian>();
396    auto InsertResult =
397        FunctionRecords.insert(std::make_pair(NameRef, Records.size()));
398    if (InsertResult.second) {
399      StringRef FuncName;
400      if (Error Err = CFR->template getFuncName<Endian>(ProfileNames, FuncName))
401        return Err;
402      Records.emplace_back(Version, FuncName, FuncHash, Mapping, FilenamesBegin,
403                           Filenames.size() - FilenamesBegin);
404      return Error::success();
405    }
406    // Update the existing record if it's a dummy and the new record is real.
407    size_t OldRecordIndex = InsertResult.first->second;
408    BinaryCoverageReader::ProfileMappingRecord &OldRecord =
409        Records[OldRecordIndex];
410    Expected<bool> OldIsDummyExpected = isCoverageMappingDummy(
411        OldRecord.FunctionHash, OldRecord.CoverageMapping);
412    if (Error Err = OldIsDummyExpected.takeError())
413      return Err;
414    if (!*OldIsDummyExpected)
415      return Error::success();
416    Expected<bool> NewIsDummyExpected =
417        isCoverageMappingDummy(FuncHash, Mapping);
418    if (Error Err = NewIsDummyExpected.takeError())
419      return Err;
420    if (*NewIsDummyExpected)
421      return Error::success();
422    OldRecord.FunctionHash = FuncHash;
423    OldRecord.CoverageMapping = Mapping;
424    OldRecord.FilenamesBegin = FilenamesBegin;
425    OldRecord.FilenamesSize = Filenames.size() - FilenamesBegin;
426    return Error::success();
427  }
428
429public:
430  VersionedCovMapFuncRecordReader(
431      InstrProfSymtab &P,
432      std::vector<BinaryCoverageReader::ProfileMappingRecord> &R,
433      std::vector<StringRef> &F)
434      : ProfileNames(P), Filenames(F), Records(R) {}
435  ~VersionedCovMapFuncRecordReader() override {}
436
437  Expected<const char *> readFunctionRecords(const char *Buf,
438                                             const char *End) override {
439    using namespace support;
440    if (Buf + sizeof(CovMapHeader) > End)
441      return make_error<CoverageMapError>(coveragemap_error::malformed);
442    auto CovHeader = reinterpret_cast<const coverage::CovMapHeader *>(Buf);
443    uint32_t NRecords = CovHeader->getNRecords<Endian>();
444    uint32_t FilenamesSize = CovHeader->getFilenamesSize<Endian>();
445    uint32_t CoverageSize = CovHeader->getCoverageSize<Endian>();
446    assert((CovMapVersion)CovHeader->getVersion<Endian>() == Version);
447    Buf = reinterpret_cast<const char *>(CovHeader + 1);
448
449    // Skip past the function records, saving the start and end for later.
450    const char *FunBuf = Buf;
451    Buf += NRecords * sizeof(FuncRecordType);
452    const char *FunEnd = Buf;
453
454    // Get the filenames.
455    if (Buf + FilenamesSize > End)
456      return make_error<CoverageMapError>(coveragemap_error::malformed);
457    size_t FilenamesBegin = Filenames.size();
458    RawCoverageFilenamesReader Reader(StringRef(Buf, FilenamesSize), Filenames);
459    if (auto Err = Reader.read())
460      return std::move(Err);
461    Buf += FilenamesSize;
462
463    // We'll read the coverage mapping records in the loop below.
464    const char *CovBuf = Buf;
465    Buf += CoverageSize;
466    const char *CovEnd = Buf;
467
468    if (Buf > End)
469      return make_error<CoverageMapError>(coveragemap_error::malformed);
470    // Each coverage map has an alignment of 8, so we need to adjust alignment
471    // before reading the next map.
472    Buf += alignmentAdjustment(Buf, 8);
473
474    auto CFR = reinterpret_cast<const FuncRecordType *>(FunBuf);
475    while ((const char *)CFR < FunEnd) {
476      // Read the function information
477      uint32_t DataSize = CFR->template getDataSize<Endian>();
478
479      // Now use that to read the coverage data.
480      if (CovBuf + DataSize > CovEnd)
481        return make_error<CoverageMapError>(coveragemap_error::malformed);
482      auto Mapping = StringRef(CovBuf, DataSize);
483      CovBuf += DataSize;
484
485      if (Error Err =
486              insertFunctionRecordIfNeeded(CFR, Mapping, FilenamesBegin))
487        return std::move(Err);
488      CFR++;
489    }
490    return Buf;
491  }
492};
493} // end anonymous namespace
494
495template <class IntPtrT, support::endianness Endian>
496Expected<std::unique_ptr<CovMapFuncRecordReader>> CovMapFuncRecordReader::get(
497    coverage::CovMapVersion Version, InstrProfSymtab &P,
498    std::vector<BinaryCoverageReader::ProfileMappingRecord> &R,
499    std::vector<StringRef> &F) {
500  using namespace coverage;
501  switch (Version) {
502  case CovMapVersion::Version1:
503    return llvm::make_unique<VersionedCovMapFuncRecordReader<
504        CovMapVersion::Version1, IntPtrT, Endian>>(P, R, F);
505  case CovMapVersion::Version2:
506    // Decompress the name data.
507    if (Error E = P.create(P.getNameData()))
508      return std::move(E);
509    return llvm::make_unique<VersionedCovMapFuncRecordReader<
510        CovMapVersion::Version2, IntPtrT, Endian>>(P, R, F);
511  }
512  llvm_unreachable("Unsupported version");
513}
514
515template <typename T, support::endianness Endian>
516static Error readCoverageMappingData(
517    InstrProfSymtab &ProfileNames, StringRef Data,
518    std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records,
519    std::vector<StringRef> &Filenames) {
520  using namespace coverage;
521  // Read the records in the coverage data section.
522  auto CovHeader =
523      reinterpret_cast<const coverage::CovMapHeader *>(Data.data());
524  CovMapVersion Version = (CovMapVersion)CovHeader->getVersion<Endian>();
525  if (Version > coverage::CovMapVersion::CurrentVersion)
526    return make_error<CoverageMapError>(coveragemap_error::unsupported_version);
527  Expected<std::unique_ptr<CovMapFuncRecordReader>> ReaderExpected =
528      CovMapFuncRecordReader::get<T, Endian>(Version, ProfileNames, Records,
529                                             Filenames);
530  if (Error E = ReaderExpected.takeError())
531    return E;
532  auto Reader = std::move(ReaderExpected.get());
533  for (const char *Buf = Data.data(), *End = Buf + Data.size(); Buf < End;) {
534    auto NextHeaderOrErr = Reader->readFunctionRecords(Buf, End);
535    if (auto E = NextHeaderOrErr.takeError())
536      return E;
537    Buf = NextHeaderOrErr.get();
538  }
539  return Error::success();
540}
541static const char *TestingFormatMagic = "llvmcovmtestdata";
542
543static Error loadTestingFormat(StringRef Data, InstrProfSymtab &ProfileNames,
544                               StringRef &CoverageMapping,
545                               uint8_t &BytesInAddress,
546                               support::endianness &Endian) {
547  BytesInAddress = 8;
548  Endian = support::endianness::little;
549
550  Data = Data.substr(StringRef(TestingFormatMagic).size());
551  if (Data.size() < 1)
552    return make_error<CoverageMapError>(coveragemap_error::truncated);
553  unsigned N = 0;
554  auto ProfileNamesSize =
555      decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
556  if (N > Data.size())
557    return make_error<CoverageMapError>(coveragemap_error::malformed);
558  Data = Data.substr(N);
559  if (Data.size() < 1)
560    return make_error<CoverageMapError>(coveragemap_error::truncated);
561  N = 0;
562  uint64_t Address =
563      decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
564  if (N > Data.size())
565    return make_error<CoverageMapError>(coveragemap_error::malformed);
566  Data = Data.substr(N);
567  if (Data.size() < ProfileNamesSize)
568    return make_error<CoverageMapError>(coveragemap_error::malformed);
569  if (Error E = ProfileNames.create(Data.substr(0, ProfileNamesSize), Address))
570    return E;
571  CoverageMapping = Data.substr(ProfileNamesSize);
572  // Skip the padding bytes because coverage map data has an alignment of 8.
573  if (CoverageMapping.size() < 1)
574    return make_error<CoverageMapError>(coveragemap_error::truncated);
575  size_t Pad = alignmentAdjustment(CoverageMapping.data(), 8);
576  if (CoverageMapping.size() < Pad)
577    return make_error<CoverageMapError>(coveragemap_error::malformed);
578  CoverageMapping = CoverageMapping.substr(Pad);
579  return Error::success();
580}
581
582static Expected<SectionRef> lookupSection(ObjectFile &OF, StringRef Name) {
583  StringRef FoundName;
584  for (const auto &Section : OF.sections()) {
585    if (auto EC = Section.getName(FoundName))
586      return errorCodeToError(EC);
587    if (FoundName == Name)
588      return Section;
589  }
590  return make_error<CoverageMapError>(coveragemap_error::no_data_found);
591}
592
593static Error loadBinaryFormat(MemoryBufferRef ObjectBuffer,
594                              InstrProfSymtab &ProfileNames,
595                              StringRef &CoverageMapping,
596                              uint8_t &BytesInAddress,
597                              support::endianness &Endian, StringRef Arch) {
598  auto BinOrErr = object::createBinary(ObjectBuffer);
599  if (!BinOrErr)
600    return BinOrErr.takeError();
601  auto Bin = std::move(BinOrErr.get());
602  std::unique_ptr<ObjectFile> OF;
603  if (auto *Universal = dyn_cast<object::MachOUniversalBinary>(Bin.get())) {
604    // If we have a universal binary, try to look up the object for the
605    // appropriate architecture.
606    auto ObjectFileOrErr = Universal->getObjectForArch(Arch);
607    if (!ObjectFileOrErr)
608      return ObjectFileOrErr.takeError();
609    OF = std::move(ObjectFileOrErr.get());
610  } else if (isa<object::ObjectFile>(Bin.get())) {
611    // For any other object file, upcast and take ownership.
612    OF.reset(cast<object::ObjectFile>(Bin.release()));
613    // If we've asked for a particular arch, make sure they match.
614    if (!Arch.empty() && OF->getArch() != Triple(Arch).getArch())
615      return errorCodeToError(object_error::arch_not_found);
616  } else
617    // We can only handle object files.
618    return make_error<CoverageMapError>(coveragemap_error::malformed);
619
620  // The coverage uses native pointer sizes for the object it's written in.
621  BytesInAddress = OF->getBytesInAddress();
622  Endian = OF->isLittleEndian() ? support::endianness::little
623                                : support::endianness::big;
624
625  // Look for the sections that we are interested in.
626  auto NamesSection = lookupSection(*OF, getInstrProfNameSectionName(false));
627  if (auto E = NamesSection.takeError())
628    return E;
629  auto CoverageSection =
630      lookupSection(*OF, getInstrProfCoverageSectionName(false));
631  if (auto E = CoverageSection.takeError())
632    return E;
633
634  // Get the contents of the given sections.
635  if (auto EC = CoverageSection->getContents(CoverageMapping))
636    return errorCodeToError(EC);
637  if (Error E = ProfileNames.create(*NamesSection))
638    return E;
639
640  return Error::success();
641}
642
643Expected<std::unique_ptr<BinaryCoverageReader>>
644BinaryCoverageReader::create(std::unique_ptr<MemoryBuffer> &ObjectBuffer,
645                             StringRef Arch) {
646  std::unique_ptr<BinaryCoverageReader> Reader(new BinaryCoverageReader());
647
648  StringRef Coverage;
649  uint8_t BytesInAddress;
650  support::endianness Endian;
651  Error E;
652  consumeError(std::move(E));
653  if (ObjectBuffer->getBuffer().startswith(TestingFormatMagic))
654    // This is a special format used for testing.
655    E = loadTestingFormat(ObjectBuffer->getBuffer(), Reader->ProfileNames,
656                          Coverage, BytesInAddress, Endian);
657  else
658    E = loadBinaryFormat(ObjectBuffer->getMemBufferRef(), Reader->ProfileNames,
659                         Coverage, BytesInAddress, Endian, Arch);
660  if (E)
661    return std::move(E);
662
663  if (BytesInAddress == 4 && Endian == support::endianness::little)
664    E = readCoverageMappingData<uint32_t, support::endianness::little>(
665        Reader->ProfileNames, Coverage, Reader->MappingRecords,
666        Reader->Filenames);
667  else if (BytesInAddress == 4 && Endian == support::endianness::big)
668    E = readCoverageMappingData<uint32_t, support::endianness::big>(
669        Reader->ProfileNames, Coverage, Reader->MappingRecords,
670        Reader->Filenames);
671  else if (BytesInAddress == 8 && Endian == support::endianness::little)
672    E = readCoverageMappingData<uint64_t, support::endianness::little>(
673        Reader->ProfileNames, Coverage, Reader->MappingRecords,
674        Reader->Filenames);
675  else if (BytesInAddress == 8 && Endian == support::endianness::big)
676    E = readCoverageMappingData<uint64_t, support::endianness::big>(
677        Reader->ProfileNames, Coverage, Reader->MappingRecords,
678        Reader->Filenames);
679  else
680    return make_error<CoverageMapError>(coveragemap_error::malformed);
681  if (E)
682    return std::move(E);
683  return std::move(Reader);
684}
685
686Error BinaryCoverageReader::readNextRecord(CoverageMappingRecord &Record) {
687  if (CurrentRecord >= MappingRecords.size())
688    return make_error<CoverageMapError>(coveragemap_error::eof);
689
690  FunctionsFilenames.clear();
691  Expressions.clear();
692  MappingRegions.clear();
693  auto &R = MappingRecords[CurrentRecord];
694  RawCoverageMappingReader Reader(
695      R.CoverageMapping,
696      makeArrayRef(Filenames).slice(R.FilenamesBegin, R.FilenamesSize),
697      FunctionsFilenames, Expressions, MappingRegions);
698  if (auto Err = Reader.read())
699    return Err;
700
701  Record.FunctionName = R.FunctionName;
702  Record.FunctionHash = R.FunctionHash;
703  Record.Filenames = FunctionsFilenames;
704  Record.Expressions = Expressions;
705  Record.MappingRegions = MappingRegions;
706
707  ++CurrentRecord;
708  return Error::success();
709}
710