/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp

Bug Summary

File:	llvm/lib/ProfileData/SampleProfReader.cpp
Warning:	line 313, column 21 The left expression of the compound assignment is an uninitialized value. The computed value will also be garbage
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SampleProfReader.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/build-llvm/lib/ProfileData -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/build-llvm/lib/ProfileData -I /build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData -I /build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/include -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/build-llvm/lib/ProfileData -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-08-25-171901-26424-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp
1//===- SampleProfReader.cpp - Read LLVM sample profile data ---------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the class that reads LLVM sample profiles. It
10// supports three file formats: text, binary and gcov.
11//
12// The textual representation is useful for debugging and testing purposes. The
13// binary representation is more compact, resulting in smaller file sizes.
14//
15// The gcov encoding is the one generated by GCC's AutoFDO profile creation
16// tool (https://github.com/google/autofdo)
17//
18// All three encodings can be used interchangeably as an input sample profile.
19//
20//===----------------------------------------------------------------------===//

22#include "llvm/ProfileData/SampleProfReader.h"
23#include "llvm/ADT/DenseMap.h"
24#include "llvm/ADT/STLExtras.h"
25#include "llvm/ADT/StringRef.h"
26#include "llvm/IR/ProfileSummary.h"
27#include "llvm/ProfileData/ProfileCommon.h"
28#include "llvm/ProfileData/SampleProf.h"
29#include "llvm/Support/CommandLine.h"
30#include "llvm/Support/Compression.h"
31#include "llvm/Support/ErrorOr.h"
32#include "llvm/Support/LEB128.h"
33#include "llvm/Support/LineIterator.h"
34#include "llvm/Support/MD5.h"
35#include "llvm/Support/MemoryBuffer.h"
36#include "llvm/Support/raw_ostream.h"
37#include <algorithm>
38#include <cstddef>
39#include <cstdint>
40#include <limits>
41#include <memory>
42#include <set>
43#include <system_error>
44#include <vector>

46using namespace llvm;
47using namespace sampleprof;

49#define DEBUG_TYPE"samplepgo-reader" "samplepgo-reader"

51// This internal option specifies if the profile uses FS discriminators.
52// It only applies to text, binary and compact binary format profiles.
53// For ext-binary format profiles, the flag is set in the summary.
54static cl::opt<bool> ProfileIsFSDisciminator(
  "profile-isfs", cl::Hidden, cl::init(false),
  cl::desc("Profile uses flow sensitive discriminators"));

58/// Dump the function profile for \p FName.
59///
60/// \param FName Name of the function to print.
61/// \param OS Stream to emit the output to.
62void SampleProfileReader::dumpFunctionProfile(StringRef FName,
                                            raw_ostream &OS) {
OS << "Function: " << FName << ": " << Profiles[FName];
65}

67/// Dump all the function profiles found on stream \p OS.
68void SampleProfileReader::dump(raw_ostream &OS) {
std::vector<NameFunctionSamples> V;
sortFuncProfiles(Profiles, V);
for (const auto &I : V)
  dumpFunctionProfile(I.first, OS);
73}

75/// Parse \p Input as function head.
76///
77/// Parse one line of \p Input, and update function name in \p FName,
78/// function's total sample count in \p NumSamples, function's entry
79/// count in \p NumHeadSamples.
80///
81/// \returns true if parsing is successful.
82static bool ParseHead(const StringRef &Input, StringRef &FName,
                    uint64_t &NumSamples, uint64_t &NumHeadSamples) {
if (Input[0] == ' ')
  return false;
size_t n2 = Input.rfind(':');
size_t n1 = Input.rfind(':', n2 - 1);
FName = Input.substr(0, n1);
if (Input.substr(n1 + 1, n2 - n1 - 1).getAsInteger(10, NumSamples))
  return false;
if (Input.substr(n2 + 1).getAsInteger(10, NumHeadSamples))
  return false;
return true;
94}

96/// Returns true if line offset \p L is legal (only has 16 bits).
97static bool isOffsetLegal(unsigned L) { return (L & 0xffff) == L; }

99/// Parse \p Input that contains metadata.
100/// Possible metadata:
101/// - CFG Checksum information:
102///     !CFGChecksum: 12345
103/// - CFG Checksum information:
104///     !Attributes: 1
105/// Stores the FunctionHash (a.k.a. CFG Checksum) into \p FunctionHash.
106static bool parseMetadata(const StringRef &Input, uint64_t &FunctionHash,
                        uint32_t &Attributes) {
if (Input.startswith("!CFGChecksum:")) {
16
←
Assuming the condition is true→
17
←
Taking true branch→
  StringRef CFGInfo = Input.substr(strlen("!CFGChecksum:")).trim();
  return !CFGInfo.getAsInteger(10, FunctionHash);
18
←
Assuming the condition is true→
19
←
Returning the value 1, which participates in a condition later→
}

if (Input.startswith("!Attributes:")) {
  StringRef Attrib = Input.substr(strlen("!Attributes:")).trim();
  return !Attrib.getAsInteger(10, Attributes);
}

return false;
119}

121enum class LineType {
CallSiteProfile,
BodyProfile,
Metadata,
125};

127/// Parse \p Input as line sample.
128///
129/// \param Input input line.
130/// \param LineTy Type of this line.
131/// \param Depth the depth of the inline stack.
132/// \param NumSamples total samples of the line/inlined callsite.
133/// \param LineOffset line offset to the start of the function.
134/// \param Discriminator discriminator of the line.
135/// \param TargetCountMap map from indirect call target to count.
136/// \param FunctionHash the function's CFG hash, used by pseudo probe.
137///
138/// returns true if parsing is successful.
139static bool ParseLine(const StringRef &Input, LineType &LineTy, uint32_t &Depth,
                    uint64_t &NumSamples, uint32_t &LineOffset,
                    uint32_t &Discriminator, StringRef &CalleeName,
                    DenseMap<StringRef, uint64_t> &TargetCountMap,
                    uint64_t &FunctionHash, uint32_t &Attributes) {
for (Depth = 0; Input[Depth] == ' '; Depth++)
9
←
Assuming the condition is true→
10
←
Loop condition is true.  Entering loop body→
11
←
Assuming the condition is false→
12
←
Loop condition is false. Execution continues on line 146→
  ;
if (Depth12.1
'Depth' is not equal to 0
 == 0)
  return false;

if (Depth12.2
'Depth' is equal to 1
 == 1 && Input[Depth] == '!') {
13
←
Assuming the condition is true→
14
←
Taking true branch→
  LineTy = LineType::Metadata;
  return parseMetadata(Input.substr(Depth), FunctionHash, Attributes);
15
←
Calling 'parseMetadata'→
20
←
Returning from 'parseMetadata'→
21
←
Returning without writing to 'Discriminator'→
22
←
Returning the value 1, which participates in a condition later→
}

size_t n1 = Input.find(':');
StringRef Loc = Input.substr(Depth, n1 - Depth);
size_t n2 = Loc.find('.');
if (n2 == StringRef::npos) {
  if (Loc.getAsInteger(10, LineOffset) || !isOffsetLegal(LineOffset))
    return false;
  Discriminator = 0;
} else {
  if (Loc.substr(0, n2).getAsInteger(10, LineOffset))
    return false;
  if (Loc.substr(n2 + 1).getAsInteger(10, Discriminator))
    return false;
}

StringRef Rest = Input.substr(n1 + 2);
if (isDigit(Rest[0])) {
  LineTy = LineType::BodyProfile;
  size_t n3 = Rest.find(' ');
  if (n3 == StringRef::npos) {
    if (Rest.getAsInteger(10, NumSamples))
      return false;
  } else {
    if (Rest.substr(0, n3).getAsInteger(10, NumSamples))
      return false;
  }
  // Find call targets and their sample counts.
  // Note: In some cases, there are symbols in the profile which are not
  // mangled. To accommodate such cases, use colon + integer pairs as the
  // anchor points.
  // An example:
  // _M_construct<char *>:1000 string_view<std::allocator<char> >:437
  // ":1000" and ":437" are used as anchor points so the string above will
  // be interpreted as
  // target: _M_construct<char *>
  // count: 1000
  // target: string_view<std::allocator<char> >
  // count: 437
  while (n3 != StringRef::npos) {
    n3 += Rest.substr(n3).find_first_not_of(' ');
    Rest = Rest.substr(n3);
    n3 = Rest.find_first_of(':');
    if (n3 == StringRef::npos || n3 == 0)
      return false;

    StringRef Target;
    uint64_t count, n4;
    while (true) {
      // Get the segment after the current colon.
      StringRef AfterColon = Rest.substr(n3 + 1);
      // Get the target symbol before the current colon.
      Target = Rest.substr(0, n3);
      // Check if the word after the current colon is an integer.
      n4 = AfterColon.find_first_of(' ');
      n4 = (n4 != StringRef::npos) ? n3 + n4 + 1 : Rest.size();
      StringRef WordAfterColon = Rest.substr(n3 + 1, n4 - n3 - 1);
      if (!WordAfterColon.getAsInteger(10, count))
        break;

      // Try to find the next colon.
      uint64_t n5 = AfterColon.find_first_of(':');
      if (n5 == StringRef::npos)
        return false;
      n3 += n5 + 1;
    }

    // An anchor point is found. Save the {target, count} pair
    TargetCountMap[Target] = count;
    if (n4 == Rest.size())
      break;
    // Change n3 to the next blank space after colon + integer pair.
    n3 = n4;
  }
} else {
  LineTy = LineType::CallSiteProfile;
  size_t n3 = Rest.find_last_of(':');
  CalleeName = Rest.substr(0, n3);
  if (Rest.substr(n3 + 1).getAsInteger(10, NumSamples))
    return false;
}
return true;
234}

236/// Load samples from a text file.
237///
238/// See the documentation at the top of the file for an explanation of
239/// the expected format.
240///
241/// \returns true if the file was loaded successfully, false otherwise.
242std::error_code SampleProfileReaderText::readImpl() {
line_iterator LineIt(*Buffer, /*SkipBlanks=*/true, '#');
sampleprof_error Result = sampleprof_error::success;

InlineCallStack InlineStack;
uint32_t ProbeProfileCount = 0;

// SeenMetadata tracks whether we have processed metadata for the current
// top-level function profile.
bool SeenMetadata = false;

ProfileIsFS = ProfileIsFSDisciminator;
for (; !LineIt.is_at_eof(); ++LineIt) {
1
Assuming the condition is true→
2
←
Loop condition is true.  Entering loop body→
  if ((*LineIt)[(*LineIt).find_first_not_of(' ')] == '#')
3
←
Assuming the condition is false→
4
←
Taking false branch→
    continue;
  // Read the header of each function.
  //
  // Note that for function identifiers we are actually expecting
  // mangled names, but we may not always get them. This happens when
  // the compiler decides not to emit the function (e.g., it was inlined
  // and removed). In this case, the binary will not have the linkage
  // name for the function, so the profiler will emit the function's
  // unmangled name, which may contain characters like ':' and '>' in its
  // name (member functions, templates, etc).
  //
  // The only requirement we place on the identifier, then, is that it
  // should not begin with a number.
  if ((*LineIt)[0] != ' ') {
5
←
Assuming the condition is false→
6
←
Taking false branch→
    uint64_t NumSamples, NumHeadSamples;
    StringRef FName;
    if (!ParseHead(*LineIt, FName, NumSamples, NumHeadSamples)) {
      reportError(LineIt.line_number(),
                  "Expected 'mangled_name:NUM:NUM', found " + *LineIt);
      return sampleprof_error::malformed;
    }
    SeenMetadata = false;
    SampleContext FContext(FName);
    if (FContext.hasContext())
      ++CSProfileCount;
    Profiles[FContext] = FunctionSamples();
    FunctionSamples &FProfile = Profiles[FContext];
    FProfile.setName(FContext.getNameWithoutContext());
    FProfile.setContext(FContext);
    MergeResult(Result, FProfile.addTotalSamples(NumSamples));
    MergeResult(Result, FProfile.addHeadSamples(NumHeadSamples));
    InlineStack.clear();
    InlineStack.push_back(&FProfile);
  } else {
    uint64_t NumSamples;
    StringRef FName;
    DenseMap<StringRef, uint64_t> TargetCountMap;
    uint32_t Depth, LineOffset, Discriminator;
7
←
'Discriminator' declared without an initial value→
    LineType LineTy;
    uint64_t FunctionHash = 0;
    uint32_t Attributes = 0;
    if (!ParseLine(*LineIt, LineTy, Depth, NumSamples, LineOffset,
8
←
Calling 'ParseLine'→
23
←
Returning from 'ParseLine'→
                   Discriminator, FName, TargetCountMap, FunctionHash,
                   Attributes)) {
      reportError(LineIt.line_number(),
                  "Expected 'NUM[.NUM]: NUM[ mangled_name:NUM]*', found " +
                      *LineIt);
      return sampleprof_error::malformed;
    }
    if (SeenMetadata23.1
'SeenMetadata' is false
 && LineTy != LineType::Metadata) {
      // Metadata must be put at the end of a function profile.
      reportError(LineIt.line_number(),
                  "Found non-metadata after metadata: " + *LineIt);
      return sampleprof_error::malformed;
    }

    // Here we handle FS discriminators.
    Discriminator &= getDiscriminatorMask();
24
←
The left expression of the compound assignment is an uninitialized value. The computed value will also be garbage

    while (InlineStack.size() > Depth) {
      InlineStack.pop_back();
    }
    switch (LineTy) {
    case LineType::CallSiteProfile: {
      FunctionSamples &FSamples = InlineStack.back()->functionSamplesAt(
          LineLocation(LineOffset, Discriminator))[std::string(FName)];
      FSamples.setName(FName);
      MergeResult(Result, FSamples.addTotalSamples(NumSamples));
      InlineStack.push_back(&FSamples);
      break;
    }
    case LineType::BodyProfile: {
      while (InlineStack.size() > Depth) {
        InlineStack.pop_back();
      }
      FunctionSamples &FProfile = *InlineStack.back();
      for (const auto &name_count : TargetCountMap) {
        MergeResult(Result, FProfile.addCalledTargetSamples(
                                LineOffset, Discriminator, name_count.first,
                                name_count.second));
      }
      MergeResult(Result, FProfile.addBodySamples(LineOffset, Discriminator,
                                                  NumSamples));
      break;
    }
    case LineType::Metadata: {
      FunctionSamples &FProfile = *InlineStack.back();
      if (FunctionHash) {
        FProfile.setFunctionHash(FunctionHash);
        ++ProbeProfileCount;
      }
      if (Attributes)
        FProfile.getContext().setAllAttributes(Attributes);
      SeenMetadata = true;
      break;
    }
    }
  }
}

assert((CSProfileCount == 0 || CSProfileCount == Profiles.size()) &&(static_cast <bool> ((CSProfileCount == 0 || CSProfileCount
 == Profiles.size()) && "Cannot have both context-sensitive and regular profile"
) ? void (0) : __assert_fail ("(CSProfileCount == 0 || CSProfileCount == Profiles.size()) && \"Cannot have both context-sensitive and regular profile\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 357, __extension__ __PRETTY_FUNCTION__))
       "Cannot have both context-sensitive and regular profile")(static_cast <bool> ((CSProfileCount == 0 || CSProfileCount
 == Profiles.size()) && "Cannot have both context-sensitive and regular profile"
) ? void (0) : __assert_fail ("(CSProfileCount == 0 || CSProfileCount == Profiles.size()) && \"Cannot have both context-sensitive and regular profile\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 357, __extension__ __PRETTY_FUNCTION__));
ProfileIsCS = (CSProfileCount > 0);
assert((ProbeProfileCount == 0 || ProbeProfileCount == Profiles.size()) &&(static_cast <bool> ((ProbeProfileCount == 0 || ProbeProfileCount
 == Profiles.size()) && "Cannot have both probe-based profiles and regular profiles"
) ? void (0) : __assert_fail ("(ProbeProfileCount == 0 || ProbeProfileCount == Profiles.size()) && \"Cannot have both probe-based profiles and regular profiles\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 360, __extension__ __PRETTY_FUNCTION__))
       "Cannot have both probe-based profiles and regular profiles")(static_cast <bool> ((ProbeProfileCount == 0 || ProbeProfileCount
 == Profiles.size()) && "Cannot have both probe-based profiles and regular profiles"
) ? void (0) : __assert_fail ("(ProbeProfileCount == 0 || ProbeProfileCount == Profiles.size()) && \"Cannot have both probe-based profiles and regular profiles\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 360, __extension__ __PRETTY_FUNCTION__));
ProfileIsProbeBased = (ProbeProfileCount > 0);
FunctionSamples::ProfileIsProbeBased = ProfileIsProbeBased;
FunctionSamples::ProfileIsCS = ProfileIsCS;

if (Result == sampleprof_error::success)
  computeSummary();

return Result;
369}

371bool SampleProfileReaderText::hasFormat(const MemoryBuffer &Buffer) {
bool result = false;

// Check that the first non-comment line is a valid function header.
line_iterator LineIt(Buffer, /*SkipBlanks=*/true, '#');
if (!LineIt.is_at_eof()) {
  if ((*LineIt)[0] != ' ') {
    uint64_t NumSamples, NumHeadSamples;
    StringRef FName;
    result = ParseHead(*LineIt, FName, NumSamples, NumHeadSamples);
  }
}

return result;
385}

387template <typename T> ErrorOr<T> SampleProfileReaderBinary::readNumber() {
unsigned NumBytesRead = 0;
std::error_code EC;
uint64_t Val = decodeULEB128(Data, &NumBytesRead);

if (Val > std::numeric_limits<T>::max())
  EC = sampleprof_error::malformed;
else if (Data + NumBytesRead > End)
  EC = sampleprof_error::truncated;
else
  EC = sampleprof_error::success;

if (EC) {
  reportError(0, EC.message());
  return EC;
}

Data += NumBytesRead;
return static_cast<T>(Val);
406}

408ErrorOr<StringRef> SampleProfileReaderBinary::readString() {
std::error_code EC;
StringRef Str(reinterpret_cast<const char *>(Data));
if (Data + Str.size() + 1 > End) {
  EC = sampleprof_error::truncated;
  reportError(0, EC.message());
  return EC;
}

Data += Str.size() + 1;
return Str;
419}

421template <typename T>
422ErrorOr<T> SampleProfileReaderBinary::readUnencodedNumber() {
std::error_code EC;

if (Data + sizeof(T) > End) {
  EC = sampleprof_error::truncated;
  reportError(0, EC.message());
  return EC;
}

using namespace support;
T Val = endian::readNext<T, little, unaligned>(Data);
return Val;
434}

436template <typename T>
437inline ErrorOr<uint32_t> SampleProfileReaderBinary::readStringIndex(T &Table) {
std::error_code EC;
auto Idx = readNumber<uint32_t>();
if (std::error_code EC = Idx.getError())
  return EC;
if (*Idx >= Table.size())
  return sampleprof_error::truncated_name_table;
return *Idx;
445}

447ErrorOr<StringRef> SampleProfileReaderBinary::readStringFromTable() {
auto Idx = readStringIndex(NameTable);
if (std::error_code EC = Idx.getError())
  return EC;

return NameTable[*Idx];
453}

455ErrorOr<StringRef> SampleProfileReaderExtBinaryBase::readStringFromTable() {
if (!FixedLengthMD5)
  return SampleProfileReaderBinary::readStringFromTable();

// read NameTable index.
auto Idx = readStringIndex(NameTable);
if (std::error_code EC = Idx.getError())
  return EC;

// Check whether the name to be accessed has been accessed before,
// if not, read it from memory directly.
StringRef &SR = NameTable[*Idx];
if (SR.empty()) {
  const uint8_t *SavedData = Data;
  Data = MD5NameMemStart + ((*Idx) * sizeof(uint64_t));
  auto FID = readUnencodedNumber<uint64_t>();
  if (std::error_code EC = FID.getError())
    return EC;
  // Save the string converted from uint64_t in MD5StringBuf. All the
  // references to the name are all StringRefs refering to the string
  // in MD5StringBuf.
  MD5StringBuf->push_back(std::to_string(*FID));
  SR = MD5StringBuf->back();
  Data = SavedData;
}
return SR;
481}

483ErrorOr<StringRef> SampleProfileReaderCompactBinary::readStringFromTable() {
auto Idx = readStringIndex(NameTable);
if (std::error_code EC = Idx.getError())
  return EC;

return StringRef(NameTable[*Idx]);
489}

491std::error_code
492SampleProfileReaderBinary::readProfile(FunctionSamples &FProfile) {
auto NumSamples = readNumber<uint64_t>();
if (std::error_code EC = NumSamples.getError())
  return EC;
FProfile.addTotalSamples(*NumSamples);

// Read the samples in the body.
auto NumRecords = readNumber<uint32_t>();
if (std::error_code EC = NumRecords.getError())
  return EC;

for (uint32_t I = 0; I < *NumRecords; ++I) {
  auto LineOffset = readNumber<uint64_t>();
  if (std::error_code EC = LineOffset.getError())
    return EC;

  if (!isOffsetLegal(*LineOffset)) {
    return std::error_code();
  }

  auto Discriminator = readNumber<uint64_t>();
  if (std::error_code EC = Discriminator.getError())
    return EC;

  auto NumSamples = readNumber<uint64_t>();
  if (std::error_code EC = NumSamples.getError())
    return EC;

  auto NumCalls = readNumber<uint32_t>();
  if (std::error_code EC = NumCalls.getError())
    return EC;

  // Here we handle FS discriminators:
  uint32_t DiscriminatorVal = (*Discriminator) & getDiscriminatorMask();

  for (uint32_t J = 0; J < *NumCalls; ++J) {
    auto CalledFunction(readStringFromTable());
    if (std::error_code EC = CalledFunction.getError())
      return EC;

    auto CalledFunctionSamples = readNumber<uint64_t>();
    if (std::error_code EC = CalledFunctionSamples.getError())
      return EC;

    FProfile.addCalledTargetSamples(*LineOffset, DiscriminatorVal,
                                    *CalledFunction, *CalledFunctionSamples);
  }

  FProfile.addBodySamples(*LineOffset, DiscriminatorVal, *NumSamples);
}

// Read all the samples for inlined function calls.
auto NumCallsites = readNumber<uint32_t>();
if (std::error_code EC = NumCallsites.getError())
  return EC;

for (uint32_t J = 0; J < *NumCallsites; ++J) {
  auto LineOffset = readNumber<uint64_t>();
  if (std::error_code EC = LineOffset.getError())
    return EC;

  auto Discriminator = readNumber<uint64_t>();
  if (std::error_code EC = Discriminator.getError())
    return EC;

  auto FName(readStringFromTable());
  if (std::error_code EC = FName.getError())
    return EC;

  // Here we handle FS discriminators:
  uint32_t DiscriminatorVal = (*Discriminator) & getDiscriminatorMask();

  FunctionSamples &CalleeProfile = FProfile.functionSamplesAt(
      LineLocation(*LineOffset, DiscriminatorVal))[std::string(*FName)];
  CalleeProfile.setName(*FName);
  if (std::error_code EC = readProfile(CalleeProfile))
    return EC;
}

return sampleprof_error::success;
572}

574std::error_code
575SampleProfileReaderBinary::readFuncProfile(const uint8_t *Start) {
Data = Start;
auto NumHeadSamples = readNumber<uint64_t>();
if (std::error_code EC = NumHeadSamples.getError())
  return EC;

auto FName(readStringFromTable());
if (std::error_code EC = FName.getError())
  return EC;

SampleContext FContext(*FName);
Profiles[FContext] = FunctionSamples();
FunctionSamples &FProfile = Profiles[FContext];
FProfile.setName(FContext.getNameWithoutContext());
FProfile.setContext(FContext);
FProfile.addHeadSamples(*NumHeadSamples);

if (FContext.hasContext())
  CSProfileCount++;

if (std::error_code EC = readProfile(FProfile))
  return EC;
return sampleprof_error::success;
598}

600std::error_code SampleProfileReaderBinary::readImpl() {
ProfileIsFS = ProfileIsFSDisciminator;
while (!at_eof()) {
  if (std::error_code EC = readFuncProfile(Data))
    return EC;
}

return sampleprof_error::success;
608}

610std::error_code SampleProfileReaderExtBinaryBase::readOneSection(
  const uint8_t *Start, uint64_t Size, const SecHdrTableEntry &Entry) {
Data = Start;
End = Start + Size;
switch (Entry.Type) {
case SecProfSummary:
  if (std::error_code EC = readSummary())
    return EC;
  if (hasSecFlag(Entry, SecProfSummaryFlags::SecFlagPartial))
    Summary->setPartialProfile(true);
  if (hasSecFlag(Entry, SecProfSummaryFlags::SecFlagFullContext))
    FunctionSamples::ProfileIsCS = ProfileIsCS = true;
  if (hasSecFlag(Entry, SecProfSummaryFlags::SecFlagFSDiscriminator))
    FunctionSamples::ProfileIsFS = ProfileIsFS = true;
  break;
case SecNameTable: {
  FixedLengthMD5 =
      hasSecFlag(Entry, SecNameTableFlags::SecFlagFixedLengthMD5);
  bool UseMD5 = hasSecFlag(Entry, SecNameTableFlags::SecFlagMD5Name);
  assert((!FixedLengthMD5 || UseMD5) &&(static_cast <bool> ((!FixedLengthMD5 || UseMD5) &&
 "If FixedLengthMD5 is true, UseMD5 has to be true") ? void (
0) : __assert_fail ("(!FixedLengthMD5 || UseMD5) && \"If FixedLengthMD5 is true, UseMD5 has to be true\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 630, __extension__ __PRETTY_FUNCTION__))
         "If FixedLengthMD5 is true, UseMD5 has to be true")(static_cast <bool> ((!FixedLengthMD5 || UseMD5) &&
 "If FixedLengthMD5 is true, UseMD5 has to be true") ? void (
0) : __assert_fail ("(!FixedLengthMD5 || UseMD5) && \"If FixedLengthMD5 is true, UseMD5 has to be true\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 630, __extension__ __PRETTY_FUNCTION__));
  FunctionSamples::HasUniqSuffix =
      hasSecFlag(Entry, SecNameTableFlags::SecFlagUniqSuffix);
  if (std::error_code EC = readNameTableSec(UseMD5))
    return EC;
  break;
}
case SecLBRProfile:
  if (std::error_code EC = readFuncProfiles())
    return EC;
  break;
case SecFuncOffsetTable:
  if (std::error_code EC = readFuncOffsetTable())
    return EC;
  break;
case SecFuncMetadata: {
  ProfileIsProbeBased =
      hasSecFlag(Entry, SecFuncMetadataFlags::SecFlagIsProbeBased);
  FunctionSamples::ProfileIsProbeBased = ProfileIsProbeBased;
  bool HasAttribute =
      hasSecFlag(Entry, SecFuncMetadataFlags::SecFlagHasAttribute);
  if (std::error_code EC = readFuncMetadata(HasAttribute))
    return EC;
  break;
}
case SecProfileSymbolList:
  if (std::error_code EC = readProfileSymbolList())
    return EC;
  break;
default:
  if (std::error_code EC = readCustomSection(Entry))
    return EC;
  break;
}
return sampleprof_error::success;
665}

667bool SampleProfileReaderExtBinaryBase::collectFuncsFromModule() {
if (!M)
  return false;
FuncsToUse.clear();
for (auto &F : *M)
  FuncsToUse.insert(FunctionSamples::getCanonicalFnName(F));
return true;
674}

676std::error_code SampleProfileReaderExtBinaryBase::readFuncOffsetTable() {
// If there are more than one FuncOffsetTable, the profile read associated
// with previous FuncOffsetTable has to be done before next FuncOffsetTable
// is read.
FuncOffsetTable.clear();

auto Size = readNumber<uint64_t>();
if (std::error_code EC = Size.getError())
  return EC;

FuncOffsetTable.reserve(*Size);
for (uint32_t I = 0; I < *Size; ++I) {
  auto FName(readStringFromTable());
  if (std::error_code EC = FName.getError())
    return EC;

  auto Offset = readNumber<uint64_t>();
  if (std::error_code EC = Offset.getError())
    return EC;

  FuncOffsetTable[*FName] = *Offset;
}
return sampleprof_error::success;
699}

701std::error_code SampleProfileReaderExtBinaryBase::readFuncProfiles() {
// Collect functions used by current module if the Reader has been
// given a module.
// collectFuncsFromModule uses FunctionSamples::getCanonicalFnName
// which will query FunctionSamples::HasUniqSuffix, so it has to be
// called after FunctionSamples::HasUniqSuffix is set, i.e. after
// NameTable section is read.
bool LoadFuncsToBeUsed = collectFuncsFromModule();

// When LoadFuncsToBeUsed is false, load all the function profiles.
const uint8_t *Start = Data;
if (!LoadFuncsToBeUsed) {
  while (Data < End) {
    if (std::error_code EC = readFuncProfile(Data))
      return EC;
  }
  assert(Data == End && "More data is read than expected")(static_cast <bool> (Data == End && "More data is read than expected"
) ? void (0) : __assert_fail ("Data == End && \"More data is read than expected\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 717, __extension__ __PRETTY_FUNCTION__));
} else {
  // Load function profiles on demand.
  if (Remapper) {
    for (auto Name : FuncsToUse) {
      Remapper->insert(Name);
    }
  }

  if (useMD5()) {
    for (auto Name : FuncsToUse) {
      auto GUID = std::to_string(MD5Hash(Name));
      auto iter = FuncOffsetTable.find(StringRef(GUID));
      if (iter == FuncOffsetTable.end())
        continue;
      const uint8_t *FuncProfileAddr = Start + iter->second;
      assert(FuncProfileAddr < End && "out of LBRProfile section")(static_cast <bool> (FuncProfileAddr < End &&
 "out of LBRProfile section") ? void (0) : __assert_fail ("FuncProfileAddr < End && \"out of LBRProfile section\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 733, __extension__ __PRETTY_FUNCTION__));
      if (std::error_code EC = readFuncProfile(FuncProfileAddr))
        return EC;
    }
  } else if (FunctionSamples::ProfileIsCS) {
    // Compute the ordered set of names, so we can
    // get all context profiles under a subtree by
    // iterating through the ordered names.
    struct Comparer {
      // Ignore the closing ']' when ordering context
      bool operator()(const StringRef &L, const StringRef &R) const {
        return L.substr(0, L.size() - 1) < R.substr(0, R.size() - 1);
      }
    };
    std::set<StringRef, Comparer> OrderedNames;
    for (auto Name : FuncOffsetTable) {
      OrderedNames.insert(Name.first);
    }

    // For each function in current module, load all
    // context profiles for the function.
    for (auto NameOffset : FuncOffsetTable) {
      StringRef ContextName = NameOffset.first;
      SampleContext FContext(ContextName);
      auto FuncName = FContext.getNameWithoutContext();
      if (!FuncsToUse.count(FuncName) &&
          (!Remapper || !Remapper->exist(FuncName)))
        continue;

      // For each context profile we need, try to load
      // all context profile in the subtree. This can
      // help profile guided importing for ThinLTO.
      auto It = OrderedNames.find(ContextName);
      while (It != OrderedNames.end() &&
             It->startswith(ContextName.substr(0, ContextName.size() - 1))) {
        const uint8_t *FuncProfileAddr = Start + FuncOffsetTable[*It];
        assert(FuncProfileAddr < End && "out of LBRProfile section")(static_cast <bool> (FuncProfileAddr < End &&
 "out of LBRProfile section") ? void (0) : __assert_fail ("FuncProfileAddr < End && \"out of LBRProfile section\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 769, __extension__ __PRETTY_FUNCTION__));
        if (std::error_code EC = readFuncProfile(FuncProfileAddr))
          return EC;
        // Remove loaded context profile so we won't
        // load it repeatedly.
        It = OrderedNames.erase(It);
      }
    }
  } else {
    for (auto NameOffset : FuncOffsetTable) {
      SampleContext FContext(NameOffset.first);
      auto FuncName = FContext.getNameWithoutContext();
      if (!FuncsToUse.count(FuncName) &&
          (!Remapper || !Remapper->exist(FuncName)))
        continue;
      const uint8_t *FuncProfileAddr = Start + NameOffset.second;
      assert(FuncProfileAddr < End && "out of LBRProfile section")(static_cast <bool> (FuncProfileAddr < End &&
 "out of LBRProfile section") ? void (0) : __assert_fail ("FuncProfileAddr < End && \"out of LBRProfile section\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 785, __extension__ __PRETTY_FUNCTION__));
      if (std::error_code EC = readFuncProfile(FuncProfileAddr))
        return EC;
    }
  }
  Data = End;
}
assert((CSProfileCount == 0 || CSProfileCount == Profiles.size()) &&(static_cast <bool> ((CSProfileCount == 0 || CSProfileCount
 == Profiles.size()) && "Cannot have both context-sensitive and regular profile"
) ? void (0) : __assert_fail ("(CSProfileCount == 0 || CSProfileCount == Profiles.size()) && \"Cannot have both context-sensitive and regular profile\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 793, __extension__ __PRETTY_FUNCTION__))
       "Cannot have both context-sensitive and regular profile")(static_cast <bool> ((CSProfileCount == 0 || CSProfileCount
 == Profiles.size()) && "Cannot have both context-sensitive and regular profile"
) ? void (0) : __assert_fail ("(CSProfileCount == 0 || CSProfileCount == Profiles.size()) && \"Cannot have both context-sensitive and regular profile\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 793, __extension__ __PRETTY_FUNCTION__));
assert(ProfileIsCS == (CSProfileCount > 0) &&(static_cast <bool> (ProfileIsCS == (CSProfileCount >
 0) && "Section flag should be consistent with actual profile"
) ? void (0) : __assert_fail ("ProfileIsCS == (CSProfileCount > 0) && \"Section flag should be consistent with actual profile\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 795, __extension__ __PRETTY_FUNCTION__))
       "Section flag should be consistent with actual profile")(static_cast <bool> (ProfileIsCS == (CSProfileCount >
 0) && "Section flag should be consistent with actual profile"
) ? void (0) : __assert_fail ("ProfileIsCS == (CSProfileCount > 0) && \"Section flag should be consistent with actual profile\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 795, __extension__ __PRETTY_FUNCTION__));
return sampleprof_error::success;
797}

799std::error_code SampleProfileReaderExtBinaryBase::readProfileSymbolList() {
if (!ProfSymList)
  ProfSymList = std::make_unique<ProfileSymbolList>();

if (std::error_code EC = ProfSymList->read(Data, End - Data))
  return EC;

Data = End;
return sampleprof_error::success;
808}

810std::error_code SampleProfileReaderExtBinaryBase::decompressSection(
  const uint8_t *SecStart, const uint64_t SecSize,
  const uint8_t *&DecompressBuf, uint64_t &DecompressBufSize) {
Data = SecStart;
End = SecStart + SecSize;
auto DecompressSize = readNumber<uint64_t>();
if (std::error_code EC = DecompressSize.getError())
  return EC;
DecompressBufSize = *DecompressSize;

auto CompressSize = readNumber<uint64_t>();
if (std::error_code EC = CompressSize.getError())
  return EC;

if (!llvm::zlib::isAvailable())
  return sampleprof_error::zlib_unavailable;

StringRef CompressedStrings(reinterpret_cast<const char *>(Data),
                            *CompressSize);
char *Buffer = Allocator.Allocate<char>(DecompressBufSize);
size_t UCSize = DecompressBufSize;
llvm::Error E =
    zlib::uncompress(CompressedStrings, Buffer, UCSize);
if (E)
  return sampleprof_error::uncompress_failed;
DecompressBuf = reinterpret_cast<const uint8_t *>(Buffer);
return sampleprof_error::success;
837}

839std::error_code SampleProfileReaderExtBinaryBase::readImpl() {
const uint8_t *BufStart =
    reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());

for (auto &Entry : SecHdrTable) {
  // Skip empty section.
  if (!Entry.Size)
    continue;

  // Skip sections without context when SkipFlatProf is true.
  if (SkipFlatProf && hasSecFlag(Entry, SecCommonFlags::SecFlagFlat))
    continue;

  const uint8_t *SecStart = BufStart + Entry.Offset;
  uint64_t SecSize = Entry.Size;

  // If the section is compressed, decompress it into a buffer
  // DecompressBuf before reading the actual data. The pointee of
  // 'Data' will be changed to buffer hold by DecompressBuf
  // temporarily when reading the actual data.
  bool isCompressed = hasSecFlag(Entry, SecCommonFlags::SecFlagCompress);
  if (isCompressed) {
    const uint8_t *DecompressBuf;
    uint64_t DecompressBufSize;
    if (std::error_code EC = decompressSection(
            SecStart, SecSize, DecompressBuf, DecompressBufSize))
      return EC;
    SecStart = DecompressBuf;
    SecSize = DecompressBufSize;
  }

  if (std::error_code EC = readOneSection(SecStart, SecSize, Entry))
    return EC;
  if (Data != SecStart + SecSize)
    return sampleprof_error::malformed;

  // Change the pointee of 'Data' from DecompressBuf to original Buffer.
  if (isCompressed) {
    Data = BufStart + Entry.Offset;
    End = BufStart + Buffer->getBufferSize();
  }
}

return sampleprof_error::success;
883}

885std::error_code SampleProfileReaderCompactBinary::readImpl() {
// Collect functions used by current module if the Reader has been
// given a module.
bool LoadFuncsToBeUsed = collectFuncsFromModule();
ProfileIsFS = ProfileIsFSDisciminator;
std::vector<uint64_t> OffsetsToUse;
if (!LoadFuncsToBeUsed) {
  // load all the function profiles.
  for (auto FuncEntry : FuncOffsetTable) {
    OffsetsToUse.push_back(FuncEntry.second);
  }
} else {
  // load function profiles on demand.
  for (auto Name : FuncsToUse) {
    auto GUID = std::to_string(MD5Hash(Name));
    auto iter = FuncOffsetTable.find(StringRef(GUID));
    if (iter == FuncOffsetTable.end())
      continue;
    OffsetsToUse.push_back(iter->second);
  }
}

for (auto Offset : OffsetsToUse) {
  const uint8_t *SavedData = Data;
  if (std::error_code EC = readFuncProfile(
          reinterpret_cast<const uint8_t *>(Buffer->getBufferStart()) +
          Offset))
    return EC;
  Data = SavedData;
}
return sampleprof_error::success;
916}

918std::error_code SampleProfileReaderRawBinary::verifySPMagic(uint64_t Magic) {
if (Magic == SPMagic())
  return sampleprof_error::success;
return sampleprof_error::bad_magic;
922}

924std::error_code SampleProfileReaderExtBinary::verifySPMagic(uint64_t Magic) {
if (Magic == SPMagic(SPF_Ext_Binary))
  return sampleprof_error::success;
return sampleprof_error::bad_magic;
928}

930std::error_code
931SampleProfileReaderCompactBinary::verifySPMagic(uint64_t Magic) {
if (Magic == SPMagic(SPF_Compact_Binary))
  return sampleprof_error::success;
return sampleprof_error::bad_magic;
935}

937std::error_code SampleProfileReaderBinary::readNameTable() {
auto Size = readNumber<uint32_t>();
if (std::error_code EC = Size.getError())
  return EC;
NameTable.reserve(*Size + NameTable.size());
for (uint32_t I = 0; I < *Size; ++I) {
  auto Name(readString());
  if (std::error_code EC = Name.getError())
    return EC;
  NameTable.push_back(*Name);
}

return sampleprof_error::success;
950}

952std::error_code SampleProfileReaderExtBinaryBase::readMD5NameTable() {
auto Size = readNumber<uint64_t>();
if (std::error_code EC = Size.getError())
  return EC;
MD5StringBuf = std::make_unique<std::vector<std::string>>();
MD5StringBuf->reserve(*Size);
if (FixedLengthMD5) {
  // Preallocate and initialize NameTable so we can check whether a name
  // index has been read before by checking whether the element in the
  // NameTable is empty, meanwhile readStringIndex can do the boundary
  // check using the size of NameTable.
  NameTable.resize(*Size + NameTable.size());

  MD5NameMemStart = Data;
  Data = Data + (*Size) * sizeof(uint64_t);
  return sampleprof_error::success;
}
NameTable.reserve(*Size);
for (uint32_t I = 0; I < *Size; ++I) {
  auto FID = readNumber<uint64_t>();
  if (std::error_code EC = FID.getError())
    return EC;
  MD5StringBuf->push_back(std::to_string(*FID));
  // NameTable is a vector of StringRef. Here it is pushing back a
  // StringRef initialized with the last string in MD5stringBuf.
  NameTable.push_back(MD5StringBuf->back());
}
return sampleprof_error::success;
980}

982std::error_code SampleProfileReaderExtBinaryBase::readNameTableSec(bool IsMD5) {
if (IsMD5)
  return readMD5NameTable();
return SampleProfileReaderBinary::readNameTable();
986}

988std::error_code
989SampleProfileReaderExtBinaryBase::readFuncMetadata(bool ProfileHasAttribute) {
while (Data < End) {
  auto FName(readStringFromTable());
  if (std::error_code EC = FName.getError())
    return EC;

  SampleContext FContext(*FName);
  bool ProfileInMap = Profiles.count(FContext);

  if (ProfileIsProbeBased) {
    auto Checksum = readNumber<uint64_t>();
    if (std::error_code EC = Checksum.getError())
      return EC;
    if (ProfileInMap)
      Profiles[FContext].setFunctionHash(*Checksum);
  }

  if (ProfileHasAttribute) {
    auto Attributes = readNumber<uint32_t>();
    if (std::error_code EC = Attributes.getError())
      return EC;
    if (ProfileInMap)
      Profiles[FContext].getContext().setAllAttributes(*Attributes);
  }
}

assert(Data == End && "More data is read than expected")(static_cast <bool> (Data == End && "More data is read than expected"
) ? void (0) : __assert_fail ("Data == End && \"More data is read than expected\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 1015, __extension__ __PRETTY_FUNCTION__));
return sampleprof_error::success;
1017}

1019std::error_code SampleProfileReaderCompactBinary::readNameTable() {
auto Size = readNumber<uint64_t>();
if (std::error_code EC = Size.getError())
  return EC;
NameTable.reserve(*Size);
for (uint32_t I = 0; I < *Size; ++I) {
  auto FID = readNumber<uint64_t>();
  if (std::error_code EC = FID.getError())
    return EC;
  NameTable.push_back(std::to_string(*FID));
}
return sampleprof_error::success;
1031}

1033std::error_code
1034SampleProfileReaderExtBinaryBase::readSecHdrTableEntry(uint32_t Idx) {
SecHdrTableEntry Entry;
auto Type = readUnencodedNumber<uint64_t>();
if (std::error_code EC = Type.getError())
  return EC;
Entry.Type = static_cast<SecType>(*Type);

auto Flags = readUnencodedNumber<uint64_t>();
if (std::error_code EC = Flags.getError())
  return EC;
Entry.Flags = *Flags;

auto Offset = readUnencodedNumber<uint64_t>();
if (std::error_code EC = Offset.getError())
  return EC;
Entry.Offset = *Offset;

auto Size = readUnencodedNumber<uint64_t>();
if (std::error_code EC = Size.getError())
  return EC;
Entry.Size = *Size;

Entry.LayoutIndex = Idx;
SecHdrTable.push_back(std::move(Entry));
return sampleprof_error::success;
1059}

1061std::error_code SampleProfileReaderExtBinaryBase::readSecHdrTable() {
auto EntryNum = readUnencodedNumber<uint64_t>();
if (std::error_code EC = EntryNum.getError())
  return EC;

for (uint32_t i = 0; i < (*EntryNum); i++)
  if (std::error_code EC = readSecHdrTableEntry(i))
    return EC;

return sampleprof_error::success;
1071}

1073std::error_code SampleProfileReaderExtBinaryBase::readHeader() {
const uint8_t *BufStart =
    reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
Data = BufStart;
End = BufStart + Buffer->getBufferSize();

if (std::error_code EC = readMagicIdent())
  return EC;

if (std::error_code EC = readSecHdrTable())
  return EC;

return sampleprof_error::success;
1086}

1088uint64_t SampleProfileReaderExtBinaryBase::getSectionSize(SecType Type) {
uint64_t Size = 0;
for (auto &Entry : SecHdrTable) {
  if (Entry.Type == Type)
    Size += Entry.Size;
}
return Size;
1095}

1097uint64_t SampleProfileReaderExtBinaryBase::getFileSize() {
// Sections in SecHdrTable is not necessarily in the same order as
// sections in the profile because section like FuncOffsetTable needs
// to be written after section LBRProfile but needs to be read before
// section LBRProfile, so we cannot simply use the last entry in
// SecHdrTable to calculate the file size.
uint64_t FileSize = 0;
for (auto &Entry : SecHdrTable) {
  FileSize = std::max(Entry.Offset + Entry.Size, FileSize);
}
return FileSize;
1108}

1110static std::string getSecFlagsStr(const SecHdrTableEntry &Entry) {
std::string Flags;
if (hasSecFlag(Entry, SecCommonFlags::SecFlagCompress))
  Flags.append("{compressed,");
else
  Flags.append("{");

if (hasSecFlag(Entry, SecCommonFlags::SecFlagFlat))
  Flags.append("flat,");

switch (Entry.Type) {
case SecNameTable:
  if (hasSecFlag(Entry, SecNameTableFlags::SecFlagFixedLengthMD5))
    Flags.append("fixlenmd5,");
  else if (hasSecFlag(Entry, SecNameTableFlags::SecFlagMD5Name))
    Flags.append("md5,");
  if (hasSecFlag(Entry, SecNameTableFlags::SecFlagUniqSuffix))
    Flags.append("uniq,");
  break;
case SecProfSummary:
  if (hasSecFlag(Entry, SecProfSummaryFlags::SecFlagPartial))
    Flags.append("partial,");
  if (hasSecFlag(Entry, SecProfSummaryFlags::SecFlagFullContext))
    Flags.append("context,");
  if (hasSecFlag(Entry, SecProfSummaryFlags::SecFlagFSDiscriminator))
    Flags.append("fs-discriminator,");
  break;
default:
  break;
}
char &last = Flags.back();
if (last == ',')
  last = '}';
else
  Flags.append("}");
return Flags;
1146}

1148bool SampleProfileReaderExtBinaryBase::dumpSectionInfo(raw_ostream &OS) {
uint64_t TotalSecsSize = 0;
for (auto &Entry : SecHdrTable) {
  OS << getSecName(Entry.Type) << " - Offset: " << Entry.Offset
     << ", Size: " << Entry.Size << ", Flags: " << getSecFlagsStr(Entry)
     << "\n";
  ;
  TotalSecsSize += Entry.Size;
}
uint64_t HeaderSize = SecHdrTable.front().Offset;
assert(HeaderSize + TotalSecsSize == getFileSize() &&(static_cast <bool> (HeaderSize + TotalSecsSize == getFileSize
() && "Size of 'header + sections' doesn't match the total size of profile"
) ? void (0) : __assert_fail ("HeaderSize + TotalSecsSize == getFileSize() && \"Size of 'header + sections' doesn't match the total size of profile\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 1159, __extension__ __PRETTY_FUNCTION__))
       "Size of 'header + sections' doesn't match the total size of profile")(static_cast <bool> (HeaderSize + TotalSecsSize == getFileSize
() && "Size of 'header + sections' doesn't match the total size of profile"
) ? void (0) : __assert_fail ("HeaderSize + TotalSecsSize == getFileSize() && \"Size of 'header + sections' doesn't match the total size of profile\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 1159, __extension__ __PRETTY_FUNCTION__));

OS << "Header Size: " << HeaderSize << "\n";
OS << "Total Sections Size: " << TotalSecsSize << "\n";
OS << "File Size: " << getFileSize() << "\n";
return true;
1165}

1167std::error_code SampleProfileReaderBinary::readMagicIdent() {
// Read and check the magic identifier.
auto Magic = readNumber<uint64_t>();
if (std::error_code EC = Magic.getError())
  return EC;
else if (std::error_code EC = verifySPMagic(*Magic))
  return EC;

// Read the version number.
auto Version = readNumber<uint64_t>();
if (std::error_code EC = Version.getError())
  return EC;
else if (*Version != SPVersion())
  return sampleprof_error::unsupported_version;

return sampleprof_error::success;
1183}

1185std::error_code SampleProfileReaderBinary::readHeader() {
Data = reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
End = Data + Buffer->getBufferSize();

if (std::error_code EC = readMagicIdent())
  return EC;

if (std::error_code EC = readSummary())
  return EC;

if (std::error_code EC = readNameTable())
  return EC;
return sampleprof_error::success;
1198}

1200std::error_code SampleProfileReaderCompactBinary::readHeader() {
SampleProfileReaderBinary::readHeader();
if (std::error_code EC = readFuncOffsetTable())
  return EC;
return sampleprof_error::success;
1205}

1207std::error_code SampleProfileReaderCompactBinary::readFuncOffsetTable() {
auto TableOffset = readUnencodedNumber<uint64_t>();
if (std::error_code EC = TableOffset.getError())
  return EC;

const uint8_t *SavedData = Data;
const uint8_t *TableStart =
    reinterpret_cast<const uint8_t *>(Buffer->getBufferStart()) +
    *TableOffset;
Data = TableStart;

auto Size = readNumber<uint64_t>();
if (std::error_code EC = Size.getError())
  return EC;

FuncOffsetTable.reserve(*Size);
for (uint32_t I = 0; I < *Size; ++I) {
  auto FName(readStringFromTable());
  if (std::error_code EC = FName.getError())
    return EC;

  auto Offset = readNumber<uint64_t>();
  if (std::error_code EC = Offset.getError())
    return EC;

  FuncOffsetTable[*FName] = *Offset;
}
End = TableStart;
Data = SavedData;
return sampleprof_error::success;
1237}

1239bool SampleProfileReaderCompactBinary::collectFuncsFromModule() {
if (!M)
  return false;
FuncsToUse.clear();
for (auto &F : *M)
  FuncsToUse.insert(FunctionSamples::getCanonicalFnName(F));
return true;
1246}

1248std::error_code SampleProfileReaderBinary::readSummaryEntry(
  std::vector<ProfileSummaryEntry> &Entries) {
auto Cutoff = readNumber<uint64_t>();
if (std::error_code EC = Cutoff.getError())
  return EC;

auto MinBlockCount = readNumber<uint64_t>();
if (std::error_code EC = MinBlockCount.getError())
  return EC;

auto NumBlocks = readNumber<uint64_t>();
if (std::error_code EC = NumBlocks.getError())
  return EC;

Entries.emplace_back(*Cutoff, *MinBlockCount, *NumBlocks);
return sampleprof_error::success;
1264}

1266std::error_code SampleProfileReaderBinary::readSummary() {
auto TotalCount = readNumber<uint64_t>();
if (std::error_code EC = TotalCount.getError())
  return EC;

auto MaxBlockCount = readNumber<uint64_t>();
if (std::error_code EC = MaxBlockCount.getError())
  return EC;

auto MaxFunctionCount = readNumber<uint64_t>();
if (std::error_code EC = MaxFunctionCount.getError())
  return EC;

auto NumBlocks = readNumber<uint64_t>();
if (std::error_code EC = NumBlocks.getError())
  return EC;

auto NumFunctions = readNumber<uint64_t>();
if (std::error_code EC = NumFunctions.getError())
  return EC;

auto NumSummaryEntries = readNumber<uint64_t>();
if (std::error_code EC = NumSummaryEntries.getError())
  return EC;

std::vector<ProfileSummaryEntry> Entries;
for (unsigned i = 0; i < *NumSummaryEntries; i++) {
  std::error_code EC = readSummaryEntry(Entries);
  if (EC != sampleprof_error::success)
    return EC;
}
Summary = std::make_unique<ProfileSummary>(
    ProfileSummary::PSK_Sample, Entries, *TotalCount, *MaxBlockCount, 0,
    *MaxFunctionCount, *NumBlocks, *NumFunctions);

return sampleprof_error::success;
1302}

1304bool SampleProfileReaderRawBinary::hasFormat(const MemoryBuffer &Buffer) {
const uint8_t *Data =
    reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
uint64_t Magic = decodeULEB128(Data);
return Magic == SPMagic();
1309}

1311bool SampleProfileReaderExtBinary::hasFormat(const MemoryBuffer &Buffer) {
const uint8_t *Data =
    reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
uint64_t Magic = decodeULEB128(Data);
return Magic == SPMagic(SPF_Ext_Binary);
1316}

1318bool SampleProfileReaderCompactBinary::hasFormat(const MemoryBuffer &Buffer) {
const uint8_t *Data =
    reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
uint64_t Magic = decodeULEB128(Data);
return Magic == SPMagic(SPF_Compact_Binary);
1323}

1325std::error_code SampleProfileReaderGCC::skipNextWord() {
uint32_t dummy;
if (!GcovBuffer.readInt(dummy))
  return sampleprof_error::truncated;
return sampleprof_error::success;
1330}

1332template <typename T> ErrorOr<T> SampleProfileReaderGCC::readNumber() {
if (sizeof(T) <= sizeof(uint32_t)) {
  uint32_t Val;
  if (GcovBuffer.readInt(Val) && Val <= std::numeric_limits<T>::max())
    return static_cast<T>(Val);
} else if (sizeof(T) <= sizeof(uint64_t)) {
  uint64_t Val;
  if (GcovBuffer.readInt64(Val) && Val <= std::numeric_limits<T>::max())
    return static_cast<T>(Val);
}

std::error_code EC = sampleprof_error::malformed;
reportError(0, EC.message());
return EC;
1346}

1348ErrorOr<StringRef> SampleProfileReaderGCC::readString() {
StringRef Str;
if (!GcovBuffer.readString(Str))
  return sampleprof_error::truncated;
return Str;
1353}

1355std::error_code SampleProfileReaderGCC::readHeader() {
// Read the magic identifier.
if (!GcovBuffer.readGCDAFormat())
  return sampleprof_error::unrecognized_format;

// Read the version number. Note - the GCC reader does not validate this
// version, but the profile creator generates v704.
GCOV::GCOVVersion version;
if (!GcovBuffer.readGCOVVersion(version))
  return sampleprof_error::unrecognized_format;

if (version != GCOV::V407)
  return sampleprof_error::unsupported_version;

// Skip the empty integer.
if (std::error_code EC = skipNextWord())
  return EC;

return sampleprof_error::success;
1374}

1376std::error_code SampleProfileReaderGCC::readSectionTag(uint32_t Expected) {
uint32_t Tag;
if (!GcovBuffer.readInt(Tag))
  return sampleprof_error::truncated;

if (Tag != Expected)
  return sampleprof_error::malformed;

if (std::error_code EC = skipNextWord())
  return EC;

return sampleprof_error::success;
1388}

1390std::error_code SampleProfileReaderGCC::readNameTable() {
if (std::error_code EC = readSectionTag(GCOVTagAFDOFileNames))
  return EC;

uint32_t Size;
if (!GcovBuffer.readInt(Size))
  return sampleprof_error::truncated;

for (uint32_t I = 0; I < Size; ++I) {
  StringRef Str;
  if (!GcovBuffer.readString(Str))
    return sampleprof_error::truncated;
  Names.push_back(std::string(Str));
}

return sampleprof_error::success;
1406}

1408std::error_code SampleProfileReaderGCC::readFunctionProfiles() {
if (std::error_code EC = readSectionTag(GCOVTagAFDOFunction))
  return EC;

uint32_t NumFunctions;
if (!GcovBuffer.readInt(NumFunctions))
  return sampleprof_error::truncated;

InlineCallStack Stack;
for (uint32_t I = 0; I < NumFunctions; ++I)
  if (std::error_code EC = readOneFunctionProfile(Stack, true, 0))
    return EC;

computeSummary();
return sampleprof_error::success;
1423}

1425std::error_code SampleProfileReaderGCC::readOneFunctionProfile(
  const InlineCallStack &InlineStack, bool Update, uint32_t Offset) {
uint64_t HeadCount = 0;
if (InlineStack.size() == 0)
  if (!GcovBuffer.readInt64(HeadCount))
    return sampleprof_error::truncated;

uint32_t NameIdx;
if (!GcovBuffer.readInt(NameIdx))
  return sampleprof_error::truncated;

StringRef Name(Names[NameIdx]);

uint32_t NumPosCounts;
if (!GcovBuffer.readInt(NumPosCounts))
  return sampleprof_error::truncated;

uint32_t NumCallsites;
if (!GcovBuffer.readInt(NumCallsites))
  return sampleprof_error::truncated;

FunctionSamples *FProfile = nullptr;
if (InlineStack.size() == 0) {
  // If this is a top function that we have already processed, do not
  // update its profile again.  This happens in the presence of
  // function aliases.  Since these aliases share the same function
  // body, there will be identical replicated profiles for the
  // original function.  In this case, we simply not bother updating
  // the profile of the original function.
  FProfile = &Profiles[Name];
  FProfile->addHeadSamples(HeadCount);
  if (FProfile->getTotalSamples() > 0)
    Update = false;
} else {
  // Otherwise, we are reading an inlined instance. The top of the
  // inline stack contains the profile of the caller. Insert this
  // callee in the caller's CallsiteMap.
  FunctionSamples *CallerProfile = InlineStack.front();
  uint32_t LineOffset = Offset >> 16;
  uint32_t Discriminator = Offset & 0xffff;
  FProfile = &CallerProfile->functionSamplesAt(
      LineLocation(LineOffset, Discriminator))[std::string(Name)];
}
FProfile->setName(Name);

for (uint32_t I = 0; I < NumPosCounts; ++I) {
  uint32_t Offset;
  if (!GcovBuffer.readInt(Offset))
    return sampleprof_error::truncated;

  uint32_t NumTargets;
  if (!GcovBuffer.readInt(NumTargets))
    return sampleprof_error::truncated;

  uint64_t Count;
  if (!GcovBuffer.readInt64(Count))
    return sampleprof_error::truncated;

  // The line location is encoded in the offset as:
  //   high 16 bits: line offset to the start of the function.
  //   low 16 bits: discriminator.
  uint32_t LineOffset = Offset >> 16;
  uint32_t Discriminator = Offset & 0xffff;

  InlineCallStack NewStack;
  NewStack.push_back(FProfile);
  llvm::append_range(NewStack, InlineStack);
  if (Update) {
    // Walk up the inline stack, adding the samples on this line to
    // the total sample count of the callers in the chain.
    for (auto CallerProfile : NewStack)
      CallerProfile->addTotalSamples(Count);

    // Update the body samples for the current profile.
    FProfile->addBodySamples(LineOffset, Discriminator, Count);
  }

  // Process the list of functions called at an indirect call site.
  // These are all the targets that a function pointer (or virtual
  // function) resolved at runtime.
  for (uint32_t J = 0; J < NumTargets; J++) {
    uint32_t HistVal;
    if (!GcovBuffer.readInt(HistVal))
      return sampleprof_error::truncated;

    if (HistVal != HIST_TYPE_INDIR_CALL_TOPN)
      return sampleprof_error::malformed;

    uint64_t TargetIdx;
    if (!GcovBuffer.readInt64(TargetIdx))
      return sampleprof_error::truncated;
    StringRef TargetName(Names[TargetIdx]);

    uint64_t TargetCount;
    if (!GcovBuffer.readInt64(TargetCount))
      return sampleprof_error::truncated;

    if (Update)
      FProfile->addCalledTargetSamples(LineOffset, Discriminator,
                                       TargetName, TargetCount);
  }
}

// Process all the inlined callers into the current function. These
// are all the callsites that were inlined into this function.
for (uint32_t I = 0; I < NumCallsites; I++) {
  // The offset is encoded as:
  //   high 16 bits: line offset to the start of the function.
  //   low 16 bits: discriminator.
  uint32_t Offset;
  if (!GcovBuffer.readInt(Offset))
    return sampleprof_error::truncated;
  InlineCallStack NewStack;
  NewStack.push_back(FProfile);
  llvm::append_range(NewStack, InlineStack);
  if (std::error_code EC = readOneFunctionProfile(NewStack, Update, Offset))
    return EC;
}

return sampleprof_error::success;
1545}

1547/// Read a GCC AutoFDO profile.
1548///
1549/// This format is generated by the Linux Perf conversion tool at
1550/// https://github.com/google/autofdo.
1551std::error_code SampleProfileReaderGCC::readImpl() {
assert(!ProfileIsFSDisciminator && "Gcc profiles not support FSDisciminator")(static_cast <bool> (!ProfileIsFSDisciminator &&
 "Gcc profiles not support FSDisciminator") ? void (0) : __assert_fail
 ("!ProfileIsFSDisciminator && \"Gcc profiles not support FSDisciminator\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 1552, __extension__ __PRETTY_FUNCTION__));
// Read the string table.
if (std::error_code EC = readNameTable())
  return EC;

// Read the source profile.
if (std::error_code EC = readFunctionProfiles())
  return EC;

return sampleprof_error::success;
1562}

1564bool SampleProfileReaderGCC::hasFormat(const MemoryBuffer &Buffer) {
StringRef Magic(reinterpret_cast<const char *>(Buffer.getBufferStart()));
return Magic == "adcg*704";
1567}

1569void SampleProfileReaderItaniumRemapper::applyRemapping(LLVMContext &Ctx) {
// If the reader uses MD5 to represent string, we can't remap it because
// we don't know what the original function names were.
if (Reader.useMD5()) {
  Ctx.diagnose(DiagnosticInfoSampleProfile(
      Reader.getBuffer()->getBufferIdentifier(),
      "Profile data remapping cannot be applied to profile data "
      "in compact format (original mangled names are not available).",
      DS_Warning));
  return;
}

// CSSPGO-TODO: Remapper is not yet supported.
// We will need to remap the entire context string.
assert(Remappings && "should be initialized while creating remapper")(static_cast <bool> (Remappings && "should be initialized while creating remapper"
) ? void (0) : __assert_fail ("Remappings && \"should be initialized while creating remapper\""
, "/build/llvm-toolchain-snapshot-14~++20210825111122+868bd9938db1/llvm/lib/ProfileData/SampleProfReader.cpp"
, 1583, __extension__ __PRETTY_FUNCTION__));
for (auto &Sample : Reader.getProfiles()) {
  DenseSet<StringRef> NamesInSample;
  Sample.second.findAllNames(NamesInSample);
  for (auto &Name : NamesInSample)
    if (auto Key = Remappings->insert(Name))
      NameMap.insert({Key, Name});
}

RemappingApplied = true;
1593}

1595Optional<StringRef>
1596SampleProfileReaderItaniumRemapper::lookUpNameInProfile(StringRef Fname) {
if (auto Key = Remappings->lookup(Fname))
  return NameMap.lookup(Key);
return None;
1600}

1602/// Prepare a memory buffer for the contents of \p Filename.
1603///
1604/// \returns an error code indicating the status of the buffer.
1605static ErrorOr<std::unique_ptr<MemoryBuffer>>
1606setupMemoryBuffer(const Twine &Filename) {
auto BufferOrErr = MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/true);
if (std::error_code EC = BufferOrErr.getError())
  return EC;
auto Buffer = std::move(BufferOrErr.get());

// Sanity check the file.
if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<uint32_t>::max())
  return sampleprof_error::too_large;

return std::move(Buffer);
1617}

1619/// Create a sample profile reader based on the format of the input file.
1620///
1621/// \param Filename The file to open.
1622///
1623/// \param C The LLVM context to use to emit diagnostics.
1624///
1625/// \param P The FSDiscriminatorPass.
1626///
1627/// \param RemapFilename The file used for profile remapping.
1628///
1629/// \returns an error code indicating the status of the created reader.
1630ErrorOr<std::unique_ptr<SampleProfileReader>>
1631SampleProfileReader::create(const std::string Filename, LLVMContext &C,
                          FSDiscriminatorPass P,
                          const std::string RemapFilename) {
auto BufferOrError = setupMemoryBuffer(Filename);
if (std::error_code EC = BufferOrError.getError())
  return EC;
return create(BufferOrError.get(), C, P, RemapFilename);
1638}

1640/// Create a sample profile remapper from the given input, to remap the
1641/// function names in the given profile data.
1642///
1643/// \param Filename The file to open.
1644///
1645/// \param Reader The profile reader the remapper is going to be applied to.
1646///
1647/// \param C The LLVM context to use to emit diagnostics.
1648///
1649/// \returns an error code indicating the status of the created reader.
1650ErrorOr<std::unique_ptr<SampleProfileReaderItaniumRemapper>>
1651SampleProfileReaderItaniumRemapper::create(const std::string Filename,
                                         SampleProfileReader &Reader,
                                         LLVMContext &C) {
auto BufferOrError = setupMemoryBuffer(Filename);
if (std::error_code EC = BufferOrError.getError())
  return EC;
return create(BufferOrError.get(), Reader, C);
1658}

1660/// Create a sample profile remapper from the given input, to remap the
1661/// function names in the given profile data.
1662///
1663/// \param B The memory buffer to create the reader from (assumes ownership).
1664///
1665/// \param C The LLVM context to use to emit diagnostics.
1666///
1667/// \param Reader The profile reader the remapper is going to be applied to.
1668///
1669/// \returns an error code indicating the status of the created reader.
1670ErrorOr<std::unique_ptr<SampleProfileReaderItaniumRemapper>>
1671SampleProfileReaderItaniumRemapper::create(std::unique_ptr<MemoryBuffer> &B,
                                         SampleProfileReader &Reader,
                                         LLVMContext &C) {
auto Remappings = std::make_unique<SymbolRemappingReader>();
if (Error E = Remappings->read(*B.get())) {
  handleAllErrors(
      std::move(E), [&](const SymbolRemappingParseError &ParseError) {
        C.diagnose(DiagnosticInfoSampleProfile(B->getBufferIdentifier(),
                                               ParseError.getLineNum(),
                                               ParseError.getMessage()));
      });
  return sampleprof_error::malformed;
}

return std::make_unique<SampleProfileReaderItaniumRemapper>(
    std::move(B), std::move(Remappings), Reader);
1687}

1689/// Create a sample profile reader based on the format of the input data.
1690///
1691/// \param B The memory buffer to create the reader from (assumes ownership).
1692///
1693/// \param C The LLVM context to use to emit diagnostics.
1694///
1695/// \param P The FSDiscriminatorPass.
1696///
1697/// \param RemapFilename The file used for profile remapping.
1698///
1699/// \returns an error code indicating the status of the created reader.
1700ErrorOr<std::unique_ptr<SampleProfileReader>>
1701SampleProfileReader::create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C,
                          FSDiscriminatorPass P,
                          const std::string RemapFilename) {
std::unique_ptr<SampleProfileReader> Reader;
if (SampleProfileReaderRawBinary::hasFormat(*B))
  Reader.reset(new SampleProfileReaderRawBinary(std::move(B), C));
else if (SampleProfileReaderExtBinary::hasFormat(*B))
  Reader.reset(new SampleProfileReaderExtBinary(std::move(B), C));
else if (SampleProfileReaderCompactBinary::hasFormat(*B))
  Reader.reset(new SampleProfileReaderCompactBinary(std::move(B), C));
else if (SampleProfileReaderGCC::hasFormat(*B))
  Reader.reset(new SampleProfileReaderGCC(std::move(B), C));
else if (SampleProfileReaderText::hasFormat(*B))
  Reader.reset(new SampleProfileReaderText(std::move(B), C));
else
  return sampleprof_error::unrecognized_format;

if (!RemapFilename.empty()) {
  auto ReaderOrErr =
      SampleProfileReaderItaniumRemapper::create(RemapFilename, *Reader, C);
  if (std::error_code EC = ReaderOrErr.getError()) {
    std::string Msg = "Could not create remapper: " + EC.message();
    C.diagnose(DiagnosticInfoSampleProfile(RemapFilename, Msg));
    return EC;
  }
  Reader->Remapper = std::move(ReaderOrErr.get());
}

FunctionSamples::Format = Reader->getFormat();
if (std::error_code EC = Reader->readHeader()) {
  return EC;
}

Reader->setDiscriminatorMaskedBitFrom(P);

return std::move(Reader);
1737}

1739// For text and GCC file formats, we compute the summary after reading the
1740// profile. Binary format has the profile summary in its header.
1741void SampleProfileReader::computeSummary() {
SampleProfileSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);
Summary = Builder.computeSummaryForProfiles(Profiles);
1744}