1 //===- SampleProfReader.cpp - Read LLVM sample profile data ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the class that reads LLVM sample profiles. It
11 // supports two file formats: text and binary. The textual representation
12 // is useful for debugging and testing purposes. The binary representation
13 // is more compact, resulting in smaller file sizes. However, they can
14 // both be used interchangeably.
16 // NOTE: If you are making changes to the file format, please remember
17 // to document them in the Clang documentation at
18 // tools/clang/docs/UsersManual.rst.
23 // Sample profiles are written as ASCII text. The file is divided into
24 // sections, which correspond to each of the functions executed at runtime.
25 // Each section has the following format
27 // function1:total_samples:total_head_samples
28 // offset1[.discriminator]: number_of_samples [fn1:num fn2:num ... ]
29 // offset2[.discriminator]: number_of_samples [fn3:num fn4:num ... ]
31 // offsetN[.discriminator]: number_of_samples [fn5:num fn6:num ... ]
32 // offsetA[.discriminator]: fnA:num_of_total_samples
33 // offsetA1[.discriminator]: number_of_samples [fn7:num fn8:num ... ]
36 // This is a nested tree in which the identation represent the nest level
37 // of the inline stack. There is no blank line in the file. And the spacing
38 // within a single line is fixed. Additional spaces will result in an error
39 // while reading the file.
41 // Inline stack is a stack of source locations in which the top of the stack
42 // represents the leaf function, and the bottom of the stack represents the
43 // actual symbol in which the instruction belongs.
45 // Function names must be mangled in order for the profile loader to
46 // match them in the current translation unit. The two numbers in the
47 // function header specify how many total samples were accumulated in the
48 // function (first number), and the total number of samples accumulated
49 // in the prologue of the function (second number). This head sample
50 // count provides an indicator of how frequently the function is invoked.
52 // There are two types of lines in the function body.
54 // * Sampled line represents the profile information of a source location.
55 // * Callsite line represents the profile inofrmation of a callsite.
57 // Each sampled line may contain several items. Some are optional (marked
60 // a. Source line offset. This number represents the line number
61 // in the function where the sample was collected. The line number is
62 // always relative to the line where symbol of the function is
63 // defined. So, if the function has its header at line 280, the offset
64 // 13 is at line 293 in the file.
66 // Note that this offset should never be a negative number. This could
67 // happen in cases like macros. The debug machinery will register the
68 // line number at the point of macro expansion. So, if the macro was
69 // expanded in a line before the start of the function, the profile
70 // converter should emit a 0 as the offset (this means that the optimizers
71 // will not be able to associate a meaningful weight to the instructions
74 // b. [OPTIONAL] Discriminator. This is used if the sampled program
75 // was compiled with DWARF discriminator support
76 // (http://wiki.dwarfstd.org/index.php?title=Path_Discriminators).
77 // DWARF discriminators are unsigned integer values that allow the
78 // compiler to distinguish between multiple execution paths on the
79 // same source line location.
81 // For example, consider the line of code ``if (cond) foo(); else bar();``.
82 // If the predicate ``cond`` is true 80% of the time, then the edge
83 // into function ``foo`` should be considered to be taken most of the
84 // time. But both calls to ``foo`` and ``bar`` are at the same source
85 // line, so a sample count at that line is not sufficient. The
86 // compiler needs to know which part of that line is taken more
89 // This is what discriminators provide. In this case, the calls to
90 // ``foo`` and ``bar`` will be at the same line, but will have
91 // different discriminator values. This allows the compiler to correctly
92 // set edge weights into ``foo`` and ``bar``.
94 // c. Number of samples. This is an integer quantity representing the
95 // number of samples collected by the profiler at this source
98 // d. [OPTIONAL] Potential call targets and samples. If present, this
99 // line contains a call instruction. This models both direct and
100 // number of samples. For example,
102 // 130: 7 foo:3 bar:2 baz:7
104 // The above means that at relative line offset 130 there is a call
105 // instruction that calls one of ``foo()``, ``bar()`` and ``baz()``,
106 // with ``baz()`` being the relatively more frequently called target.
108 // Each callsite line may contain several items. Some are optional.
110 // a. Source line offset. This number represents the line number of the
111 // callsite that is inlined in the profiled binary.
113 // b. [OPTIONAL] Discriminator. Same as the discriminator for sampled line.
115 // c. Number of samples. This is an integer quantity representing the
116 // total number of samples collected for the inlined instance at this
118 //===----------------------------------------------------------------------===//
120 #include "llvm/ProfileData/SampleProfReader.h"
121 #include "llvm/Support/Debug.h"
122 #include "llvm/Support/ErrorOr.h"
123 #include "llvm/Support/LEB128.h"
124 #include "llvm/Support/LineIterator.h"
125 #include "llvm/Support/MemoryBuffer.h"
126 #include "llvm/ADT/DenseMap.h"
127 #include "llvm/ADT/SmallVector.h"
129 using namespace llvm::sampleprof;
130 using namespace llvm;
132 /// \brief Print the samples collected for a function on stream \p OS.
134 /// \param OS Stream to emit the output to.
135 void FunctionSamples::print(raw_ostream &OS, unsigned Indent) const {
136 OS << TotalSamples << ", " << TotalHeadSamples << ", " << BodySamples.size()
137 << " sampled lines\n";
138 for (const auto &SI : BodySamples) {
139 LineLocation Loc = SI.first;
140 const SampleRecord &Sample = SI.second;
142 OS << "line offset: " << Loc.LineOffset
143 << ", discriminator: " << Loc.Discriminator
144 << ", number of samples: " << Sample.getSamples();
145 if (Sample.hasCalls()) {
147 for (const auto &I : Sample.getCallTargets())
148 OS << " " << I.first() << ":" << I.second;
152 for (const auto &CS : CallsiteSamples) {
153 CallsiteLocation Loc = CS.first;
154 const FunctionSamples &CalleeSamples = CS.second;
156 OS << "line offset: " << Loc.LineOffset
157 << ", discriminator: " << Loc.Discriminator
158 << ", inlined callee: " << Loc.CalleeName << ": ";
159 CalleeSamples.print(OS, Indent + 2);
163 /// \brief Dump the function profile for \p FName.
165 /// \param FName Name of the function to print.
166 /// \param OS Stream to emit the output to.
167 void SampleProfileReader::dumpFunctionProfile(StringRef FName,
169 OS << "Function: " << FName << ": ";
170 Profiles[FName].print(OS);
173 /// \brief Dump all the function profiles found on stream \p OS.
174 void SampleProfileReader::dump(raw_ostream &OS) {
175 for (const auto &I : Profiles)
176 dumpFunctionProfile(I.getKey(), OS);
179 /// \brief Parse \p Input as function head.
181 /// Parse one line of \p Input, and update function name in \p FName,
182 /// function's total sample count in \p NumSamples, function's entry
183 /// count in \p NumHeadSamples.
185 /// \returns true if parsing is successful.
186 static bool ParseHead(const StringRef &Input, StringRef &FName,
187 unsigned &NumSamples, unsigned &NumHeadSamples) {
190 size_t n2 = Input.rfind(':');
191 size_t n1 = Input.rfind(':', n2 - 1);
192 FName = Input.substr(0, n1);
193 if (Input.substr(n1 + 1, n2 - n1 - 1).getAsInteger(10, NumSamples))
195 if (Input.substr(n2 + 1).getAsInteger(10, NumHeadSamples))
200 /// \brief Parse \p Input as line sample.
202 /// \param Input input line.
203 /// \param IsCallsite true if the line represents an inlined callsite.
204 /// \param Depth the depth of the inline stack.
205 /// \param NumSamples total samples of the line/inlined callsite.
206 /// \param LineOffset line offset to the start of the function.
207 /// \param Discriminator discriminator of the line.
208 /// \param TargetCountMap map from indirect call target to count.
210 /// returns true if parsing is successful.
211 static bool ParseLine(const StringRef &Input, bool &IsCallsite, unsigned &Depth,
212 unsigned &NumSamples, unsigned &LineOffset,
213 unsigned &Discriminator, StringRef &CalleeName,
214 DenseMap<StringRef, unsigned> &TargetCountMap) {
215 for (Depth = 0; Input[Depth] == ' '; Depth++)
220 size_t n1 = Input.find(':');
221 StringRef Loc = Input.substr(Depth, n1 - Depth);
222 size_t n2 = Loc.find('.');
223 if (n2 == StringRef::npos) {
224 if (Loc.getAsInteger(10, LineOffset))
228 if (Loc.substr(0, n2).getAsInteger(10, LineOffset))
230 if (Loc.substr(n2 + 1).getAsInteger(10, Discriminator))
234 StringRef Rest = Input.substr(n1 + 2);
235 if (Rest[0] >= '0' && Rest[0] <= '9') {
237 size_t n3 = Rest.find(' ');
238 if (n3 == StringRef::npos) {
239 if (Rest.getAsInteger(10, NumSamples))
242 if (Rest.substr(0, n3).getAsInteger(10, NumSamples))
245 while (n3 != StringRef::npos) {
246 n3 += Rest.substr(n3).find_first_not_of(' ');
247 Rest = Rest.substr(n3);
249 StringRef pair = Rest;
250 if (n3 != StringRef::npos) {
251 pair = Rest.substr(0, n3);
253 int n4 = pair.find(':');
255 if (pair.substr(n4 + 1).getAsInteger(10, count))
257 TargetCountMap[pair.substr(0, n4)] = count;
261 int n3 = Rest.find_last_of(':');
262 CalleeName = Rest.substr(0, n3);
263 if (Rest.substr(n3 + 1).getAsInteger(10, NumSamples))
269 /// \brief Load samples from a text file.
271 /// See the documentation at the top of the file for an explanation of
272 /// the expected format.
274 /// \returns true if the file was loaded successfully, false otherwise.
275 std::error_code SampleProfileReaderText::read() {
276 line_iterator LineIt(*Buffer, /*SkipBlanks=*/true, '#');
278 InlineCallStack InlineStack;
280 for (; !LineIt.is_at_eof(); ++LineIt) {
281 if ((*LineIt)[(*LineIt).find_first_not_of(' ')] == '#')
283 // Read the header of each function.
285 // Note that for function identifiers we are actually expecting
286 // mangled names, but we may not always get them. This happens when
287 // the compiler decides not to emit the function (e.g., it was inlined
288 // and removed). In this case, the binary will not have the linkage
289 // name for the function, so the profiler will emit the function's
290 // unmangled name, which may contain characters like ':' and '>' in its
291 // name (member functions, templates, etc).
293 // The only requirement we place on the identifier, then, is that it
294 // should not begin with a number.
295 if ((*LineIt)[0] != ' ') {
296 unsigned NumSamples, NumHeadSamples;
298 if (!ParseHead(*LineIt, FName, NumSamples, NumHeadSamples)) {
299 reportError(LineIt.line_number(),
300 "Expected 'mangled_name:NUM:NUM', found " + *LineIt);
301 return sampleprof_error::malformed;
303 Profiles[FName] = FunctionSamples();
304 FunctionSamples &FProfile = Profiles[FName];
305 FProfile.addTotalSamples(NumSamples);
306 FProfile.addHeadSamples(NumHeadSamples);
308 InlineStack.push_back(&FProfile);
312 DenseMap<StringRef, unsigned> TargetCountMap;
314 unsigned Depth, LineOffset, Discriminator;
315 if (!ParseLine(*LineIt, IsCallsite, Depth, NumSamples, LineOffset,
316 Discriminator, FName, TargetCountMap)) {
317 reportError(LineIt.line_number(),
318 "Expected 'NUM[.NUM]: NUM[ mangled_name:NUM]*', found " +
320 return sampleprof_error::malformed;
323 while (InlineStack.size() > Depth) {
324 InlineStack.pop_back();
326 FunctionSamples &FSamples = InlineStack.back()->functionSamplesAt(
327 CallsiteLocation(LineOffset, Discriminator, FName));
328 FSamples.addTotalSamples(NumSamples);
329 InlineStack.push_back(&FSamples);
331 while (InlineStack.size() > Depth) {
332 InlineStack.pop_back();
334 FunctionSamples &FProfile = *InlineStack.back();
335 for (const auto &name_count : TargetCountMap) {
336 FProfile.addCalledTargetSamples(LineOffset, Discriminator,
337 name_count.first, name_count.second);
339 FProfile.addBodySamples(LineOffset, Discriminator, NumSamples);
344 return sampleprof_error::success;
347 template <typename T> ErrorOr<T> SampleProfileReaderBinary::readNumber() {
348 unsigned NumBytesRead = 0;
350 uint64_t Val = decodeULEB128(Data, &NumBytesRead);
352 if (Val > std::numeric_limits<T>::max())
353 EC = sampleprof_error::malformed;
354 else if (Data + NumBytesRead > End)
355 EC = sampleprof_error::truncated;
357 EC = sampleprof_error::success;
360 reportError(0, EC.message());
364 Data += NumBytesRead;
365 return static_cast<T>(Val);
368 ErrorOr<StringRef> SampleProfileReaderBinary::readString() {
370 StringRef Str(reinterpret_cast<const char *>(Data));
371 if (Data + Str.size() + 1 > End) {
372 EC = sampleprof_error::truncated;
373 reportError(0, EC.message());
377 Data += Str.size() + 1;
381 ErrorOr<StringRef> SampleProfileReaderBinary::readStringFromTable() {
383 auto Idx = readNumber<unsigned>();
384 if (std::error_code EC = Idx.getError())
386 if (*Idx >= NameTable.size())
387 return sampleprof_error::truncated_name_table;
388 return NameTable[*Idx];
392 SampleProfileReaderBinary::readProfile(FunctionSamples &FProfile) {
393 auto Val = readNumber<unsigned>();
394 if (std::error_code EC = Val.getError())
396 FProfile.addTotalSamples(*Val);
398 Val = readNumber<unsigned>();
399 if (std::error_code EC = Val.getError())
401 FProfile.addHeadSamples(*Val);
403 // Read the samples in the body.
404 auto NumRecords = readNumber<unsigned>();
405 if (std::error_code EC = NumRecords.getError())
408 for (unsigned I = 0; I < *NumRecords; ++I) {
409 auto LineOffset = readNumber<uint64_t>();
410 if (std::error_code EC = LineOffset.getError())
413 auto Discriminator = readNumber<uint64_t>();
414 if (std::error_code EC = Discriminator.getError())
417 auto NumSamples = readNumber<uint64_t>();
418 if (std::error_code EC = NumSamples.getError())
421 auto NumCalls = readNumber<unsigned>();
422 if (std::error_code EC = NumCalls.getError())
425 for (unsigned J = 0; J < *NumCalls; ++J) {
426 auto CalledFunction(readStringFromTable());
427 if (std::error_code EC = CalledFunction.getError())
430 auto CalledFunctionSamples = readNumber<uint64_t>();
431 if (std::error_code EC = CalledFunctionSamples.getError())
434 FProfile.addCalledTargetSamples(*LineOffset, *Discriminator,
435 *CalledFunction, *CalledFunctionSamples);
438 FProfile.addBodySamples(*LineOffset, *Discriminator, *NumSamples);
441 // Read all the samples for inlined function calls.
442 auto NumCallsites = readNumber<unsigned>();
443 if (std::error_code EC = NumCallsites.getError())
446 for (unsigned J = 0; J < *NumCallsites; ++J) {
447 auto LineOffset = readNumber<uint64_t>();
448 if (std::error_code EC = LineOffset.getError())
451 auto Discriminator = readNumber<uint64_t>();
452 if (std::error_code EC = Discriminator.getError())
455 auto FName(readStringFromTable());
456 if (std::error_code EC = FName.getError())
459 FunctionSamples &CalleeProfile = FProfile.functionSamplesAt(
460 CallsiteLocation(*LineOffset, *Discriminator, *FName));
461 if (std::error_code EC = readProfile(CalleeProfile))
465 return sampleprof_error::success;
468 std::error_code SampleProfileReaderBinary::read() {
470 auto FName(readStringFromTable());
471 if (std::error_code EC = FName.getError())
474 Profiles[*FName] = FunctionSamples();
475 FunctionSamples &FProfile = Profiles[*FName];
477 if (std::error_code EC = readProfile(FProfile))
481 return sampleprof_error::success;
484 std::error_code SampleProfileReaderBinary::readHeader() {
485 Data = reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
486 End = Data + Buffer->getBufferSize();
488 // Read and check the magic identifier.
489 auto Magic = readNumber<uint64_t>();
490 if (std::error_code EC = Magic.getError())
492 else if (*Magic != SPMagic())
493 return sampleprof_error::bad_magic;
495 // Read the version number.
496 auto Version = readNumber<uint64_t>();
497 if (std::error_code EC = Version.getError())
499 else if (*Version != SPVersion())
500 return sampleprof_error::unsupported_version;
502 // Read the name table.
503 auto Size = readNumber<size_t>();
504 if (std::error_code EC = Size.getError())
506 NameTable.reserve(*Size);
507 for (size_t I = 0; I < *Size; ++I) {
508 auto Name(readString());
509 if (std::error_code EC = Name.getError())
511 NameTable.push_back(*Name);
514 return sampleprof_error::success;
517 bool SampleProfileReaderBinary::hasFormat(const MemoryBuffer &Buffer) {
518 const uint8_t *Data =
519 reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
520 uint64_t Magic = decodeULEB128(Data);
521 return Magic == SPMagic();
524 std::error_code SampleProfileReaderGCC::skipNextWord() {
526 if (!GcovBuffer.readInt(dummy))
527 return sampleprof_error::truncated;
528 return sampleprof_error::success;
531 template <typename T> ErrorOr<T> SampleProfileReaderGCC::readNumber() {
532 if (sizeof(T) <= sizeof(uint32_t)) {
534 if (GcovBuffer.readInt(Val) && Val <= std::numeric_limits<T>::max())
535 return static_cast<T>(Val);
536 } else if (sizeof(T) <= sizeof(uint64_t)) {
538 if (GcovBuffer.readInt64(Val) && Val <= std::numeric_limits<T>::max())
539 return static_cast<T>(Val);
542 std::error_code EC = sampleprof_error::malformed;
543 reportError(0, EC.message());
547 ErrorOr<StringRef> SampleProfileReaderGCC::readString() {
549 if (!GcovBuffer.readString(Str))
550 return sampleprof_error::truncated;
554 std::error_code SampleProfileReaderGCC::readHeader() {
555 // Read the magic identifier.
556 if (!GcovBuffer.readGCDAFormat())
557 return sampleprof_error::unrecognized_format;
559 // Read the version number. Note - the GCC reader does not validate this
560 // version, but the profile creator generates v704.
561 GCOV::GCOVVersion version;
562 if (!GcovBuffer.readGCOVVersion(version))
563 return sampleprof_error::unrecognized_format;
565 if (version != GCOV::V704)
566 return sampleprof_error::unsupported_version;
568 // Skip the empty integer.
569 if (std::error_code EC = skipNextWord())
572 return sampleprof_error::success;
575 std::error_code SampleProfileReaderGCC::readSectionTag(uint32_t Expected) {
577 if (!GcovBuffer.readInt(Tag))
578 return sampleprof_error::truncated;
581 return sampleprof_error::malformed;
583 if (std::error_code EC = skipNextWord())
586 return sampleprof_error::success;
589 std::error_code SampleProfileReaderGCC::readNameTable() {
590 if (std::error_code EC = readSectionTag(GCOVTagAFDOFileNames))
594 if (!GcovBuffer.readInt(Size))
595 return sampleprof_error::truncated;
597 for (uint32_t I = 0; I < Size; ++I) {
599 if (!GcovBuffer.readString(Str))
600 return sampleprof_error::truncated;
601 Names.push_back(Str);
604 return sampleprof_error::success;
607 std::error_code SampleProfileReaderGCC::readFunctionProfiles() {
608 if (std::error_code EC = readSectionTag(GCOVTagAFDOFunction))
611 uint32_t NumFunctions;
612 if (!GcovBuffer.readInt(NumFunctions))
613 return sampleprof_error::truncated;
615 InlineCallStack Stack;
616 for (uint32_t I = 0; I < NumFunctions; ++I)
617 if (std::error_code EC = readOneFunctionProfile(Stack, true, 0))
620 return sampleprof_error::success;
623 std::error_code SampleProfileReaderGCC::readOneFunctionProfile(
624 const InlineCallStack &InlineStack, bool Update, uint32_t Offset) {
625 uint64_t HeadCount = 0;
626 if (InlineStack.size() == 0)
627 if (!GcovBuffer.readInt64(HeadCount))
628 return sampleprof_error::truncated;
631 if (!GcovBuffer.readInt(NameIdx))
632 return sampleprof_error::truncated;
634 StringRef Name(Names[NameIdx]);
636 uint32_t NumPosCounts;
637 if (!GcovBuffer.readInt(NumPosCounts))
638 return sampleprof_error::truncated;
640 uint32_t NumCallsites;
641 if (!GcovBuffer.readInt(NumCallsites))
642 return sampleprof_error::truncated;
644 FunctionSamples *FProfile = nullptr;
645 if (InlineStack.size() == 0) {
646 // If this is a top function that we have already processed, do not
647 // update its profile again. This happens in the presence of
648 // function aliases. Since these aliases share the same function
649 // body, there will be identical replicated profiles for the
650 // original function. In this case, we simply not bother updating
651 // the profile of the original function.
652 FProfile = &Profiles[Name];
653 FProfile->addHeadSamples(HeadCount);
654 if (FProfile->getTotalSamples() > 0)
657 // Otherwise, we are reading an inlined instance. The top of the
658 // inline stack contains the profile of the caller. Insert this
659 // callee in the caller's CallsiteMap.
660 FunctionSamples *CallerProfile = InlineStack.front();
661 uint32_t LineOffset = Offset >> 16;
662 uint32_t Discriminator = Offset & 0xffff;
663 FProfile = &CallerProfile->functionSamplesAt(
664 CallsiteLocation(LineOffset, Discriminator, Name));
667 for (uint32_t I = 0; I < NumPosCounts; ++I) {
669 if (!GcovBuffer.readInt(Offset))
670 return sampleprof_error::truncated;
673 if (!GcovBuffer.readInt(NumTargets))
674 return sampleprof_error::truncated;
677 if (!GcovBuffer.readInt64(Count))
678 return sampleprof_error::truncated;
680 // The line location is encoded in the offset as:
681 // high 16 bits: line offset to the start of the function.
682 // low 16 bits: discriminator.
683 uint32_t LineOffset = Offset >> 16;
684 uint32_t Discriminator = Offset & 0xffff;
686 InlineCallStack NewStack;
687 NewStack.push_back(FProfile);
688 NewStack.insert(NewStack.end(), InlineStack.begin(), InlineStack.end());
690 // Walk up the inline stack, adding the samples on this line to
691 // the total sample count of the callers in the chain.
692 for (auto CallerProfile : NewStack)
693 CallerProfile->addTotalSamples(Count);
695 // Update the body samples for the current profile.
696 FProfile->addBodySamples(LineOffset, Discriminator, Count);
699 // Process the list of functions called at an indirect call site.
700 // These are all the targets that a function pointer (or virtual
701 // function) resolved at runtime.
702 for (uint32_t J = 0; J < NumTargets; J++) {
704 if (!GcovBuffer.readInt(HistVal))
705 return sampleprof_error::truncated;
707 if (HistVal != HIST_TYPE_INDIR_CALL_TOPN)
708 return sampleprof_error::malformed;
711 if (!GcovBuffer.readInt64(TargetIdx))
712 return sampleprof_error::truncated;
713 StringRef TargetName(Names[TargetIdx]);
715 uint64_t TargetCount;
716 if (!GcovBuffer.readInt64(TargetCount))
717 return sampleprof_error::truncated;
720 FunctionSamples &TargetProfile = Profiles[TargetName];
721 TargetProfile.addCalledTargetSamples(LineOffset, Discriminator,
722 TargetName, TargetCount);
727 // Process all the inlined callers into the current function. These
728 // are all the callsites that were inlined into this function.
729 for (uint32_t I = 0; I < NumCallsites; I++) {
730 // The offset is encoded as:
731 // high 16 bits: line offset to the start of the function.
732 // low 16 bits: discriminator.
734 if (!GcovBuffer.readInt(Offset))
735 return sampleprof_error::truncated;
736 InlineCallStack NewStack;
737 NewStack.push_back(FProfile);
738 NewStack.insert(NewStack.end(), InlineStack.begin(), InlineStack.end());
739 if (std::error_code EC = readOneFunctionProfile(NewStack, Update, Offset))
743 return sampleprof_error::success;
746 /// \brief Read a GCC AutoFDO profile.
748 /// This format is generated by the Linux Perf conversion tool at
749 /// https://github.com/google/autofdo.
750 std::error_code SampleProfileReaderGCC::read() {
751 // Read the string table.
752 if (std::error_code EC = readNameTable())
755 // Read the source profile.
756 if (std::error_code EC = readFunctionProfiles())
759 return sampleprof_error::success;
762 bool SampleProfileReaderGCC::hasFormat(const MemoryBuffer &Buffer) {
763 StringRef Magic(reinterpret_cast<const char *>(Buffer.getBufferStart()));
764 return Magic == "adcg*704";
767 /// \brief Prepare a memory buffer for the contents of \p Filename.
769 /// \returns an error code indicating the status of the buffer.
770 static ErrorOr<std::unique_ptr<MemoryBuffer>>
771 setupMemoryBuffer(std::string Filename) {
772 auto BufferOrErr = MemoryBuffer::getFileOrSTDIN(Filename);
773 if (std::error_code EC = BufferOrErr.getError())
775 auto Buffer = std::move(BufferOrErr.get());
777 // Sanity check the file.
778 if (Buffer->getBufferSize() > std::numeric_limits<unsigned>::max())
779 return sampleprof_error::too_large;
781 return std::move(Buffer);
784 /// \brief Create a sample profile reader based on the format of the input file.
786 /// \param Filename The file to open.
788 /// \param Reader The reader to instantiate according to \p Filename's format.
790 /// \param C The LLVM context to use to emit diagnostics.
792 /// \returns an error code indicating the status of the created reader.
793 ErrorOr<std::unique_ptr<SampleProfileReader>>
794 SampleProfileReader::create(StringRef Filename, LLVMContext &C) {
795 auto BufferOrError = setupMemoryBuffer(Filename);
796 if (std::error_code EC = BufferOrError.getError())
799 auto Buffer = std::move(BufferOrError.get());
800 std::unique_ptr<SampleProfileReader> Reader;
801 if (SampleProfileReaderBinary::hasFormat(*Buffer))
802 Reader.reset(new SampleProfileReaderBinary(std::move(Buffer), C));
803 else if (SampleProfileReaderGCC::hasFormat(*Buffer))
804 Reader.reset(new SampleProfileReaderGCC(std::move(Buffer), C));
806 Reader.reset(new SampleProfileReaderText(std::move(Buffer), C));
808 if (std::error_code EC = Reader->readHeader())
811 return std::move(Reader);