LLVM  13.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  CountersDelta = swap(Header.CountersDelta);
370  NamesDelta = swap(Header.NamesDelta);
371  auto DataSize = swap(Header.DataSize);
372  auto PaddingBytesBeforeCounters = swap(Header.PaddingBytesBeforeCounters);
373  auto CountersSize = swap(Header.CountersSize);
374  auto PaddingBytesAfterCounters = swap(Header.PaddingBytesAfterCounters);
375  NamesSize = swap(Header.NamesSize);
376  ValueKindLast = swap(Header.ValueKindLast);
377  BinaryIdsSize = swap(Header.BinaryIdsSize);
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  ptrdiff_t CounterOffset = getCounterOffset(CounterPtr);
441  if (CounterOffset < 0 || CounterOffset > MaxNumCounters ||
442  ((uint32_t)CounterOffset + NumCounters) > (uint32_t)MaxNumCounters)
444 
445  auto RawCounts = makeArrayRef(getCounter(CounterOffset), NumCounters);
446 
447  if (ShouldSwapBytes) {
448  Record.Counts.clear();
449  Record.Counts.reserve(RawCounts.size());
450  for (uint64_t Count : RawCounts)
451  Record.Counts.push_back(swap(Count));
452  } else
453  Record.Counts = RawCounts;
454 
455  return success();
456 }
457 
458 template <class IntPtrT>
461  Record.clearValueData();
462  CurValueDataSize = 0;
463  // Need to match the logic in value profile dumper code in compiler-rt:
464  uint32_t NumValueKinds = 0;
465  for (uint32_t I = 0; I < IPVK_Last + 1; I++)
466  NumValueKinds += (Data->NumValueSites[I] != 0);
467 
468  if (!NumValueKinds)
469  return success();
470 
472  ValueProfData::getValueProfData(
473  ValueDataStart, (const unsigned char *)DataBuffer->getBufferEnd(),
474  getDataEndianness());
475 
476  if (Error E = VDataPtrOrErr.takeError())
477  return E;
478 
479  // Note that besides deserialization, this also performs the conversion for
480  // indirect call targets. The function pointers from the raw profile are
481  // remapped into function name hashes.
482  VDataPtrOrErr.get()->deserializeTo(Record, Symtab.get());
483  CurValueDataSize = VDataPtrOrErr.get()->getSize();
484  return success();
485 }
486 
487 template <class IntPtrT>
489  if (atEnd())
490  // At this point, ValueDataStart field points to the next header.
491  if (Error E = readNextHeader(getNextHeaderPos()))
492  return error(std::move(E));
493 
494  // Read name ad set it in Record.
495  if (Error E = readName(Record))
496  return error(std::move(E));
497 
498  // Read FuncHash and set it in Record.
499  if (Error E = readFuncHash(Record))
500  return error(std::move(E));
501 
502  // Read raw counts and set Record.
503  if (Error E = readRawCounts(Record))
504  return error(std::move(E));
505 
506  // Read value data and set Record.
507  if (Error E = readValueProfilingData(Record))
508  return error(std::move(E));
509 
510  // Iterate.
511  advanceData();
512  return success();
513 }
514 
515 template <class IntPtrT>
517  if (BinaryIdsSize == 0)
518  return success();
519 
520  OS << "Binary IDs: \n";
521  const uint8_t *BI = BinaryIdsStart;
522  while (BI < BinaryIdsStart + BinaryIdsSize) {
523  uint64_t BinaryIdLen = swap(*reinterpret_cast<const uint64_t *>(BI));
524  // Increment by binary id length data type size.
525  BI += sizeof(BinaryIdLen);
526  if (BI > (const uint8_t *)DataBuffer->getBufferEnd())
527  return make_error<InstrProfError>(instrprof_error::malformed);
528 
529  for (uint64_t I = 0; I < BinaryIdLen; I++)
530  OS << format("%02x", BI[I]);
531  OS << "\n";
532 
533  // Increment by binary id data length.
534  BI += BinaryIdLen;
535  if (BI > (const uint8_t *)DataBuffer->getBufferEnd())
536  return make_error<InstrProfError>(instrprof_error::malformed);
537  }
538 
539  return success();
540 }
541 
542 namespace llvm {
543 
544 template class RawInstrProfReader<uint32_t>;
545 template class RawInstrProfReader<uint64_t>;
546 
547 } // end namespace llvm
548 
551  return IndexedInstrProf::ComputeHash(HashType, K);
552 }
553 
556 
558  const unsigned char *&D, const unsigned char *const End) {
560  ValueProfData::getValueProfData(D, End, ValueProfDataEndianness);
561 
562  if (VDataPtrOrErr.takeError())
563  return false;
564 
565  VDataPtrOrErr.get()->deserializeTo(DataBuffer.back(), nullptr);
566  D += VDataPtrOrErr.get()->TotalSize;
567 
568  return true;
569 }
570 
572  offset_type N) {
573  using namespace support;
574 
575  // Check if the data is corrupt. If so, don't try to read it.
576  if (N % sizeof(uint64_t))
577  return data_type();
578 
579  DataBuffer.clear();
580  std::vector<uint64_t> CounterBuffer;
581 
582  const unsigned char *End = D + N;
583  while (D < End) {
584  // Read hash.
585  if (D + sizeof(uint64_t) >= End)
586  return data_type();
587  uint64_t Hash = endian::readNext<uint64_t, little, unaligned>(D);
588 
589  // Initialize number of counters for GET_VERSION(FormatVersion) == 1.
590  uint64_t CountsSize = N / sizeof(uint64_t) - 1;
591  // If format version is different then read the number of counters.
592  if (GET_VERSION(FormatVersion) != IndexedInstrProf::ProfVersion::Version1) {
593  if (D + sizeof(uint64_t) > End)
594  return data_type();
595  CountsSize = endian::readNext<uint64_t, little, unaligned>(D);
596  }
597  // Read counter values.
598  if (D + CountsSize * sizeof(uint64_t) > End)
599  return data_type();
600 
601  CounterBuffer.clear();
602  CounterBuffer.reserve(CountsSize);
603  for (uint64_t J = 0; J < CountsSize; ++J)
604  CounterBuffer.push_back(endian::readNext<uint64_t, little, unaligned>(D));
605 
606  DataBuffer.emplace_back(K, Hash, std::move(CounterBuffer));
607 
608  // Read value profiling data.
609  if (GET_VERSION(FormatVersion) > IndexedInstrProf::ProfVersion::Version2 &&
610  !readValueProfilingData(D, End)) {
611  DataBuffer.clear();
612  return data_type();
613  }
614  }
615  return DataBuffer;
616 }
617 
618 template <typename HashTableImpl>
621  auto Iter = HashTable->find(FuncName);
622  if (Iter == HashTable->end())
623  return make_error<InstrProfError>(instrprof_error::unknown_function);
624 
625  Data = (*Iter);
626  if (Data.empty())
627  return make_error<InstrProfError>(instrprof_error::malformed);
628 
629  return Error::success();
630 }
631 
632 template <typename HashTableImpl>
635  if (atEnd())
636  return make_error<InstrProfError>(instrprof_error::eof);
637 
638  Data = *RecordIterator;
639 
640  if (Data.empty())
641  return make_error<InstrProfError>(instrprof_error::malformed);
642 
643  return Error::success();
644 }
645 
646 template <typename HashTableImpl>
648  const unsigned char *Buckets, const unsigned char *const Payload,
649  const unsigned char *const Base, IndexedInstrProf::HashT HashType,
650  uint64_t Version) {
651  FormatVersion = Version;
652  HashTable.reset(HashTableImpl::Create(
653  Buckets, Payload, Base,
654  typename HashTableImpl::InfoType(HashType, Version)));
655  RecordIterator = HashTable->data_begin();
656 }
657 
658 namespace {
659 /// A remapper that does not apply any remappings.
660 class InstrProfReaderNullRemapper : public InstrProfReaderRemapper {
662 
663 public:
664  InstrProfReaderNullRemapper(InstrProfReaderIndexBase &Underlying)
665  : Underlying(Underlying) {}
666 
667  Error getRecords(StringRef FuncName,
669  return Underlying.getRecords(FuncName, Data);
670  }
671 };
672 }
673 
674 /// A remapper that applies remappings based on a symbol remapping file.
675 template <typename HashTableImpl>
677  : public InstrProfReaderRemapper {
678 public:
680  std::unique_ptr<MemoryBuffer> RemapBuffer,
682  : RemapBuffer(std::move(RemapBuffer)), Underlying(Underlying) {
683  }
684 
685  /// Extract the original function name from a PGO function name.
687  // We can have multiple :-separated pieces; there can be pieces both
688  // before and after the mangled name. Find the first part that starts
689  // with '_Z'; we'll assume that's the mangled name we want.
690  std::pair<StringRef, StringRef> Parts = {StringRef(), Name};
691  while (true) {
692  Parts = Parts.second.split(':');
693  if (Parts.first.startswith("_Z"))
694  return Parts.first;
695  if (Parts.second.empty())
696  return Name;
697  }
698  }
699 
700  /// Given a mangled name extracted from a PGO function name, and a new
701  /// form for that mangled name, reconstitute the name.
702  static void reconstituteName(StringRef OrigName, StringRef ExtractedName,
703  StringRef Replacement,
704  SmallVectorImpl<char> &Out) {
705  Out.reserve(OrigName.size() + Replacement.size() - ExtractedName.size());
706  Out.insert(Out.end(), OrigName.begin(), ExtractedName.begin());
707  Out.insert(Out.end(), Replacement.begin(), Replacement.end());
708  Out.insert(Out.end(), ExtractedName.end(), OrigName.end());
709  }
710 
712  if (Error E = Remappings.read(*RemapBuffer))
713  return E;
714  for (StringRef Name : Underlying.HashTable->keys()) {
715  StringRef RealName = extractName(Name);
716  if (auto Key = Remappings.insert(RealName)) {
717  // FIXME: We could theoretically map the same equivalence class to
718  // multiple names in the profile data. If that happens, we should
719  // return NamedInstrProfRecords from all of them.
720  MappedNames.insert({Key, RealName});
721  }
722  }
723  return Error::success();
724  }
725 
728  StringRef RealName = extractName(FuncName);
729  if (auto Key = Remappings.lookup(RealName)) {
730  StringRef Remapped = MappedNames.lookup(Key);
731  if (!Remapped.empty()) {
732  if (RealName.begin() == FuncName.begin() &&
733  RealName.end() == FuncName.end())
734  FuncName = Remapped;
735  else {
736  // Try rebuilding the name from the given remapping.
737  SmallString<256> Reconstituted;
738  reconstituteName(FuncName, RealName, Remapped, Reconstituted);
739  Error E = Underlying.getRecords(Reconstituted, Data);
740  if (!E)
741  return E;
742 
743  // If we failed because the name doesn't exist, fall back to asking
744  // about the original name.
745  if (Error Unhandled = handleErrors(
746  std::move(E), [](std::unique_ptr<InstrProfError> Err) {
747  return Err->get() == instrprof_error::unknown_function
748  ? Error::success()
749  : Error(std::move(Err));
750  }))
751  return Unhandled;
752  }
753  }
754  }
755  return Underlying.getRecords(FuncName, Data);
756  }
757 
758 private:
759  /// The memory buffer containing the remapping configuration. Remappings
760  /// holds pointers into this buffer.
761  std::unique_ptr<MemoryBuffer> RemapBuffer;
762 
763  /// The mangling remapper.
764  SymbolRemappingReader Remappings;
765 
766  /// Mapping from mangled name keys to the name used for the key in the
767  /// profile data.
768  /// FIXME: Can we store a location within the on-disk hash table instead of
769  /// redoing lookup?
771 
772  /// The real profile data reader.
774 };
775 
777  using namespace support;
778 
779  if (DataBuffer.getBufferSize() < 8)
780  return false;
781  uint64_t Magic =
782  endian::read<uint64_t, little, aligned>(DataBuffer.getBufferStart());
783  // Verify that it's magical.
784  return Magic == IndexedInstrProf::Magic;
785 }
786 
787 const unsigned char *
788 IndexedInstrProfReader::readSummary(IndexedInstrProf::ProfVersion Version,
789  const unsigned char *Cur, bool UseCS) {
790  using namespace IndexedInstrProf;
791  using namespace support;
792 
794  const IndexedInstrProf::Summary *SummaryInLE =
795  reinterpret_cast<const IndexedInstrProf::Summary *>(Cur);
796  uint64_t NFields =
797  endian::byte_swap<uint64_t, little>(SummaryInLE->NumSummaryFields);
798  uint64_t NEntries =
799  endian::byte_swap<uint64_t, little>(SummaryInLE->NumCutoffEntries);
800  uint32_t SummarySize =
801  IndexedInstrProf::Summary::getSize(NFields, NEntries);
802  std::unique_ptr<IndexedInstrProf::Summary> SummaryData =
803  IndexedInstrProf::allocSummary(SummarySize);
804 
805  const uint64_t *Src = reinterpret_cast<const uint64_t *>(SummaryInLE);
806  uint64_t *Dst = reinterpret_cast<uint64_t *>(SummaryData.get());
807  for (unsigned I = 0; I < SummarySize / sizeof(uint64_t); I++)
808  Dst[I] = endian::byte_swap<uint64_t, little>(Src[I]);
809 
810  SummaryEntryVector DetailedSummary;
811  for (unsigned I = 0; I < SummaryData->NumCutoffEntries; I++) {
812  const IndexedInstrProf::Summary::Entry &Ent = SummaryData->getEntry(I);
813  DetailedSummary.emplace_back((uint32_t)Ent.Cutoff, Ent.MinBlockCount,
814  Ent.NumBlocks);
815  }
816  std::unique_ptr<llvm::ProfileSummary> &Summary =
817  UseCS ? this->CS_Summary : this->Summary;
818 
819  // initialize InstrProfSummary using the SummaryData from disk.
820  Summary = std::make_unique<ProfileSummary>(
822  DetailedSummary, SummaryData->get(Summary::TotalBlockCount),
823  SummaryData->get(Summary::MaxBlockCount),
824  SummaryData->get(Summary::MaxInternalBlockCount),
825  SummaryData->get(Summary::MaxFunctionCount),
826  SummaryData->get(Summary::TotalNumBlocks),
827  SummaryData->get(Summary::TotalNumFunctions));
828  return Cur + SummarySize;
829  } else {
830  // The older versions do not support a profile summary. This just computes
831  // an empty summary, which will not result in accurate hot/cold detection.
832  // We would need to call addRecord for all NamedInstrProfRecords to get the
833  // correct summary. However, this version is old (prior to early 2016) and
834  // has not been supporting an accurate summary for several years.
836  Summary = Builder.getSummary();
837  return Cur;
838  }
839 }
840 
842  using namespace support;
843 
844  const unsigned char *Start =
845  (const unsigned char *)DataBuffer->getBufferStart();
846  const unsigned char *Cur = Start;
847  if ((const unsigned char *)DataBuffer->getBufferEnd() - Cur < 24)
849 
850  auto *Header = reinterpret_cast<const IndexedInstrProf::Header *>(Cur);
851  Cur += sizeof(IndexedInstrProf::Header);
852 
853  // Check the magic number.
854  uint64_t Magic = endian::byte_swap<uint64_t, little>(Header->Magic);
857 
858  // Read the version.
859  uint64_t FormatVersion = endian::byte_swap<uint64_t, little>(Header->Version);
860  if (GET_VERSION(FormatVersion) >
863 
864  Cur = readSummary((IndexedInstrProf::ProfVersion)FormatVersion, Cur,
865  /* UseCS */ false);
866  if (FormatVersion & VARIANT_MASK_CSIR_PROF)
867  Cur = readSummary((IndexedInstrProf::ProfVersion)FormatVersion, Cur,
868  /* UseCS */ true);
869 
870  // Read the hash type and start offset.
871  IndexedInstrProf::HashT HashType = static_cast<IndexedInstrProf::HashT>(
872  endian::byte_swap<uint64_t, little>(Header->HashType));
873  if (HashType > IndexedInstrProf::HashT::Last)
875 
876  uint64_t HashOffset = endian::byte_swap<uint64_t, little>(Header->HashOffset);
877 
878  // The rest of the file is an on disk hash table.
879  auto IndexPtr =
880  std::make_unique<InstrProfReaderIndex<OnDiskHashTableImplV3>>(
881  Start + HashOffset, Cur, Start, HashType, FormatVersion);
882 
883  // Load the remapping table now if requested.
884  if (RemappingBuffer) {
885  Remapper = std::make_unique<
887  std::move(RemappingBuffer), *IndexPtr);
888  if (Error E = Remapper->populateRemappings())
889  return E;
890  } else {
891  Remapper = std::make_unique<InstrProfReaderNullRemapper>(*IndexPtr);
892  }
893  Index = std::move(IndexPtr);
894 
895  return success();
896 }
897 
899  if (Symtab.get())
900  return *Symtab.get();
901 
902  std::unique_ptr<InstrProfSymtab> NewSymtab = std::make_unique<InstrProfSymtab>();
903  if (Error E = Index->populateSymtab(*NewSymtab.get())) {
905  }
906 
907  Symtab = std::move(NewSymtab);
908  return *Symtab.get();
909 }
910 
913  uint64_t FuncHash) {
915  Error Err = Remapper->getRecords(FuncName, Data);
916  if (Err)
917  return std::move(Err);
918  // Found it. Look for counters with the right hash.
919  for (unsigned I = 0, E = Data.size(); I < E; ++I) {
920  // Check for a match and fill the vector if there is one.
921  if (Data[I].Hash == FuncHash) {
922  return std::move(Data[I]);
923  }
924  }
926 }
927 
929  uint64_t FuncHash,
930  std::vector<uint64_t> &Counts) {
931  Expected<InstrProfRecord> Record = getInstrProfRecord(FuncName, FuncHash);
932  if (Error E = Record.takeError())
933  return error(std::move(E));
934 
935  Counts = Record.get().Counts;
936  return success();
937 }
938 
941 
942  Error E = Index->getRecords(Data);
943  if (E)
944  return error(std::move(E));
945 
946  Record = Data[RecordIndex++];
947  if (RecordIndex >= Data.size()) {
948  Index->advanceToNextKey();
949  RecordIndex = 0;
950  }
951  return success();
952 }
953 
955  uint64_t NumFuncs = 0;
956  for (const auto &Func : *this) {
957  if (isIRLevelProfile()) {
958  bool FuncIsCS = NamedInstrProfRecord::hasCSFlagInHash(Func.Hash);
959  if (FuncIsCS != IsCS)
960  continue;
961  }
962  Func.accumulateCounts(Sum);
963  ++NumFuncs;
964  }
965  Sum.NumEntries = NumFuncs;
966 }
llvm::coverage::coveragemap_error::success
@ success
MemoryBuffer.h
llvm::IndexedInstrProfReader::getSymtab
InstrProfSymtab & getSymtab() override
Return the PGO symtab.
Definition: InstrProfReader.cpp:898
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:939
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:555
llvm::IndexedInstrProfReader::hasFormat
static bool hasFormat(const MemoryBuffer &DataBuffer)
Return true if the given buffer is in an indexed instrprof format.
Definition: InstrProfReader.cpp:776
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:647
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:332
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:550
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:1039
llvm::Data
@ Data
Definition: SIMachineScheduler.h:56
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:1534
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:679
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:928
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:841
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:912
llvm::InstrProfReaderItaniumRemapper::extractName
static StringRef extractName(StringRef Name)
Extract the original function name from a PGO function name.
Definition: InstrProfReader.cpp:686
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:726
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:1617
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
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:1592
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:570
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:571
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:954
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:702
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:488
llvm::InstrProfReaderIndexBase
Definition: InstrProfReader.h:374
llvm::RawInstrProf::ProfileData
Definition: InstrProf.h:1123
llvm::IndexedInstrProfReader::readNextRecord
Error readNextRecord(NamedInstrProfRecord &Record) override
Read a single record.
Definition: InstrProfReader.cpp:939
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:590
llvm::RawInstrProfReader::printBinaryIds
Error printBinaryIds(raw_ostream &OS) override
Print binary ids on stream OS.
Definition: InstrProfReader.cpp:516
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:1107
llvm::RawInstrProf::Header
Definition: InstrProf.h:1132
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:711
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:557
llvm::InstrProfReaderIndex::getRecords
Error getRecords(ArrayRef< NamedInstrProfRecord > &Data) override
Definition: InstrProfReader.cpp:633
llvm::SmallVectorImpl::insert
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:773