LLVM  4.0.0
SampleProfReader.cpp
Go to the documentation of this file.
1 //===- SampleProfReader.cpp - Read LLVM sample profile data ---------------===//
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 implements the class that reads LLVM sample profiles. It
11 // supports three file formats: text, binary and gcov.
12 //
13 // The textual representation is useful for debugging and testing purposes. The
14 // binary representation is more compact, resulting in smaller file sizes.
15 //
16 // The gcov encoding is the one generated by GCC's AutoFDO profile creation
17 // tool (https://github.com/google/autofdo)
18 //
19 // All three encodings can be used interchangeably as an input sample profile.
20 //
21 //===----------------------------------------------------------------------===//
22 
24 #include "llvm/ADT/DenseMap.h"
25 #include "llvm/ADT/STLExtras.h"
26 #include "llvm/Support/Debug.h"
27 #include "llvm/Support/ErrorOr.h"
28 #include "llvm/Support/LEB128.h"
31 
32 using namespace llvm::sampleprof;
33 using namespace llvm;
34 
35 /// \brief Dump the function profile for \p FName.
36 ///
37 /// \param FName Name of the function to print.
38 /// \param OS Stream to emit the output to.
40  raw_ostream &OS) {
41  OS << "Function: " << FName << ": " << Profiles[FName];
42 }
43 
44 /// \brief Dump all the function profiles found on stream \p OS.
46  for (const auto &I : Profiles)
47  dumpFunctionProfile(I.getKey(), OS);
48 }
49 
50 /// \brief Parse \p Input as function head.
51 ///
52 /// Parse one line of \p Input, and update function name in \p FName,
53 /// function's total sample count in \p NumSamples, function's entry
54 /// count in \p NumHeadSamples.
55 ///
56 /// \returns true if parsing is successful.
57 static bool ParseHead(const StringRef &Input, StringRef &FName,
58  uint64_t &NumSamples, uint64_t &NumHeadSamples) {
59  if (Input[0] == ' ')
60  return false;
61  size_t n2 = Input.rfind(':');
62  size_t n1 = Input.rfind(':', n2 - 1);
63  FName = Input.substr(0, n1);
64  if (Input.substr(n1 + 1, n2 - n1 - 1).getAsInteger(10, NumSamples))
65  return false;
66  if (Input.substr(n2 + 1).getAsInteger(10, NumHeadSamples))
67  return false;
68  return true;
69 }
70 
71 /// \brief Returns true if line offset \p L is legal (only has 16 bits).
72 static bool isOffsetLegal(unsigned L) { return (L & 0xffff) == L; }
73 
74 /// \brief Parse \p Input as line sample.
75 ///
76 /// \param Input input line.
77 /// \param IsCallsite true if the line represents an inlined callsite.
78 /// \param Depth the depth of the inline stack.
79 /// \param NumSamples total samples of the line/inlined callsite.
80 /// \param LineOffset line offset to the start of the function.
81 /// \param Discriminator discriminator of the line.
82 /// \param TargetCountMap map from indirect call target to count.
83 ///
84 /// returns true if parsing is successful.
85 static bool ParseLine(const StringRef &Input, bool &IsCallsite, uint32_t &Depth,
86  uint64_t &NumSamples, uint32_t &LineOffset,
87  uint32_t &Discriminator, StringRef &CalleeName,
88  DenseMap<StringRef, uint64_t> &TargetCountMap) {
89  for (Depth = 0; Input[Depth] == ' '; Depth++)
90  ;
91  if (Depth == 0)
92  return false;
93 
94  size_t n1 = Input.find(':');
95  StringRef Loc = Input.substr(Depth, n1 - Depth);
96  size_t n2 = Loc.find('.');
97  if (n2 == StringRef::npos) {
98  if (Loc.getAsInteger(10, LineOffset) || !isOffsetLegal(LineOffset))
99  return false;
100  Discriminator = 0;
101  } else {
102  if (Loc.substr(0, n2).getAsInteger(10, LineOffset))
103  return false;
104  if (Loc.substr(n2 + 1).getAsInteger(10, Discriminator))
105  return false;
106  }
107 
108  StringRef Rest = Input.substr(n1 + 2);
109  if (Rest[0] >= '0' && Rest[0] <= '9') {
110  IsCallsite = false;
111  size_t n3 = Rest.find(' ');
112  if (n3 == StringRef::npos) {
113  if (Rest.getAsInteger(10, NumSamples))
114  return false;
115  } else {
116  if (Rest.substr(0, n3).getAsInteger(10, NumSamples))
117  return false;
118  }
119  while (n3 != StringRef::npos) {
120  n3 += Rest.substr(n3).find_first_not_of(' ');
121  Rest = Rest.substr(n3);
122  n3 = Rest.find(' ');
123  StringRef pair = Rest;
124  if (n3 != StringRef::npos) {
125  pair = Rest.substr(0, n3);
126  }
127  size_t n4 = pair.find(':');
128  uint64_t count;
129  if (pair.substr(n4 + 1).getAsInteger(10, count))
130  return false;
131  TargetCountMap[pair.substr(0, n4)] = count;
132  }
133  } else {
134  IsCallsite = true;
135  size_t n3 = Rest.find_last_of(':');
136  CalleeName = Rest.substr(0, n3);
137  if (Rest.substr(n3 + 1).getAsInteger(10, NumSamples))
138  return false;
139  }
140  return true;
141 }
142 
143 /// \brief Load samples from a text file.
144 ///
145 /// See the documentation at the top of the file for an explanation of
146 /// the expected format.
147 ///
148 /// \returns true if the file was loaded successfully, false otherwise.
149 std::error_code SampleProfileReaderText::read() {
150  line_iterator LineIt(*Buffer, /*SkipBlanks=*/true, '#');
152 
153  InlineCallStack InlineStack;
154 
155  for (; !LineIt.is_at_eof(); ++LineIt) {
156  if ((*LineIt)[(*LineIt).find_first_not_of(' ')] == '#')
157  continue;
158  // Read the header of each function.
159  //
160  // Note that for function identifiers we are actually expecting
161  // mangled names, but we may not always get them. This happens when
162  // the compiler decides not to emit the function (e.g., it was inlined
163  // and removed). In this case, the binary will not have the linkage
164  // name for the function, so the profiler will emit the function's
165  // unmangled name, which may contain characters like ':' and '>' in its
166  // name (member functions, templates, etc).
167  //
168  // The only requirement we place on the identifier, then, is that it
169  // should not begin with a number.
170  if ((*LineIt)[0] != ' ') {
171  uint64_t NumSamples, NumHeadSamples;
172  StringRef FName;
173  if (!ParseHead(*LineIt, FName, NumSamples, NumHeadSamples)) {
174  reportError(LineIt.line_number(),
175  "Expected 'mangled_name:NUM:NUM', found " + *LineIt);
177  }
178  Profiles[FName] = FunctionSamples();
179  FunctionSamples &FProfile = Profiles[FName];
180  FProfile.setName(FName);
181  MergeResult(Result, FProfile.addTotalSamples(NumSamples));
182  MergeResult(Result, FProfile.addHeadSamples(NumHeadSamples));
183  InlineStack.clear();
184  InlineStack.push_back(&FProfile);
185  } else {
186  uint64_t NumSamples;
187  StringRef FName;
188  DenseMap<StringRef, uint64_t> TargetCountMap;
189  bool IsCallsite;
190  uint32_t Depth, LineOffset, Discriminator;
191  if (!ParseLine(*LineIt, IsCallsite, Depth, NumSamples, LineOffset,
192  Discriminator, FName, TargetCountMap)) {
193  reportError(LineIt.line_number(),
194  "Expected 'NUM[.NUM]: NUM[ mangled_name:NUM]*', found " +
195  *LineIt);
197  }
198  if (IsCallsite) {
199  while (InlineStack.size() > Depth) {
200  InlineStack.pop_back();
201  }
202  FunctionSamples &FSamples = InlineStack.back()->functionSamplesAt(
203  LineLocation(LineOffset, Discriminator));
204  FSamples.setName(FName);
205  MergeResult(Result, FSamples.addTotalSamples(NumSamples));
206  InlineStack.push_back(&FSamples);
207  } else {
208  while (InlineStack.size() > Depth) {
209  InlineStack.pop_back();
210  }
211  FunctionSamples &FProfile = *InlineStack.back();
212  for (const auto &name_count : TargetCountMap) {
213  MergeResult(Result, FProfile.addCalledTargetSamples(
214  LineOffset, Discriminator, name_count.first,
215  name_count.second));
216  }
217  MergeResult(Result, FProfile.addBodySamples(LineOffset, Discriminator,
218  NumSamples));
219  }
220  }
221  }
222  if (Result == sampleprof_error::success)
223  computeSummary();
224 
225  return Result;
226 }
227 
229  bool result = false;
230 
231  // Check that the first non-comment line is a valid function header.
232  line_iterator LineIt(Buffer, /*SkipBlanks=*/true, '#');
233  if (!LineIt.is_at_eof()) {
234  if ((*LineIt)[0] != ' ') {
235  uint64_t NumSamples, NumHeadSamples;
236  StringRef FName;
237  result = ParseHead(*LineIt, FName, NumSamples, NumHeadSamples);
238  }
239  }
240 
241  return result;
242 }
243 
245  unsigned NumBytesRead = 0;
246  std::error_code EC;
247  uint64_t Val = decodeULEB128(Data, &NumBytesRead);
248 
249  if (Val > std::numeric_limits<T>::max())
251  else if (Data + NumBytesRead > End)
253  else
255 
256  if (EC) {
257  reportError(0, EC.message());
258  return EC;
259  }
260 
261  Data += NumBytesRead;
262  return static_cast<T>(Val);
263 }
264 
266  std::error_code EC;
267  StringRef Str(reinterpret_cast<const char *>(Data));
268  if (Data + Str.size() + 1 > End) {
270  reportError(0, EC.message());
271  return EC;
272  }
273 
274  Data += Str.size() + 1;
275  return Str;
276 }
277 
279  std::error_code EC;
280  auto Idx = readNumber<uint32_t>();
281  if (std::error_code EC = Idx.getError())
282  return EC;
283  if (*Idx >= NameTable.size())
285  return NameTable[*Idx];
286 }
287 
288 std::error_code
290  auto NumSamples = readNumber<uint64_t>();
291  if (std::error_code EC = NumSamples.getError())
292  return EC;
293  FProfile.addTotalSamples(*NumSamples);
294 
295  // Read the samples in the body.
296  auto NumRecords = readNumber<uint32_t>();
297  if (std::error_code EC = NumRecords.getError())
298  return EC;
299 
300  for (uint32_t I = 0; I < *NumRecords; ++I) {
301  auto LineOffset = readNumber<uint64_t>();
302  if (std::error_code EC = LineOffset.getError())
303  return EC;
304 
305  if (!isOffsetLegal(*LineOffset)) {
306  return std::error_code();
307  }
308 
309  auto Discriminator = readNumber<uint64_t>();
310  if (std::error_code EC = Discriminator.getError())
311  return EC;
312 
313  auto NumSamples = readNumber<uint64_t>();
314  if (std::error_code EC = NumSamples.getError())
315  return EC;
316 
317  auto NumCalls = readNumber<uint32_t>();
318  if (std::error_code EC = NumCalls.getError())
319  return EC;
320 
321  for (uint32_t J = 0; J < *NumCalls; ++J) {
322  auto CalledFunction(readStringFromTable());
323  if (std::error_code EC = CalledFunction.getError())
324  return EC;
325 
326  auto CalledFunctionSamples = readNumber<uint64_t>();
327  if (std::error_code EC = CalledFunctionSamples.getError())
328  return EC;
329 
330  FProfile.addCalledTargetSamples(*LineOffset, *Discriminator,
331  *CalledFunction, *CalledFunctionSamples);
332  }
333 
334  FProfile.addBodySamples(*LineOffset, *Discriminator, *NumSamples);
335  }
336 
337  // Read all the samples for inlined function calls.
338  auto NumCallsites = readNumber<uint32_t>();
339  if (std::error_code EC = NumCallsites.getError())
340  return EC;
341 
342  for (uint32_t J = 0; J < *NumCallsites; ++J) {
343  auto LineOffset = readNumber<uint64_t>();
344  if (std::error_code EC = LineOffset.getError())
345  return EC;
346 
347  auto Discriminator = readNumber<uint64_t>();
348  if (std::error_code EC = Discriminator.getError())
349  return EC;
350 
351  auto FName(readStringFromTable());
352  if (std::error_code EC = FName.getError())
353  return EC;
354 
355  FunctionSamples &CalleeProfile =
356  FProfile.functionSamplesAt(LineLocation(*LineOffset, *Discriminator));
357  CalleeProfile.setName(*FName);
358  if (std::error_code EC = readProfile(CalleeProfile))
359  return EC;
360  }
361 
363 }
364 
366  while (!at_eof()) {
367  auto NumHeadSamples = readNumber<uint64_t>();
368  if (std::error_code EC = NumHeadSamples.getError())
369  return EC;
370 
371  auto FName(readStringFromTable());
372  if (std::error_code EC = FName.getError())
373  return EC;
374 
375  Profiles[*FName] = FunctionSamples();
376  FunctionSamples &FProfile = Profiles[*FName];
377  FProfile.setName(*FName);
378 
379  FProfile.addHeadSamples(*NumHeadSamples);
380 
381  if (std::error_code EC = readProfile(FProfile))
382  return EC;
383  }
384 
386 }
387 
389  Data = reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
390  End = Data + Buffer->getBufferSize();
391 
392  // Read and check the magic identifier.
393  auto Magic = readNumber<uint64_t>();
394  if (std::error_code EC = Magic.getError())
395  return EC;
396  else if (*Magic != SPMagic())
398 
399  // Read the version number.
400  auto Version = readNumber<uint64_t>();
401  if (std::error_code EC = Version.getError())
402  return EC;
403  else if (*Version != SPVersion())
405 
406  if (std::error_code EC = readSummary())
407  return EC;
408 
409  // Read the name table.
410  auto Size = readNumber<uint32_t>();
411  if (std::error_code EC = Size.getError())
412  return EC;
413  NameTable.reserve(*Size);
414  for (uint32_t I = 0; I < *Size; ++I) {
415  auto Name(readString());
416  if (std::error_code EC = Name.getError())
417  return EC;
418  NameTable.push_back(*Name);
419  }
420 
422 }
423 
424 std::error_code SampleProfileReaderBinary::readSummaryEntry(
425  std::vector<ProfileSummaryEntry> &Entries) {
426  auto Cutoff = readNumber<uint64_t>();
427  if (std::error_code EC = Cutoff.getError())
428  return EC;
429 
430  auto MinBlockCount = readNumber<uint64_t>();
431  if (std::error_code EC = MinBlockCount.getError())
432  return EC;
433 
434  auto NumBlocks = readNumber<uint64_t>();
435  if (std::error_code EC = NumBlocks.getError())
436  return EC;
437 
438  Entries.emplace_back(*Cutoff, *MinBlockCount, *NumBlocks);
440 }
441 
442 std::error_code SampleProfileReaderBinary::readSummary() {
443  auto TotalCount = readNumber<uint64_t>();
444  if (std::error_code EC = TotalCount.getError())
445  return EC;
446 
447  auto MaxBlockCount = readNumber<uint64_t>();
448  if (std::error_code EC = MaxBlockCount.getError())
449  return EC;
450 
451  auto MaxFunctionCount = readNumber<uint64_t>();
452  if (std::error_code EC = MaxFunctionCount.getError())
453  return EC;
454 
455  auto NumBlocks = readNumber<uint64_t>();
456  if (std::error_code EC = NumBlocks.getError())
457  return EC;
458 
459  auto NumFunctions = readNumber<uint64_t>();
460  if (std::error_code EC = NumFunctions.getError())
461  return EC;
462 
463  auto NumSummaryEntries = readNumber<uint64_t>();
464  if (std::error_code EC = NumSummaryEntries.getError())
465  return EC;
466 
467  std::vector<ProfileSummaryEntry> Entries;
468  for (unsigned i = 0; i < *NumSummaryEntries; i++) {
469  std::error_code EC = readSummaryEntry(Entries);
470  if (EC != sampleprof_error::success)
471  return EC;
472  }
473  Summary = llvm::make_unique<ProfileSummary>(
474  ProfileSummary::PSK_Sample, Entries, *TotalCount, *MaxBlockCount, 0,
475  *MaxFunctionCount, *NumBlocks, *NumFunctions);
476 
478 }
479 
481  const uint8_t *Data =
482  reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
483  uint64_t Magic = decodeULEB128(Data);
484  return Magic == SPMagic();
485 }
486 
488  uint32_t dummy;
489  if (!GcovBuffer.readInt(dummy))
492 }
493 
495  if (sizeof(T) <= sizeof(uint32_t)) {
496  uint32_t Val;
497  if (GcovBuffer.readInt(Val) && Val <= std::numeric_limits<T>::max())
498  return static_cast<T>(Val);
499  } else if (sizeof(T) <= sizeof(uint64_t)) {
500  uint64_t Val;
501  if (GcovBuffer.readInt64(Val) && Val <= std::numeric_limits<T>::max())
502  return static_cast<T>(Val);
503  }
504 
505  std::error_code EC = sampleprof_error::malformed;
506  reportError(0, EC.message());
507  return EC;
508 }
509 
511  StringRef Str;
512  if (!GcovBuffer.readString(Str))
514  return Str;
515 }
516 
518  // Read the magic identifier.
519  if (!GcovBuffer.readGCDAFormat())
521 
522  // Read the version number. Note - the GCC reader does not validate this
523  // version, but the profile creator generates v704.
524  GCOV::GCOVVersion version;
525  if (!GcovBuffer.readGCOVVersion(version))
527 
528  if (version != GCOV::V704)
530 
531  // Skip the empty integer.
532  if (std::error_code EC = skipNextWord())
533  return EC;
534 
536 }
537 
539  uint32_t Tag;
540  if (!GcovBuffer.readInt(Tag))
542 
543  if (Tag != Expected)
545 
546  if (std::error_code EC = skipNextWord())
547  return EC;
548 
550 }
551 
553  if (std::error_code EC = readSectionTag(GCOVTagAFDOFileNames))
554  return EC;
555 
556  uint32_t Size;
557  if (!GcovBuffer.readInt(Size))
559 
560  for (uint32_t I = 0; I < Size; ++I) {
561  StringRef Str;
562  if (!GcovBuffer.readString(Str))
564  Names.push_back(Str);
565  }
566 
568 }
569 
571  if (std::error_code EC = readSectionTag(GCOVTagAFDOFunction))
572  return EC;
573 
574  uint32_t NumFunctions;
575  if (!GcovBuffer.readInt(NumFunctions))
577 
578  InlineCallStack Stack;
579  for (uint32_t I = 0; I < NumFunctions; ++I)
580  if (std::error_code EC = readOneFunctionProfile(Stack, true, 0))
581  return EC;
582 
583  computeSummary();
585 }
586 
588  const InlineCallStack &InlineStack, bool Update, uint32_t Offset) {
589  uint64_t HeadCount = 0;
590  if (InlineStack.size() == 0)
591  if (!GcovBuffer.readInt64(HeadCount))
593 
594  uint32_t NameIdx;
595  if (!GcovBuffer.readInt(NameIdx))
597 
598  StringRef Name(Names[NameIdx]);
599 
600  uint32_t NumPosCounts;
601  if (!GcovBuffer.readInt(NumPosCounts))
603 
604  uint32_t NumCallsites;
605  if (!GcovBuffer.readInt(NumCallsites))
607 
608  FunctionSamples *FProfile = nullptr;
609  if (InlineStack.size() == 0) {
610  // If this is a top function that we have already processed, do not
611  // update its profile again. This happens in the presence of
612  // function aliases. Since these aliases share the same function
613  // body, there will be identical replicated profiles for the
614  // original function. In this case, we simply not bother updating
615  // the profile of the original function.
616  FProfile = &Profiles[Name];
617  FProfile->addHeadSamples(HeadCount);
618  if (FProfile->getTotalSamples() > 0)
619  Update = false;
620  } else {
621  // Otherwise, we are reading an inlined instance. The top of the
622  // inline stack contains the profile of the caller. Insert this
623  // callee in the caller's CallsiteMap.
624  FunctionSamples *CallerProfile = InlineStack.front();
625  uint32_t LineOffset = Offset >> 16;
626  uint32_t Discriminator = Offset & 0xffff;
627  FProfile = &CallerProfile->functionSamplesAt(
628  LineLocation(LineOffset, Discriminator));
629  }
630  FProfile->setName(Name);
631 
632  for (uint32_t I = 0; I < NumPosCounts; ++I) {
634  if (!GcovBuffer.readInt(Offset))
636 
637  uint32_t NumTargets;
638  if (!GcovBuffer.readInt(NumTargets))
640 
641  uint64_t Count;
642  if (!GcovBuffer.readInt64(Count))
644 
645  // The line location is encoded in the offset as:
646  // high 16 bits: line offset to the start of the function.
647  // low 16 bits: discriminator.
648  uint32_t LineOffset = Offset >> 16;
649  uint32_t Discriminator = Offset & 0xffff;
650 
651  InlineCallStack NewStack;
652  NewStack.push_back(FProfile);
653  NewStack.insert(NewStack.end(), InlineStack.begin(), InlineStack.end());
654  if (Update) {
655  // Walk up the inline stack, adding the samples on this line to
656  // the total sample count of the callers in the chain.
657  for (auto CallerProfile : NewStack)
658  CallerProfile->addTotalSamples(Count);
659 
660  // Update the body samples for the current profile.
661  FProfile->addBodySamples(LineOffset, Discriminator, Count);
662  }
663 
664  // Process the list of functions called at an indirect call site.
665  // These are all the targets that a function pointer (or virtual
666  // function) resolved at runtime.
667  for (uint32_t J = 0; J < NumTargets; J++) {
668  uint32_t HistVal;
669  if (!GcovBuffer.readInt(HistVal))
671 
672  if (HistVal != HIST_TYPE_INDIR_CALL_TOPN)
674 
675  uint64_t TargetIdx;
676  if (!GcovBuffer.readInt64(TargetIdx))
678  StringRef TargetName(Names[TargetIdx]);
679 
680  uint64_t TargetCount;
681  if (!GcovBuffer.readInt64(TargetCount))
683 
684  if (Update) {
685  FunctionSamples &TargetProfile = Profiles[TargetName];
686  TargetProfile.addCalledTargetSamples(LineOffset, Discriminator,
687  TargetName, TargetCount);
688  }
689  }
690  }
691 
692  // Process all the inlined callers into the current function. These
693  // are all the callsites that were inlined into this function.
694  for (uint32_t I = 0; I < NumCallsites; I++) {
695  // The offset is encoded as:
696  // high 16 bits: line offset to the start of the function.
697  // low 16 bits: discriminator.
699  if (!GcovBuffer.readInt(Offset))
701  InlineCallStack NewStack;
702  NewStack.push_back(FProfile);
703  NewStack.insert(NewStack.end(), InlineStack.begin(), InlineStack.end());
704  if (std::error_code EC = readOneFunctionProfile(NewStack, Update, Offset))
705  return EC;
706  }
707 
709 }
710 
711 /// \brief Read a GCC AutoFDO profile.
712 ///
713 /// This format is generated by the Linux Perf conversion tool at
714 /// https://github.com/google/autofdo.
715 std::error_code SampleProfileReaderGCC::read() {
716  // Read the string table.
717  if (std::error_code EC = readNameTable())
718  return EC;
719 
720  // Read the source profile.
721  if (std::error_code EC = readFunctionProfiles())
722  return EC;
723 
725 }
726 
728  StringRef Magic(reinterpret_cast<const char *>(Buffer.getBufferStart()));
729  return Magic == "adcg*704";
730 }
731 
732 /// \brief Prepare a memory buffer for the contents of \p Filename.
733 ///
734 /// \returns an error code indicating the status of the buffer.
736 setupMemoryBuffer(const Twine &Filename) {
737  auto BufferOrErr = MemoryBuffer::getFileOrSTDIN(Filename);
738  if (std::error_code EC = BufferOrErr.getError())
739  return EC;
740  auto Buffer = std::move(BufferOrErr.get());
741 
742  // Sanity check the file.
743  if (Buffer->getBufferSize() > std::numeric_limits<uint32_t>::max())
745 
746  return std::move(Buffer);
747 }
748 
749 /// \brief Create a sample profile reader based on the format of the input file.
750 ///
751 /// \param Filename The file to open.
752 ///
753 /// \param Reader The reader to instantiate according to \p Filename's format.
754 ///
755 /// \param C The LLVM context to use to emit diagnostics.
756 ///
757 /// \returns an error code indicating the status of the created reader.
760  auto BufferOrError = setupMemoryBuffer(Filename);
761  if (std::error_code EC = BufferOrError.getError())
762  return EC;
763  return create(BufferOrError.get(), C);
764 }
765 
766 /// \brief Create a sample profile reader based on the format of the input data.
767 ///
768 /// \param B The memory buffer to create the reader from (assumes ownership).
769 ///
770 /// \param Reader The reader to instantiate according to \p Filename's format.
771 ///
772 /// \param C The LLVM context to use to emit diagnostics.
773 ///
774 /// \returns an error code indicating the status of the created reader.
776 SampleProfileReader::create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C) {
777  std::unique_ptr<SampleProfileReader> Reader;
779  Reader.reset(new SampleProfileReaderBinary(std::move(B), C));
781  Reader.reset(new SampleProfileReaderGCC(std::move(B), C));
783  Reader.reset(new SampleProfileReaderText(std::move(B), C));
784  else
786 
787  if (std::error_code EC = Reader->readHeader())
788  return EC;
789 
790  return std::move(Reader);
791 }
792 
793 // For text and GCC file formats, we compute the summary after reading the
794 // profile. Binary format has the profile summary in its header.
797  for (const auto &I : Profiles) {
798  const FunctionSamples &Profile = I.second;
799  Builder.addRecord(Profile);
800  }
801  Summary = Builder.getSummary();
802 }
MachineLoop * L
std::enable_if< std::numeric_limits< T >::is_signed, bool >::type getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:494
void push_back(const T &Elt)
Definition: SmallVector.h:211
Represents either an error or a value T.
Definition: ErrorOr.h:68
const char * getBufferStart() const
Definition: MemoryBuffer.h:55
size_t i
int64_t line_number() const
Return the current line number. May return any number at EOF.
Definition: LineIterator.h:56
std::error_code read() override
Read sample profiles from the associated file.
std::error_code readHeader() override
Read and validate the file header.
static ErrorOr< std::unique_ptr< SampleProfileReader > > create(const Twine &Filename, LLVMContext &C)
Create a sample profile reader appropriate to the file format.
std::error_code read() override
Read sample profiles from the associated file.
A forward iterator which reads text lines from a buffer.
Definition: LineIterator.h:32
static const ArrayRef< uint32_t > DefaultCutoffs
A vector of useful cutoff values for detailed summary.
Definition: ProfileCommon.h:66
std::error_code readProfile(FunctionSamples &FProfile)
Read the contents of the given profile instance.
static bool hasFormat(const MemoryBuffer &Buffer)
Return true if Buffer is in the format supported by this class.
Representation of the samples collected for a function.
Definition: SampleProf.h:181
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
Tagged union holding either a T or a Error.
static bool ParseHead(const StringRef &Input, StringRef &FName, uint64_t &NumSamples, uint64_t &NumHeadSamples)
Parse Input as function head.
void setName(StringRef FunctionName)
Set the name of the function.
Definition: SampleProf.h:293
static bool hasFormat(const MemoryBuffer &Buffer)
Return true if Buffer is in the format supported by this class.
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
auto count(R &&Range, const E &Element) -> typename std::iterator_traits< decltype(std::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:791
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:135
static uint64_t SPVersion()
Definition: SampleProf.h:77
static bool ParseLine(const StringRef &Input, bool &IsCallsite, uint32_t &Depth, uint64_t &NumSamples, uint32_t &LineOffset, uint32_t &Discriminator, StringRef &CalleeName, DenseMap< StringRef, uint64_t > &TargetCountMap)
Parse Input as line sample.
uint64_t decodeULEB128(const uint8_t *p, unsigned *n=nullptr)
Utility function to decode a ULEB128 value.
Definition: LEB128.h:80
std::error_code readOneFunctionProfile(const InlineCallStack &InlineStack, bool Update, uint32_t Offset)
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:295
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:48
sampleprof_error
Definition: SampleProf.h:31
sampleprof_error addBodySamples(uint32_t LineOffset, uint32_t Discriminator, uint64_t Num, uint64_t Weight=1)
Definition: SampleProf.h:200
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:115
LLVM_NODISCARD size_t find_last_of(char C, size_t From=npos) const
Find the last character in the string that is C, or npos if not found.
Definition: StringRef.h:418
ErrorOr< T > readNumber()
Read a numeric value of type T from the profile.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:587
uint32_t Offset
static const unsigned End
ErrorOr< StringRef > readString()
Read a string from the profile.
uint64_t getTotalSamples() const
Return the total number of samples collected inside the function.
Definition: SampleProf.h:258
LLVM_NODISCARD size_t find_first_not_of(char C, size_t From=0) const
Find the first character in the string that is not C or npos if not found.
Definition: StringRef.cpp:264
GCOVVersion
Definition: GCOV.h:42
void dumpFunctionProfile(StringRef FName, raw_ostream &OS=dbgs())
Print the profile for FName on stream OS.
LLVM_NODISCARD size_t rfind(char C, size_t From=npos) const
Search for the last character C in the string.
Definition: StringRef.h:357
static const char *const Magic
Definition: Archive.cpp:25
sampleprof_error addCalledTargetSamples(uint32_t LineOffset, uint32_t Discriminator, const std::string &FName, uint64_t Num, uint64_t Weight=1)
Definition: SampleProf.h:205
sampleprof_error addTotalSamples(uint64_t Num, uint64_t Weight=1)
Definition: SampleProf.h:186
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
void addRecord(const sampleprof::FunctionSamples &FS)
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:40
static bool hasFormat(const MemoryBuffer &Buffer)
Return true if Buffer is in the format supported by this class.
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:464
std::unique_ptr< ProfileSummary > getSummary()
static int reportError(const char *ProgName, Twine Msg)
Definition: Main.cpp:49
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 "-".
static uint64_t SPMagic()
Definition: SampleProf.h:70
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:119
static const size_t npos
Definition: StringRef.h:51
Represents the relative location of an instruction.
Definition: SampleProf.h:88
#define I(x, y, z)
Definition: MD5.cpp:54
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
sampleprof_error addHeadSamples(uint64_t Num, uint64_t Weight=1)
Definition: SampleProf.h:193
Provides ErrorOr<T> smart pointer.
std::error_code readSectionTag(uint32_t Expected)
Read the section tag and check that it's the same as Expected.
static ErrorOr< std::unique_ptr< MemoryBuffer > > setupMemoryBuffer(const Twine &Filename)
Prepare a memory buffer for the contents of Filename.
bool is_at_eof() const
Return true if we've reached EOF or are an "end" iterator.
Definition: LineIterator.h:50
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
ErrorOr< StringRef > readStringFromTable()
Read a string indirectly via the name table.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
std::error_code readHeader() override
Read and validate the file header.
void computeSummary()
Compute summary for this profile.
void dump(raw_ostream &OS=dbgs())
Print all the profiles on stream OS.
std::error_code read() override
Read sample profiles from the associated file.
const uint64_t Version
Definition: InstrProf.h:799
static bool isOffsetLegal(unsigned L)
Returns true if line offset L is legal (only has 16 bits).
sampleprof_error MergeResult(sampleprof_error &Accumulator, sampleprof_error Result)
Definition: SampleProf.h:49
FunctionSamples & functionSamplesAt(const LineLocation &Loc)
Return the function samples at the given callsite location.
Definition: SampleProf.h:241