[llvm-profdata][NFC] ProfileReader cleanup - 4

[huangjd]

Summary

This cleanup simply rearrange the order of class members and methods so that they appear roughtly in logical order as the profile reader invokes them while reading a profile. There is no code change

[davidxl]

I suggest limiting the clean ups to declarations and simple function definitions such as readHeader, readMagic or other small wrapper functions. For large function definitions, keep the original order (to make future git blame easier).

llvm/include/llvm/ProfileData/SampleProfReader.h

protected:
   /// Read a string from the profile.
   ///
   /// If an error occurs during decoding, a diagnostic message is emitted and
   /// EC is set.
   ///
   /// \returns the read value.
   ErrorOr<StringRef> readString();
 
-  /// Read the string index and check whether it overflows the table.
-  template <typename T> inline ErrorOr<size_t> readStringIndex(T &Table);
-
-  /// Read the next function profile instance.
-  std::error_code readFuncProfile(const uint8_t *Start);
-
-  /// Read the contents of the given profile instance.
-  std::error_code readProfile(FunctionSamples &FProfile);
-
   /// Read the contents of Magic number and Version number.
   std::error_code readMagicIdent();
 
   /// Read profile summary.
   std::error_code readSummary();
 
   /// Read the whole name table with regular strings.
   std::error_code readNameTable();
 
   /// Read the whole name table with ULEB128 encoded MD5 values.
   std::error_code readMD5NameTable();
 
+  /// Read the string index and check whether it overflows the table.
+  template <typename T> inline ErrorOr<size_t> readStringIndex(T &Table);
+
   /// Read a string indirectly via the name table.
   ErrorOr<StringRef> readStringFromTable();
 
   /// Read a context indirectly via the CSNameTable.
   ErrorOr<SampleContextFrames> readContextFromTable();
 
   /// Read a context indirectly via the CSNameTable if the profile has context,
   /// otherwise same as readStringFromTable.
bool useOrderedFuncOffsets() {
     return ProfileIsCS || (!useMD5() && Remapper);
   }
 
   /// Read the whole function offset table from the profile file, and store it
   /// to either OrderedFuncOffsets (list) or FuncOffsetTable (map). Clear the
   /// previous function offset table.
   std::error_code readFuncOffsetTable();
 
+  /// Read the next function profile instance.
+  std::error_code readFuncProfile(const uint8_t *Start);
+
+  /// Read the contents of the given profile instance.
+  std::error_code readProfile(FunctionSamples &FProfile);
+
   /// Read function profiles. If a module is present and function offset table
   /// is available, only read profiles of functions present in the module.
   std::error_code readFuncProfiles();
 
   /// Points to the current location in the buffer.
   const uint8_t *Data = nullptr;
 
   /// Points to the end of the buffer.

llvm/lib/ProfileData/SampleProfReader.cpp

if ((*LineIt)[0] != ' ') {
       StringRef FName;
       result = ParseHead(*LineIt, FName, NumSamples, NumHeadSamples);
     }
   }
 
   return result;
 }
 
+std::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;
+}
+
+std::error_code SampleProfileReaderBinary::readImpl() {
+  ProfileIsFS = ProfileIsFSDisciminator;
+  FunctionSamples::ProfileIsFS = ProfileIsFS;
+  return readFuncProfiles();
+}
+
 template <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)
if (Data + sizeof(T) > End) {
     return EC;
   }
 
   using namespace support;
   T Val = endian::readNext<T, little, unaligned>(Data);
   return Val;
 }
 
+std::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;
+}
+
+std::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;
+}
+
+std::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;
+}
+
+std::error_code SampleProfileReaderBinary::readNameTable() {
+  auto Size = readNumber<size_t>();
+  if (std::error_code EC = Size.getError())
+    return EC;
+
+  // Normally if useMD5 is true, the name table should have MD5 values, not
+  // strings, however in the case that ExtBinary profile has multiple name
+  // tables mixing string and MD5, all of them have to be normalized to use MD5,
+  // because optimization passes can only handle either type.
+  bool UseMD5 = useMD5();
+  if (UseMD5)
+    MD5StringBuf.reserve(MD5StringBuf.size() + *Size);
+
+  NameTable.clear();
+  NameTable.reserve(*Size);
+  for (size_t I = 0; I < *Size; ++I) {
+    auto Name(readString());
+    if (std::error_code EC = Name.getError())
+      return EC;
+    if (UseMD5) {
+      uint64_t MD5 = MD5Hash(*Name);
+      NameTable.emplace_back(MD5StringBuf.emplace_back(std::to_string(MD5)));
+    } else
+      NameTable.push_back(*Name);
+  }
+
+  return sampleprof_error::success;
+}
+
+std::error_code SampleProfileReaderBinary::readMD5NameTable() {
+  auto Size = readNumber<uint64_t>();
+  if (std::error_code EC = Size.getError())
+    return EC;
+
+  MD5StringBuf.reserve(MD5StringBuf.size() + *Size);
+  NameTable.clear();
+  NameTable.reserve(*Size);
+  for (size_t I = 0; I < *Size; ++I) {
+    auto FID = readNumber<uint64_t>();
+    if (std::error_code EC = FID.getError())
+      return EC;
+    NameTable.emplace_back(MD5StringBuf.emplace_back(std::to_string(*FID)));
+  }
+  return sampleprof_error::success;
+}
+
 template <typename T>
 inline ErrorOr<size_t> SampleProfileReaderBinary::readStringIndex(T &Table) {
   std::error_code EC;
   auto Idx = readNumber<size_t>();
   if (std::error_code EC = Idx.getError())
     return EC;
   if (*Idx >= Table.size())
     return sampleprof_error::truncated_name_table;
if (!SR.data()) {
     using namespace support;
     uint64_t FID = endian::read<uint64_t, little, unaligned>(
         MD5NameMemStart + (*Idx) * sizeof(uint64_t));
     SR = MD5StringBuf.emplace_back(std::to_string(FID));
   }
   return SR;
 }
 
+ErrorOr<SampleContextFrames> SampleProfileReaderBinary::readContextFromTable() {
+  auto ContextIdx = readNumber<size_t>();
+  if (std::error_code EC = ContextIdx.getError())
+    return EC;
+  if (*ContextIdx >= CSNameTable.size())
+    return sampleprof_error::truncated_name_table;
+  return CSNameTable[*ContextIdx];
+}
+
+ErrorOr<SampleContext> SampleProfileReaderBinary::readSampleContextFromTable() {
+  if (ProfileIsCS) {
+    auto FContext(readContextFromTable());
+    if (std::error_code EC = FContext.getError())
+      return EC;
+    return SampleContext(*FContext);
+  } else {
+    auto FName(readStringFromTable());
+    if (std::error_code EC = FName.getError())
+      return EC;
+    return SampleContext(*FName);
+  }
+}
+
+std::error_code SampleProfileReaderBinary::readFuncOffsetTable() {
+  // If there are more than one function offset table, the profile associated
+  // with the previous table has to be done reading before next one
+  // is read.
+  FuncOffsetTable.clear();
+  OrderedFuncOffsets.clear();
+
+  auto Size = readNumber<uint64_t>();
+  if (std::error_code EC = Size.getError())
+    return EC;
+
+  bool UseOrderedFuncOffsets = useOrderedFuncOffsets();
+  if (UseOrderedFuncOffsets)
+    OrderedFuncOffsets.reserve(*Size);
+  else
+    FuncOffsetTable.reserve(*Size);
+
+  for (uint64_t I = 0; I < *Size; ++I) {
+    auto FContext = readSampleContextFromTable();
+    if (std::error_code EC = FContext.getError())
+      return EC;
+
+    auto Offset = readNumber<uint64_t>();
+    if (std::error_code EC = Offset.getError())
+      return EC;
+
+    if (UseOrderedFuncOffsets)
+      OrderedFuncOffsets.emplace_back(*FContext, *Offset);
+    else
+      FuncOffsetTable[*FContext] = *Offset;
+  }
+
+  return sampleprof_error::success;
+}
+
 std::error_code
 SampleProfileReaderBinary::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.
SampleProfileReaderBinary::readFuncProfile(const uint8_t *Start) {
   if (FContext->hasContext())
     CSProfileCount++;
 
   if (std::error_code EC = readProfile(FProfile))
     return EC;
   return sampleprof_error::success;
 }
 
-std::error_code SampleProfileReaderBinary::readImpl() {
-  ProfileIsFS = ProfileIsFSDisciminator;
-  FunctionSamples::ProfileIsFS = ProfileIsFS;
-  return readFuncProfiles();
-}
-
-ErrorOr<SampleContextFrames> SampleProfileReaderBinary::readContextFromTable() {
-  auto ContextIdx = readNumber<size_t>();
-  if (std::error_code EC = ContextIdx.getError())
-    return EC;
-  if (*ContextIdx >= CSNameTable.size())
-    return sampleprof_error::truncated_name_table;
-  return CSNameTable[*ContextIdx];
-}
-
-ErrorOr<SampleContext> SampleProfileReaderBinary::readSampleContextFromTable() {
-  if (ProfileIsCS) {
-    auto FContext(readContextFromTable());
-    if (std::error_code EC = FContext.getError())
-      return EC;
-    return SampleContext(*FContext);
-  } else {
-    auto FName(readStringFromTable());
-    if (std::error_code EC = FName.getError())
-      return EC;
-    return SampleContext(*FName);
-  }
-}
-
-std::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::SecFlagIsPreInlined))
-      FunctionSamples::ProfileIsPreInlined = ProfileIsPreInlined = true;
-    if (hasSecFlag(Entry, SecProfSummaryFlags::SecFlagFSDiscriminator))
-      FunctionSamples::ProfileIsFS = ProfileIsFS = true;
-    break;
-  case SecNameTable: {
-    /// Use fixed length MD5 instead of ULEB128 encoding so NameTable doesn't
-    /// need to be read in up front and can be directly accessed using index.
-    bool FixedLengthMD5 =
-        hasSecFlag(Entry, SecNameTableFlags::SecFlagFixedLengthMD5);
-    bool UseMD5 =
-        FixedLengthMD5 || hasSecFlag(Entry, SecNameTableFlags::SecFlagMD5Name);
-    FunctionSamples::HasUniqSuffix =
-        hasSecFlag(Entry, SecNameTableFlags::SecFlagUniqSuffix);
-    if (std::error_code EC = readNameTableSec(UseMD5, FixedLengthMD5))
-      return EC;
-    break;
-  }
-  case SecCSNameTable: {
-    if (std::error_code EC = readCSNameTableSec())
-      return EC;
-    break;
-  }
-  case SecLBRProfile:
-    if (std::error_code EC = readFuncProfiles())
-      return EC;
-    break;
-  case SecFuncOffsetTable:
-    // Only read function offset table if module is present, otherwise all
-    // profiles must be loaded anyways.
-    if (!M) {
-      Data = End;
-    } else {
-      bool FuncOffsetsOrdered =
-          hasSecFlag(Entry, SecFuncOffsetFlags::SecFlagOrdered);
-      assert((!ProfileIsCS || FuncOffsetsOrdered) &&
-                    "func offset table should always be sorted in CS profile");
-      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;
-}
-
-bool SampleProfileReaderExtBinaryBase::collectFuncsFromModule() {
-  if (!M)
-    return false;
-  FuncsToUse.clear();
-  for (auto &F : *M)
-    FuncsToUse.insert(FunctionSamples::getCanonicalFnName(F));
-  return true;
-}
-
-std::error_code SampleProfileReaderBinary::readFuncOffsetTable() {
-  // If there are more than one function offset table, the profile associated
-  // with the previous table has to be done reading before next one
-  // is read.
-  FuncOffsetTable.clear();
-  OrderedFuncOffsets.clear();
-
-  auto Size = readNumber<uint64_t>();
-  if (std::error_code EC = Size.getError())
-    return EC;
-
-  bool UseOrderedFuncOffsets = useOrderedFuncOffsets();
-  if (UseOrderedFuncOffsets)
-    OrderedFuncOffsets.reserve(*Size);
-  else
-    FuncOffsetTable.reserve(*Size);
-
-  for (uint64_t I = 0; I < *Size; ++I) {
-    auto FContext = readSampleContextFromTable();
-    if (std::error_code EC = FContext.getError())
-      return EC;
-
-    auto Offset = readNumber<uint64_t>();
-    if (std::error_code EC = Offset.getError())
-      return EC;
-
-    if (UseOrderedFuncOffsets)
-      OrderedFuncOffsets.emplace_back(*FContext, *Offset);
-    else
-      FuncOffsetTable[*FContext] = *Offset;
-  }
-
-  return sampleprof_error::success;
-}
-
 std::error_code SampleProfileReaderBinary::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();
if (isCompressed) {
       Data = BufStart + Entry.Offset;
       End = BufStart + Buffer->getBufferSize();
     }
   }
 
   return sampleprof_error::success;
 }
 
-std::error_code SampleProfileReaderCompactBinary::readImpl() {
-  auto TableOffset = readUnencodedNumber<uint64_t>();
-  if (std::error_code EC = TableOffset.getError())
-    return EC;
-
-  const uint8_t *TableStart =
-      reinterpret_cast<const uint8_t *>(Buffer->getBufferStart()) +
-      *TableOffset;
-
-  // Only read function offset table if a module is present, otherwise all
-  // profiles must be loaded anyways. In this case offset is from the beginning
-  // of the file.
-  if (M) {
-    Data = TableStart;
-    if (std::error_code EC = readFuncOffsetTable())
-      return EC;
-    Data = reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
-  }
-  End = TableStart;
-
-  return SampleProfileReaderBinary::readImpl();
-}
-
-std::error_code SampleProfileReaderRawBinary::verifySPMagic(uint64_t Magic) {
-  if (Magic == SPMagic())
-    return sampleprof_error::success;
-  return sampleprof_error::bad_magic;
-}
-
-std::error_code SampleProfileReaderExtBinary::verifySPMagic(uint64_t Magic) {
-  if (Magic == SPMagic(SPF_Ext_Binary))
-    return sampleprof_error::success;
-  return sampleprof_error::bad_magic;
-}
-
-std::error_code
-SampleProfileReaderCompactBinary::verifySPMagic(uint64_t Magic) {
-  if (Magic == SPMagic(SPF_Compact_Binary))
-    return sampleprof_error::success;
-  return sampleprof_error::bad_magic;
-}
-
-std::error_code SampleProfileReaderBinary::readNameTable() {
-  auto Size = readNumber<size_t>();
-  if (std::error_code EC = Size.getError())
-    return EC;
-
-  // Normally if useMD5 is true, the name table should have MD5 values, not
-  // strings, however in the case that ExtBinary profile has multiple name
-  // tables mixing string and MD5, all of them have to be normalized to use MD5,
-  // because optimization passes can only handle either type.
-  bool UseMD5 = useMD5();
-  if (UseMD5)
-    MD5StringBuf.reserve(MD5StringBuf.size() + *Size);
-
-  NameTable.clear();
-  NameTable.reserve(*Size);
-  for (size_t I = 0; I < *Size; ++I) {
-    auto Name(readString());
-    if (std::error_code EC = Name.getError())
-      return EC;
-    if (UseMD5) {
-      uint64_t MD5 = MD5Hash(*Name);
-      NameTable.emplace_back(MD5StringBuf.emplace_back(std::to_string(MD5)));
-    } else
-      NameTable.push_back(*Name);
-  }
-
-  return sampleprof_error::success;
-}
-
-std::error_code SampleProfileReaderBinary::readMD5NameTable() {
-  auto Size = readNumber<uint64_t>();
-  if (std::error_code EC = Size.getError())
-    return EC;
-
-  MD5StringBuf.reserve(MD5StringBuf.size() + *Size);
-  NameTable.clear();
-  NameTable.reserve(*Size);
-  for (size_t I = 0; I < *Size; ++I) {
-    auto FID = readNumber<uint64_t>();
-    if (std::error_code EC = FID.getError())
-      return EC;
-    NameTable.emplace_back(MD5StringBuf.emplace_back(std::to_string(*FID)));
-  }
-  return sampleprof_error::success;
-}
-
 std::error_code
 SampleProfileReaderExtBinaryBase::readNameTableSec(bool IsMD5,
                                                    bool FixedLengthMD5) {
   if (!FixedLengthMD5) {
     if (!IsMD5)
       return SampleProfileReaderBinary::readNameTable();
     else
       return SampleProfileReaderBinary::readMD5NameTable();
for (uint32_t J = 0; J < *ContextSize; ++J) {
           FName.get(), LineLocation(LineOffset.get(), Discriminator.get()));
     }
   }
 
   return sampleprof_error::success;
 }
 
 std::error_code
-
 SampleProfileReaderExtBinaryBase::readFuncMetadata(bool ProfileHasAttribute,
                                                    FunctionSamples *FProfile) {
   if (Data < End) {
     if (ProfileIsProbeBased) {
       auto Checksum = readNumber<uint64_t>();
       if (std::error_code EC = Checksum.getError())
         return EC;
       if (FProfile)
uint64_t SampleProfileReaderExtBinaryBase::getFileSize() {
   // SecHdrTable to calculate the file size.
   uint64_t FileSize = 0;
   for (auto &Entry : SecHdrTable) {
     FileSize = std::max(Entry.Offset + Entry.Size, FileSize);
   }
   return FileSize;
 }
 
+std::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::SecFlagIsPreInlined))
+      FunctionSamples::ProfileIsPreInlined = ProfileIsPreInlined = true;
+    if (hasSecFlag(Entry, SecProfSummaryFlags::SecFlagFSDiscriminator))
+      FunctionSamples::ProfileIsFS = ProfileIsFS = true;
+    break;
+  case SecNameTable: {
+    /// Use fixed length MD5 instead of ULEB128 encoding so NameTable doesn't
+    /// need to be read in up front and can be directly accessed using index.
+    bool FixedLengthMD5 =
+        hasSecFlag(Entry, SecNameTableFlags::SecFlagFixedLengthMD5);
+    bool UseMD5 =
+        FixedLengthMD5 || hasSecFlag(Entry, SecNameTableFlags::SecFlagMD5Name);
+    FunctionSamples::HasUniqSuffix =
+        hasSecFlag(Entry, SecNameTableFlags::SecFlagUniqSuffix);
+    if (std::error_code EC = readNameTableSec(UseMD5, FixedLengthMD5))
+      return EC;
+    break;
+  }
+  case SecCSNameTable: {
+    if (std::error_code EC = readCSNameTableSec())
+      return EC;
+    break;
+  }
+  case SecLBRProfile:
+    if (std::error_code EC = readFuncProfiles())
+      return EC;
+    break;
+  case SecFuncOffsetTable:
+    // Only read function offset table if module is present, otherwise all
+    // profiles must be loaded anyways.
+    if (!M) {
+      Data = End;
+    } else {
+      bool FuncOffsetsOrdered =
+          hasSecFlag(Entry, SecFuncOffsetFlags::SecFlagOrdered);
+      assert((!ProfileIsCS || FuncOffsetsOrdered) &&
+                    "func offset table should always be sorted in CS profile");
+      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;
+}
+
+bool SampleProfileReaderExtBinaryBase::collectFuncsFromModule() {
+  if (!M)
+    return false;
+  FuncsToUse.clear();
+  for (auto &F : *M)
+    FuncsToUse.insert(FunctionSamples::getCanonicalFnName(F));
+  return true;
+}
+
 static 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))
assert(HeaderSize + TotalSecsSize == getFileSize() &&
          "Size of 'header + sections' doesn't match the total size of profile");
 
   OS << "Header Size: " << HeaderSize << "\n";
   OS << "Total Sections Size: " << TotalSecsSize << "\n";
   OS << "File Size: " << getFileSize() << "\n";
   return true;
 }
 
-std::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;
-}
-
-std::error_code SampleProfileReaderBinary::readHeader() {
+std::error_code SampleProfileReaderCompactBinary::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())
+  if (std::error_code EC = readMD5NameTable())
     return EC;
+
   return sampleprof_error::success;
 }
 
-std::error_code SampleProfileReaderCompactBinary::readHeader() {
-  Data = reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
-  End = Data + Buffer->getBufferSize();
-
-  if (std::error_code EC = readMagicIdent())
+std::error_code SampleProfileReaderCompactBinary::readImpl() {
+  auto TableOffset = readUnencodedNumber<uint64_t>();
+  if (std::error_code EC = TableOffset.getError())
     return EC;
 
-  if (std::error_code EC = readSummary())
-    return EC;
+  const uint8_t *TableStart =
+      reinterpret_cast<const uint8_t *>(Buffer->getBufferStart()) +
+      *TableOffset;
 
-  if (std::error_code EC = readMD5NameTable())
+  // Only read function offset table if a module is present, otherwise all
+  // profiles must be loaded anyways. In this case offset is from the beginning
+  // of the file.
+  if (M) {
+    Data = TableStart;
+    if (std::error_code EC = readFuncOffsetTable())
       return EC;
+    Data = reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
+  }
+  End = TableStart;
 
-  return sampleprof_error::success;
+  return SampleProfileReaderBinary::readImpl();
 }
 
 bool SampleProfileReaderCompactBinary::collectFuncsFromModule() {
   if (!M)
     return false;
   FuncsToUse.clear();
   for (auto &F : *M)
     FuncsToUse.insert(FunctionSamples::getCanonicalFnName(F));
   return true;
 }
 
-std::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);
+std::error_code SampleProfileReaderRawBinary::verifySPMagic(uint64_t Magic) {
+  if (Magic == SPMagic())
     return sampleprof_error::success;
+  return sampleprof_error::bad_magic;
 }
 
-std::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);
+std::error_code SampleProfileReaderExtBinary::verifySPMagic(uint64_t Magic) {
+  if (Magic == SPMagic(SPF_Ext_Binary))
+    return sampleprof_error::success;
+  return sampleprof_error::bad_magic;
 
+std::error_code
+SampleProfileReaderCompactBinary::verifySPMagic(uint64_t Magic) {
+  if (Magic == SPMagic(SPF_Compact_Binary))
     return sampleprof_error::success;
+  return sampleprof_error::bad_magic;
 }
 
 bool SampleProfileReaderRawBinary::hasFormat(const MemoryBuffer &Buffer) {
   const uint8_t *Data =
       reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
   uint64_t Magic = decodeULEB128(Data);
   return Magic == SPMagic();
 }