LLVM  7.0.0svn
InstrProfReader.cpp
Go to the documentation of this file.
1 //===- InstrProfReader.cpp - Instrumented profiling reader ----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for reading profiling data for clang's
11 // instrumentation based PGO and coverage.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "llvm/ADT/ArrayRef.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/IR/ProfileSummary.h"
22 #include "llvm/Support/Endian.h"
23 #include "llvm/Support/Error.h"
24 #include "llvm/Support/ErrorOr.h"
27 #include <algorithm>
28 #include <cctype>
29 #include <cstddef>
30 #include <cstdint>
31 #include <limits>
32 #include <memory>
33 #include <system_error>
34 #include <utility>
35 #include <vector>
36 
37 using namespace llvm;
38 
40 setupMemoryBuffer(const Twine &Path) {
43  if (std::error_code EC = BufferOrErr.getError())
44  return errorCodeToError(EC);
45  return std::move(BufferOrErr.get());
46 }
47 
49  return Reader.readHeader();
50 }
51 
54  // Set up the buffer to read.
55  auto BufferOrError = setupMemoryBuffer(Path);
56  if (Error E = BufferOrError.takeError())
57  return std::move(E);
58  return InstrProfReader::create(std::move(BufferOrError.get()));
59 }
60 
62 InstrProfReader::create(std::unique_ptr<MemoryBuffer> Buffer) {
63  // Sanity check the buffer.
64  if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<unsigned>::max())
65  return make_error<InstrProfError>(instrprof_error::too_large);
66 
67  if (Buffer->getBufferSize() == 0)
68  return make_error<InstrProfError>(instrprof_error::empty_raw_profile);
69 
70  std::unique_ptr<InstrProfReader> Result;
71  // Create the reader.
73  Result.reset(new IndexedInstrProfReader(std::move(Buffer)));
74  else if (RawInstrProfReader64::hasFormat(*Buffer))
75  Result.reset(new RawInstrProfReader64(std::move(Buffer)));
76  else if (RawInstrProfReader32::hasFormat(*Buffer))
77  Result.reset(new RawInstrProfReader32(std::move(Buffer)));
78  else if (TextInstrProfReader::hasFormat(*Buffer))
79  Result.reset(new TextInstrProfReader(std::move(Buffer)));
80  else
81  return make_error<InstrProfError>(instrprof_error::unrecognized_format);
82 
83  // Initialize the reader and return the result.
84  if (Error E = initializeReader(*Result))
85  return std::move(E);
86 
87  return std::move(Result);
88 }
89 
92  // Set up the buffer to read.
93  auto BufferOrError = setupMemoryBuffer(Path);
94  if (Error E = BufferOrError.takeError())
95  return std::move(E);
96  return IndexedInstrProfReader::create(std::move(BufferOrError.get()));
97 }
98 
100 IndexedInstrProfReader::create(std::unique_ptr<MemoryBuffer> Buffer) {
101  // Sanity check the buffer.
102  if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<unsigned>::max())
103  return make_error<InstrProfError>(instrprof_error::too_large);
104 
105  // Create the reader.
106  if (!IndexedInstrProfReader::hasFormat(*Buffer))
107  return make_error<InstrProfError>(instrprof_error::bad_magic);
108  auto Result = llvm::make_unique<IndexedInstrProfReader>(std::move(Buffer));
109 
110  // Initialize the reader and return the result.
111  if (Error E = initializeReader(*Result))
112  return std::move(E);
113 
114  return std::move(Result);
115 }
116 
117 void InstrProfIterator::Increment() {
118  if (auto E = Reader->readNextRecord(Record)) {
119  // Handle errors in the reader.
120  InstrProfError::take(std::move(E));
121  *this = InstrProfIterator();
122  }
123 }
124 
126  // Verify that this really looks like plain ASCII text by checking a
127  // 'reasonable' number of characters (up to profile magic size).
128  size_t count = std::min(Buffer.getBufferSize(), sizeof(uint64_t));
129  StringRef buffer = Buffer.getBufferStart();
130  return count == 0 ||
131  std::all_of(buffer.begin(), buffer.begin() + count,
132  [](char c) { return ::isprint(c) || ::isspace(c); });
133 }
134 
135 // Read the profile variant flag from the header: ":FE" means this is a FE
136 // generated profile. ":IR" means this is an IR level profile. Other strings
137 // with a leading ':' will be reported an error format.
139  Symtab.reset(new InstrProfSymtab());
140  bool IsIRInstr = false;
141  if (!Line->startswith(":")) {
142  IsIRLevelProfile = false;
143  return success();
144  }
145  StringRef Str = (Line)->substr(1);
146  if (Str.equals_lower("ir"))
147  IsIRInstr = true;
148  else if (Str.equals_lower("fe"))
149  IsIRInstr = false;
150  else
152 
153  ++Line;
154  IsIRLevelProfile = IsIRInstr;
155  return success();
156 }
157 
158 Error
159 TextInstrProfReader::readValueProfileData(InstrProfRecord &Record) {
160 
161 #define CHECK_LINE_END(Line) \
162  if (Line.is_at_end()) \
163  return error(instrprof_error::truncated);
164 #define READ_NUM(Str, Dst) \
165  if ((Str).getAsInteger(10, (Dst))) \
166  return error(instrprof_error::malformed);
167 #define VP_READ_ADVANCE(Val) \
168  CHECK_LINE_END(Line); \
169  uint32_t Val; \
170  READ_NUM((*Line), (Val)); \
171  Line++;
172 
173  if (Line.is_at_end())
174  return success();
175 
176  uint32_t NumValueKinds;
177  if (Line->getAsInteger(10, NumValueKinds)) {
178  // No value profile data
179  return success();
180  }
181  if (NumValueKinds == 0 || NumValueKinds > IPVK_Last + 1)
183  Line++;
184 
185  for (uint32_t VK = 0; VK < NumValueKinds; VK++) {
187  if (ValueKind > IPVK_Last)
189  VP_READ_ADVANCE(NumValueSites);
190  if (!NumValueSites)
191  continue;
192 
193  Record.reserveSites(VK, NumValueSites);
194  for (uint32_t S = 0; S < NumValueSites; S++) {
195  VP_READ_ADVANCE(NumValueData);
196 
197  std::vector<InstrProfValueData> CurrentValues;
198  for (uint32_t V = 0; V < NumValueData; V++) {
199  CHECK_LINE_END(Line);
200  std::pair<StringRef, StringRef> VD = Line->rsplit(':');
201  uint64_t TakenCount, Value;
202  if (ValueKind == IPVK_IndirectCallTarget) {
203  if (InstrProfSymtab::isExternalSymbol(VD.first)) {
204  Value = 0;
205  } else {
206  if (Error E = Symtab->addFuncName(VD.first))
207  return E;
208  Value = IndexedInstrProf::ComputeHash(VD.first);
209  }
210  } else {
211  READ_NUM(VD.first, Value);
212  }
213  READ_NUM(VD.second, TakenCount);
214  CurrentValues.push_back({Value, TakenCount});
215  Line++;
216  }
217  Record.addValueData(ValueKind, S, CurrentValues.data(), NumValueData,
218  nullptr);
219  }
220  }
221  return success();
222 
223 #undef CHECK_LINE_END
224 #undef READ_NUM
225 #undef VP_READ_ADVANCE
226 }
227 
229  // Skip empty lines and comments.
230  while (!Line.is_at_end() && (Line->empty() || Line->startswith("#")))
231  ++Line;
232  // If we hit EOF while looking for a name, we're done.
233  if (Line.is_at_end()) {
234  return error(instrprof_error::eof);
235  }
236 
237  // Read the function name.
238  Record.Name = *Line++;
239  if (Error E = Symtab->addFuncName(Record.Name))
240  return error(std::move(E));
241 
242  // Read the function hash.
243  if (Line.is_at_end())
245  if ((Line++)->getAsInteger(0, Record.Hash))
247 
248  // Read the number of counters.
249  uint64_t NumCounters;
250  if (Line.is_at_end())
252  if ((Line++)->getAsInteger(10, NumCounters))
254  if (NumCounters == 0)
256 
257  // Read each counter and fill our internal storage with the values.
258  Record.Clear();
259  Record.Counts.reserve(NumCounters);
260  for (uint64_t I = 0; I < NumCounters; ++I) {
261  if (Line.is_at_end())
263  uint64_t Count;
264  if ((Line++)->getAsInteger(10, Count))
266  Record.Counts.push_back(Count);
267  }
268 
269  // Check if value profile data exists and read it if so.
270  if (Error E = readValueProfileData(Record))
271  return error(std::move(E));
272 
273  return success();
274 }
275 
276 template <class IntPtrT>
278  if (DataBuffer.getBufferSize() < sizeof(uint64_t))
279  return false;
280  uint64_t Magic =
281  *reinterpret_cast<const uint64_t *>(DataBuffer.getBufferStart());
282  return RawInstrProf::getMagic<IntPtrT>() == Magic ||
283  sys::getSwappedBytes(RawInstrProf::getMagic<IntPtrT>()) == Magic;
284 }
285 
286 template <class IntPtrT>
288  if (!hasFormat(*DataBuffer))
290  if (DataBuffer->getBufferSize() < sizeof(RawInstrProf::Header))
292  auto *Header = reinterpret_cast<const RawInstrProf::Header *>(
293  DataBuffer->getBufferStart());
294  ShouldSwapBytes = Header->Magic != RawInstrProf::getMagic<IntPtrT>();
295  return readHeader(*Header);
296 }
297 
298 template <class IntPtrT>
299 Error RawInstrProfReader<IntPtrT>::readNextHeader(const char *CurrentPos) {
300  const char *End = DataBuffer->getBufferEnd();
301  // Skip zero padding between profiles.
302  while (CurrentPos != End && *CurrentPos == 0)
303  ++CurrentPos;
304  // If there's nothing left, we're done.
305  if (CurrentPos == End)
306  return make_error<InstrProfError>(instrprof_error::eof);
307  // If there isn't enough space for another header, this is probably just
308  // garbage at the end of the file.
309  if (CurrentPos + sizeof(RawInstrProf::Header) > End)
310  return make_error<InstrProfError>(instrprof_error::malformed);
311  // The writer ensures each profile is padded to start at an aligned address.
312  if (reinterpret_cast<size_t>(CurrentPos) % alignof(uint64_t))
313  return make_error<InstrProfError>(instrprof_error::malformed);
314  // The magic should have the same byte order as in the previous header.
315  uint64_t Magic = *reinterpret_cast<const uint64_t *>(CurrentPos);
316  if (Magic != swap(RawInstrProf::getMagic<IntPtrT>()))
317  return make_error<InstrProfError>(instrprof_error::bad_magic);
318 
319  // There's another profile to read, so we need to process the header.
320  auto *Header = reinterpret_cast<const RawInstrProf::Header *>(CurrentPos);
321  return readHeader(*Header);
322 }
323 
324 template <class IntPtrT>
326  if (Error E = Symtab.create(StringRef(NamesStart, NamesSize)))
327  return error(std::move(E));
328  for (const RawInstrProf::ProfileData<IntPtrT> *I = Data; I != DataEnd; ++I) {
329  const IntPtrT FPtr = swap(I->FunctionPointer);
330  if (!FPtr)
331  continue;
332  Symtab.mapAddress(FPtr, I->NameRef);
333  }
334  return success();
335 }
336 
337 template <class IntPtrT>
339  const RawInstrProf::Header &Header) {
340  Version = swap(Header.Version);
341  if (GET_VERSION(Version) != RawInstrProf::Version)
343 
344  CountersDelta = swap(Header.CountersDelta);
345  NamesDelta = swap(Header.NamesDelta);
346  auto DataSize = swap(Header.DataSize);
347  auto CountersSize = swap(Header.CountersSize);
348  NamesSize = swap(Header.NamesSize);
349  ValueKindLast = swap(Header.ValueKindLast);
350 
351  auto DataSizeInBytes = DataSize * sizeof(RawInstrProf::ProfileData<IntPtrT>);
352  auto PaddingSize = getNumPaddingBytes(NamesSize);
353 
354  ptrdiff_t DataOffset = sizeof(RawInstrProf::Header);
355  ptrdiff_t CountersOffset = DataOffset + DataSizeInBytes;
356  ptrdiff_t NamesOffset = CountersOffset + sizeof(uint64_t) * CountersSize;
357  ptrdiff_t ValueDataOffset = NamesOffset + NamesSize + PaddingSize;
358 
359  auto *Start = reinterpret_cast<const char *>(&Header);
360  if (Start + ValueDataOffset > DataBuffer->getBufferEnd())
362 
363  Data = reinterpret_cast<const RawInstrProf::ProfileData<IntPtrT> *>(
364  Start + DataOffset);
365  DataEnd = Data + DataSize;
366  CountersStart = reinterpret_cast<const uint64_t *>(Start + CountersOffset);
367  NamesStart = Start + NamesOffset;
368  ValueDataStart = reinterpret_cast<const uint8_t *>(Start + ValueDataOffset);
369 
370  std::unique_ptr<InstrProfSymtab> NewSymtab = make_unique<InstrProfSymtab>();
371  if (Error E = createSymtab(*NewSymtab.get()))
372  return E;
373 
374  Symtab = std::move(NewSymtab);
375  return success();
376 }
377 
378 template <class IntPtrT>
380  Record.Name = getName(Data->NameRef);
381  return success();
382 }
383 
384 template <class IntPtrT>
386  Record.Hash = swap(Data->FuncHash);
387  return success();
388 }
389 
390 template <class IntPtrT>
392  InstrProfRecord &Record) {
393  uint32_t NumCounters = swap(Data->NumCounters);
394  IntPtrT CounterPtr = Data->CounterPtr;
395  if (NumCounters == 0)
397 
398  auto RawCounts = makeArrayRef(getCounter(CounterPtr), NumCounters);
399  auto *NamesStartAsCounter = reinterpret_cast<const uint64_t *>(NamesStart);
400 
401  // Check bounds.
402  if (RawCounts.data() < CountersStart ||
403  RawCounts.data() + RawCounts.size() > NamesStartAsCounter)
405 
406  if (ShouldSwapBytes) {
407  Record.Counts.clear();
408  Record.Counts.reserve(RawCounts.size());
409  for (uint64_t Count : RawCounts)
410  Record.Counts.push_back(swap(Count));
411  } else
412  Record.Counts = RawCounts;
413 
414  return success();
415 }
416 
417 template <class IntPtrT>
419  InstrProfRecord &Record) {
420  Record.clearValueData();
421  CurValueDataSize = 0;
422  // Need to match the logic in value profile dumper code in compiler-rt:
423  uint32_t NumValueKinds = 0;
424  for (uint32_t I = 0; I < IPVK_Last + 1; I++)
425  NumValueKinds += (Data->NumValueSites[I] != 0);
426 
427  if (!NumValueKinds)
428  return success();
429 
431  ValueProfData::getValueProfData(
432  ValueDataStart, (const unsigned char *)DataBuffer->getBufferEnd(),
433  getDataEndianness());
434 
435  if (Error E = VDataPtrOrErr.takeError())
436  return E;
437 
438  // Note that besides deserialization, this also performs the conversion for
439  // indirect call targets. The function pointers from the raw profile are
440  // remapped into function name hashes.
441  VDataPtrOrErr.get()->deserializeTo(Record, Symtab.get());
442  CurValueDataSize = VDataPtrOrErr.get()->getSize();
443  return success();
444 }
445 
446 template <class IntPtrT>
448  if (atEnd())
449  // At this point, ValueDataStart field points to the next header.
450  if (Error E = readNextHeader(getNextHeaderPos()))
451  return error(std::move(E));
452 
453  // Read name ad set it in Record.
454  if (Error E = readName(Record))
455  return error(std::move(E));
456 
457  // Read FuncHash and set it in Record.
458  if (Error E = readFuncHash(Record))
459  return error(std::move(E));
460 
461  // Read raw counts and set Record.
462  if (Error E = readRawCounts(Record))
463  return error(std::move(E));
464 
465  // Read value data and set Record.
466  if (Error E = readValueProfilingData(Record))
467  return error(std::move(E));
468 
469  // Iterate.
470  advanceData();
471  return success();
472 }
473 
474 namespace llvm {
475 
476 template class RawInstrProfReader<uint32_t>;
477 template class RawInstrProfReader<uint64_t>;
478 
479 } // end namespace llvm
480 
484 }
485 
488 
490  const unsigned char *&D, const unsigned char *const End) {
492  ValueProfData::getValueProfData(D, End, ValueProfDataEndianness);
493 
494  if (VDataPtrOrErr.takeError())
495  return false;
496 
497  VDataPtrOrErr.get()->deserializeTo(DataBuffer.back(), nullptr);
498  D += VDataPtrOrErr.get()->TotalSize;
499 
500  return true;
501 }
502 
504  offset_type N) {
505  using namespace support;
506 
507  // Check if the data is corrupt. If so, don't try to read it.
508  if (N % sizeof(uint64_t))
509  return data_type();
510 
511  DataBuffer.clear();
512  std::vector<uint64_t> CounterBuffer;
513 
514  const unsigned char *End = D + N;
515  while (D < End) {
516  // Read hash.
517  if (D + sizeof(uint64_t) >= End)
518  return data_type();
519  uint64_t Hash = endian::readNext<uint64_t, little, unaligned>(D);
520 
521  // Initialize number of counters for GET_VERSION(FormatVersion) == 1.
522  uint64_t CountsSize = N / sizeof(uint64_t) - 1;
523  // If format version is different then read the number of counters.
524  if (GET_VERSION(FormatVersion) != IndexedInstrProf::ProfVersion::Version1) {
525  if (D + sizeof(uint64_t) > End)
526  return data_type();
527  CountsSize = endian::readNext<uint64_t, little, unaligned>(D);
528  }
529  // Read counter values.
530  if (D + CountsSize * sizeof(uint64_t) > End)
531  return data_type();
532 
533  CounterBuffer.clear();
534  CounterBuffer.reserve(CountsSize);
535  for (uint64_t J = 0; J < CountsSize; ++J)
536  CounterBuffer.push_back(endian::readNext<uint64_t, little, unaligned>(D));
537 
538  DataBuffer.emplace_back(K, Hash, std::move(CounterBuffer));
539 
540  // Read value profiling data.
541  if (GET_VERSION(FormatVersion) > IndexedInstrProf::ProfVersion::Version2 &&
542  !readValueProfilingData(D, End)) {
543  DataBuffer.clear();
544  return data_type();
545  }
546  }
547  return DataBuffer;
548 }
549 
550 template <typename HashTableImpl>
553  auto Iter = HashTable->find(FuncName);
554  if (Iter == HashTable->end())
555  return make_error<InstrProfError>(instrprof_error::unknown_function);
556 
557  Data = (*Iter);
558  if (Data.empty())
559  return make_error<InstrProfError>(instrprof_error::malformed);
560 
561  return Error::success();
562 }
563 
564 template <typename HashTableImpl>
567  if (atEnd())
568  return make_error<InstrProfError>(instrprof_error::eof);
569 
570  Data = *RecordIterator;
571 
572  if (Data.empty())
573  return make_error<InstrProfError>(instrprof_error::malformed);
574 
575  return Error::success();
576 }
577 
578 template <typename HashTableImpl>
580  const unsigned char *Buckets, const unsigned char *const Payload,
581  const unsigned char *const Base, IndexedInstrProf::HashT HashType,
582  uint64_t Version) {
583  FormatVersion = Version;
584  HashTable.reset(HashTableImpl::Create(
585  Buckets, Payload, Base,
586  typename HashTableImpl::InfoType(HashType, Version)));
587  RecordIterator = HashTable->data_begin();
588 }
589 
591  using namespace support;
592 
593  if (DataBuffer.getBufferSize() < 8)
594  return false;
595  uint64_t Magic =
596  endian::read<uint64_t, little, aligned>(DataBuffer.getBufferStart());
597  // Verify that it's magical.
598  return Magic == IndexedInstrProf::Magic;
599 }
600 
601 const unsigned char *
602 IndexedInstrProfReader::readSummary(IndexedInstrProf::ProfVersion Version,
603  const unsigned char *Cur) {
604  using namespace IndexedInstrProf;
605  using namespace support;
606 
608  const IndexedInstrProf::Summary *SummaryInLE =
609  reinterpret_cast<const IndexedInstrProf::Summary *>(Cur);
610  uint64_t NFields =
611  endian::byte_swap<uint64_t, little>(SummaryInLE->NumSummaryFields);
612  uint64_t NEntries =
613  endian::byte_swap<uint64_t, little>(SummaryInLE->NumCutoffEntries);
614  uint32_t SummarySize =
615  IndexedInstrProf::Summary::getSize(NFields, NEntries);
616  std::unique_ptr<IndexedInstrProf::Summary> SummaryData =
617  IndexedInstrProf::allocSummary(SummarySize);
618 
619  const uint64_t *Src = reinterpret_cast<const uint64_t *>(SummaryInLE);
620  uint64_t *Dst = reinterpret_cast<uint64_t *>(SummaryData.get());
621  for (unsigned I = 0; I < SummarySize / sizeof(uint64_t); I++)
622  Dst[I] = endian::byte_swap<uint64_t, little>(Src[I]);
623 
624  SummaryEntryVector DetailedSummary;
625  for (unsigned I = 0; I < SummaryData->NumCutoffEntries; I++) {
626  const IndexedInstrProf::Summary::Entry &Ent = SummaryData->getEntry(I);
627  DetailedSummary.emplace_back((uint32_t)Ent.Cutoff, Ent.MinBlockCount,
628  Ent.NumBlocks);
629  }
630  // initialize InstrProfSummary using the SummaryData from disk.
631  this->Summary = llvm::make_unique<ProfileSummary>(
632  ProfileSummary::PSK_Instr, DetailedSummary,
633  SummaryData->get(Summary::TotalBlockCount),
634  SummaryData->get(Summary::MaxBlockCount),
635  SummaryData->get(Summary::MaxInternalBlockCount),
636  SummaryData->get(Summary::MaxFunctionCount),
637  SummaryData->get(Summary::TotalNumBlocks),
638  SummaryData->get(Summary::TotalNumFunctions));
639  return Cur + SummarySize;
640  } else {
641  // For older version of profile data, we need to compute on the fly:
642  using namespace IndexedInstrProf;
643 
645  // FIXME: This only computes an empty summary. Need to call addRecord for
646  // all NamedInstrProfRecords to get the correct summary.
647  this->Summary = Builder.getSummary();
648  return Cur;
649  }
650 }
651 
653  using namespace support;
654 
655  const unsigned char *Start =
656  (const unsigned char *)DataBuffer->getBufferStart();
657  const unsigned char *Cur = Start;
658  if ((const unsigned char *)DataBuffer->getBufferEnd() - Cur < 24)
660 
661  auto *Header = reinterpret_cast<const IndexedInstrProf::Header *>(Cur);
662  Cur += sizeof(IndexedInstrProf::Header);
663 
664  // Check the magic number.
665  uint64_t Magic = endian::byte_swap<uint64_t, little>(Header->Magic);
666  if (Magic != IndexedInstrProf::Magic)
668 
669  // Read the version.
670  uint64_t FormatVersion = endian::byte_swap<uint64_t, little>(Header->Version);
671  if (GET_VERSION(FormatVersion) >
674 
675  Cur = readSummary((IndexedInstrProf::ProfVersion)FormatVersion, Cur);
676 
677  // Read the hash type and start offset.
679  endian::byte_swap<uint64_t, little>(Header->HashType));
680  if (HashType > IndexedInstrProf::HashT::Last)
682 
683  uint64_t HashOffset = endian::byte_swap<uint64_t, little>(Header->HashOffset);
684 
685  // The rest of the file is an on disk hash table.
686  InstrProfReaderIndexBase *IndexPtr = nullptr;
688  Start + HashOffset, Cur, Start, HashType, FormatVersion);
689  Index.reset(IndexPtr);
690  return success();
691 }
692 
694  if (Symtab.get())
695  return *Symtab.get();
696 
697  std::unique_ptr<InstrProfSymtab> NewSymtab = make_unique<InstrProfSymtab>();
698  if (Error E = Index->populateSymtab(*NewSymtab.get())) {
700  }
701 
702  Symtab = std::move(NewSymtab);
703  return *Symtab.get();
704 }
705 
708  uint64_t FuncHash) {
710  Error Err = Index->getRecords(FuncName, Data);
711  if (Err)
712  return std::move(Err);
713  // Found it. Look for counters with the right hash.
714  for (unsigned I = 0, E = Data.size(); I < E; ++I) {
715  // Check for a match and fill the vector if there is one.
716  if (Data[I].Hash == FuncHash) {
717  return std::move(Data[I]);
718  }
719  }
721 }
722 
724  uint64_t FuncHash,
725  std::vector<uint64_t> &Counts) {
726  Expected<InstrProfRecord> Record = getInstrProfRecord(FuncName, FuncHash);
727  if (Error E = Record.takeError())
728  return error(std::move(E));
729 
730  Counts = Record.get().Counts;
731  return success();
732 }
733 
736 
737  Error E = Index->getRecords(Data);
738  if (E)
739  return error(std::move(E));
740 
741  Record = Data[RecordIndex++];
742  if (RecordIndex >= Data.size()) {
743  Index->advanceToNextKey();
744  RecordIndex = 0;
745  }
746  return success();
747 }
#define VP_READ_ADVANCE(Val)
Represents either an error or a value T.
Definition: ErrorOr.h:69
A symbol table used for function PGO name look-up with keys (such as pointers, md5hash values) to the...
Definition: InstrProf.h:411
Error readHeader() override
Read the header. Required before reading first record.
static uint32_t getSize(uint32_t NumSumFields, uint32_t NumCutoffEntries)
Definition: InstrProf.h:952
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
uint64_t MinBlockCount
The minimum execution count for this percentile.
Definition: InstrProf.h:918
LLVM_NODISCARD bool equals_lower(StringRef RHS) const
equals_lower - Check for string equality, ignoring case.
Definition: StringRef.h:176
void addValueData(uint32_t ValueKind, uint32_t Site, InstrProfValueData *VData, uint32_t N, InstrProfSymtab *SymTab)
Add ValueData for ValueKind at value Site.
Definition: InstrProf.cpp:588
static bool hasFormat(const MemoryBuffer &DataBuffer)
Return true if the given buffer is in an indexed instrprof format.
static instrprof_error take(Error E)
Consume an Error and return the raw enum value contained within it.
Definition: InstrProf.h:324
static bool isExternalSymbol(const StringRef &Symbol)
True if Symbol is the value used to represent external symbols.
Definition: InstrProf.h:508
Error error(instrprof_error Err)
Set the current error and return same.
std::unique_ptr< Summary > allocSummary(uint32_t TotalSize)
Definition: InstrProf.h:992
static const ArrayRef< uint32_t > DefaultCutoffs
A vector of useful cutoff values for detailed summary.
Definition: ProfileCommon.h:65
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:908
InstrProfSymtab & getSymtab() override
Return the PGO symtab.
size_t getBufferSize() const
Definition: MemoryBuffer.h:63
Error takeError()
Take ownership of the stored error.
Definition: Error.h:545
InstrProfLookupTrait::offset_type offset_type
Error readNextRecord(NamedInstrProfRecord &Record) override
Read a single record.
void reserveSites(uint32_t ValueKind, uint32_t NumValueSites)
Reserve space for NumValueSites sites.
Definition: InstrProf.h:831
Error readHeader() override
Read the header.
data_type ReadData(StringRef K, const unsigned char *D, offset_type N)
const uint64_t Magic
Definition: InstrProf.h:871
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
static Expected< std::unique_ptr< InstrProfReader > > create(const Twine &Path)
Factory method to create an appropriately typed reader for the given instrprof file.
const HashT HashType
Definition: InstrProf.h:897
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:451
static StringRef getName(Value *V)
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
void mapAddress(uint64_t Addr, uint64_t MD5Val)
Map a function address to its name&#39;s MD5 hash.
Definition: InstrProf.h:486
static bool hasFormat(const MemoryBuffer &Buffer)
Return true if the given buffer is in text instrprof format.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
const uint64_t Version
Definition: InstrProf.h:1008
Reader for the simple text based instrprof format.
uint64_t NumBlocks
Number of blocks >= the minumum execution count.
Definition: InstrProf.h:919
static bool hasFormat(const MemoryBuffer &DataBuffer)
auto count(R &&Range, const E &Element) -> typename std::iterator_traits< decltype(adl_begin(Range))>::difference_type
Wrapper function around std::count to count the number of times an element Element occurs in the give...
Definition: STLExtras.h:974
InstrProfLookupTrait::data_type data_type
hash_value_type ComputeHash(StringRef K)
ArrayRef< NamedInstrProfRecord > data_type
Base class and interface for reading profiling data of any known instrprof format.
uint64_t Cutoff
The required percentile of total execution count.
Definition: InstrProf.h:916
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:78
ValueKind
Value kinds.
std::error_code getError() const
Definition: ErrorOr.h:172
bool readValueProfilingData(const unsigned char *&D, const unsigned char *const End)
std::unique_ptr< InstrProfSymtab > Symtab
uint64_t ComputeHash(StringRef K)
Definition: InstrProf.h:899
Error getRecords(ArrayRef< NamedInstrProfRecord > &Data) override
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:970
#define CHECK_LINE_END(Line)
#define READ_NUM(Str, Dst)
void clearValueData()
Clear value data entries.
Definition: InstrProf.h:705
static const char *const Magic
Definition: Archive.cpp:42
static Expected< std::unique_ptr< MemoryBuffer > > setupMemoryBuffer(const Twine &Path)
Error create(object::SectionRef &Section)
Create InstrProfSymtab from an object file section which contains function PGO names.
static ErrorSuccess success()
Create a success value.
Definition: Error.h:321
Error readNextRecord(NamedInstrProfRecord &Record) override
Read a single record.
RawInstrProfReader< uint32_t > RawInstrProfReader32
std::unique_ptr< ProfileSummary > getSummary()
A file format agnostic iterator over profiling data.
Reader for the raw instrprof binary format from runtime.
reference get()
Returns a reference to the stored T value.
Definition: Error.h:525
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
RawInstrProfReader< uint64_t > RawInstrProfReader64
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:42
InstrProfReaderIndex(const unsigned char *Buckets, const unsigned char *const Payload, const unsigned char *const Base, IndexedInstrProf::HashT HashType, uint64_t Version)
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:924
Error readNextRecord(NamedInstrProfRecord &Record) override
Read a single record.
iterator begin() const
Definition: StringRef.h:106
unsigned char getSwappedBytes(unsigned char C)
Definition: SwapByteOrder.h:72
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileOrSTDIN(const Twine &Filename, int64_t FileSize=-1, bool RequiresNullTerminator=true)
Open the specified file as a MemoryBuffer, or open stdin if the Filename is "-".
std::vector< uint64_t > Counts
Definition: InstrProf.h:623
Error readHeader() override
Read the file header.
virtual Error readHeader()=0
Read the header. Required before reading first record.
Profiling information for a single function.
Definition: InstrProf.h:622
Expected< InstrProfRecord > getInstrProfRecord(StringRef FuncName, uint64_t FuncHash)
Return the NamedInstrProfRecord associated with FuncName and FuncHash.
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
const char * getBufferStart() const
Definition: MemoryBuffer.h:61
Provides ErrorOr<T> smart pointer.
LLVM Value Representation.
Definition: Value.h:73
static Expected< std::unique_ptr< IndexedInstrProfReader > > create(const Twine &Path)
Factory method to create an indexed reader.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Reader for the indexed binary instrprof format.
std::vector< ProfileSummaryEntry > SummaryEntryVector
const uint64_t Version
Definition: InstrProf.h:895
void Clear()
Clear value data entries and edge counters.
Definition: InstrProf.h:699
reference get()
Definition: ErrorOr.h:169
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:144
Error success()
Clear the current error and return a successful one.
Error getFunctionCounts(StringRef FuncName, uint64_t FuncHash, std::vector< uint64_t > &Counts)
Fill Counts with the profile data for the given function name.
static Error initializeReader(InstrProfReader &Reader)