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 three file formats: text, binary and gcov.
13 // The textual representation is useful for debugging and testing purposes. The
14 // binary representation is more compact, resulting in smaller file sizes.
16 // The gcov encoding is the one generated by GCC's AutoFDO profile creation
17 // tool (https://github.com/google/autofdo)
19 // All three encodings can be used interchangeably as an input sample profile.
21 //===----------------------------------------------------------------------===//
23 #include "llvm/ProfileData/SampleProfReader.h"
24 #include "llvm/ADT/DenseMap.h"
25 #include "llvm/ADT/STLExtras.h"
26 #include "llvm/ADT/StringRef.h"
27 #include "llvm/IR/ProfileSummary.h"
28 #include "llvm/ProfileData/ProfileCommon.h"
29 #include "llvm/ProfileData/SampleProf.h"
30 #include "llvm/Support/ErrorOr.h"
31 #include "llvm/Support/LEB128.h"
32 #include "llvm/Support/LineIterator.h"
33 #include "llvm/Support/MemoryBuffer.h"
34 #include "llvm/Support/raw_ostream.h"
40 #include <system_error>
44 using namespace sampleprof;
46 /// \brief Dump the function profile for \p FName.
48 /// \param FName Name of the function to print.
49 /// \param OS Stream to emit the output to.
50 void SampleProfileReader::dumpFunctionProfile(StringRef FName,
52 OS << "Function: " << FName << ": " << Profiles[FName];
55 /// \brief Dump all the function profiles found on stream \p OS.
56 void SampleProfileReader::dump(raw_ostream &OS) {
57 for (const auto &I : Profiles)
58 dumpFunctionProfile(I.getKey(), OS);
61 /// \brief Parse \p Input as function head.
63 /// Parse one line of \p Input, and update function name in \p FName,
64 /// function's total sample count in \p NumSamples, function's entry
65 /// count in \p NumHeadSamples.
67 /// \returns true if parsing is successful.
68 static bool ParseHead(const StringRef &Input, StringRef &FName,
69 uint64_t &NumSamples, uint64_t &NumHeadSamples) {
72 size_t n2 = Input.rfind(':');
73 size_t n1 = Input.rfind(':', n2 - 1);
74 FName = Input.substr(0, n1);
75 if (Input.substr(n1 + 1, n2 - n1 - 1).getAsInteger(10, NumSamples))
77 if (Input.substr(n2 + 1).getAsInteger(10, NumHeadSamples))
82 /// \brief Returns true if line offset \p L is legal (only has 16 bits).
83 static bool isOffsetLegal(unsigned L) { return (L & 0xffff) == L; }
85 /// \brief Parse \p Input as line sample.
87 /// \param Input input line.
88 /// \param IsCallsite true if the line represents an inlined callsite.
89 /// \param Depth the depth of the inline stack.
90 /// \param NumSamples total samples of the line/inlined callsite.
91 /// \param LineOffset line offset to the start of the function.
92 /// \param Discriminator discriminator of the line.
93 /// \param TargetCountMap map from indirect call target to count.
95 /// returns true if parsing is successful.
96 static bool ParseLine(const StringRef &Input, bool &IsCallsite, uint32_t &Depth,
97 uint64_t &NumSamples, uint32_t &LineOffset,
98 uint32_t &Discriminator, StringRef &CalleeName,
99 DenseMap<StringRef, uint64_t> &TargetCountMap) {
100 for (Depth = 0; Input[Depth] == ' '; Depth++)
105 size_t n1 = Input.find(':');
106 StringRef Loc = Input.substr(Depth, n1 - Depth);
107 size_t n2 = Loc.find('.');
108 if (n2 == StringRef::npos) {
109 if (Loc.getAsInteger(10, LineOffset) || !isOffsetLegal(LineOffset))
113 if (Loc.substr(0, n2).getAsInteger(10, LineOffset))
115 if (Loc.substr(n2 + 1).getAsInteger(10, Discriminator))
119 StringRef Rest = Input.substr(n1 + 2);
120 if (Rest[0] >= '0' && Rest[0] <= '9') {
122 size_t n3 = Rest.find(' ');
123 if (n3 == StringRef::npos) {
124 if (Rest.getAsInteger(10, NumSamples))
127 if (Rest.substr(0, n3).getAsInteger(10, NumSamples))
130 while (n3 != StringRef::npos) {
131 n3 += Rest.substr(n3).find_first_not_of(' ');
132 Rest = Rest.substr(n3);
134 StringRef pair = Rest;
135 if (n3 != StringRef::npos) {
136 pair = Rest.substr(0, n3);
138 size_t n4 = pair.find(':');
140 if (pair.substr(n4 + 1).getAsInteger(10, count))
142 TargetCountMap[pair.substr(0, n4)] = count;
146 size_t n3 = Rest.find_last_of(':');
147 CalleeName = Rest.substr(0, n3);
148 if (Rest.substr(n3 + 1).getAsInteger(10, NumSamples))
154 /// \brief Load samples from a text file.
156 /// See the documentation at the top of the file for an explanation of
157 /// the expected format.
159 /// \returns true if the file was loaded successfully, false otherwise.
160 std::error_code SampleProfileReaderText::read() {
161 line_iterator LineIt(*Buffer, /*SkipBlanks=*/true, '#');
162 sampleprof_error Result = sampleprof_error::success;
164 InlineCallStack InlineStack;
166 for (; !LineIt.is_at_eof(); ++LineIt) {
167 if ((*LineIt)[(*LineIt).find_first_not_of(' ')] == '#')
169 // Read the header of each function.
171 // Note that for function identifiers we are actually expecting
172 // mangled names, but we may not always get them. This happens when
173 // the compiler decides not to emit the function (e.g., it was inlined
174 // and removed). In this case, the binary will not have the linkage
175 // name for the function, so the profiler will emit the function's
176 // unmangled name, which may contain characters like ':' and '>' in its
177 // name (member functions, templates, etc).
179 // The only requirement we place on the identifier, then, is that it
180 // should not begin with a number.
181 if ((*LineIt)[0] != ' ') {
182 uint64_t NumSamples, NumHeadSamples;
184 if (!ParseHead(*LineIt, FName, NumSamples, NumHeadSamples)) {
185 reportError(LineIt.line_number(),
186 "Expected 'mangled_name:NUM:NUM', found " + *LineIt);
187 return sampleprof_error::malformed;
189 Profiles[FName] = FunctionSamples();
190 FunctionSamples &FProfile = Profiles[FName];
191 FProfile.setName(FName);
192 MergeResult(Result, FProfile.addTotalSamples(NumSamples));
193 MergeResult(Result, FProfile.addHeadSamples(NumHeadSamples));
195 InlineStack.push_back(&FProfile);
199 DenseMap<StringRef, uint64_t> TargetCountMap;
201 uint32_t Depth, LineOffset, Discriminator;
202 if (!ParseLine(*LineIt, IsCallsite, Depth, NumSamples, LineOffset,
203 Discriminator, FName, TargetCountMap)) {
204 reportError(LineIt.line_number(),
205 "Expected 'NUM[.NUM]: NUM[ mangled_name:NUM]*', found " +
207 return sampleprof_error::malformed;
210 while (InlineStack.size() > Depth) {
211 InlineStack.pop_back();
213 FunctionSamples &FSamples = InlineStack.back()->functionSamplesAt(
214 LineLocation(LineOffset, Discriminator))[FName];
215 FSamples.setName(FName);
216 MergeResult(Result, FSamples.addTotalSamples(NumSamples));
217 InlineStack.push_back(&FSamples);
219 while (InlineStack.size() > Depth) {
220 InlineStack.pop_back();
222 FunctionSamples &FProfile = *InlineStack.back();
223 for (const auto &name_count : TargetCountMap) {
224 MergeResult(Result, FProfile.addCalledTargetSamples(
225 LineOffset, Discriminator, name_count.first,
228 MergeResult(Result, FProfile.addBodySamples(LineOffset, Discriminator,
233 if (Result == sampleprof_error::success)
239 bool SampleProfileReaderText::hasFormat(const MemoryBuffer &Buffer) {
242 // Check that the first non-comment line is a valid function header.
243 line_iterator LineIt(Buffer, /*SkipBlanks=*/true, '#');
244 if (!LineIt.is_at_eof()) {
245 if ((*LineIt)[0] != ' ') {
246 uint64_t NumSamples, NumHeadSamples;
248 result = ParseHead(*LineIt, FName, NumSamples, NumHeadSamples);
255 template <typename T> ErrorOr<T> SampleProfileReaderBinary::readNumber() {
256 unsigned NumBytesRead = 0;
258 uint64_t Val = decodeULEB128(Data, &NumBytesRead);
260 if (Val > std::numeric_limits<T>::max())
261 EC = sampleprof_error::malformed;
262 else if (Data + NumBytesRead > End)
263 EC = sampleprof_error::truncated;
265 EC = sampleprof_error::success;
268 reportError(0, EC.message());
272 Data += NumBytesRead;
273 return static_cast<T>(Val);
276 ErrorOr<StringRef> SampleProfileReaderBinary::readString() {
278 StringRef Str(reinterpret_cast<const char *>(Data));
279 if (Data + Str.size() + 1 > End) {
280 EC = sampleprof_error::truncated;
281 reportError(0, EC.message());
285 Data += Str.size() + 1;
289 ErrorOr<StringRef> SampleProfileReaderBinary::readStringFromTable() {
291 auto Idx = readNumber<uint32_t>();
292 if (std::error_code EC = Idx.getError())
294 if (*Idx >= NameTable.size())
295 return sampleprof_error::truncated_name_table;
296 return NameTable[*Idx];
300 SampleProfileReaderBinary::readProfile(FunctionSamples &FProfile) {
301 auto NumSamples = readNumber<uint64_t>();
302 if (std::error_code EC = NumSamples.getError())
304 FProfile.addTotalSamples(*NumSamples);
306 // Read the samples in the body.
307 auto NumRecords = readNumber<uint32_t>();
308 if (std::error_code EC = NumRecords.getError())
311 for (uint32_t I = 0; I < *NumRecords; ++I) {
312 auto LineOffset = readNumber<uint64_t>();
313 if (std::error_code EC = LineOffset.getError())
316 if (!isOffsetLegal(*LineOffset)) {
317 return std::error_code();
320 auto Discriminator = readNumber<uint64_t>();
321 if (std::error_code EC = Discriminator.getError())
324 auto NumSamples = readNumber<uint64_t>();
325 if (std::error_code EC = NumSamples.getError())
328 auto NumCalls = readNumber<uint32_t>();
329 if (std::error_code EC = NumCalls.getError())
332 for (uint32_t J = 0; J < *NumCalls; ++J) {
333 auto CalledFunction(readStringFromTable());
334 if (std::error_code EC = CalledFunction.getError())
337 auto CalledFunctionSamples = readNumber<uint64_t>();
338 if (std::error_code EC = CalledFunctionSamples.getError())
341 FProfile.addCalledTargetSamples(*LineOffset, *Discriminator,
342 *CalledFunction, *CalledFunctionSamples);
345 FProfile.addBodySamples(*LineOffset, *Discriminator, *NumSamples);
348 // Read all the samples for inlined function calls.
349 auto NumCallsites = readNumber<uint32_t>();
350 if (std::error_code EC = NumCallsites.getError())
353 for (uint32_t J = 0; J < *NumCallsites; ++J) {
354 auto LineOffset = readNumber<uint64_t>();
355 if (std::error_code EC = LineOffset.getError())
358 auto Discriminator = readNumber<uint64_t>();
359 if (std::error_code EC = Discriminator.getError())
362 auto FName(readStringFromTable());
363 if (std::error_code EC = FName.getError())
366 FunctionSamples &CalleeProfile = FProfile.functionSamplesAt(
367 LineLocation(*LineOffset, *Discriminator))[*FName];
368 CalleeProfile.setName(*FName);
369 if (std::error_code EC = readProfile(CalleeProfile))
373 return sampleprof_error::success;
376 std::error_code SampleProfileReaderBinary::read() {
378 auto NumHeadSamples = readNumber<uint64_t>();
379 if (std::error_code EC = NumHeadSamples.getError())
382 auto FName(readStringFromTable());
383 if (std::error_code EC = FName.getError())
386 Profiles[*FName] = FunctionSamples();
387 FunctionSamples &FProfile = Profiles[*FName];
388 FProfile.setName(*FName);
390 FProfile.addHeadSamples(*NumHeadSamples);
392 if (std::error_code EC = readProfile(FProfile))
396 return sampleprof_error::success;
399 std::error_code SampleProfileReaderBinary::readHeader() {
400 Data = reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
401 End = Data + Buffer->getBufferSize();
403 // Read and check the magic identifier.
404 auto Magic = readNumber<uint64_t>();
405 if (std::error_code EC = Magic.getError())
407 else if (*Magic != SPMagic())
408 return sampleprof_error::bad_magic;
410 // Read the version number.
411 auto Version = readNumber<uint64_t>();
412 if (std::error_code EC = Version.getError())
414 else if (*Version != SPVersion())
415 return sampleprof_error::unsupported_version;
417 if (std::error_code EC = readSummary())
420 // Read the name table.
421 auto Size = readNumber<uint32_t>();
422 if (std::error_code EC = Size.getError())
424 NameTable.reserve(*Size);
425 for (uint32_t I = 0; I < *Size; ++I) {
426 auto Name(readString());
427 if (std::error_code EC = Name.getError())
429 NameTable.push_back(*Name);
432 return sampleprof_error::success;
435 std::error_code SampleProfileReaderBinary::readSummaryEntry(
436 std::vector<ProfileSummaryEntry> &Entries) {
437 auto Cutoff = readNumber<uint64_t>();
438 if (std::error_code EC = Cutoff.getError())
441 auto MinBlockCount = readNumber<uint64_t>();
442 if (std::error_code EC = MinBlockCount.getError())
445 auto NumBlocks = readNumber<uint64_t>();
446 if (std::error_code EC = NumBlocks.getError())
449 Entries.emplace_back(*Cutoff, *MinBlockCount, *NumBlocks);
450 return sampleprof_error::success;
453 std::error_code SampleProfileReaderBinary::readSummary() {
454 auto TotalCount = readNumber<uint64_t>();
455 if (std::error_code EC = TotalCount.getError())
458 auto MaxBlockCount = readNumber<uint64_t>();
459 if (std::error_code EC = MaxBlockCount.getError())
462 auto MaxFunctionCount = readNumber<uint64_t>();
463 if (std::error_code EC = MaxFunctionCount.getError())
466 auto NumBlocks = readNumber<uint64_t>();
467 if (std::error_code EC = NumBlocks.getError())
470 auto NumFunctions = readNumber<uint64_t>();
471 if (std::error_code EC = NumFunctions.getError())
474 auto NumSummaryEntries = readNumber<uint64_t>();
475 if (std::error_code EC = NumSummaryEntries.getError())
478 std::vector<ProfileSummaryEntry> Entries;
479 for (unsigned i = 0; i < *NumSummaryEntries; i++) {
480 std::error_code EC = readSummaryEntry(Entries);
481 if (EC != sampleprof_error::success)
484 Summary = llvm::make_unique<ProfileSummary>(
485 ProfileSummary::PSK_Sample, Entries, *TotalCount, *MaxBlockCount, 0,
486 *MaxFunctionCount, *NumBlocks, *NumFunctions);
488 return sampleprof_error::success;
491 bool SampleProfileReaderBinary::hasFormat(const MemoryBuffer &Buffer) {
492 const uint8_t *Data =
493 reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
494 uint64_t Magic = decodeULEB128(Data);
495 return Magic == SPMagic();
498 std::error_code SampleProfileReaderGCC::skipNextWord() {
500 if (!GcovBuffer.readInt(dummy))
501 return sampleprof_error::truncated;
502 return sampleprof_error::success;
505 template <typename T> ErrorOr<T> SampleProfileReaderGCC::readNumber() {
506 if (sizeof(T) <= sizeof(uint32_t)) {
508 if (GcovBuffer.readInt(Val) && Val <= std::numeric_limits<T>::max())
509 return static_cast<T>(Val);
510 } else if (sizeof(T) <= sizeof(uint64_t)) {
512 if (GcovBuffer.readInt64(Val) && Val <= std::numeric_limits<T>::max())
513 return static_cast<T>(Val);
516 std::error_code EC = sampleprof_error::malformed;
517 reportError(0, EC.message());
521 ErrorOr<StringRef> SampleProfileReaderGCC::readString() {
523 if (!GcovBuffer.readString(Str))
524 return sampleprof_error::truncated;
528 std::error_code SampleProfileReaderGCC::readHeader() {
529 // Read the magic identifier.
530 if (!GcovBuffer.readGCDAFormat())
531 return sampleprof_error::unrecognized_format;
533 // Read the version number. Note - the GCC reader does not validate this
534 // version, but the profile creator generates v704.
535 GCOV::GCOVVersion version;
536 if (!GcovBuffer.readGCOVVersion(version))
537 return sampleprof_error::unrecognized_format;
539 if (version != GCOV::V704)
540 return sampleprof_error::unsupported_version;
542 // Skip the empty integer.
543 if (std::error_code EC = skipNextWord())
546 return sampleprof_error::success;
549 std::error_code SampleProfileReaderGCC::readSectionTag(uint32_t Expected) {
551 if (!GcovBuffer.readInt(Tag))
552 return sampleprof_error::truncated;
555 return sampleprof_error::malformed;
557 if (std::error_code EC = skipNextWord())
560 return sampleprof_error::success;
563 std::error_code SampleProfileReaderGCC::readNameTable() {
564 if (std::error_code EC = readSectionTag(GCOVTagAFDOFileNames))
568 if (!GcovBuffer.readInt(Size))
569 return sampleprof_error::truncated;
571 for (uint32_t I = 0; I < Size; ++I) {
573 if (!GcovBuffer.readString(Str))
574 return sampleprof_error::truncated;
575 Names.push_back(Str);
578 return sampleprof_error::success;
581 std::error_code SampleProfileReaderGCC::readFunctionProfiles() {
582 if (std::error_code EC = readSectionTag(GCOVTagAFDOFunction))
585 uint32_t NumFunctions;
586 if (!GcovBuffer.readInt(NumFunctions))
587 return sampleprof_error::truncated;
589 InlineCallStack Stack;
590 for (uint32_t I = 0; I < NumFunctions; ++I)
591 if (std::error_code EC = readOneFunctionProfile(Stack, true, 0))
595 return sampleprof_error::success;
598 std::error_code SampleProfileReaderGCC::readOneFunctionProfile(
599 const InlineCallStack &InlineStack, bool Update, uint32_t Offset) {
600 uint64_t HeadCount = 0;
601 if (InlineStack.size() == 0)
602 if (!GcovBuffer.readInt64(HeadCount))
603 return sampleprof_error::truncated;
606 if (!GcovBuffer.readInt(NameIdx))
607 return sampleprof_error::truncated;
609 StringRef Name(Names[NameIdx]);
611 uint32_t NumPosCounts;
612 if (!GcovBuffer.readInt(NumPosCounts))
613 return sampleprof_error::truncated;
615 uint32_t NumCallsites;
616 if (!GcovBuffer.readInt(NumCallsites))
617 return sampleprof_error::truncated;
619 FunctionSamples *FProfile = nullptr;
620 if (InlineStack.size() == 0) {
621 // If this is a top function that we have already processed, do not
622 // update its profile again. This happens in the presence of
623 // function aliases. Since these aliases share the same function
624 // body, there will be identical replicated profiles for the
625 // original function. In this case, we simply not bother updating
626 // the profile of the original function.
627 FProfile = &Profiles[Name];
628 FProfile->addHeadSamples(HeadCount);
629 if (FProfile->getTotalSamples() > 0)
632 // Otherwise, we are reading an inlined instance. The top of the
633 // inline stack contains the profile of the caller. Insert this
634 // callee in the caller's CallsiteMap.
635 FunctionSamples *CallerProfile = InlineStack.front();
636 uint32_t LineOffset = Offset >> 16;
637 uint32_t Discriminator = Offset & 0xffff;
638 FProfile = &CallerProfile->functionSamplesAt(
639 LineLocation(LineOffset, Discriminator))[Name];
641 FProfile->setName(Name);
643 for (uint32_t I = 0; I < NumPosCounts; ++I) {
645 if (!GcovBuffer.readInt(Offset))
646 return sampleprof_error::truncated;
649 if (!GcovBuffer.readInt(NumTargets))
650 return sampleprof_error::truncated;
653 if (!GcovBuffer.readInt64(Count))
654 return sampleprof_error::truncated;
656 // The line location is encoded in the offset as:
657 // high 16 bits: line offset to the start of the function.
658 // low 16 bits: discriminator.
659 uint32_t LineOffset = Offset >> 16;
660 uint32_t Discriminator = Offset & 0xffff;
662 InlineCallStack NewStack;
663 NewStack.push_back(FProfile);
664 NewStack.insert(NewStack.end(), InlineStack.begin(), InlineStack.end());
666 // Walk up the inline stack, adding the samples on this line to
667 // the total sample count of the callers in the chain.
668 for (auto CallerProfile : NewStack)
669 CallerProfile->addTotalSamples(Count);
671 // Update the body samples for the current profile.
672 FProfile->addBodySamples(LineOffset, Discriminator, Count);
675 // Process the list of functions called at an indirect call site.
676 // These are all the targets that a function pointer (or virtual
677 // function) resolved at runtime.
678 for (uint32_t J = 0; J < NumTargets; J++) {
680 if (!GcovBuffer.readInt(HistVal))
681 return sampleprof_error::truncated;
683 if (HistVal != HIST_TYPE_INDIR_CALL_TOPN)
684 return sampleprof_error::malformed;
687 if (!GcovBuffer.readInt64(TargetIdx))
688 return sampleprof_error::truncated;
689 StringRef TargetName(Names[TargetIdx]);
691 uint64_t TargetCount;
692 if (!GcovBuffer.readInt64(TargetCount))
693 return sampleprof_error::truncated;
696 FProfile->addCalledTargetSamples(LineOffset, Discriminator,
697 TargetName, TargetCount);
701 // Process all the inlined callers into the current function. These
702 // are all the callsites that were inlined into this function.
703 for (uint32_t I = 0; I < NumCallsites; I++) {
704 // The offset is encoded as:
705 // high 16 bits: line offset to the start of the function.
706 // low 16 bits: discriminator.
708 if (!GcovBuffer.readInt(Offset))
709 return sampleprof_error::truncated;
710 InlineCallStack NewStack;
711 NewStack.push_back(FProfile);
712 NewStack.insert(NewStack.end(), InlineStack.begin(), InlineStack.end());
713 if (std::error_code EC = readOneFunctionProfile(NewStack, Update, Offset))
717 return sampleprof_error::success;
720 /// \brief Read a GCC AutoFDO profile.
722 /// This format is generated by the Linux Perf conversion tool at
723 /// https://github.com/google/autofdo.
724 std::error_code SampleProfileReaderGCC::read() {
725 // Read the string table.
726 if (std::error_code EC = readNameTable())
729 // Read the source profile.
730 if (std::error_code EC = readFunctionProfiles())
733 return sampleprof_error::success;
736 bool SampleProfileReaderGCC::hasFormat(const MemoryBuffer &Buffer) {
737 StringRef Magic(reinterpret_cast<const char *>(Buffer.getBufferStart()));
738 return Magic == "adcg*704";
741 /// \brief Prepare a memory buffer for the contents of \p Filename.
743 /// \returns an error code indicating the status of the buffer.
744 static ErrorOr<std::unique_ptr<MemoryBuffer>>
745 setupMemoryBuffer(const Twine &Filename) {
746 auto BufferOrErr = MemoryBuffer::getFileOrSTDIN(Filename);
747 if (std::error_code EC = BufferOrErr.getError())
749 auto Buffer = std::move(BufferOrErr.get());
751 // Sanity check the file.
752 if (Buffer->getBufferSize() > std::numeric_limits<uint32_t>::max())
753 return sampleprof_error::too_large;
755 return std::move(Buffer);
758 /// \brief Create a sample profile reader based on the format of the input file.
760 /// \param Filename The file to open.
762 /// \param Reader The reader to instantiate according to \p Filename's format.
764 /// \param C The LLVM context to use to emit diagnostics.
766 /// \returns an error code indicating the status of the created reader.
767 ErrorOr<std::unique_ptr<SampleProfileReader>>
768 SampleProfileReader::create(const Twine &Filename, LLVMContext &C) {
769 auto BufferOrError = setupMemoryBuffer(Filename);
770 if (std::error_code EC = BufferOrError.getError())
772 return create(BufferOrError.get(), C);
775 /// \brief Create a sample profile reader based on the format of the input data.
777 /// \param B The memory buffer to create the reader from (assumes ownership).
779 /// \param Reader The reader to instantiate according to \p Filename's format.
781 /// \param C The LLVM context to use to emit diagnostics.
783 /// \returns an error code indicating the status of the created reader.
784 ErrorOr<std::unique_ptr<SampleProfileReader>>
785 SampleProfileReader::create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C) {
786 std::unique_ptr<SampleProfileReader> Reader;
787 if (SampleProfileReaderBinary::hasFormat(*B))
788 Reader.reset(new SampleProfileReaderBinary(std::move(B), C));
789 else if (SampleProfileReaderGCC::hasFormat(*B))
790 Reader.reset(new SampleProfileReaderGCC(std::move(B), C));
791 else if (SampleProfileReaderText::hasFormat(*B))
792 Reader.reset(new SampleProfileReaderText(std::move(B), C));
794 return sampleprof_error::unrecognized_format;
796 if (std::error_code EC = Reader->readHeader())
799 return std::move(Reader);
802 // For text and GCC file formats, we compute the summary after reading the
803 // profile. Binary format has the profile summary in its header.
804 void SampleProfileReader::computeSummary() {
805 SampleProfileSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);
806 for (const auto &I : Profiles) {
807 const FunctionSamples &Profile = I.second;
808 Builder.addRecord(Profile);
810 Summary = Builder.getSummary();