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/Support/Debug.h"
27 #include "llvm/Support/ErrorOr.h"
28 #include "llvm/Support/LEB128.h"
29 #include "llvm/Support/LineIterator.h"
30 #include "llvm/Support/MemoryBuffer.h"
32 using namespace llvm::sampleprof;
35 /// \brief Dump the function profile for \p FName.
37 /// \param FName Name of the function to print.
38 /// \param OS Stream to emit the output to.
39 void SampleProfileReader::dumpFunctionProfile(StringRef FName,
41 OS << "Function: " << FName << ": " << Profiles[FName];
44 /// \brief Dump all the function profiles found on stream \p OS.
45 void SampleProfileReader::dump(raw_ostream &OS) {
46 for (const auto &I : Profiles)
47 dumpFunctionProfile(I.getKey(), OS);
50 /// \brief Parse \p Input as function head.
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.
56 /// \returns true if parsing is successful.
57 static bool ParseHead(const StringRef &Input, StringRef &FName,
58 uint64_t &NumSamples, uint64_t &NumHeadSamples) {
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))
66 if (Input.substr(n2 + 1).getAsInteger(10, NumHeadSamples))
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; }
74 /// \brief Parse \p Input as line sample.
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.
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++)
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))
102 if (Loc.substr(0, n2).getAsInteger(10, LineOffset))
104 if (Loc.substr(n2 + 1).getAsInteger(10, Discriminator))
108 StringRef Rest = Input.substr(n1 + 2);
109 if (Rest[0] >= '0' && Rest[0] <= '9') {
111 size_t n3 = Rest.find(' ');
112 if (n3 == StringRef::npos) {
113 if (Rest.getAsInteger(10, NumSamples))
116 if (Rest.substr(0, n3).getAsInteger(10, NumSamples))
119 while (n3 != StringRef::npos) {
120 n3 += Rest.substr(n3).find_first_not_of(' ');
121 Rest = Rest.substr(n3);
123 StringRef pair = Rest;
124 if (n3 != StringRef::npos) {
125 pair = Rest.substr(0, n3);
127 size_t n4 = pair.find(':');
129 if (pair.substr(n4 + 1).getAsInteger(10, count))
131 TargetCountMap[pair.substr(0, n4)] = count;
135 size_t n3 = Rest.find_last_of(':');
136 CalleeName = Rest.substr(0, n3);
137 if (Rest.substr(n3 + 1).getAsInteger(10, NumSamples))
143 /// \brief Load samples from a text file.
145 /// See the documentation at the top of the file for an explanation of
146 /// the expected format.
148 /// \returns true if the file was loaded successfully, false otherwise.
149 std::error_code SampleProfileReaderText::read() {
150 line_iterator LineIt(*Buffer, /*SkipBlanks=*/true, '#');
151 sampleprof_error Result = sampleprof_error::success;
153 InlineCallStack InlineStack;
155 for (; !LineIt.is_at_eof(); ++LineIt) {
156 if ((*LineIt)[(*LineIt).find_first_not_of(' ')] == '#')
158 // Read the header of each function.
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).
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;
173 if (!ParseHead(*LineIt, FName, NumSamples, NumHeadSamples)) {
174 reportError(LineIt.line_number(),
175 "Expected 'mangled_name:NUM:NUM', found " + *LineIt);
176 return sampleprof_error::malformed;
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));
184 InlineStack.push_back(&FProfile);
188 DenseMap<StringRef, uint64_t> TargetCountMap;
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 " +
196 return sampleprof_error::malformed;
199 while (InlineStack.size() > Depth) {
200 InlineStack.pop_back();
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);
208 while (InlineStack.size() > Depth) {
209 InlineStack.pop_back();
211 FunctionSamples &FProfile = *InlineStack.back();
212 for (const auto &name_count : TargetCountMap) {
213 MergeResult(Result, FProfile.addCalledTargetSamples(
214 LineOffset, Discriminator, name_count.first,
217 MergeResult(Result, FProfile.addBodySamples(LineOffset, Discriminator,
222 if (Result == sampleprof_error::success)
228 bool SampleProfileReaderText::hasFormat(const MemoryBuffer &Buffer) {
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;
237 result = ParseHead(*LineIt, FName, NumSamples, NumHeadSamples);
244 template <typename T> ErrorOr<T> SampleProfileReaderBinary::readNumber() {
245 unsigned NumBytesRead = 0;
247 uint64_t Val = decodeULEB128(Data, &NumBytesRead);
249 if (Val > std::numeric_limits<T>::max())
250 EC = sampleprof_error::malformed;
251 else if (Data + NumBytesRead > End)
252 EC = sampleprof_error::truncated;
254 EC = sampleprof_error::success;
257 reportError(0, EC.message());
261 Data += NumBytesRead;
262 return static_cast<T>(Val);
265 ErrorOr<StringRef> SampleProfileReaderBinary::readString() {
267 StringRef Str(reinterpret_cast<const char *>(Data));
268 if (Data + Str.size() + 1 > End) {
269 EC = sampleprof_error::truncated;
270 reportError(0, EC.message());
274 Data += Str.size() + 1;
278 ErrorOr<StringRef> SampleProfileReaderBinary::readStringFromTable() {
280 auto Idx = readNumber<uint32_t>();
281 if (std::error_code EC = Idx.getError())
283 if (*Idx >= NameTable.size())
284 return sampleprof_error::truncated_name_table;
285 return NameTable[*Idx];
289 SampleProfileReaderBinary::readProfile(FunctionSamples &FProfile) {
290 auto NumSamples = readNumber<uint64_t>();
291 if (std::error_code EC = NumSamples.getError())
293 FProfile.addTotalSamples(*NumSamples);
295 // Read the samples in the body.
296 auto NumRecords = readNumber<uint32_t>();
297 if (std::error_code EC = NumRecords.getError())
300 for (uint32_t I = 0; I < *NumRecords; ++I) {
301 auto LineOffset = readNumber<uint64_t>();
302 if (std::error_code EC = LineOffset.getError())
305 if (!isOffsetLegal(*LineOffset)) {
306 return std::error_code();
309 auto Discriminator = readNumber<uint64_t>();
310 if (std::error_code EC = Discriminator.getError())
313 auto NumSamples = readNumber<uint64_t>();
314 if (std::error_code EC = NumSamples.getError())
317 auto NumCalls = readNumber<uint32_t>();
318 if (std::error_code EC = NumCalls.getError())
321 for (uint32_t J = 0; J < *NumCalls; ++J) {
322 auto CalledFunction(readStringFromTable());
323 if (std::error_code EC = CalledFunction.getError())
326 auto CalledFunctionSamples = readNumber<uint64_t>();
327 if (std::error_code EC = CalledFunctionSamples.getError())
330 FProfile.addCalledTargetSamples(*LineOffset, *Discriminator,
331 *CalledFunction, *CalledFunctionSamples);
334 FProfile.addBodySamples(*LineOffset, *Discriminator, *NumSamples);
337 // Read all the samples for inlined function calls.
338 auto NumCallsites = readNumber<uint32_t>();
339 if (std::error_code EC = NumCallsites.getError())
342 for (uint32_t J = 0; J < *NumCallsites; ++J) {
343 auto LineOffset = readNumber<uint64_t>();
344 if (std::error_code EC = LineOffset.getError())
347 auto Discriminator = readNumber<uint64_t>();
348 if (std::error_code EC = Discriminator.getError())
351 auto FName(readStringFromTable());
352 if (std::error_code EC = FName.getError())
355 FunctionSamples &CalleeProfile =
356 FProfile.functionSamplesAt(LineLocation(*LineOffset, *Discriminator));
357 CalleeProfile.setName(*FName);
358 if (std::error_code EC = readProfile(CalleeProfile))
362 return sampleprof_error::success;
365 std::error_code SampleProfileReaderBinary::read() {
367 auto NumHeadSamples = readNumber<uint64_t>();
368 if (std::error_code EC = NumHeadSamples.getError())
371 auto FName(readStringFromTable());
372 if (std::error_code EC = FName.getError())
375 Profiles[*FName] = FunctionSamples();
376 FunctionSamples &FProfile = Profiles[*FName];
377 FProfile.setName(*FName);
379 FProfile.addHeadSamples(*NumHeadSamples);
381 if (std::error_code EC = readProfile(FProfile))
385 return sampleprof_error::success;
388 std::error_code SampleProfileReaderBinary::readHeader() {
389 Data = reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
390 End = Data + Buffer->getBufferSize();
392 // Read and check the magic identifier.
393 auto Magic = readNumber<uint64_t>();
394 if (std::error_code EC = Magic.getError())
396 else if (*Magic != SPMagic())
397 return sampleprof_error::bad_magic;
399 // Read the version number.
400 auto Version = readNumber<uint64_t>();
401 if (std::error_code EC = Version.getError())
403 else if (*Version != SPVersion())
404 return sampleprof_error::unsupported_version;
406 if (std::error_code EC = readSummary())
409 // Read the name table.
410 auto Size = readNumber<uint32_t>();
411 if (std::error_code EC = Size.getError())
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())
418 NameTable.push_back(*Name);
421 return sampleprof_error::success;
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())
430 auto MinBlockCount = readNumber<uint64_t>();
431 if (std::error_code EC = MinBlockCount.getError())
434 auto NumBlocks = readNumber<uint64_t>();
435 if (std::error_code EC = NumBlocks.getError())
438 Entries.emplace_back(*Cutoff, *MinBlockCount, *NumBlocks);
439 return sampleprof_error::success;
442 std::error_code SampleProfileReaderBinary::readSummary() {
443 auto TotalCount = readNumber<uint64_t>();
444 if (std::error_code EC = TotalCount.getError())
447 auto MaxBlockCount = readNumber<uint64_t>();
448 if (std::error_code EC = MaxBlockCount.getError())
451 auto MaxFunctionCount = readNumber<uint64_t>();
452 if (std::error_code EC = MaxFunctionCount.getError())
455 auto NumBlocks = readNumber<uint64_t>();
456 if (std::error_code EC = NumBlocks.getError())
459 auto NumFunctions = readNumber<uint64_t>();
460 if (std::error_code EC = NumFunctions.getError())
463 auto NumSummaryEntries = readNumber<uint64_t>();
464 if (std::error_code EC = NumSummaryEntries.getError())
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)
473 Summary = llvm::make_unique<ProfileSummary>(
474 ProfileSummary::PSK_Sample, Entries, *TotalCount, *MaxBlockCount, 0,
475 *MaxFunctionCount, *NumBlocks, *NumFunctions);
477 return sampleprof_error::success;
480 bool SampleProfileReaderBinary::hasFormat(const MemoryBuffer &Buffer) {
481 const uint8_t *Data =
482 reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
483 uint64_t Magic = decodeULEB128(Data);
484 return Magic == SPMagic();
487 std::error_code SampleProfileReaderGCC::skipNextWord() {
489 if (!GcovBuffer.readInt(dummy))
490 return sampleprof_error::truncated;
491 return sampleprof_error::success;
494 template <typename T> ErrorOr<T> SampleProfileReaderGCC::readNumber() {
495 if (sizeof(T) <= sizeof(uint32_t)) {
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)) {
501 if (GcovBuffer.readInt64(Val) && Val <= std::numeric_limits<T>::max())
502 return static_cast<T>(Val);
505 std::error_code EC = sampleprof_error::malformed;
506 reportError(0, EC.message());
510 ErrorOr<StringRef> SampleProfileReaderGCC::readString() {
512 if (!GcovBuffer.readString(Str))
513 return sampleprof_error::truncated;
517 std::error_code SampleProfileReaderGCC::readHeader() {
518 // Read the magic identifier.
519 if (!GcovBuffer.readGCDAFormat())
520 return sampleprof_error::unrecognized_format;
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))
526 return sampleprof_error::unrecognized_format;
528 if (version != GCOV::V704)
529 return sampleprof_error::unsupported_version;
531 // Skip the empty integer.
532 if (std::error_code EC = skipNextWord())
535 return sampleprof_error::success;
538 std::error_code SampleProfileReaderGCC::readSectionTag(uint32_t Expected) {
540 if (!GcovBuffer.readInt(Tag))
541 return sampleprof_error::truncated;
544 return sampleprof_error::malformed;
546 if (std::error_code EC = skipNextWord())
549 return sampleprof_error::success;
552 std::error_code SampleProfileReaderGCC::readNameTable() {
553 if (std::error_code EC = readSectionTag(GCOVTagAFDOFileNames))
557 if (!GcovBuffer.readInt(Size))
558 return sampleprof_error::truncated;
560 for (uint32_t I = 0; I < Size; ++I) {
562 if (!GcovBuffer.readString(Str))
563 return sampleprof_error::truncated;
564 Names.push_back(Str);
567 return sampleprof_error::success;
570 std::error_code SampleProfileReaderGCC::readFunctionProfiles() {
571 if (std::error_code EC = readSectionTag(GCOVTagAFDOFunction))
574 uint32_t NumFunctions;
575 if (!GcovBuffer.readInt(NumFunctions))
576 return sampleprof_error::truncated;
578 InlineCallStack Stack;
579 for (uint32_t I = 0; I < NumFunctions; ++I)
580 if (std::error_code EC = readOneFunctionProfile(Stack, true, 0))
584 return sampleprof_error::success;
587 std::error_code SampleProfileReaderGCC::readOneFunctionProfile(
588 const InlineCallStack &InlineStack, bool Update, uint32_t Offset) {
589 uint64_t HeadCount = 0;
590 if (InlineStack.size() == 0)
591 if (!GcovBuffer.readInt64(HeadCount))
592 return sampleprof_error::truncated;
595 if (!GcovBuffer.readInt(NameIdx))
596 return sampleprof_error::truncated;
598 StringRef Name(Names[NameIdx]);
600 uint32_t NumPosCounts;
601 if (!GcovBuffer.readInt(NumPosCounts))
602 return sampleprof_error::truncated;
604 uint32_t NumCallsites;
605 if (!GcovBuffer.readInt(NumCallsites))
606 return sampleprof_error::truncated;
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)
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));
630 FProfile->setName(Name);
632 for (uint32_t I = 0; I < NumPosCounts; ++I) {
634 if (!GcovBuffer.readInt(Offset))
635 return sampleprof_error::truncated;
638 if (!GcovBuffer.readInt(NumTargets))
639 return sampleprof_error::truncated;
642 if (!GcovBuffer.readInt64(Count))
643 return sampleprof_error::truncated;
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;
651 InlineCallStack NewStack;
652 NewStack.push_back(FProfile);
653 NewStack.insert(NewStack.end(), InlineStack.begin(), InlineStack.end());
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);
660 // Update the body samples for the current profile.
661 FProfile->addBodySamples(LineOffset, Discriminator, Count);
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++) {
669 if (!GcovBuffer.readInt(HistVal))
670 return sampleprof_error::truncated;
672 if (HistVal != HIST_TYPE_INDIR_CALL_TOPN)
673 return sampleprof_error::malformed;
676 if (!GcovBuffer.readInt64(TargetIdx))
677 return sampleprof_error::truncated;
678 StringRef TargetName(Names[TargetIdx]);
680 uint64_t TargetCount;
681 if (!GcovBuffer.readInt64(TargetCount))
682 return sampleprof_error::truncated;
685 FunctionSamples &TargetProfile = Profiles[TargetName];
686 TargetProfile.addCalledTargetSamples(LineOffset, Discriminator,
687 TargetName, TargetCount);
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))
700 return sampleprof_error::truncated;
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))
708 return sampleprof_error::success;
711 /// \brief Read a GCC AutoFDO profile.
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())
720 // Read the source profile.
721 if (std::error_code EC = readFunctionProfiles())
724 return sampleprof_error::success;
727 bool SampleProfileReaderGCC::hasFormat(const MemoryBuffer &Buffer) {
728 StringRef Magic(reinterpret_cast<const char *>(Buffer.getBufferStart()));
729 return Magic == "adcg*704";
732 /// \brief Prepare a memory buffer for the contents of \p Filename.
734 /// \returns an error code indicating the status of the buffer.
735 static ErrorOr<std::unique_ptr<MemoryBuffer>>
736 setupMemoryBuffer(const Twine &Filename) {
737 auto BufferOrErr = MemoryBuffer::getFileOrSTDIN(Filename);
738 if (std::error_code EC = BufferOrErr.getError())
740 auto Buffer = std::move(BufferOrErr.get());
742 // Sanity check the file.
743 if (Buffer->getBufferSize() > std::numeric_limits<uint32_t>::max())
744 return sampleprof_error::too_large;
746 return std::move(Buffer);
749 /// \brief Create a sample profile reader based on the format of the input file.
751 /// \param Filename The file to open.
753 /// \param Reader The reader to instantiate according to \p Filename's format.
755 /// \param C The LLVM context to use to emit diagnostics.
757 /// \returns an error code indicating the status of the created reader.
758 ErrorOr<std::unique_ptr<SampleProfileReader>>
759 SampleProfileReader::create(const Twine &Filename, LLVMContext &C) {
760 auto BufferOrError = setupMemoryBuffer(Filename);
761 if (std::error_code EC = BufferOrError.getError())
763 return create(BufferOrError.get(), C);
766 /// \brief Create a sample profile reader based on the format of the input data.
768 /// \param B The memory buffer to create the reader from (assumes ownership).
770 /// \param Reader The reader to instantiate according to \p Filename's format.
772 /// \param C The LLVM context to use to emit diagnostics.
774 /// \returns an error code indicating the status of the created reader.
775 ErrorOr<std::unique_ptr<SampleProfileReader>>
776 SampleProfileReader::create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C) {
777 std::unique_ptr<SampleProfileReader> Reader;
778 if (SampleProfileReaderBinary::hasFormat(*B))
779 Reader.reset(new SampleProfileReaderBinary(std::move(B), C));
780 else if (SampleProfileReaderGCC::hasFormat(*B))
781 Reader.reset(new SampleProfileReaderGCC(std::move(B), C));
782 else if (SampleProfileReaderText::hasFormat(*B))
783 Reader.reset(new SampleProfileReaderText(std::move(B), C));
785 return sampleprof_error::unrecognized_format;
787 if (std::error_code EC = Reader->readHeader())
790 return std::move(Reader);
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.
795 void SampleProfileReader::computeSummary() {
796 SampleProfileSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);
797 for (const auto &I : Profiles) {
798 const FunctionSamples &Profile = I.second;
799 Builder.addRecord(Profile);
801 Summary = Builder.getSummary();