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