LLVM  13.0.0git
CoverageMappingReader.cpp
Go to the documentation of this file.
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 
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"
26 #include "llvm/Object/ObjectFile.h"
28 #include "llvm/Support/Casting.h"
30 #include "llvm/Support/Debug.h"
31 #include "llvm/Support/Endian.h"
32 #include "llvm/Support/Error.h"
34 #include "llvm/Support/LEB128.h"
36 #include "llvm/Support/Path.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 
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 
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 
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 
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 
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>(
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>(
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.
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 {
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) {
187  switch (Tag) {
188  case Counter::Zero:
189  C = Counter::getZero();
190  return Error::success();
193  return Error::success();
194  default:
195  break;
196  }
198  switch (Tag) {
200  case CounterExpression::Add: {
202  if (ID >= Expressions.size())
203  return make_error<CoverageMapError>(coveragemap_error::malformed);
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
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;
240 
241  // Read the combined counter + region kind.
242  uint64_t EncodedCounterAndRegion;
243  if (auto Err = readIntMax(EncodedCounterAndRegion,
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) {
267  ExpandedFileID = EncodedCounterAndRegion >>
269  if (ExpandedFileID >= NumFileIDs)
270  return make_error<CoverageMapError>(coveragemap_error::malformed);
271  } else {
272  switch (EncodedCounterAndRegion >>
275  // Don't do anything when we have a code region with a zero counter.
276  break;
279  break;
281  // For a Branch Region, read two successive counters.
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)) {
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;
326  }
327 
328  LLVM_DEBUG({
329  dbgs() << "Counter in file " << InferredFileID << " " << LineStart << ":"
330  << ColumnStart << " -> " << (LineStart + NumLines) << ":"
331  << ColumnEnd << ", ";
333  dbgs() << "Expands to file " << ExpandedFileID;
334  else
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 
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,
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) {
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 
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,
442  return std::move(Err);
443  unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask;
444  return Tag == Counter::Zero;
445 }
446 
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.
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>
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 =
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.
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;
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(
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;
628  FuncRecBuf = CovBuf;
629  CovBuf += NRecords * sizeof(FuncRecordType);
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 
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 
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);
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;
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);
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>
745  std::vector<BinaryCoverageReader::ProfileMappingRecord> &R, StringRef D,
746  std::vector<std::string> &F) {
747  using namespace coverage;
748 
749  switch (Version) {
751  return std::make_unique<VersionedCovMapFuncRecordReader<
752  CovMapVersion::Version1, IntPtrT, Endian>>(P, R, D, F);
758  // Decompress the name data.
759  if (Error E = P.create(P.getNameData()))
760  return std::move(E);
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>
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>();
792  return make_error<CoverageMapError>(coveragemap_error::unsupported_version);
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.
818  return Reader->readFunctionRecords(FuncRecBuf, FuncRecBufEnd, None, nullptr,
819  nullptr);
820  return Error::success();
821 }
822 
823 static const char *TestingFormatMagic = "llvmcovmtestdata";
824 
827  StringRef Coverage, std::string &&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;
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 
862 loadTestingFormat(StringRef Data, StringRef CompilationDir) {
863  uint8_t BytesInAddress = 8;
865 
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());
897  (CovMapVersion)CovHeader->getVersion<support::endianness::little>();
898  StringRef CoverageMapping, CoverageRecords;
901  if (CoverageMapping.empty())
902  return make_error<CoverageMapError>(coveragemap_error::truncated);
903  } else {
904  uint32_t FilenamesSize =
905  CovHeader->getFilenamesSize<support::endianness::little>();
906  uint32_t CoverageMappingSize = sizeof(CovMapHeader) + FilenamesSize;
907  CoverageMapping = Data.substr(0, CoverageMappingSize);
908  if (CoverageMapping.empty())
909  return make_error<CoverageMapError>(coveragemap_error::truncated);
910  Data = Data.substr(CoverageMappingSize);
911  // Skip the padding bytes because coverage records data has an alignment
912  // of 8.
913  Pad = offsetToAlignedAddr(Data.data(), Align(8));
914  if (Data.size() < Pad)
915  return make_error<CoverageMapError>(coveragemap_error::malformed);
916  CoverageRecords = Data.substr(Pad);
917  if (CoverageRecords.empty())
918  return make_error<CoverageMapError>(coveragemap_error::truncated);
919  }
921  CoverageMapping, CoverageRecords.str(), std::move(ProfileNames),
922  BytesInAddress, Endian, CompilationDir);
923 }
924 
925 /// Find all sections that match \p Name. There may be more than one if comdats
926 /// are in use, e.g. for the __llvm_covfun section on ELF.
928  StringRef Name) {
929  // On COFF, the object file section name may end in "$M". This tells the
930  // linker to sort these sections between "$A" and "$Z". The linker removes the
931  // dollar and everything after it in the final binary. Do the same to match.
932  bool IsCOFF = isa<COFFObjectFile>(OF);
933  auto stripSuffix = [IsCOFF](StringRef N) {
934  return IsCOFF ? N.split('$').first : N;
935  };
936  Name = stripSuffix(Name);
937 
938  std::vector<SectionRef> Sections;
939  for (const auto &Section : OF.sections()) {
940  Expected<StringRef> NameOrErr = Section.getName();
941  if (!NameOrErr)
942  return NameOrErr.takeError();
943  if (stripSuffix(*NameOrErr) == Name)
944  Sections.push_back(Section);
945  }
946  if (Sections.empty())
947  return make_error<CoverageMapError>(coveragemap_error::no_data_found);
948  return Sections;
949 }
950 
952 loadBinaryFormat(std::unique_ptr<Binary> Bin, StringRef Arch,
953  StringRef CompilationDir = "") {
954  std::unique_ptr<ObjectFile> OF;
955  if (auto *Universal = dyn_cast<MachOUniversalBinary>(Bin.get())) {
956  // If we have a universal binary, try to look up the object for the
957  // appropriate architecture.
958  auto ObjectFileOrErr = Universal->getMachOObjectForArch(Arch);
959  if (!ObjectFileOrErr)
960  return ObjectFileOrErr.takeError();
961  OF = std::move(ObjectFileOrErr.get());
962  } else if (isa<ObjectFile>(Bin.get())) {
963  // For any other object file, upcast and take ownership.
964  OF.reset(cast<ObjectFile>(Bin.release()));
965  // If we've asked for a particular arch, make sure they match.
966  if (!Arch.empty() && OF->getArch() != Triple(Arch).getArch())
967  return errorCodeToError(object_error::arch_not_found);
968  } else
969  // We can only handle object files.
970  return make_error<CoverageMapError>(coveragemap_error::malformed);
971 
972  // The coverage uses native pointer sizes for the object it's written in.
973  uint8_t BytesInAddress = OF->getBytesInAddress();
974  support::endianness Endian = OF->isLittleEndian()
977 
978  // Look for the sections that we are interested in.
979  auto ObjFormat = OF->getTripleObjectFormat();
980  auto NamesSection =
981  lookupSections(*OF, getInstrProfSectionName(IPSK_name, ObjFormat,
982  /*AddSegmentInfo=*/false));
983  if (auto E = NamesSection.takeError())
984  return std::move(E);
985  auto CoverageSection =
986  lookupSections(*OF, getInstrProfSectionName(IPSK_covmap, ObjFormat,
987  /*AddSegmentInfo=*/false));
988  if (auto E = CoverageSection.takeError())
989  return std::move(E);
990  std::vector<SectionRef> CoverageSectionRefs = *CoverageSection;
991  if (CoverageSectionRefs.size() != 1)
992  return make_error<CoverageMapError>(coveragemap_error::malformed);
993  auto CoverageMappingOrErr = CoverageSectionRefs.back().getContents();
994  if (!CoverageMappingOrErr)
995  return CoverageMappingOrErr.takeError();
996  StringRef CoverageMapping = CoverageMappingOrErr.get();
997 
998  InstrProfSymtab ProfileNames;
999  std::vector<SectionRef> NamesSectionRefs = *NamesSection;
1000  if (NamesSectionRefs.size() != 1)
1001  return make_error<CoverageMapError>(coveragemap_error::malformed);
1002  if (Error E = ProfileNames.create(NamesSectionRefs.back()))
1003  return std::move(E);
1004 
1005  // Look for the coverage records section (Version4 only).
1006  std::string FuncRecords;
1007  auto CoverageRecordsSections =
1008  lookupSections(*OF, getInstrProfSectionName(IPSK_covfun, ObjFormat,
1009  /*AddSegmentInfo=*/false));
1010  if (auto E = CoverageRecordsSections.takeError())
1012  else {
1013  for (SectionRef Section : *CoverageRecordsSections) {
1014  auto CoverageRecordsOrErr = Section.getContents();
1015  if (!CoverageRecordsOrErr)
1016  return CoverageRecordsOrErr.takeError();
1017  FuncRecords += CoverageRecordsOrErr.get();
1018  while (FuncRecords.size() % 8 != 0)
1019  FuncRecords += '\0';
1020  }
1021  }
1022 
1024  CoverageMapping, std::move(FuncRecords), std::move(ProfileNames),
1025  BytesInAddress, Endian, CompilationDir);
1026 }
1027 
1028 /// Determine whether \p Arch is invalid or empty, given \p Bin.
1029 static bool isArchSpecifierInvalidOrMissing(Binary *Bin, StringRef Arch) {
1030  // If we have a universal binary and Arch doesn't identify any of its slices,
1031  // it's user error.
1032  if (auto *Universal = dyn_cast<MachOUniversalBinary>(Bin)) {
1033  for (auto &ObjForArch : Universal->objects())
1034  if (Arch == ObjForArch.getArchFlagName())
1035  return false;
1036  return true;
1037  }
1038  return false;
1039 }
1040 
1043  MemoryBufferRef ObjectBuffer, StringRef Arch,
1044  SmallVectorImpl<std::unique_ptr<MemoryBuffer>> &ObjectFileBuffers,
1045  StringRef CompilationDir) {
1046  std::vector<std::unique_ptr<BinaryCoverageReader>> Readers;
1047 
1048  if (ObjectBuffer.getBuffer().startswith(TestingFormatMagic)) {
1049  // This is a special format used for testing.
1050  auto ReaderOrErr =
1051  loadTestingFormat(ObjectBuffer.getBuffer(), CompilationDir);
1052  if (!ReaderOrErr)
1053  return ReaderOrErr.takeError();
1054  Readers.push_back(std::move(ReaderOrErr.get()));
1055  return std::move(Readers);
1056  }
1057 
1058  auto BinOrErr = createBinary(ObjectBuffer);
1059  if (!BinOrErr)
1060  return BinOrErr.takeError();
1061  std::unique_ptr<Binary> Bin = std::move(BinOrErr.get());
1062 
1063  if (isArchSpecifierInvalidOrMissing(Bin.get(), Arch))
1064  return make_error<CoverageMapError>(
1066 
1067  // MachO universal binaries which contain archives need to be treated as
1068  // archives, not as regular binaries.
1069  if (auto *Universal = dyn_cast<MachOUniversalBinary>(Bin.get())) {
1070  for (auto &ObjForArch : Universal->objects()) {
1071  // Skip slices within the universal binary which target the wrong arch.
1072  std::string ObjArch = ObjForArch.getArchFlagName();
1073  if (Arch != ObjArch)
1074  continue;
1075 
1076  auto ArchiveOrErr = ObjForArch.getAsArchive();
1077  if (!ArchiveOrErr) {
1078  // If this is not an archive, try treating it as a regular object.
1079  consumeError(ArchiveOrErr.takeError());
1080  break;
1081  }
1082 
1084  ArchiveOrErr.get()->getMemoryBufferRef(), Arch, ObjectFileBuffers,
1085  CompilationDir);
1086  }
1087  }
1088 
1089  // Load coverage out of archive members.
1090  if (auto *Ar = dyn_cast<Archive>(Bin.get())) {
1091  Error Err = Error::success();
1092  for (auto &Child : Ar->children(Err)) {
1093  Expected<MemoryBufferRef> ChildBufOrErr = Child.getMemoryBufferRef();
1094  if (!ChildBufOrErr)
1095  return ChildBufOrErr.takeError();
1096 
1097  auto ChildReadersOrErr = BinaryCoverageReader::create(
1098  ChildBufOrErr.get(), Arch, ObjectFileBuffers, CompilationDir);
1099  if (!ChildReadersOrErr)
1100  return ChildReadersOrErr.takeError();
1101  for (auto &Reader : ChildReadersOrErr.get())
1102  Readers.push_back(std::move(Reader));
1103  }
1104  if (Err)
1105  return std::move(Err);
1106 
1107  // Thin archives reference object files outside of the archive file, i.e.
1108  // files which reside in memory not owned by the caller. Transfer ownership
1109  // to the caller.
1110  if (Ar->isThin())
1111  for (auto &Buffer : Ar->takeThinBuffers())
1112  ObjectFileBuffers.push_back(std::move(Buffer));
1113 
1114  return std::move(Readers);
1115  }
1116 
1117  auto ReaderOrErr = loadBinaryFormat(std::move(Bin), Arch, CompilationDir);
1118  if (!ReaderOrErr)
1119  return ReaderOrErr.takeError();
1120  Readers.push_back(std::move(ReaderOrErr.get()));
1121  return std::move(Readers);
1122 }
1123 
1125  if (CurrentRecord >= MappingRecords.size())
1126  return make_error<CoverageMapError>(coveragemap_error::eof);
1127 
1128  FunctionsFilenames.clear();
1129  Expressions.clear();
1130  MappingRegions.clear();
1131  auto &R = MappingRecords[CurrentRecord];
1132  auto F = makeArrayRef(Filenames).slice(R.FilenamesBegin, R.FilenamesSize);
1133  RawCoverageMappingReader Reader(R.CoverageMapping, F, FunctionsFilenames,
1134  Expressions, MappingRegions);
1135  if (auto Err = Reader.read())
1136  return Err;
1137 
1138  Record.FunctionName = R.FunctionName;
1139  Record.FunctionHash = R.FunctionHash;
1140  Record.Filenames = FunctionsFilenames;
1141  Record.Expressions = Expressions;
1142  Record.MappingRegions = MappingRegions;
1143 
1144  ++CurrentRecord;
1145  return Error::success();
1146 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::coverage::Counter::getExpression
static Counter getExpression(unsigned ExpressionId)
Return the counter that corresponds to a specific addition counter expression.
Definition: CoverageMapping.h:142
llvm::coverage::coveragemap_error::success
@ success
llvm::coverage::CounterExpression
A Counter expression is a value that represents an arithmetic operation with two counters.
Definition: CoverageMapping.h:149
Compression.h
llvm::StringRef::startswith
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:286
llvm::coverage::BinaryCoverageReader::ProfileMappingRecord::FilenamesBegin
size_t FilenamesBegin
Definition: CoverageMappingReader.h:171
FilenameRange::Length
unsigned Length
Definition: CoverageMappingReader.cpp:484
MathExtras.h
llvm
Definition: AllocatorList.h:23
llvm::coverage::Version4
@ Version4
Definition: CoverageMapping.h:1003
llvm::coverage::CovMapTraits::NameRefType
uint64_t NameRefType
Definition: CoverageMapping.h:1015
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
TestingFormatMagic
static const char * TestingFormatMagic
Definition: CoverageMappingReader.cpp:823
llvm::coverage::CoverageMapError
Definition: CoverageMapping.h:68
llvm::coverage::CoverageMapError::get
coveragemap_error get() const
Definition: CoverageMapping.h:82
Insert
Vector Rotate Left Mask Mask Insert
Definition: README_P9.txt:112
FilenameRange
A range of filename indices.
Definition: CoverageMappingReader.cpp:482
llvm::coverage::coveragemap_error::no_data_found
@ no_data_found
llvm::coverage::Version3
@ Version3
Definition: CoverageMapping.h:1001
llvm::coverage::CounterExpression::ExprKind
ExprKind
Definition: CoverageMapping.h:150
llvm::coverage::CovMapVersion
CovMapVersion
Definition: CoverageMapping.h:993
llvm::coverage::CounterExpression::Subtract
@ Subtract
Definition: CoverageMapping.h:150
llvm::coverage::CounterMappingRegion
A Counter mapping region associates a source range with a specific counter.
Definition: CoverageMapping.h:208
StringRef.h
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::coverage::BinaryCoverageReader::createCoverageReaderFromBuffer
static Expected< std::unique_ptr< BinaryCoverageReader > > createCoverageReaderFromBuffer(StringRef Coverage, std::string &&FuncRecords, InstrProfSymtab &&ProfileNames, uint8_t BytesInAddress, support::endianness Endian, StringRef CompilationDir="")
Definition: CoverageMappingReader.cpp:826
llvm::SmallVector< char, 0 >
Statistic.h
llvm::IndexedInstrProf::ComputeHash
uint64_t ComputeHash(StringRef K)
Definition: InstrProf.h:995
Path.h
llvm::sys::path::is_absolute
bool is_absolute(const Twine &path, Style style=Style::native)
Is path absolute?
Definition: Path.cpp:669
llvm::coverage::Counter::Expression
@ Expression
Definition: CoverageMapping.h:95
ErrorHandling.h
llvm::InstrProfSymtab::create
Error create(object::SectionRef &Section)
Create InstrProfSymtab from an object file section which contains function PGO names.
llvm::zlib::uncompress
Error uncompress(StringRef InputBuffer, char *UncompressedBuffer, size_t &UncompressedSize)
Definition: Compression.cpp:63
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:332
llvm::coverage::BinaryCoverageReader::readNextRecord
Error readNextRecord(CoverageMappingRecord &Record) override
Definition: CoverageMappingReader.cpp:1124
FilenameRange::isInvalid
bool isInvalid() const
Definition: CoverageMappingReader.cpp:490
Error.h
isArchSpecifierInvalidOrMissing
static bool isArchSpecifierInvalidOrMissing(Binary *Bin, StringRef Arch)
Determine whether Arch is invalid or empty, given Bin.
Definition: CoverageMappingReader.cpp:1029
llvm::coverage::Counter::getCounter
static Counter getCounter(unsigned CounterId)
Return the counter that corresponds to a specific profile counter.
Definition: CoverageMapping.h:136
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:45
llvm::coverage::Counter::CounterValueReference
@ CounterValueReference
Definition: CoverageMapping.h:95
DenseMap.h
llvm::coverage::BinaryCoverageReader
Reader for the coverage mapping data that is emitted by the frontend and stored in an object file.
Definition: CoverageMappingReader.h:164
readCoverageMappingData
static Error readCoverageMappingData(InstrProfSymtab &ProfileNames, StringRef CovMap, StringRef FuncRecords, std::vector< BinaryCoverageReader::ProfileMappingRecord > &Records, StringRef CompilationDir, std::vector< std::string > &Filenames)
Definition: CoverageMappingReader.cpp:781
llvm::Optional
Definition: APInt.h:33
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::coverage::CounterMappingRegion::ExpansionRegion
@ ExpansionRegion
An ExpansionRegion represents a file expansion region that associates a source range with the expansi...
Definition: CoverageMapping.h:216
llvm::coverage::CounterExpression::Add
@ Add
Definition: CoverageMapping.h:150
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
STLExtras.h
llvm::coverage::BinaryCoverageReader::ProfileMappingRecord::CoverageMapping
StringRef CoverageMapping
Definition: CoverageMappingReader.h:170
llvm::dwarf::Tag
Tag
Definition: Dwarf.h:104
llvm::coverage::coveragemap_error::unsupported_version
@ unsupported_version
llvm::consumeError
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1006
llvm::Data
@ Data
Definition: SIMachineScheduler.h:56
llvm::MemoryBufferRef
Definition: MemoryBufferRef.h:22
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:122
llvm::coverage::coveragemap_error::decompression_failed
@ decompression_failed
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:180
llvm::lltok::equal
@ equal
Definition: LLToken.h:25
llvm::sys::path::append
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:454
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
llvm::ARMBuildAttrs::Section
@ Section
Legacy Tags.
Definition: ARMBuildAttributes.h:78
readULEB128
static uint64_t readULEB128(WasmObjectFile::ReadContext &Ctx)
Definition: WasmObjectFile.cpp:104
llvm::coverage::coveragemap_error::eof
@ eof
llvm::decodeULEB128
uint64_t decodeULEB128(const uint8_t *p, unsigned *n=nullptr, const uint8_t *end=nullptr, const char **error=nullptr)
Utility function to decode a ULEB128 value.
Definition: LEB128.h:128
llvm::coverage::Version1
@ Version1
Definition: CoverageMapping.h:994
llvm::coverage::BinaryCoverageReader::ProfileMappingRecord
Definition: CoverageMappingReader.h:166
llvm::coverage::CurrentVersion
@ CurrentVersion
Definition: CoverageMapping.h:1010
Error.h
llvm::coverage::RawCoverageMappingDummyChecker::isDummy
Expected< bool > isDummy()
Definition: CoverageMappingReader.cpp:417
llvm::coverage::Version5
@ Version5
Definition: CoverageMapping.h:1005
llvm::coverage::coveragemap_error::malformed
@ malformed
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::support::little
@ little
Definition: Endian.h:27
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::errorCodeToError
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:87
MachOUniversal.h
llvm::coverage::CoverageMappingIterator
A file format agnostic iterator over coverage mapping data.
Definition: CoverageMappingReader.h:44
InstrProf.h
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
llvm::coverage::coveragemap_error::invalid_or_missing_arch_specifier
@ invalid_or_missing_arch_specifier
llvm::SmallVectorImpl::resize
void resize(size_type N)
Definition: SmallVector.h:605
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:991
llvm::coverage::RawCoverageReader::readSize
Error readSize(uint64_t &Result)
Definition: CoverageMappingReader.cpp:83
Align
uint64_t Align
Definition: ELFObjHandler.cpp:83
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::coverage::CounterMappingContext::dump
void dump(const Counter &C, raw_ostream &OS) const
Definition: CoverageMapping.cpp:135
llvm::StringRef::str
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:245
llvm::coverage::BinaryCoverageReader::ProfileMappingRecord::FunctionHash
uint64_t FunctionHash
Definition: CoverageMappingReader.h:169
llvm::None
const NoneType None
Definition: None.h:23
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::coverage::BinaryCoverageReader::create
static Expected< std::vector< std::unique_ptr< BinaryCoverageReader > > > create(MemoryBufferRef ObjectBuffer, StringRef Arch, SmallVectorImpl< std::unique_ptr< MemoryBuffer >> &ObjectFileBuffers, StringRef CompilationDir="")
Definition: CoverageMappingReader.cpp:1042
llvm::SmallString< 256 >
llvm::coverage::coveragemap_error::truncated
@ truncated
llvm::coverage::RawCoverageMappingReader
Reader for the raw coverage mapping data.
Definition: CoverageMappingReader.h:132
CoverageMappingReader.h
llvm::coverage::BinaryCoverageReader::ProfileMappingRecord::FilenamesSize
size_t FilenamesSize
Definition: CoverageMappingReader.h:172
object
bar al al movzbl eax ret Missed when stored in a memory object
Definition: README.txt:1411
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
LEB128.h
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::DenseMap
Definition: DenseMap.h:714
llvm::coverage::CovMapFunctionRecordV3
Definition: CoverageMapping.h:915
llvm::coverage::Counter
A Counter is an abstract value that describes how to compute the execution count for a region of code...
Definition: CoverageMapping.h:92
I
#define I(x, y, z)
Definition: MD5.cpp:59
ArrayRef.h
llvm::HighlightColor::Address
@ Address
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::find
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:150
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::coverage::CovMapHeader
Definition: CoverageMapping.h:971
ObjectFile.h
llvm::MemoryBufferRef::getBuffer
StringRef getBuffer() const
Definition: MemoryBufferRef.h:32
llvm::zlib::isAvailable
bool isAvailable()
Definition: Compression.cpp:47
llvm::Record
Definition: Record.h:1472
llvm::coverage::CounterMappingRegion::BranchRegion
@ BranchRegion
A BranchRegion represents leaf-level boolean expressions and is associated with two counters,...
Definition: CoverageMapping.h:229
llvm::coverage::RawCoverageMappingDummyChecker
Checks if the given coverage mapping data is exported for an unused function.
Definition: CoverageMappingReader.h:123
llvm::coverage::CounterMappingRegion::GapRegion
@ GapRegion
A GapRegion is like a CodeRegion, but its count is only set as the line execution count when its the ...
Definition: CoverageMapping.h:224
Triple.h
llvm::size
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1463
llvm::offsetToAlignedAddr
uint64_t offsetToAlignedAddr(const void *Addr, Align Alignment)
Returns the necessary adjustment for aligning Addr to Alignment bytes, rounding up.
Definition: Alignment.h:202
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::coverage::Counter::EncodingCounterTagAndExpansionRegionTagBits
static const unsigned EncodingCounterTagAndExpansionRegionTagBits
Definition: CoverageMapping.h:98
llvm::coverage::RawCoverageMappingReader::read
Error read()
Definition: CoverageMappingReader.cpp:349
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
llvm::coverage::CoverageMapping
The mapping of profile information to coverage data.
Definition: CoverageMapping.h:570
llvm::Expected::get
reference get()
Returns a reference to the stored T value.
Definition: Error.h:537
isCoverageMappingDummy
static Expected< bool > isCoverageMappingDummy(uint64_t Hash, StringRef Mapping)
Definition: CoverageMappingReader.cpp:473
uint32_t
EncodingExpansionRegionBit
static const unsigned EncodingExpansionRegionBit
Definition: CoverageMappingReader.cpp:224
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::coverage::RawCoverageReader::readULEB128
Error readULEB128(uint64_t &Result)
Definition: CoverageMappingReader.cpp:64
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::insert
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:207
llvm::coverage::RawCoverageFilenamesReader
Reader for the raw coverage filenames.
Definition: CoverageMappingReader.h:219
llvm::coverage::CounterMappingRegion::RegionKind
RegionKind
Definition: CoverageMapping.h:209
llvm::coverage::RawCoverageReader::readIntMax
Error readIntMax(uint64_t &Result, uint64_t MaxPlus1)
Definition: CoverageMappingReader.cpp:75
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::InstrProfSymtab
A symbol table used for function PGO name look-up with keys (such as pointers, md5hash values) to the...
Definition: InstrProf.h:414
get
Should compile to something r4 addze r3 instead we get
Definition: README.txt:24
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::end
iterator end()
Definition: DenseMap.h:83
FilenameRange::markInvalid
void markInvalid()
Definition: CoverageMappingReader.cpp:489
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
Casting.h
FilenameRange::FilenameRange
FilenameRange(unsigned StartingIndex, unsigned Length)
Definition: CoverageMappingReader.cpp:486
llvm::coverage::CounterMappingContext
A Counter mapping context is used to connect the counters, expressions and the obtained counter value...
Definition: CoverageMapping.h:320
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:476
llvm::InstrProfSymtab::getFuncName
StringRef getFuncName(uint64_t FuncNameAddress, size_t NameSize)
Return function's PGO name from the function name's symbol address in the object file.
Definition: CoverageMappingReader.cpp:463
llvm::getInstrProfSectionName
std::string getInstrProfSectionName(InstrProfSectKind IPSK, Triple::ObjectFormatType OF, bool AddSegmentInfo=true)
Return the name of the profile section corresponding to IPSK.
Definition: InstrProf.cpp:174
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:557
llvm::coverage::Counter::Zero
@ Zero
Definition: CoverageMapping.h:95
llvm::Pass
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:91
Binary.h
FilenameRange::StartingIndex
unsigned StartingIndex
Definition: CoverageMappingReader.cpp:483
SmallVector.h
COFF.h
N
#define N
llvm::coverage::Version6
@ Version6
Definition: CoverageMapping.h:1008
Expressions
gvn Early GVN Hoisting of Expressions
Definition: GVNHoist.cpp:1259
llvm::coverage::Version2
@ Version2
Definition: CoverageMapping.h:998
llvm::coverage::Counter::EncodingTagMask
static const unsigned EncodingTagMask
Definition: CoverageMapping.h:97
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
support
Reimplement select in terms of SEL *We would really like to support but we need to prove that the add doesn t need to overflow between the two bit chunks *Implement pre post increment support(e.g. PR935) *Implement smarter const ant generation for binops with large immediates. A few ARMv6T2 ops should be pattern matched
Definition: README.txt:10
llvm::object::createBinary
Expected< std::unique_ptr< Binary > > createBinary(MemoryBufferRef Source, LLVMContext *Context=nullptr, bool InitContent=true)
Create a Binary from Source, autodetecting the file type.
Definition: Binary.cpp:46
llvm::support::endianness
endianness
Definition: Endian.h:27
loadTestingFormat
static Expected< std::unique_ptr< BinaryCoverageReader > > loadTestingFormat(StringRef Data, StringRef CompilationDir)
Definition: CoverageMappingReader.cpp:862
llvm::StringRef::data
const LLVM_NODISCARD char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:149
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
llvm::instrprof_error::malformed
@ malformed
llvm::coverage::Counter::getZero
static Counter getZero()
Return the counter that represents the number zero.
Definition: CoverageMapping.h:133
loadBinaryFormat
static Expected< std::unique_ptr< BinaryCoverageReader > > loadBinaryFormat(std::unique_ptr< Binary > Bin, StringRef Arch, StringRef CompilationDir="")
Definition: CoverageMappingReader.cpp:952
llvm::coverage::CounterMappingRegion::CodeRegion
@ CodeRegion
A CodeRegion associates some code with a counter.
Definition: CoverageMapping.h:211
lookupSections
static Expected< std::vector< SectionRef > > lookupSections(ObjectFile &OF, StringRef Name)
Find all sections that match Name.
Definition: CoverageMappingReader.cpp:927
readString
static StringRef readString(WasmObjectFile::ReadContext &Ctx)
Definition: WasmObjectFile.cpp:114
raw_ostream.h
llvm::coverage::RawCoverageFilenamesReader::read
Error read(CovMapVersion Version)
Definition: CoverageMappingReader.cpp:101
llvm::StringRef::size
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:157
llvm::coverage::Counter::EncodingTagBits
static const unsigned EncodingTagBits
Definition: CoverageMapping.h:96
Endian.h
llvm::coverage::CoverageMappingRecord
Coverage mapping information for a single function.
Definition: CoverageMappingReader.h:35
llvm::handleAllErrors
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
Definition: Error.h:929
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
Debug.h
llvm::coverage::CounterMappingRegion::SkippedRegion
@ SkippedRegion
A SkippedRegion represents a source range with code that was skipped by a preprocessor or similar mea...
Definition: CoverageMapping.h:220
llvm::support::big
@ big
Definition: Endian.h:27
llvm::coverage::RawCoverageReader::readString
Error readString(StringRef &Result)
Definition: CoverageMappingReader.cpp:92
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38