LLVM  8.0.0svn
InstrProfReader.cpp
Go to the documentation of this file.
1 //===- InstrProfReader.cpp - Instrumented profiling reader ----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for reading profiling data for clang's
11 // instrumentation based PGO and coverage.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "llvm/ADT/ArrayRef.h"
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/IR/ProfileSummary.h"
23 #include "llvm/Support/Endian.h"
24 #include "llvm/Support/Error.h"
25 #include "llvm/Support/ErrorOr.h"
29 #include <algorithm>
30 #include <cctype>
31 #include <cstddef>
32 #include <cstdint>
33 #include <limits>
34 #include <memory>
35 #include <system_error>
36 #include <utility>
37 #include <vector>
38 
39 using namespace llvm;
40 
42 setupMemoryBuffer(const Twine &Path) {
45  if (std::error_code EC = BufferOrErr.getError())
46  return errorCodeToError(EC);
47  return std::move(BufferOrErr.get());
48 }
49 
51  return Reader.readHeader();
52 }
53 
56  // Set up the buffer to read.
57  auto BufferOrError = setupMemoryBuffer(Path);
58  if (Error E = BufferOrError.takeError())
59  return std::move(E);
60  return InstrProfReader::create(std::move(BufferOrError.get()));
61 }
62 
64 InstrProfReader::create(std::unique_ptr<MemoryBuffer> Buffer) {
65  // Sanity check the buffer.
66  if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<unsigned>::max())
67  return make_error<InstrProfError>(instrprof_error::too_large);
68 
69  if (Buffer->getBufferSize() == 0)
70  return make_error<InstrProfError>(instrprof_error::empty_raw_profile);
71 
72  std::unique_ptr<InstrProfReader> Result;
73  // Create the reader.
75  Result.reset(new IndexedInstrProfReader(std::move(Buffer)));
76  else if (RawInstrProfReader64::hasFormat(*Buffer))
77  Result.reset(new RawInstrProfReader64(std::move(Buffer)));
78  else if (RawInstrProfReader32::hasFormat(*Buffer))
79  Result.reset(new RawInstrProfReader32(std::move(Buffer)));
80  else if (TextInstrProfReader::hasFormat(*Buffer))
81  Result.reset(new TextInstrProfReader(std::move(Buffer)));
82  else
83  return make_error<InstrProfError>(instrprof_error::unrecognized_format);
84 
85  // Initialize the reader and return the result.
86  if (Error E = initializeReader(*Result))
87  return std::move(E);
88 
89  return std::move(Result);
90 }
91 
93 IndexedInstrProfReader::create(const Twine &Path, const Twine &RemappingPath) {
94  // Set up the buffer to read.
95  auto BufferOrError = setupMemoryBuffer(Path);
96  if (Error E = BufferOrError.takeError())
97  return std::move(E);
98 
99  // Set up the remapping buffer if requested.
100  std::unique_ptr<MemoryBuffer> RemappingBuffer;
101  std::string RemappingPathStr = RemappingPath.str();
102  if (!RemappingPathStr.empty()) {
103  auto RemappingBufferOrError = setupMemoryBuffer(RemappingPathStr);
104  if (Error E = RemappingBufferOrError.takeError())
105  return std::move(E);
106  RemappingBuffer = std::move(RemappingBufferOrError.get());
107  }
108 
109  return IndexedInstrProfReader::create(std::move(BufferOrError.get()),
110  std::move(RemappingBuffer));
111 }
112 
114 IndexedInstrProfReader::create(std::unique_ptr<MemoryBuffer> Buffer,
115  std::unique_ptr<MemoryBuffer> RemappingBuffer) {
116  // Sanity check the buffer.
117  if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<unsigned>::max())
118  return make_error<InstrProfError>(instrprof_error::too_large);
119 
120  // Create the reader.
121  if (!IndexedInstrProfReader::hasFormat(*Buffer))
122  return make_error<InstrProfError>(instrprof_error::bad_magic);
123  auto Result = llvm::make_unique<IndexedInstrProfReader>(
124  std::move(Buffer), std::move(RemappingBuffer));
125 
126  // Initialize the reader and return the result.
127  if (Error E = initializeReader(*Result))
128  return std::move(E);
129 
130  return std::move(Result);
131 }
132 
133 void InstrProfIterator::Increment() {
134  if (auto E = Reader->readNextRecord(Record)) {
135  // Handle errors in the reader.
136  InstrProfError::take(std::move(E));
137  *this = InstrProfIterator();
138  }
139 }
140 
142  // Verify that this really looks like plain ASCII text by checking a
143  // 'reasonable' number of characters (up to profile magic size).
144  size_t count = std::min(Buffer.getBufferSize(), sizeof(uint64_t));
145  StringRef buffer = Buffer.getBufferStart();
146  return count == 0 ||
147  std::all_of(buffer.begin(), buffer.begin() + count,
148  [](char c) { return isPrint(c) || ::isspace(c); });
149 }
150 
151 // Read the profile variant flag from the header: ":FE" means this is a FE
152 // generated profile. ":IR" means this is an IR level profile. Other strings
153 // with a leading ':' will be reported an error format.
155  Symtab.reset(new InstrProfSymtab());
156  bool IsIRInstr = false;
157  if (!Line->startswith(":")) {
158  IsIRLevelProfile = false;
159  return success();
160  }
161  StringRef Str = (Line)->substr(1);
162  if (Str.equals_lower("ir"))
163  IsIRInstr = true;
164  else if (Str.equals_lower("fe"))
165  IsIRInstr = false;
166  else
168 
169  ++Line;
170  IsIRLevelProfile = IsIRInstr;
171  return success();
172 }
173 
174 Error
175 TextInstrProfReader::readValueProfileData(InstrProfRecord &Record) {
176 
177 #define CHECK_LINE_END(Line) \
178  if (Line.is_at_end()) \
179  return error(instrprof_error::truncated);
180 #define READ_NUM(Str, Dst) \
181  if ((Str).getAsInteger(10, (Dst))) \
182  return error(instrprof_error::malformed);
183 #define VP_READ_ADVANCE(Val) \
184  CHECK_LINE_END(Line); \
185  uint32_t Val; \
186  READ_NUM((*Line), (Val)); \
187  Line++;
188 
189  if (Line.is_at_end())
190  return success();
191 
192  uint32_t NumValueKinds;
193  if (Line->getAsInteger(10, NumValueKinds)) {
194  // No value profile data
195  return success();
196  }
197  if (NumValueKinds == 0 || NumValueKinds > IPVK_Last + 1)
199  Line++;
200 
201  for (uint32_t VK = 0; VK < NumValueKinds; VK++) {
203  if (ValueKind > IPVK_Last)
205  VP_READ_ADVANCE(NumValueSites);
206  if (!NumValueSites)
207  continue;
208 
209  Record.reserveSites(VK, NumValueSites);
210  for (uint32_t S = 0; S < NumValueSites; S++) {
211  VP_READ_ADVANCE(NumValueData);
212 
213  std::vector<InstrProfValueData> CurrentValues;
214  for (uint32_t V = 0; V < NumValueData; V++) {
215  CHECK_LINE_END(Line);
216  std::pair<StringRef, StringRef> VD = Line->rsplit(':');
217  uint64_t TakenCount, Value;
218  if (ValueKind == IPVK_IndirectCallTarget) {
219  if (InstrProfSymtab::isExternalSymbol(VD.first)) {
220  Value = 0;
221  } else {
222  if (Error E = Symtab->addFuncName(VD.first))
223  return E;
224  Value = IndexedInstrProf::ComputeHash(VD.first);
225  }
226  } else {
227  READ_NUM(VD.first, Value);
228  }
229  READ_NUM(VD.second, TakenCount);
230  CurrentValues.push_back({Value, TakenCount});
231  Line++;
232  }
233  Record.addValueData(ValueKind, S, CurrentValues.data(), NumValueData,
234  nullptr);
235  }
236  }
237  return success();
238 
239 #undef CHECK_LINE_END
240 #undef READ_NUM
241 #undef VP_READ_ADVANCE
242 }
243 
245  // Skip empty lines and comments.
246  while (!Line.is_at_end() && (Line->empty() || Line->startswith("#")))
247  ++Line;
248  // If we hit EOF while looking for a name, we're done.
249  if (Line.is_at_end()) {
250  return error(instrprof_error::eof);
251  }
252 
253  // Read the function name.
254  Record.Name = *Line++;
255  if (Error E = Symtab->addFuncName(Record.Name))
256  return error(std::move(E));
257 
258  // Read the function hash.
259  if (Line.is_at_end())
261  if ((Line++)->getAsInteger(0, Record.Hash))
263 
264  // Read the number of counters.
265  uint64_t NumCounters;
266  if (Line.is_at_end())
268  if ((Line++)->getAsInteger(10, NumCounters))
270  if (NumCounters == 0)
272 
273  // Read each counter and fill our internal storage with the values.
274  Record.Clear();
275  Record.Counts.reserve(NumCounters);
276  for (uint64_t I = 0; I < NumCounters; ++I) {
277  if (Line.is_at_end())
279  uint64_t Count;
280  if ((Line++)->getAsInteger(10, Count))
282  Record.Counts.push_back(Count);
283  }
284 
285  // Check if value profile data exists and read it if so.
286  if (Error E = readValueProfileData(Record))
287  return error(std::move(E));
288 
289  return success();
290 }
291 
292 template <class IntPtrT>
294  if (DataBuffer.getBufferSize() < sizeof(uint64_t))
295  return false;
296  uint64_t Magic =
297  *reinterpret_cast<const uint64_t *>(DataBuffer.getBufferStart());
298  return RawInstrProf::getMagic<IntPtrT>() == Magic ||
299  sys::getSwappedBytes(RawInstrProf::getMagic<IntPtrT>()) == Magic;
300 }
301 
302 template <class IntPtrT>
304  if (!hasFormat(*DataBuffer))
306  if (DataBuffer->getBufferSize() < sizeof(RawInstrProf::Header))
308  auto *Header = reinterpret_cast<const RawInstrProf::Header *>(
309  DataBuffer->getBufferStart());
310  ShouldSwapBytes = Header->Magic != RawInstrProf::getMagic<IntPtrT>();
311  return readHeader(*Header);
312 }
313 
314 template <class IntPtrT>
315 Error RawInstrProfReader<IntPtrT>::readNextHeader(const char *CurrentPos) {
316  const char *End = DataBuffer->getBufferEnd();
317  // Skip zero padding between profiles.
318  while (CurrentPos != End && *CurrentPos == 0)
319  ++CurrentPos;
320  // If there's nothing left, we're done.
321  if (CurrentPos == End)
322  return make_error<InstrProfError>(instrprof_error::eof);
323  // If there isn't enough space for another header, this is probably just
324  // garbage at the end of the file.
325  if (CurrentPos + sizeof(RawInstrProf::Header) > End)
326  return make_error<InstrProfError>(instrprof_error::malformed);
327  // The writer ensures each profile is padded to start at an aligned address.
328  if (reinterpret_cast<size_t>(CurrentPos) % alignof(uint64_t))
329  return make_error<InstrProfError>(instrprof_error::malformed);
330  // The magic should have the same byte order as in the previous header.
331  uint64_t Magic = *reinterpret_cast<const uint64_t *>(CurrentPos);
332  if (Magic != swap(RawInstrProf::getMagic<IntPtrT>()))
333  return make_error<InstrProfError>(instrprof_error::bad_magic);
334 
335  // There's another profile to read, so we need to process the header.
336  auto *Header = reinterpret_cast<const RawInstrProf::Header *>(CurrentPos);
337  return readHeader(*Header);
338 }
339 
340 template <class IntPtrT>
342  if (Error E = Symtab.create(StringRef(NamesStart, NamesSize)))
343  return error(std::move(E));
344  for (const RawInstrProf::ProfileData<IntPtrT> *I = Data; I != DataEnd; ++I) {
345  const IntPtrT FPtr = swap(I->FunctionPointer);
346  if (!FPtr)
347  continue;
348  Symtab.mapAddress(FPtr, I->NameRef);
349  }
350  return success();
351 }
352 
353 template <class IntPtrT>
355  const RawInstrProf::Header &Header) {
356  Version = swap(Header.Version);
357  if (GET_VERSION(Version) != RawInstrProf::Version)
359 
360  CountersDelta = swap(Header.CountersDelta);
361  NamesDelta = swap(Header.NamesDelta);
362  auto DataSize = swap(Header.DataSize);
363  auto CountersSize = swap(Header.CountersSize);
364  NamesSize = swap(Header.NamesSize);
365  ValueKindLast = swap(Header.ValueKindLast);
366 
367  auto DataSizeInBytes = DataSize * sizeof(RawInstrProf::ProfileData<IntPtrT>);
368  auto PaddingSize = getNumPaddingBytes(NamesSize);
369 
370  ptrdiff_t DataOffset = sizeof(RawInstrProf::Header);
371  ptrdiff_t CountersOffset = DataOffset + DataSizeInBytes;
372  ptrdiff_t NamesOffset = CountersOffset + sizeof(uint64_t) * CountersSize;
373  ptrdiff_t ValueDataOffset = NamesOffset + NamesSize + PaddingSize;
374 
375  auto *Start = reinterpret_cast<const char *>(&Header);
376  if (Start + ValueDataOffset > DataBuffer->getBufferEnd())
378 
379  Data = reinterpret_cast<const RawInstrProf::ProfileData<IntPtrT> *>(
380  Start + DataOffset);
381  DataEnd = Data + DataSize;
382  CountersStart = reinterpret_cast<const uint64_t *>(Start + CountersOffset);
383  NamesStart = Start + NamesOffset;
384  ValueDataStart = reinterpret_cast<const uint8_t *>(Start + ValueDataOffset);
385 
386  std::unique_ptr<InstrProfSymtab> NewSymtab = make_unique<InstrProfSymtab>();
387  if (Error E = createSymtab(*NewSymtab.get()))
388  return E;
389 
390  Symtab = std::move(NewSymtab);
391  return success();
392 }
393 
394 template <class IntPtrT>
396  Record.Name = getName(Data->NameRef);
397  return success();
398 }
399 
400 template <class IntPtrT>
402  Record.Hash = swap(Data->FuncHash);
403  return success();
404 }
405 
406 template <class IntPtrT>
408  InstrProfRecord &Record) {
409  uint32_t NumCounters = swap(Data->NumCounters);
410  IntPtrT CounterPtr = Data->CounterPtr;
411  if (NumCounters == 0)
413 
414  auto RawCounts = makeArrayRef(getCounter(CounterPtr), NumCounters);
415  auto *NamesStartAsCounter = reinterpret_cast<const uint64_t *>(NamesStart);
416 
417  // Check bounds.
418  if (RawCounts.data() < CountersStart ||
419  RawCounts.data() + RawCounts.size() > NamesStartAsCounter)
421 
422  if (ShouldSwapBytes) {
423  Record.Counts.clear();
424  Record.Counts.reserve(RawCounts.size());
425  for (uint64_t Count : RawCounts)
426  Record.Counts.push_back(swap(Count));
427  } else
428  Record.Counts = RawCounts;
429 
430  return success();
431 }
432 
433 template <class IntPtrT>
435  InstrProfRecord &Record) {
436  Record.clearValueData();
437  CurValueDataSize = 0;
438  // Need to match the logic in value profile dumper code in compiler-rt:
439  uint32_t NumValueKinds = 0;
440  for (uint32_t I = 0; I < IPVK_Last + 1; I++)
441  NumValueKinds += (Data->NumValueSites[I] != 0);
442 
443  if (!NumValueKinds)
444  return success();
445 
447  ValueProfData::getValueProfData(
448  ValueDataStart, (const unsigned char *)DataBuffer->getBufferEnd(),
449  getDataEndianness());
450 
451  if (Error E = VDataPtrOrErr.takeError())
452  return E;
453 
454  // Note that besides deserialization, this also performs the conversion for
455  // indirect call targets. The function pointers from the raw profile are
456  // remapped into function name hashes.
457  VDataPtrOrErr.get()->deserializeTo(Record, Symtab.get());
458  CurValueDataSize = VDataPtrOrErr.get()->getSize();
459  return success();
460 }
461 
462 template <class IntPtrT>
464  if (atEnd())
465  // At this point, ValueDataStart field points to the next header.
466  if (Error E = readNextHeader(getNextHeaderPos()))
467  return error(std::move(E));
468 
469  // Read name ad set it in Record.
470  if (Error E = readName(Record))
471  return error(std::move(E));
472 
473  // Read FuncHash and set it in Record.
474  if (Error E = readFuncHash(Record))
475  return error(std::move(E));
476 
477  // Read raw counts and set Record.
478  if (Error E = readRawCounts(Record))
479  return error(std::move(E));
480 
481  // Read value data and set Record.
482  if (Error E = readValueProfilingData(Record))
483  return error(std::move(E));
484 
485  // Iterate.
486  advanceData();
487  return success();
488 }
489 
490 namespace llvm {
491 
492 template class RawInstrProfReader<uint32_t>;
493 template class RawInstrProfReader<uint64_t>;
494 
495 } // end namespace llvm
496 
500 }
501 
504 
506  const unsigned char *&D, const unsigned char *const End) {
508  ValueProfData::getValueProfData(D, End, ValueProfDataEndianness);
509 
510  if (VDataPtrOrErr.takeError())
511  return false;
512 
513  VDataPtrOrErr.get()->deserializeTo(DataBuffer.back(), nullptr);
514  D += VDataPtrOrErr.get()->TotalSize;
515 
516  return true;
517 }
518 
520  offset_type N) {
521  using namespace support;
522 
523  // Check if the data is corrupt. If so, don't try to read it.
524  if (N % sizeof(uint64_t))
525  return data_type();
526 
527  DataBuffer.clear();
528  std::vector<uint64_t> CounterBuffer;
529 
530  const unsigned char *End = D + N;
531  while (D < End) {
532  // Read hash.
533  if (D + sizeof(uint64_t) >= End)
534  return data_type();
535  uint64_t Hash = endian::readNext<uint64_t, little, unaligned>(D);
536 
537  // Initialize number of counters for GET_VERSION(FormatVersion) == 1.
538  uint64_t CountsSize = N / sizeof(uint64_t) - 1;
539  // If format version is different then read the number of counters.
540  if (GET_VERSION(FormatVersion) != IndexedInstrProf::ProfVersion::Version1) {
541  if (D + sizeof(uint64_t) > End)
542  return data_type();
543  CountsSize = endian::readNext<uint64_t, little, unaligned>(D);
544  }
545  // Read counter values.
546  if (D + CountsSize * sizeof(uint64_t) > End)
547  return data_type();
548 
549  CounterBuffer.clear();
550  CounterBuffer.reserve(CountsSize);
551  for (uint64_t J = 0; J < CountsSize; ++J)
552  CounterBuffer.push_back(endian::readNext<uint64_t, little, unaligned>(D));
553 
554  DataBuffer.emplace_back(K, Hash, std::move(CounterBuffer));
555 
556  // Read value profiling data.
557  if (GET_VERSION(FormatVersion) > IndexedInstrProf::ProfVersion::Version2 &&
558  !readValueProfilingData(D, End)) {
559  DataBuffer.clear();
560  return data_type();
561  }
562  }
563  return DataBuffer;
564 }
565 
566 template <typename HashTableImpl>
569  auto Iter = HashTable->find(FuncName);
570  if (Iter == HashTable->end())
571  return make_error<InstrProfError>(instrprof_error::unknown_function);
572 
573  Data = (*Iter);
574  if (Data.empty())
575  return make_error<InstrProfError>(instrprof_error::malformed);
576 
577  return Error::success();
578 }
579 
580 template <typename HashTableImpl>
583  if (atEnd())
584  return make_error<InstrProfError>(instrprof_error::eof);
585 
586  Data = *RecordIterator;
587 
588  if (Data.empty())
589  return make_error<InstrProfError>(instrprof_error::malformed);
590 
591  return Error::success();
592 }
593 
594 template <typename HashTableImpl>
596  const unsigned char *Buckets, const unsigned char *const Payload,
597  const unsigned char *const Base, IndexedInstrProf::HashT HashType,
598  uint64_t Version) {
599  FormatVersion = Version;
600  HashTable.reset(HashTableImpl::Create(
601  Buckets, Payload, Base,
602  typename HashTableImpl::InfoType(HashType, Version)));
603  RecordIterator = HashTable->data_begin();
604 }
605 
606 namespace {
607 /// A remapper that does not apply any remappings.
608 class InstrProfReaderNullRemapper : public InstrProfReaderRemapper {
610 
611 public:
612  InstrProfReaderNullRemapper(InstrProfReaderIndexBase &Underlying)
613  : Underlying(Underlying) {}
614 
615  Error getRecords(StringRef FuncName,
617  return Underlying.getRecords(FuncName, Data);
618  }
619 };
620 }
621 
622 /// A remapper that applies remappings based on a symbol remapping file.
623 template <typename HashTableImpl>
625  : public InstrProfReaderRemapper {
626 public:
628  std::unique_ptr<MemoryBuffer> RemapBuffer,
630  : RemapBuffer(std::move(RemapBuffer)), Underlying(Underlying) {
631  }
632 
633  /// Extract the original function name from a PGO function name.
635  // We can have multiple :-separated pieces; there can be pieces both
636  // before and after the mangled name. Find the first part that starts
637  // with '_Z'; we'll assume that's the mangled name we want.
638  std::pair<StringRef, StringRef> Parts = {StringRef(), Name};
639  while (true) {
640  Parts = Parts.second.split(':');
641  if (Parts.first.startswith("_Z"))
642  return Parts.first;
643  if (Parts.second.empty())
644  return Name;
645  }
646  }
647 
648  /// Given a mangled name extracted from a PGO function name, and a new
649  /// form for that mangled name, reconstitute the name.
650  static void reconstituteName(StringRef OrigName, StringRef ExtractedName,
651  StringRef Replacement,
652  SmallVectorImpl<char> &Out) {
653  Out.reserve(OrigName.size() + Replacement.size() - ExtractedName.size());
654  Out.insert(Out.end(), OrigName.begin(), ExtractedName.begin());
655  Out.insert(Out.end(), Replacement.begin(), Replacement.end());
656  Out.insert(Out.end(), ExtractedName.end(), OrigName.end());
657  }
658 
660  if (Error E = Remappings.read(*RemapBuffer))
661  return E;
662  for (StringRef Name : Underlying.HashTable->keys()) {
663  StringRef RealName = extractName(Name);
664  if (auto Key = Remappings.insert(RealName)) {
665  // FIXME: We could theoretically map the same equivalence class to
666  // multiple names in the profile data. If that happens, we should
667  // return NamedInstrProfRecords from all of them.
668  MappedNames.insert({Key, RealName});
669  }
670  }
671  return Error::success();
672  }
673 
676  StringRef RealName = extractName(FuncName);
677  if (auto Key = Remappings.lookup(RealName)) {
678  StringRef Remapped = MappedNames.lookup(Key);
679  if (!Remapped.empty()) {
680  if (RealName.begin() == FuncName.begin() &&
681  RealName.end() == FuncName.end())
682  FuncName = Remapped;
683  else {
684  // Try rebuilding the name from the given remapping.
685  SmallString<256> Reconstituted;
686  reconstituteName(FuncName, RealName, Remapped, Reconstituted);
687  Error E = Underlying.getRecords(Reconstituted, Data);
688  if (!E)
689  return E;
690 
691  // If we failed because the name doesn't exist, fall back to asking
692  // about the original name.
693  if (Error Unhandled = handleErrors(
694  std::move(E), [](std::unique_ptr<InstrProfError> Err) {
695  return Err->get() == instrprof_error::unknown_function
696  ? Error::success()
697  : Error(std::move(Err));
698  }))
699  return Unhandled;
700  }
701  }
702  }
703  return Underlying.getRecords(FuncName, Data);
704  }
705 
706 private:
707  /// The memory buffer containing the remapping configuration. Remappings
708  /// holds pointers into this buffer.
709  std::unique_ptr<MemoryBuffer> RemapBuffer;
710 
711  /// The mangling remapper.
712  SymbolRemappingReader Remappings;
713 
714  /// Mapping from mangled name keys to the name used for the key in the
715  /// profile data.
716  /// FIXME: Can we store a location within the on-disk hash table instead of
717  /// redoing lookup?
719 
720  /// The real profile data reader.
722 };
723 
725  using namespace support;
726 
727  if (DataBuffer.getBufferSize() < 8)
728  return false;
729  uint64_t Magic =
730  endian::read<uint64_t, little, aligned>(DataBuffer.getBufferStart());
731  // Verify that it's magical.
732  return Magic == IndexedInstrProf::Magic;
733 }
734 
735 const unsigned char *
736 IndexedInstrProfReader::readSummary(IndexedInstrProf::ProfVersion Version,
737  const unsigned char *Cur) {
738  using namespace IndexedInstrProf;
739  using namespace support;
740 
742  const IndexedInstrProf::Summary *SummaryInLE =
743  reinterpret_cast<const IndexedInstrProf::Summary *>(Cur);
744  uint64_t NFields =
745  endian::byte_swap<uint64_t, little>(SummaryInLE->NumSummaryFields);
746  uint64_t NEntries =
747  endian::byte_swap<uint64_t, little>(SummaryInLE->NumCutoffEntries);
748  uint32_t SummarySize =
749  IndexedInstrProf::Summary::getSize(NFields, NEntries);
750  std::unique_ptr<IndexedInstrProf::Summary> SummaryData =
751  IndexedInstrProf::allocSummary(SummarySize);
752 
753  const uint64_t *Src = reinterpret_cast<const uint64_t *>(SummaryInLE);
754  uint64_t *Dst = reinterpret_cast<uint64_t *>(SummaryData.get());
755  for (unsigned I = 0; I < SummarySize / sizeof(uint64_t); I++)
756  Dst[I] = endian::byte_swap<uint64_t, little>(Src[I]);
757 
758  SummaryEntryVector DetailedSummary;
759  for (unsigned I = 0; I < SummaryData->NumCutoffEntries; I++) {
760  const IndexedInstrProf::Summary::Entry &Ent = SummaryData->getEntry(I);
761  DetailedSummary.emplace_back((uint32_t)Ent.Cutoff, Ent.MinBlockCount,
762  Ent.NumBlocks);
763  }
764  // initialize InstrProfSummary using the SummaryData from disk.
765  this->Summary = llvm::make_unique<ProfileSummary>(
766  ProfileSummary::PSK_Instr, DetailedSummary,
767  SummaryData->get(Summary::TotalBlockCount),
768  SummaryData->get(Summary::MaxBlockCount),
769  SummaryData->get(Summary::MaxInternalBlockCount),
770  SummaryData->get(Summary::MaxFunctionCount),
771  SummaryData->get(Summary::TotalNumBlocks),
772  SummaryData->get(Summary::TotalNumFunctions));
773  return Cur + SummarySize;
774  } else {
775  // For older version of profile data, we need to compute on the fly:
776  using namespace IndexedInstrProf;
777 
779  // FIXME: This only computes an empty summary. Need to call addRecord for
780  // all NamedInstrProfRecords to get the correct summary.
781  this->Summary = Builder.getSummary();
782  return Cur;
783  }
784 }
785 
787  using namespace support;
788 
789  const unsigned char *Start =
790  (const unsigned char *)DataBuffer->getBufferStart();
791  const unsigned char *Cur = Start;
792  if ((const unsigned char *)DataBuffer->getBufferEnd() - Cur < 24)
794 
795  auto *Header = reinterpret_cast<const IndexedInstrProf::Header *>(Cur);
796  Cur += sizeof(IndexedInstrProf::Header);
797 
798  // Check the magic number.
799  uint64_t Magic = endian::byte_swap<uint64_t, little>(Header->Magic);
800  if (Magic != IndexedInstrProf::Magic)
802 
803  // Read the version.
804  uint64_t FormatVersion = endian::byte_swap<uint64_t, little>(Header->Version);
805  if (GET_VERSION(FormatVersion) >
808 
809  Cur = readSummary((IndexedInstrProf::ProfVersion)FormatVersion, Cur);
810 
811  // Read the hash type and start offset.
813  endian::byte_swap<uint64_t, little>(Header->HashType));
814  if (HashType > IndexedInstrProf::HashT::Last)
816 
817  uint64_t HashOffset = endian::byte_swap<uint64_t, little>(Header->HashOffset);
818 
819  // The rest of the file is an on disk hash table.
820  auto IndexPtr =
821  llvm::make_unique<InstrProfReaderIndex<OnDiskHashTableImplV3>>(
822  Start + HashOffset, Cur, Start, HashType, FormatVersion);
823 
824  // Load the remapping table now if requested.
825  if (RemappingBuffer) {
826  Remapper = llvm::make_unique<
828  std::move(RemappingBuffer), *IndexPtr);
829  if (Error E = Remapper->populateRemappings())
830  return E;
831  } else {
832  Remapper = llvm::make_unique<InstrProfReaderNullRemapper>(*IndexPtr);
833  }
834  Index = std::move(IndexPtr);
835 
836  return success();
837 }
838 
840  if (Symtab.get())
841  return *Symtab.get();
842 
843  std::unique_ptr<InstrProfSymtab> NewSymtab = make_unique<InstrProfSymtab>();
844  if (Error E = Index->populateSymtab(*NewSymtab.get())) {
846  }
847 
848  Symtab = std::move(NewSymtab);
849  return *Symtab.get();
850 }
851 
854  uint64_t FuncHash) {
856  Error Err = Remapper->getRecords(FuncName, Data);
857  if (Err)
858  return std::move(Err);
859  // Found it. Look for counters with the right hash.
860  for (unsigned I = 0, E = Data.size(); I < E; ++I) {
861  // Check for a match and fill the vector if there is one.
862  if (Data[I].Hash == FuncHash) {
863  return std::move(Data[I]);
864  }
865  }
867 }
868 
870  uint64_t FuncHash,
871  std::vector<uint64_t> &Counts) {
872  Expected<InstrProfRecord> Record = getInstrProfRecord(FuncName, FuncHash);
873  if (Error E = Record.takeError())
874  return error(std::move(E));
875 
876  Counts = Record.get().Counts;
877  return success();
878 }
879 
882 
883  Error E = Index->getRecords(Data);
884  if (E)
885  return error(std::move(E));
886 
887  Record = Data[RecordIndex++];
888  if (RecordIndex >= Data.size()) {
889  Index->advanceToNextKey();
890  RecordIndex = 0;
891  }
892  return success();
893 }
#define VP_READ_ADVANCE(Val)
Represents either an error or a value T.
Definition: ErrorOr.h:57
A symbol table used for function PGO name look-up with keys (such as pointers, md5hash values) to the...
Definition: InstrProf.h:411
Error readHeader() override
Read the header. Required before reading first record.
static uint32_t getSize(uint32_t NumSumFields, uint32_t NumCutoffEntries)
Definition: InstrProf.h:952
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
bool isPrint(char C)
Checks whether character C is printable.
Definition: StringExtras.h:106
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
uint64_t MinBlockCount
The minimum execution count for this percentile.
Definition: InstrProf.h:918
LLVM_NODISCARD bool equals_lower(StringRef RHS) const
equals_lower - Check for string equality, ignoring case.
Definition: StringRef.h:176
void addValueData(uint32_t ValueKind, uint32_t Site, InstrProfValueData *VData, uint32_t N, InstrProfSymtab *SymTab)
Add ValueData for ValueKind at value Site.
Definition: InstrProf.cpp:588
static bool hasFormat(const MemoryBuffer &DataBuffer)
Return true if the given buffer is in an indexed instrprof format.
static instrprof_error take(Error E)
Consume an Error and return the raw enum value contained within it.
Definition: InstrProf.h:324
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
static bool isExternalSymbol(const StringRef &Symbol)
True if Symbol is the value used to represent external symbols.
Definition: InstrProf.h:508
A remapper that applies remappings based on a symbol remapping file.
Error error(instrprof_error Err)
Set the current error and return same.
std::unique_ptr< Summary > allocSummary(uint32_t TotalSize)
Definition: InstrProf.h:992
static const ArrayRef< uint32_t > DefaultCutoffs
A vector of useful cutoff values for detailed summary.
Definition: ProfileCommon.h:65
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1042
InstrProfSymtab & getSymtab() override
Return the PGO symtab.
size_t getBufferSize() const
Definition: MemoryBuffer.h:62
std::enable_if<!std::is_array< T >::value, std::unique_ptr< T > >::type make_unique(Args &&... args)
Constructs a new T() with the given args and returns a unique_ptr<T> which owns the object...
Definition: STLExtras.h:1205
Error takeError()
Take ownership of the stored error.
Definition: Error.h:553
void reserve(size_type N)
Definition: SmallVector.h:376
InstrProfLookupTrait::offset_type offset_type
Error readNextRecord(NamedInstrProfRecord &Record) override
Read a single record.
void reserveSites(uint32_t ValueKind, uint32_t NumValueSites)
Reserve space for NumValueSites sites.
Definition: InstrProf.h:831
Error readHeader() override
Read the header.
data_type ReadData(StringRef K, const unsigned char *D, offset_type N)
const uint64_t Magic
Definition: InstrProf.h:871
amdgpu Simplify well known AMD library false Value Value const Twine & Name
Definition: BitVector.h:938
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
static Expected< std::unique_ptr< InstrProfReader > > create(const Twine &Path)
Factory method to create an appropriately typed reader for the given instrprof file.
const HashT HashType
Definition: InstrProf.h:897
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:451
static StringRef getName(Value *V)
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
void mapAddress(uint64_t Addr, uint64_t MD5Val)
Map a function address to its name&#39;s MD5 hash.
Definition: InstrProf.h:486
Key
PAL metadata keys.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
static bool hasFormat(const MemoryBuffer &Buffer)
Return true if the given buffer is in text instrprof format.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
static StringRef extractName(StringRef Name)
Extract the original function name from a PGO function name.
const uint64_t Version
Definition: InstrProf.h:1008
Reader for the simple text based instrprof format.
uint64_t NumBlocks
Number of blocks >= the minumum execution count.
Definition: InstrProf.h:919
Error getRecords(StringRef FuncName, ArrayRef< NamedInstrProfRecord > &Data) override
static bool hasFormat(const MemoryBuffer &DataBuffer)
auto count(R &&Range, const E &Element) -> typename std::iterator_traits< decltype(adl_begin(Range))>::difference_type
Wrapper function around std::count to count the number of times an element Element occurs in the give...
Definition: STLExtras.h:1108
InstrProfLookupTrait::data_type data_type
hash_value_type ComputeHash(StringRef K)
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
ArrayRef< NamedInstrProfRecord > data_type
Base class and interface for reading profiling data of any known instrprof format.
uint64_t Cutoff
The required percentile of total execution count.
Definition: InstrProf.h:916
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:87
ValueKind
Value kinds.
std::error_code getError() const
Definition: ErrorOr.h:160
bool readValueProfilingData(const unsigned char *&D, const unsigned char *const End)
std::unique_ptr< InstrProfSymtab > Symtab
std::underlying_type< E >::type Underlying(E Val)
Check that Val is in range for E, and return Val cast to E&#39;s underlying type.
Definition: BitmaskEnum.h:91
uint64_t ComputeHash(StringRef K)
Definition: InstrProf.h:899
virtual Error getRecords(ArrayRef< NamedInstrProfRecord > &Data)=0
Error getRecords(ArrayRef< NamedInstrProfRecord > &Data) override
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:978
#define CHECK_LINE_END(Line)
#define READ_NUM(Str, Dst)
void clearValueData()
Clear value data entries.
Definition: InstrProf.h:705
static const char *const Magic
Definition: Archive.cpp:42
static Expected< std::unique_ptr< MemoryBuffer > > setupMemoryBuffer(const Twine &Path)
Error create(object::SectionRef &Section)
Create InstrProfSymtab from an object file section which contains function PGO names.
Name matcher supporting fuzzy matching of symbol names to names in profiles.
static ErrorSuccess success()
Create a success value.
Definition: Error.h:327
Error readNextRecord(NamedInstrProfRecord &Record) override
Read a single record.
RawInstrProfReader< uint32_t > RawInstrProfReader32
std::unique_ptr< ProfileSummary > getSummary()
LLVM_NODISCARD std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition: StringRef.h:727
A file format agnostic iterator over profiling data.
Reader for the raw instrprof binary format from runtime.
reference get()
Returns a reference to the stored T value.
Definition: Error.h:533
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
RawInstrProfReader< uint64_t > RawInstrProfReader64
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:42
InstrProfReaderIndex(const unsigned char *Buckets, const unsigned char *const Payload, const unsigned char *const Base, IndexedInstrProf::HashT HashType, uint64_t Version)
InstrProfReaderItaniumRemapper(std::unique_ptr< MemoryBuffer > RemapBuffer, InstrProfReaderIndex< HashTableImpl > &Underlying)
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:941
Error readNextRecord(NamedInstrProfRecord &Record) override
Read a single record.
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:478
iterator begin() const
Definition: StringRef.h:106
unsigned char getSwappedBytes(unsigned char C)
Definition: SwapByteOrder.h:72
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileOrSTDIN(const Twine &Filename, int64_t FileSize=-1, bool RequiresNullTerminator=true)
Open the specified file as a MemoryBuffer, or open stdin if the Filename is "-".
std::vector< uint64_t > Counts
Definition: InstrProf.h:623
Error readHeader() override
Read the file header.
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:133
virtual Error readHeader()=0
Read the header. Required before reading first record.
Profiling information for a single function.
Definition: InstrProf.h:622
Expected< InstrProfRecord > getInstrProfRecord(StringRef FuncName, uint64_t FuncHash)
Return the NamedInstrProfRecord associated with FuncName and FuncHash.
Reader for symbol remapping files.
static void reconstituteName(StringRef OrigName, StringRef ExtractedName, StringRef Replacement, SmallVectorImpl< char > &Out)
Given a mangled name extracted from a PGO function name, and a new form for that mangled name...
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
const char * getBufferStart() const
Definition: MemoryBuffer.h:60
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:18
Provides ErrorOr<T> smart pointer.
LLVM Value Representation.
Definition: Value.h:73
Lightweight error class with error context and mandatory checking.
Definition: Error.h:158
Error handleErrors(Error E, HandlerTs &&... Hs)
Pass the ErrorInfo(s) contained in E to their respective handlers.
Definition: Error.h:882
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Reader for the indexed binary instrprof format.
std::vector< ProfileSummaryEntry > SummaryEntryVector
static Expected< std::unique_ptr< IndexedInstrProfReader > > create(const Twine &Path, const Twine &RemappingPath="")
Factory method to create an indexed reader.
iterator end() const
Definition: StringRef.h:108
const uint64_t Version
Definition: InstrProf.h:895
void Clear()
Clear value data entries and edge counters.
Definition: InstrProf.h:699
reference get()
Definition: ErrorOr.h:157
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:144
Error success()
Clear the current error and return a successful one.
Error getFunctionCounts(StringRef FuncName, uint64_t FuncHash, std::vector< uint64_t > &Counts)
Fill Counts with the profile data for the given function name.
static Error initializeReader(InstrProfReader &Reader)