LLVM  14.0.0git
InstrProfReader.cpp
Go to the documentation of this file.
1 //===- InstrProfReader.cpp - Instrumented profiling 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 profiling data for clang's
10 // instrumentation based PGO and 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/StringExtras.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) {
44  MemoryBuffer::getFileOrSTDIN(Path, /*IsText=*/true);
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<uint64_t>::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<uint64_t>::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 = std::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.
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  bool IsEntryFirst = false;
158  bool IsCS = false;
159 
160  while (Line->startswith(":")) {
161  StringRef Str = Line->substr(1);
162  if (Str.equals_insensitive("ir"))
163  IsIRInstr = true;
164  else if (Str.equals_insensitive("fe"))
165  IsIRInstr = false;
166  else if (Str.equals_insensitive("csir")) {
167  IsIRInstr = true;
168  IsCS = true;
169  } else if (Str.equals_insensitive("entry_first"))
170  IsEntryFirst = true;
171  else if (Str.equals_insensitive("not_entry_first"))
172  IsEntryFirst = false;
173  else
175  ++Line;
176  }
177  IsIRLevelProfile = IsIRInstr;
178  InstrEntryBBEnabled = IsEntryFirst;
179  HasCSIRLevelProfile = IsCS;
180  return success();
181 }
182 
183 Error
184 TextInstrProfReader::readValueProfileData(InstrProfRecord &Record) {
185 
186 #define CHECK_LINE_END(Line) \
187  if (Line.is_at_end()) \
188  return error(instrprof_error::truncated);
189 #define READ_NUM(Str, Dst) \
190  if ((Str).getAsInteger(10, (Dst))) \
191  return error(instrprof_error::malformed);
192 #define VP_READ_ADVANCE(Val) \
193  CHECK_LINE_END(Line); \
194  uint32_t Val; \
195  READ_NUM((*Line), (Val)); \
196  Line++;
197 
198  if (Line.is_at_end())
199  return success();
200 
201  uint32_t NumValueKinds;
202  if (Line->getAsInteger(10, NumValueKinds)) {
203  // No value profile data
204  return success();
205  }
206  if (NumValueKinds == 0 || NumValueKinds > IPVK_Last + 1)
208  Line++;
209 
210  for (uint32_t VK = 0; VK < NumValueKinds; VK++) {
212  if (ValueKind > IPVK_Last)
214  VP_READ_ADVANCE(NumValueSites);
215  if (!NumValueSites)
216  continue;
217 
218  Record.reserveSites(VK, NumValueSites);
219  for (uint32_t S = 0; S < NumValueSites; S++) {
220  VP_READ_ADVANCE(NumValueData);
221 
222  std::vector<InstrProfValueData> CurrentValues;
223  for (uint32_t V = 0; V < NumValueData; V++) {
224  CHECK_LINE_END(Line);
225  std::pair<StringRef, StringRef> VD = Line->rsplit(':');
226  uint64_t TakenCount, Value;
227  if (ValueKind == IPVK_IndirectCallTarget) {
228  if (InstrProfSymtab::isExternalSymbol(VD.first)) {
229  Value = 0;
230  } else {
231  if (Error E = Symtab->addFuncName(VD.first))
232  return E;
234  }
235  } else {
236  READ_NUM(VD.first, Value);
237  }
238  READ_NUM(VD.second, TakenCount);
239  CurrentValues.push_back({Value, TakenCount});
240  Line++;
241  }
242  Record.addValueData(ValueKind, S, CurrentValues.data(), NumValueData,
243  nullptr);
244  }
245  }
246  return success();
247 
248 #undef CHECK_LINE_END
249 #undef READ_NUM
250 #undef VP_READ_ADVANCE
251 }
252 
254  // Skip empty lines and comments.
255  while (!Line.is_at_end() && (Line->empty() || Line->startswith("#")))
256  ++Line;
257  // If we hit EOF while looking for a name, we're done.
258  if (Line.is_at_end()) {
259  return error(instrprof_error::eof);
260  }
261 
262  // Read the function name.
263  Record.Name = *Line++;
264  if (Error E = Symtab->addFuncName(Record.Name))
265  return error(std::move(E));
266 
267  // Read the function hash.
268  if (Line.is_at_end())
270  if ((Line++)->getAsInteger(0, Record.Hash))
272 
273  // Read the number of counters.
274  uint64_t NumCounters;
275  if (Line.is_at_end())
277  if ((Line++)->getAsInteger(10, NumCounters))
279  if (NumCounters == 0)
281 
282  // Read each counter and fill our internal storage with the values.
283  Record.Clear();
284  Record.Counts.reserve(NumCounters);
285  for (uint64_t I = 0; I < NumCounters; ++I) {
286  if (Line.is_at_end())
288  uint64_t Count;
289  if ((Line++)->getAsInteger(10, Count))
291  Record.Counts.push_back(Count);
292  }
293 
294  // Check if value profile data exists and read it if so.
295  if (Error E = readValueProfileData(Record))
296  return error(std::move(E));
297 
298  return success();
299 }
300 
301 template <class IntPtrT>
303  if (DataBuffer.getBufferSize() < sizeof(uint64_t))
304  return false;
305  uint64_t Magic =
306  *reinterpret_cast<const uint64_t *>(DataBuffer.getBufferStart());
307  return RawInstrProf::getMagic<IntPtrT>() == Magic ||
308  sys::getSwappedBytes(RawInstrProf::getMagic<IntPtrT>()) == Magic;
309 }
310 
311 template <class IntPtrT>
313  if (!hasFormat(*DataBuffer))
315  if (DataBuffer->getBufferSize() < sizeof(RawInstrProf::Header))
317  auto *Header = reinterpret_cast<const RawInstrProf::Header *>(
318  DataBuffer->getBufferStart());
319  ShouldSwapBytes = Header->Magic != RawInstrProf::getMagic<IntPtrT>();
320  return readHeader(*Header);
321 }
322 
323 template <class IntPtrT>
324 Error RawInstrProfReader<IntPtrT>::readNextHeader(const char *CurrentPos) {
325  const char *End = DataBuffer->getBufferEnd();
326  // Skip zero padding between profiles.
327  while (CurrentPos != End && *CurrentPos == 0)
328  ++CurrentPos;
329  // If there's nothing left, we're done.
330  if (CurrentPos == End)
331  return make_error<InstrProfError>(instrprof_error::eof);
332  // If there isn't enough space for another header, this is probably just
333  // garbage at the end of the file.
334  if (CurrentPos + sizeof(RawInstrProf::Header) > End)
335  return make_error<InstrProfError>(instrprof_error::malformed);
336  // The writer ensures each profile is padded to start at an aligned address.
337  if (reinterpret_cast<size_t>(CurrentPos) % alignof(uint64_t))
338  return make_error<InstrProfError>(instrprof_error::malformed);
339  // The magic should have the same byte order as in the previous header.
340  uint64_t Magic = *reinterpret_cast<const uint64_t *>(CurrentPos);
341  if (Magic != swap(RawInstrProf::getMagic<IntPtrT>()))
342  return make_error<InstrProfError>(instrprof_error::bad_magic);
343 
344  // There's another profile to read, so we need to process the header.
345  auto *Header = reinterpret_cast<const RawInstrProf::Header *>(CurrentPos);
346  return readHeader(*Header);
347 }
348 
349 template <class IntPtrT>
351  if (Error E = Symtab.create(StringRef(NamesStart, NamesSize)))
352  return error(std::move(E));
353  for (const RawInstrProf::ProfileData<IntPtrT> *I = Data; I != DataEnd; ++I) {
354  const IntPtrT FPtr = swap(I->FunctionPointer);
355  if (!FPtr)
356  continue;
357  Symtab.mapAddress(FPtr, I->NameRef);
358  }
359  return success();
360 }
361 
362 template <class IntPtrT>
364  const RawInstrProf::Header &Header) {
365  Version = swap(Header.Version);
366  if (GET_VERSION(Version) != RawInstrProf::Version)
368 
369  BinaryIdsSize = swap(Header.BinaryIdsSize);
370  CountersDelta = swap(Header.CountersDelta);
371  NamesDelta = swap(Header.NamesDelta);
372  auto DataSize = swap(Header.DataSize);
373  auto PaddingBytesBeforeCounters = swap(Header.PaddingBytesBeforeCounters);
374  auto CountersSize = swap(Header.CountersSize);
375  auto PaddingBytesAfterCounters = swap(Header.PaddingBytesAfterCounters);
376  NamesSize = swap(Header.NamesSize);
377  ValueKindLast = swap(Header.ValueKindLast);
378 
379  auto DataSizeInBytes = DataSize * sizeof(RawInstrProf::ProfileData<IntPtrT>);
380  auto PaddingSize = getNumPaddingBytes(NamesSize);
381 
382  // Profile data starts after profile header and binary ids if exist.
383  ptrdiff_t DataOffset = sizeof(RawInstrProf::Header) + BinaryIdsSize;
384  ptrdiff_t CountersOffset =
385  DataOffset + DataSizeInBytes + PaddingBytesBeforeCounters;
386  ptrdiff_t NamesOffset = CountersOffset + (sizeof(uint64_t) * CountersSize) +
387  PaddingBytesAfterCounters;
388  ptrdiff_t ValueDataOffset = NamesOffset + NamesSize + PaddingSize;
389 
390  auto *Start = reinterpret_cast<const char *>(&Header);
391  if (Start + ValueDataOffset > DataBuffer->getBufferEnd())
393 
394  Data = reinterpret_cast<const RawInstrProf::ProfileData<IntPtrT> *>(
395  Start + DataOffset);
396  DataEnd = Data + DataSize;
397 
398  // Binary ids start just after the header.
399  BinaryIdsStart =
400  reinterpret_cast<const uint8_t *>(&Header) + sizeof(RawInstrProf::Header);
401  CountersStart = reinterpret_cast<const uint64_t *>(Start + CountersOffset);
402  NamesStart = Start + NamesOffset;
403  ValueDataStart = reinterpret_cast<const uint8_t *>(Start + ValueDataOffset);
404 
405  std::unique_ptr<InstrProfSymtab> NewSymtab = std::make_unique<InstrProfSymtab>();
406  if (Error E = createSymtab(*NewSymtab.get()))
407  return E;
408 
409  Symtab = std::move(NewSymtab);
410  return success();
411 }
412 
413 template <class IntPtrT>
415  Record.Name = getName(Data->NameRef);
416  return success();
417 }
418 
419 template <class IntPtrT>
421  Record.Hash = swap(Data->FuncHash);
422  return success();
423 }
424 
425 template <class IntPtrT>
428  uint32_t NumCounters = swap(Data->NumCounters);
429  IntPtrT CounterPtr = Data->CounterPtr;
430  if (NumCounters == 0)
432 
433  auto *NamesStartAsCounter = reinterpret_cast<const uint64_t *>(NamesStart);
434  ptrdiff_t MaxNumCounters = NamesStartAsCounter - CountersStart;
435 
436  // Check bounds. Note that the counter pointer embedded in the data record
437  // may itself be corrupt.
438  if (MaxNumCounters < 0 || NumCounters > (uint32_t)MaxNumCounters)
440 
441  // We need to compute the in-buffer counter offset from the in-memory address
442  // distance. The initial CountersDelta is the in-memory address difference
443  // start(__llvm_prf_cnts)-start(__llvm_prf_data), so SrcData->CounterPtr -
444  // CountersDelta computes the offset into the in-buffer counter section.
445  //
446  // CountersDelta decreases as we advance to the next data record.
447  ptrdiff_t CounterOffset = getCounterOffset(CounterPtr);
448  CountersDelta -= sizeof(*Data);
449  if (CounterOffset < 0 || CounterOffset > MaxNumCounters ||
450  ((uint32_t)CounterOffset + NumCounters) > (uint32_t)MaxNumCounters)
452 
453  auto RawCounts = makeArrayRef(getCounter(CounterOffset), NumCounters);
454 
455  if (ShouldSwapBytes) {
456  Record.Counts.clear();
457  Record.Counts.reserve(RawCounts.size());
458  for (uint64_t Count : RawCounts)
459  Record.Counts.push_back(swap(Count));
460  } else
461  Record.Counts = RawCounts;
462 
463  return success();
464 }
465 
466 template <class IntPtrT>
469  Record.clearValueData();
470  CurValueDataSize = 0;
471  // Need to match the logic in value profile dumper code in compiler-rt:
472  uint32_t NumValueKinds = 0;
473  for (uint32_t I = 0; I < IPVK_Last + 1; I++)
474  NumValueKinds += (Data->NumValueSites[I] != 0);
475 
476  if (!NumValueKinds)
477  return success();
478 
480  ValueProfData::getValueProfData(
481  ValueDataStart, (const unsigned char *)DataBuffer->getBufferEnd(),
482  getDataEndianness());
483 
484  if (Error E = VDataPtrOrErr.takeError())
485  return E;
486 
487  // Note that besides deserialization, this also performs the conversion for
488  // indirect call targets. The function pointers from the raw profile are
489  // remapped into function name hashes.
490  VDataPtrOrErr.get()->deserializeTo(Record, Symtab.get());
491  CurValueDataSize = VDataPtrOrErr.get()->getSize();
492  return success();
493 }
494 
495 template <class IntPtrT>
497  if (atEnd())
498  // At this point, ValueDataStart field points to the next header.
499  if (Error E = readNextHeader(getNextHeaderPos()))
500  return error(std::move(E));
501 
502  // Read name ad set it in Record.
503  if (Error E = readName(Record))
504  return error(std::move(E));
505 
506  // Read FuncHash and set it in Record.
507  if (Error E = readFuncHash(Record))
508  return error(std::move(E));
509 
510  // Read raw counts and set Record.
511  if (Error E = readRawCounts(Record))
512  return error(std::move(E));
513 
514  // Read value data and set Record.
515  if (Error E = readValueProfilingData(Record))
516  return error(std::move(E));
517 
518  // Iterate.
519  advanceData();
520  return success();
521 }
522 
523 template <class IntPtrT>
525  if (BinaryIdsSize == 0)
526  return success();
527 
528  OS << "Binary IDs: \n";
529  const uint8_t *BI = BinaryIdsStart;
530  while (BI < BinaryIdsStart + BinaryIdsSize) {
531  uint64_t BinaryIdLen = swap(*reinterpret_cast<const uint64_t *>(BI));
532  // Increment by binary id length data type size.
533  BI += sizeof(BinaryIdLen);
534  if (BI > (const uint8_t *)DataBuffer->getBufferEnd())
535  return make_error<InstrProfError>(instrprof_error::malformed);
536 
537  for (uint64_t I = 0; I < BinaryIdLen; I++)
538  OS << format("%02x", BI[I]);
539  OS << "\n";
540 
541  // Increment by binary id data length.
542  BI += BinaryIdLen;
543  if (BI > (const uint8_t *)DataBuffer->getBufferEnd())
544  return make_error<InstrProfError>(instrprof_error::malformed);
545  }
546 
547  return success();
548 }
549 
550 namespace llvm {
551 
552 template class RawInstrProfReader<uint32_t>;
553 template class RawInstrProfReader<uint64_t>;
554 
555 } // end namespace llvm
556 
559  return IndexedInstrProf::ComputeHash(HashType, K);
560 }
561 
564 
566  const unsigned char *&D, const unsigned char *const End) {
568  ValueProfData::getValueProfData(D, End, ValueProfDataEndianness);
569 
570  if (VDataPtrOrErr.takeError())
571  return false;
572 
573  VDataPtrOrErr.get()->deserializeTo(DataBuffer.back(), nullptr);
574  D += VDataPtrOrErr.get()->TotalSize;
575 
576  return true;
577 }
578 
580  offset_type N) {
581  using namespace support;
582 
583  // Check if the data is corrupt. If so, don't try to read it.
584  if (N % sizeof(uint64_t))
585  return data_type();
586 
587  DataBuffer.clear();
588  std::vector<uint64_t> CounterBuffer;
589 
590  const unsigned char *End = D + N;
591  while (D < End) {
592  // Read hash.
593  if (D + sizeof(uint64_t) >= End)
594  return data_type();
595  uint64_t Hash = endian::readNext<uint64_t, little, unaligned>(D);
596 
597  // Initialize number of counters for GET_VERSION(FormatVersion) == 1.
598  uint64_t CountsSize = N / sizeof(uint64_t) - 1;
599  // If format version is different then read the number of counters.
600  if (GET_VERSION(FormatVersion) != IndexedInstrProf::ProfVersion::Version1) {
601  if (D + sizeof(uint64_t) > End)
602  return data_type();
603  CountsSize = endian::readNext<uint64_t, little, unaligned>(D);
604  }
605  // Read counter values.
606  if (D + CountsSize * sizeof(uint64_t) > End)
607  return data_type();
608 
609  CounterBuffer.clear();
610  CounterBuffer.reserve(CountsSize);
611  for (uint64_t J = 0; J < CountsSize; ++J)
612  CounterBuffer.push_back(endian::readNext<uint64_t, little, unaligned>(D));
613 
614  DataBuffer.emplace_back(K, Hash, std::move(CounterBuffer));
615 
616  // Read value profiling data.
617  if (GET_VERSION(FormatVersion) > IndexedInstrProf::ProfVersion::Version2 &&
618  !readValueProfilingData(D, End)) {
619  DataBuffer.clear();
620  return data_type();
621  }
622  }
623  return DataBuffer;
624 }
625 
626 template <typename HashTableImpl>
629  auto Iter = HashTable->find(FuncName);
630  if (Iter == HashTable->end())
631  return make_error<InstrProfError>(instrprof_error::unknown_function);
632 
633  Data = (*Iter);
634  if (Data.empty())
635  return make_error<InstrProfError>(instrprof_error::malformed);
636 
637  return Error::success();
638 }
639 
640 template <typename HashTableImpl>
643  if (atEnd())
644  return make_error<InstrProfError>(instrprof_error::eof);
645 
646  Data = *RecordIterator;
647 
648  if (Data.empty())
649  return make_error<InstrProfError>(instrprof_error::malformed);
650 
651  return Error::success();
652 }
653 
654 template <typename HashTableImpl>
656  const unsigned char *Buckets, const unsigned char *const Payload,
657  const unsigned char *const Base, IndexedInstrProf::HashT HashType,
658  uint64_t Version) {
659  FormatVersion = Version;
660  HashTable.reset(HashTableImpl::Create(
661  Buckets, Payload, Base,
662  typename HashTableImpl::InfoType(HashType, Version)));
663  RecordIterator = HashTable->data_begin();
664 }
665 
666 namespace {
667 /// A remapper that does not apply any remappings.
668 class InstrProfReaderNullRemapper : public InstrProfReaderRemapper {
670 
671 public:
672  InstrProfReaderNullRemapper(InstrProfReaderIndexBase &Underlying)
673  : Underlying(Underlying) {}
674 
675  Error getRecords(StringRef FuncName,
677  return Underlying.getRecords(FuncName, Data);
678  }
679 };
680 }
681 
682 /// A remapper that applies remappings based on a symbol remapping file.
683 template <typename HashTableImpl>
685  : public InstrProfReaderRemapper {
686 public:
688  std::unique_ptr<MemoryBuffer> RemapBuffer,
690  : RemapBuffer(std::move(RemapBuffer)), Underlying(Underlying) {
691  }
692 
693  /// Extract the original function name from a PGO function name.
695  // We can have multiple :-separated pieces; there can be pieces both
696  // before and after the mangled name. Find the first part that starts
697  // with '_Z'; we'll assume that's the mangled name we want.
698  std::pair<StringRef, StringRef> Parts = {StringRef(), Name};
699  while (true) {
700  Parts = Parts.second.split(':');
701  if (Parts.first.startswith("_Z"))
702  return Parts.first;
703  if (Parts.second.empty())
704  return Name;
705  }
706  }
707 
708  /// Given a mangled name extracted from a PGO function name, and a new
709  /// form for that mangled name, reconstitute the name.
710  static void reconstituteName(StringRef OrigName, StringRef ExtractedName,
711  StringRef Replacement,
712  SmallVectorImpl<char> &Out) {
713  Out.reserve(OrigName.size() + Replacement.size() - ExtractedName.size());
714  Out.insert(Out.end(), OrigName.begin(), ExtractedName.begin());
715  Out.insert(Out.end(), Replacement.begin(), Replacement.end());
716  Out.insert(Out.end(), ExtractedName.end(), OrigName.end());
717  }
718 
720  if (Error E = Remappings.read(*RemapBuffer))
721  return E;
722  for (StringRef Name : Underlying.HashTable->keys()) {
723  StringRef RealName = extractName(Name);
724  if (auto Key = Remappings.insert(RealName)) {
725  // FIXME: We could theoretically map the same equivalence class to
726  // multiple names in the profile data. If that happens, we should
727  // return NamedInstrProfRecords from all of them.
728  MappedNames.insert({Key, RealName});
729  }
730  }
731  return Error::success();
732  }
733 
736  StringRef RealName = extractName(FuncName);
737  if (auto Key = Remappings.lookup(RealName)) {
738  StringRef Remapped = MappedNames.lookup(Key);
739  if (!Remapped.empty()) {
740  if (RealName.begin() == FuncName.begin() &&
741  RealName.end() == FuncName.end())
742  FuncName = Remapped;
743  else {
744  // Try rebuilding the name from the given remapping.
745  SmallString<256> Reconstituted;
746  reconstituteName(FuncName, RealName, Remapped, Reconstituted);
747  Error E = Underlying.getRecords(Reconstituted, Data);
748  if (!E)
749  return E;
750 
751  // If we failed because the name doesn't exist, fall back to asking
752  // about the original name.
753  if (Error Unhandled = handleErrors(
754  std::move(E), [](std::unique_ptr<InstrProfError> Err) {
755  return Err->get() == instrprof_error::unknown_function
756  ? Error::success()
757  : Error(std::move(Err));
758  }))
759  return Unhandled;
760  }
761  }
762  }
763  return Underlying.getRecords(FuncName, Data);
764  }
765 
766 private:
767  /// The memory buffer containing the remapping configuration. Remappings
768  /// holds pointers into this buffer.
769  std::unique_ptr<MemoryBuffer> RemapBuffer;
770 
771  /// The mangling remapper.
772  SymbolRemappingReader Remappings;
773 
774  /// Mapping from mangled name keys to the name used for the key in the
775  /// profile data.
776  /// FIXME: Can we store a location within the on-disk hash table instead of
777  /// redoing lookup?
779 
780  /// The real profile data reader.
782 };
783 
785  using namespace support;
786 
787  if (DataBuffer.getBufferSize() < 8)
788  return false;
789  uint64_t Magic =
790  endian::read<uint64_t, little, aligned>(DataBuffer.getBufferStart());
791  // Verify that it's magical.
792  return Magic == IndexedInstrProf::Magic;
793 }
794 
795 const unsigned char *
796 IndexedInstrProfReader::readSummary(IndexedInstrProf::ProfVersion Version,
797  const unsigned char *Cur, bool UseCS) {
798  using namespace IndexedInstrProf;
799  using namespace support;
800 
802  const IndexedInstrProf::Summary *SummaryInLE =
803  reinterpret_cast<const IndexedInstrProf::Summary *>(Cur);
804  uint64_t NFields =
805  endian::byte_swap<uint64_t, little>(SummaryInLE->NumSummaryFields);
806  uint64_t NEntries =
807  endian::byte_swap<uint64_t, little>(SummaryInLE->NumCutoffEntries);
808  uint32_t SummarySize =
809  IndexedInstrProf::Summary::getSize(NFields, NEntries);
810  std::unique_ptr<IndexedInstrProf::Summary> SummaryData =
811  IndexedInstrProf::allocSummary(SummarySize);
812 
813  const uint64_t *Src = reinterpret_cast<const uint64_t *>(SummaryInLE);
814  uint64_t *Dst = reinterpret_cast<uint64_t *>(SummaryData.get());
815  for (unsigned I = 0; I < SummarySize / sizeof(uint64_t); I++)
816  Dst[I] = endian::byte_swap<uint64_t, little>(Src[I]);
817 
818  SummaryEntryVector DetailedSummary;
819  for (unsigned I = 0; I < SummaryData->NumCutoffEntries; I++) {
820  const IndexedInstrProf::Summary::Entry &Ent = SummaryData->getEntry(I);
821  DetailedSummary.emplace_back((uint32_t)Ent.Cutoff, Ent.MinBlockCount,
822  Ent.NumBlocks);
823  }
824  std::unique_ptr<llvm::ProfileSummary> &Summary =
825  UseCS ? this->CS_Summary : this->Summary;
826 
827  // initialize InstrProfSummary using the SummaryData from disk.
828  Summary = std::make_unique<ProfileSummary>(
830  DetailedSummary, SummaryData->get(Summary::TotalBlockCount),
831  SummaryData->get(Summary::MaxBlockCount),
832  SummaryData->get(Summary::MaxInternalBlockCount),
833  SummaryData->get(Summary::MaxFunctionCount),
834  SummaryData->get(Summary::TotalNumBlocks),
835  SummaryData->get(Summary::TotalNumFunctions));
836  return Cur + SummarySize;
837  } else {
838  // The older versions do not support a profile summary. This just computes
839  // an empty summary, which will not result in accurate hot/cold detection.
840  // We would need to call addRecord for all NamedInstrProfRecords to get the
841  // correct summary. However, this version is old (prior to early 2016) and
842  // has not been supporting an accurate summary for several years.
844  Summary = Builder.getSummary();
845  return Cur;
846  }
847 }
848 
850  using namespace support;
851 
852  const unsigned char *Start =
853  (const unsigned char *)DataBuffer->getBufferStart();
854  const unsigned char *Cur = Start;
855  if ((const unsigned char *)DataBuffer->getBufferEnd() - Cur < 24)
857 
858  auto *Header = reinterpret_cast<const IndexedInstrProf::Header *>(Cur);
859  Cur += sizeof(IndexedInstrProf::Header);
860 
861  // Check the magic number.
862  uint64_t Magic = endian::byte_swap<uint64_t, little>(Header->Magic);
865 
866  // Read the version.
867  uint64_t FormatVersion = endian::byte_swap<uint64_t, little>(Header->Version);
868  if (GET_VERSION(FormatVersion) >
871 
872  Cur = readSummary((IndexedInstrProf::ProfVersion)FormatVersion, Cur,
873  /* UseCS */ false);
874  if (FormatVersion & VARIANT_MASK_CSIR_PROF)
875  Cur = readSummary((IndexedInstrProf::ProfVersion)FormatVersion, Cur,
876  /* UseCS */ true);
877 
878  // Read the hash type and start offset.
879  IndexedInstrProf::HashT HashType = static_cast<IndexedInstrProf::HashT>(
880  endian::byte_swap<uint64_t, little>(Header->HashType));
881  if (HashType > IndexedInstrProf::HashT::Last)
883 
884  uint64_t HashOffset = endian::byte_swap<uint64_t, little>(Header->HashOffset);
885 
886  // The rest of the file is an on disk hash table.
887  auto IndexPtr =
888  std::make_unique<InstrProfReaderIndex<OnDiskHashTableImplV3>>(
889  Start + HashOffset, Cur, Start, HashType, FormatVersion);
890 
891  // Load the remapping table now if requested.
892  if (RemappingBuffer) {
893  Remapper = std::make_unique<
895  std::move(RemappingBuffer), *IndexPtr);
896  if (Error E = Remapper->populateRemappings())
897  return E;
898  } else {
899  Remapper = std::make_unique<InstrProfReaderNullRemapper>(*IndexPtr);
900  }
901  Index = std::move(IndexPtr);
902 
903  return success();
904 }
905 
907  if (Symtab.get())
908  return *Symtab.get();
909 
910  std::unique_ptr<InstrProfSymtab> NewSymtab = std::make_unique<InstrProfSymtab>();
911  if (Error E = Index->populateSymtab(*NewSymtab.get())) {
913  }
914 
915  Symtab = std::move(NewSymtab);
916  return *Symtab.get();
917 }
918 
921  uint64_t FuncHash) {
923  Error Err = Remapper->getRecords(FuncName, Data);
924  if (Err)
925  return std::move(Err);
926  // Found it. Look for counters with the right hash.
927  for (unsigned I = 0, E = Data.size(); I < E; ++I) {
928  // Check for a match and fill the vector if there is one.
929  if (Data[I].Hash == FuncHash) {
930  return std::move(Data[I]);
931  }
932  }
934 }
935 
937  uint64_t FuncHash,
938  std::vector<uint64_t> &Counts) {
939  Expected<InstrProfRecord> Record = getInstrProfRecord(FuncName, FuncHash);
940  if (Error E = Record.takeError())
941  return error(std::move(E));
942 
943  Counts = Record.get().Counts;
944  return success();
945 }
946 
949 
950  Error E = Index->getRecords(Data);
951  if (E)
952  return error(std::move(E));
953 
954  Record = Data[RecordIndex++];
955  if (RecordIndex >= Data.size()) {
956  Index->advanceToNextKey();
957  RecordIndex = 0;
958  }
959  return success();
960 }
961 
963  uint64_t NumFuncs = 0;
964  for (const auto &Func : *this) {
965  if (isIRLevelProfile()) {
966  bool FuncIsCS = NamedInstrProfRecord::hasCSFlagInHash(Func.Hash);
967  if (FuncIsCS != IsCS)
968  continue;
969  }
970  Func.accumulateCounts(Sum);
971  ++NumFuncs;
972  }
973  Sum.NumEntries = NumFuncs;
974 }
llvm::coverage::coveragemap_error::success
@ success
MemoryBuffer.h
llvm::IndexedInstrProfReader::getSymtab
InstrProfSymtab & getSymtab() override
Return the PGO symtab.
Definition: InstrProfReader.cpp:906
llvm::StringRef::startswith
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:286
llvm::instrprof_error::bad_header
@ bad_header
llvm::RawInstrProfReader
Reader for the raw instrprof binary format from runtime.
Definition: InstrProfReader.h:206
getName
static StringRef getName(Value *V)
Definition: ProvenanceAnalysisEvaluator.cpp:42
llvm::InstrProfReader::success
Error success()
Clear the current error and return a successful one.
Definition: InstrProfReader.h:127
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::IndexedInstrProf::ProfVersion
ProfVersion
Definition: InstrProf.h:964
llvm::handleErrors
Error handleErrors(Error E, HandlerTs &&... Hs)
Pass the ErrorInfo(s) contained in E to their respective handlers.
Definition: Error.h:935
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
offset_type
InstrProfLookupTrait::offset_type offset_type
Definition: InstrProfReader.cpp:563
llvm::IndexedInstrProfReader::hasFormat
static bool hasFormat(const MemoryBuffer &DataBuffer)
Return true if the given buffer is in an indexed instrprof format.
Definition: InstrProfReader.cpp:784
llvm::InstrProfLookupTrait::hash_value_type
uint64_t hash_value_type
Definition: InstrProfReader.h:342
ProfileSummary.h
StringRef.h
llvm::IndexedInstrProf::Summary::Entry::NumBlocks
uint64_t NumBlocks
Number of blocks >= the minumum execution count.
Definition: InstrProf.h:1015
llvm::InstrProfReader::readNextRecord
virtual Error readNextRecord(NamedInstrProfRecord &Record)=0
Read a single record.
llvm::IndexedInstrProf::ComputeHash
uint64_t ComputeHash(StringRef K)
Definition: InstrProf.h:995
llvm::InstrProfReaderIndex::InstrProfReaderIndex
InstrProfReaderIndex(const unsigned char *Buckets, const unsigned char *const Payload, const unsigned char *const Base, IndexedInstrProf::HashT HashType, uint64_t Version)
Definition: InstrProfReader.cpp:655
llvm::RawInstrProfReader64
RawInstrProfReader< uint64_t > RawInstrProfReader64
Definition: InstrProfReader.h:315
llvm::InstrProfSymtab::create
Error create(object::SectionRef &Section)
Create InstrProfSymtab from an object file section which contains function PGO names.
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:331
Error.h
SwapByteOrder.h
llvm::IndexedInstrProf::Summary::Entry
Definition: InstrProf.h:1011
llvm::InstrProfLookupTrait::data_type
ArrayRef< NamedInstrProfRecord > data_type
Definition: InstrProfReader.h:338
llvm::BitmaskEnumDetail::Underlying
std::underlying_type_t< E > Underlying(E Val)
Check that Val is in range for E, and return Val cast to E's underlying type.
Definition: BitmaskEnum.h:90
DenseMap.h
llvm::StringRef::rsplit
LLVM_NODISCARD std::pair< StringRef, StringRef > rsplit(StringRef Separator) const
Split into two substrings around the last occurrence of a separator string.
Definition: StringRef.h:782
llvm::InstrProfLookupTrait::ComputeHash
hash_value_type ComputeHash(StringRef K)
Definition: InstrProfReader.cpp:558
error
#define error(X)
Definition: SymbolRecordMapping.cpp:14
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
STLExtras.h
ProfileCommon.h
llvm::consumeError
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1035
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::MemoryBuffer
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:50
llvm::InstrProfRecord
Profiling information for a single function.
Definition: InstrProf.h:691
llvm::StringRef::substr
LLVM_NODISCARD StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:611
llvm::TextInstrProfReader::readHeader
Error readHeader() override
Read the header.
Definition: InstrProfReader.cpp:154
llvm::IndexedInstrProf::Version4
@ Version4
Definition: InstrProf.h:980
llvm::AMDGPU::HSAMD::ValueKind
ValueKind
Value kinds.
Definition: AMDGPUMetadata.h:73
llvm::coverage::Version1
@ Version1
Definition: CoverageMapping.h:994
llvm::all_of
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:1551
llvm::coverage::CurrentVersion
@ CurrentVersion
Definition: CoverageMapping.h:1010
llvm::SymbolRemappingReader
Reader for symbol remapping files.
Definition: SymbolRemappingReader.h:97
ptrdiff_t
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::MemoryBuffer::getBufferSize
size_t getBufferSize() const
Definition: MemoryBuffer.h:67
llvm::errorCodeToError
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:87
InfoType
InfoType
FunctionInfo information type that is used to encode the optional data that is associated with a Func...
Definition: FunctionInfo.cpp:21
setupMemoryBuffer
static Expected< std::unique_ptr< MemoryBuffer > > setupMemoryBuffer(const Twine &Path)
Definition: InstrProfReader.cpp:42
llvm::AMDGPU::PALMD::Key
Key
PAL metadata keys.
Definition: AMDGPUMetadata.h:481
llvm::ErrorOr::getError
std::error_code getError() const
Definition: ErrorOr.h:153
llvm::InstrProfReaderItaniumRemapper::InstrProfReaderItaniumRemapper
InstrProfReaderItaniumRemapper(std::unique_ptr< MemoryBuffer > RemapBuffer, InstrProfReaderIndex< HashTableImpl > &Underlying)
Definition: InstrProfReader.cpp:687
CHECK_LINE_END
#define CHECK_LINE_END(Line)
InstrProf.h
llvm::instrprof_error::truncated
@ truncated
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::IndexedInstrProfReader::getFunctionCounts
Error getFunctionCounts(StringRef FuncName, uint64_t FuncHash, std::vector< uint64_t > &Counts)
Fill Counts with the profile data for the given function name.
Definition: InstrProfReader.cpp:936
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:991
llvm::TextInstrProfReader::readNextRecord
Error readNextRecord(NamedInstrProfRecord &Record) override
Read a single record.
Definition: InstrProfReader.cpp:253
c
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int int c
Definition: README.txt:418
llvm::IndexedInstrProf::Header
Definition: InstrProf.h:999
llvm::instrprof_error::bad_magic
@ bad_magic
llvm::instrprof_error::unsupported_version
@ unsupported_version
llvm::StringRef::getAsInteger
std::enable_if_t< std::numeric_limits< T >::is_signed, bool > getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:510
llvm::InstrProfReader::Symtab
std::unique_ptr< InstrProfSymtab > Symtab
Definition: InstrProfReader.h:114
llvm::IndexedInstrProfReader::readHeader
Error readHeader() override
Read the file header.
Definition: InstrProfReader.cpp:849
llvm::instrprof_error::too_large
@ too_large
llvm::InstrProfError::take
static instrprof_error take(Error E)
Consume an Error and return the raw enum value contained within it.
Definition: InstrProf.h:327
llvm::SmallString< 256 >
llvm::Twine::str
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:17
llvm::InstrProfReader::error
Error error(instrprof_error Err)
Set the current error and return same.
Definition: InstrProfReader.h:117
llvm::sys::getSwappedBytes
unsigned char getSwappedBytes(unsigned char C)
Definition: SwapByteOrder.h:103
llvm::instrprof_error::unsupported_hash_type
@ unsupported_hash_type
llvm::IndexedInstrProfReader::getInstrProfRecord
Expected< InstrProfRecord > getInstrProfRecord(StringRef FuncName, uint64_t FuncHash)
Return the NamedInstrProfRecord associated with FuncName and FuncHash.
Definition: InstrProfReader.cpp:920
llvm::InstrProfReaderItaniumRemapper::extractName
static StringRef extractName(StringRef Name)
Extract the original function name from a PGO function name.
Definition: InstrProfReader.cpp:694
InstrProfReader.h
llvm::CountSumOrPercent::NumEntries
uint64_t NumEntries
Definition: InstrProf.h:598
llvm::InstrProfReaderItaniumRemapper::getRecords
Error getRecords(StringRef FuncName, ArrayRef< NamedInstrProfRecord > &Data) override
Definition: InstrProfReader.cpp:734
SymbolRemappingReader.h
initializeReader
static Error initializeReader(InstrProfReader &Reader)
Definition: InstrProfReader.cpp:50
llvm::count
auto count(R &&Range, const E &Element)
Wrapper function around std::count to count the number of times an element Element occurs in the give...
Definition: STLExtras.h:1634
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
uint64_t
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::StringRef::end
iterator end() const
Definition: StringRef.h:130
llvm::IndexedInstrProfReader
Reader for the indexed binary instrprof format.
Definition: InstrProfReader.h:458
llvm::IndexedInstrProf::Summary::getSize
static uint32_t getSize(uint32_t NumSumFields, uint32_t NumCutoffEntries)
Definition: InstrProf.h:1048
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
ErrorOr.h
llvm::InstrProfSummaryBuilder
Definition: ProfileCommon.h:74
llvm::MemoryBuffer::getFileOrSTDIN
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileOrSTDIN(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true)
Open the specified file as a MemoryBuffer, or open stdin if the Filename is "-".
Definition: MemoryBuffer.cpp:144
llvm::CountSumOrPercent
Definition: InstrProf.h:597
llvm::TextInstrProfReader
Reader for the simple text based instrprof format.
Definition: InstrProfReader.h:159
llvm::instrprof_error::empty_raw_profile
@ empty_raw_profile
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::line_iterator::is_at_end
bool is_at_end() const
Return true if we're an "end" iterator or have reached EOF.
Definition: LineIterator.h:63
StringExtras.h
Magic
const char Magic[]
Definition: Archive.cpp:41
ArrayRef.h
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1609
std::swap
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:840
llvm::instrprof_error::unknown_function
@ unknown_function
llvm::IndexedInstrProf::HashT::Last
@ Last
llvm::instrprof_error::unrecognized_format
@ unrecognized_format
llvm::IndexedInstrProf::allocSummary
std::unique_ptr< Summary > allocSummary(uint32_t TotalSize)
Definition: InstrProf.h:1088
llvm::Record
Definition: Record.h:1472
llvm::IndexedInstrProfReader::create
static Expected< std::unique_ptr< IndexedInstrProfReader > > create(const Twine &Path, const Twine &RemappingPath="")
Factory method to create an indexed reader.
Definition: InstrProfReader.cpp:93
Builder
assume Assume Builder
Definition: AssumeBundleBuilder.cpp:651
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::InstrProfSymtab::isExternalSymbol
static bool isExternalSymbol(const StringRef &Symbol)
True if Symbol is the value used to represent external symbols.
Definition: InstrProf.h:511
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
llvm::InstrProfReaderIndex
Definition: InstrProfReader.h:401
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::IndexedInstrProf::Summary::Entry::Cutoff
uint64_t Cutoff
The required percentile of total execution count.
Definition: InstrProf.h:1012
llvm::IndexedInstrProf::Magic
const uint64_t Magic
Definition: InstrProf.h:962
llvm::IndexedInstrProf::HashT
HashT
Definition: InstrProf.h:949
llvm::NamedInstrProfRecord::hasCSFlagInHash
static bool hasCSFlagInHash(uint64_t FuncHash)
Definition: InstrProf.h:860
llvm::Expected::get
reference get()
Returns a reference to the stored T value.
Definition: Error.h:569
uint32_t
llvm::instrprof_error::eof
@ eof
llvm::IndexedInstrProf::Summary::NumCutoffEntries
uint64_t NumCutoffEntries
Definition: InstrProf.h:1041
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::RawInstrProfReader::readHeader
Error readHeader() override
Read the header. Required before reading first record.
Definition: InstrProfReader.cpp:312
llvm::format
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
llvm::ProfileSummary::PSK_CSInstr
@ PSK_CSInstr
Definition: ProfileSummary.h:47
llvm::RawInstrProfReader::hasFormat
static bool hasFormat(const MemoryBuffer &DataBuffer)
Definition: InstrProfReader.cpp:302
llvm::instrprof_error::hash_mismatch
@ hash_mismatch
llvm::SummaryEntryVector
std::vector< ProfileSummaryEntry > SummaryEntryVector
Definition: ProfileSummary.h:43
llvm::InstrProfReaderItaniumRemapper
A remapper that applies remappings based on a symbol remapping file.
Definition: InstrProfReader.h:398
VP_READ_ADVANCE
#define VP_READ_ADVANCE(Val)
llvm::InstrProfLookupTrait::ReadData
data_type ReadData(StringRef K, const unsigned char *D, offset_type N)
Definition: InstrProfReader.cpp:579
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::MemoryBuffer::getBufferStart
const char * getBufferStart() const
Definition: MemoryBuffer.h:65
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
std
Definition: BitVector.h:838
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
llvm::InstrProfReader::accumulateCounts
void accumulateCounts(CountSumOrPercent &Sum, bool IsCS)
Compute the sum of counts and return in Sum.
Definition: InstrProfReader.cpp:962
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
llvm::InstrProfReaderItaniumRemapper::reconstituteName
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,...
Definition: InstrProfReader.cpp:710
llvm::IndexedInstrProf::Summary
Definition: InstrProf.h:1010
READ_NUM
#define READ_NUM(Str, Dst)
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::InstrProfReaderRemapper
Name matcher supporting fuzzy matching of symbol names to names in profiles.
Definition: InstrProfReader.h:449
llvm::InstrProfReader::readHeader
virtual Error readHeader()=0
Read the header. Required before reading first record.
llvm::RawInstrProfReader::readNextRecord
Error readNextRecord(NamedInstrProfRecord &Record) override
Read a single record.
Definition: InstrProfReader.cpp:496
llvm::InstrProfReaderIndexBase
Definition: InstrProfReader.h:374
llvm::RawInstrProf::ProfileData
Definition: InstrProf.h:1124
llvm::IndexedInstrProfReader::readNextRecord
Error readNextRecord(NamedInstrProfRecord &Record) override
Read a single record.
Definition: InstrProfReader.cpp:947
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:476
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:589
llvm::RawInstrProfReader::printBinaryIds
Error printBinaryIds(raw_ostream &OS) override
Print binary ids on stream OS.
Definition: InstrProfReader.cpp:524
llvm::InstrProfSymtab::mapAddress
void mapAddress(uint64_t Addr, uint64_t MD5Val)
Map a function address to its name's MD5 hash.
Definition: InstrProf.h:489
llvm::ErrorOr::get
reference get()
Definition: ErrorOr.h:150
llvm::TextInstrProfReader::hasFormat
static bool hasFormat(const MemoryBuffer &Buffer)
Return true if the given buffer is in text instrprof format.
Definition: InstrProfReader.cpp:141
llvm::ProfileSummary::PSK_Instr
@ PSK_Instr
Definition: ProfileSummary.h:47
N
#define N
llvm::ErrorOr
Represents either an error or a value T.
Definition: ErrorOr.h:56
llvm::coverage::Version2
@ Version2
Definition: CoverageMapping.h:998
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::NamedInstrProfRecord
Definition: InstrProf.h:848
llvm::SmallVectorImpl< char >
llvm::instrprof_error::malformed
@ malformed
llvm::RawInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:1108
llvm::RawInstrProf::Header
Definition: InstrProf.h:1133
llvm::InstrProfLookupTrait::offset_type
uint64_t offset_type
Definition: InstrProfReader.h:343
llvm::StringRef::size
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:157
llvm::InstrProfReaderItaniumRemapper::populateRemappings
Error populateRemappings() override
Definition: InstrProfReader.cpp:719
llvm::SmallVectorImpl::reserve
void reserve(size_type N)
Definition: SmallVector.h:624
Endian.h
llvm::StringRef::begin
iterator begin() const
Definition: StringRef.h:128
llvm::InstrProfReader::create
static Expected< std::unique_ptr< InstrProfReader > > create(const Twine &Path)
Factory method to create an appropriately typed reader for the given instrprof file.
Definition: InstrProfReader.cpp:55
llvm::IndexedInstrProf::Summary::NumSummaryFields
uint64_t NumSummaryFields
Definition: InstrProf.h:1039
llvm::IndexedInstrProf::Summary::Entry::MinBlockCount
uint64_t MinBlockCount
The minimum execution count for this percentile.
Definition: InstrProf.h:1014
llvm::ProfileSummaryBuilder::DefaultCutoffs
static const ArrayRef< uint32_t > DefaultCutoffs
A vector of useful cutoff values for detailed summary.
Definition: ProfileCommon.h:65
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::InstrProfReader
Base class and interface for reading profiling data of any known instrprof format.
Definition: InstrProfReader.h:72
llvm::RawInstrProfReader32
RawInstrProfReader< uint32_t > RawInstrProfReader32
Definition: InstrProfReader.h:314
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58
llvm::InstrProfIterator::InstrProfIterator
InstrProfIterator()=default
llvm::InstrProfLookupTrait::readValueProfilingData
bool readValueProfilingData(const unsigned char *&D, const unsigned char *const End)
Definition: InstrProfReader.cpp:565
llvm::InstrProfReaderIndex::getRecords
Error getRecords(ArrayRef< NamedInstrProfRecord > &Data) override
Definition: InstrProfReader.cpp:641
llvm::SmallVectorImpl::insert
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:773