[CSSPGO] Add a SecMetadataOffsetTable to extbinary profile

[hoy]

Summary

I've been seeing compile time slowdown due to the loading of function metadata section with using CS nested profile for CSSPGO, where the metadata section is big due to its nested structure. I'm introducing SecMetadataOffsetTable to speed up the on-demand loading of the metadata section, similarly with the existing SecFunctionOffsetTable. This neables a 6% compilation speed up, based on one of our internal large benchmarks.

llvm/include/llvm/ProfileData/SampleProf.h

 enum SecType {
   SecInValid = 0,
   SecProfSummary = 1,
   SecNameTable = 2,
   SecProfileSymbolList = 3,
   SecFuncOffsetTable = 4,
   SecFuncMetadata = 5,
   SecCSNameTable = 6,
+  SecMetadataOffsetTable = 7,
   // marker for the first type of profile.
   SecFuncProfileFirst = 32,
   SecLBRProfile = SecFuncProfileFirst
 };
 
 static inline std::string getSecName(SecType Type) {
   switch ((int)Type) { // Avoid -Wcovered-switch-default
   case SecInValid:
     return "InvalidSection";
   case SecProfSummary:
     return "ProfileSummarySection";
   case SecNameTable:
     return "NameTableSection";
   case SecProfileSymbolList:
     return "ProfileSymbolListSection";
   case SecFuncOffsetTable:
     return "FuncOffsetTableSection";
   case SecFuncMetadata:
     return "FunctionMetadata";
   case SecCSNameTable:
     return "CSNameTableSection";
   case SecLBRProfile:
     return "LBRProfileSection";
+  case SecMetadataOffsetTable:
+    return "MetadtaOffsetTableSection";
   default:
     return "UnknownSection";
   }
 }
 
 // Entry type of section header table used by SampleProfileExtBinaryBaseReader
 // and SampleProfileExtBinaryBaseWriter.
 struct SecHdrTableEntry {

llvm/include/llvm/ProfileData/SampleProfReader.h

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Discriminator.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SymbolRemappingReader.h"
 #include <cstdint>
 #include <list>
 #include <memory>
+#include <set>
 #include <string>
 #include <system_error>
 #include <unordered_set>
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;

 
 protected:
   std::vector<SecHdrTableEntry> SecHdrTable;
   std::error_code readSecHdrTableEntry(uint32_t Idx);
   std::error_code readSecHdrTable();
 
   std::error_code readFuncMetadata(bool ProfileHasAttribute);
   std::error_code readFuncMetadata(bool ProfileHasAttribute,
+                                   const uint8_t *Start,
                                    FunctionSamples *FProfile);
+  std::error_code readMetadataOffsetTable();
   std::error_code readFuncOffsetTable();
   std::error_code readFuncProfiles();
   std::error_code readMD5NameTable();
   std::error_code readNameTableSec(bool IsMD5);
   std::error_code readCSNameTableSec();
   std::error_code readProfileSymbolList();
 
   virtual std::error_code readHeader() override;
   virtual std::error_code verifySPMagic(uint64_t Magic) override = 0;
   virtual std::error_code readOneSection(const uint8_t *Start, uint64_t Size,
                                          const SecHdrTableEntry &Entry);
   // placeholder for subclasses to dispatch their own section readers.
   virtual std::error_code readCustomSection(const SecHdrTableEntry &Entry) = 0;
   virtual ErrorOr<StringRef> readStringFromTable() override;
   virtual ErrorOr<SampleContext> readSampleContextFromTable() override;
   ErrorOr<SampleContextFrames> readContextFromTable();
+  std::set<uint64_t> computeReadOffsets(
+      DenseMap<SampleContext, uint64_t> &OffsetTable,
+      std::vector<std::pair<SampleContext, uint64_t>> *OrderedOffsets =
+          nullptr);
 
   std::unique_ptr<ProfileSymbolList> ProfSymList;
 
   /// The table mapping from function context to the offset of its
-  /// FunctionSample towards file start.
+  /// FunctionSample towards section start.
   DenseMap<SampleContext, uint64_t> FuncOffsetTable;
+  /// The table mapping from function context to the offset of its
+  /// metadata towards section start.
+  DenseMap<SampleContext, uint64_t> MetadataOffsetTable;
 
   /// Function offset mapping ordered by contexts.
   std::unique_ptr<std::vector<std::pair<SampleContext, uint64_t>>>
       OrderedFuncOffsets;
 
   /// The set containing the functions to use when compiling a module.
   DenseSet<StringRef> FuncsToUse;
 

llvm/include/llvm/ProfileData/SampleProfWriter.h

ExtBinaryHdrLayoutTable = {
         //
         // DefaultLayout
         SmallVector<SecHdrTableEntry, 8>({{SecProfSummary, 0, 0, 0, 0},
                                           {SecNameTable, 0, 0, 0, 0},
                                           {SecCSNameTable, 0, 0, 0, 0},
                                           {SecFuncOffsetTable, 0, 0, 0, 0},
                                           {SecLBRProfile, 0, 0, 0, 0},
                                           {SecProfileSymbolList, 0, 0, 0, 0},
+                                          {SecMetadataOffsetTable, 0, 0, 0, 0},
                                           {SecFuncMetadata, 0, 0, 0, 0}}),
         // CtxSplitLayout
         SmallVector<SecHdrTableEntry, 8>({{SecProfSummary, 0, 0, 0, 0},
                                           {SecNameTable, 0, 0, 0, 0},
                                           // profile with context
                                           // for next two sections
                                           {SecFuncOffsetTable, 0, 0, 0, 0},
                                           {SecLBRProfile, 0, 0, 0, 0},
                                           // profile without context
                                           // for next two sections
                                           {SecFuncOffsetTable, 0, 0, 0, 0},
                                           {SecLBRProfile, 0, 0, 0, 0},
                                           {SecProfileSymbolList, 0, 0, 0, 0},
+                                          {SecMetadataOffsetTable, 0, 0, 0, 0},
                                           {SecFuncMetadata, 0, 0, 0, 0}}),
 };
 
 class SampleProfileWriterExtBinaryBase : public SampleProfileWriterBinary {
   using SampleProfileWriterBinary::SampleProfileWriterBinary;
 public:
   virtual std::error_code write(const SampleProfileMap &ProfileMap) override;
 
protected:
   std::error_code writeCSNameTableSection();
 
   std::error_code writeFuncMetadata(const SampleProfileMap &Profiles);
   std::error_code writeFuncMetadata(const FunctionSamples &Profile);
 
   // Functions to write various kinds of sections.
   std::error_code writeNameTableSection(const SampleProfileMap &ProfileMap);
   std::error_code writeFuncOffsetTable();
+  std::error_code writeMetadataOffsetTable();
   std::error_code writeProfileSymbolListSection();
 
   SectionLayout SecLayout = DefaultLayout;
   // Specifiy the order of sections in section header table. Note
   // the order of sections in SecHdrTable may be different that the
   // order in SectionHdrLayout. sample Reader will follow the order
   // in SectionHdrLayout to read each section.
   SmallVector<SecHdrTableEntry, 8> SectionHdrLayout =
       ExtBinaryHdrLayoutTable[DefaultLayout];
 
   // Save the start of SecLBRProfile so we can compute the offset to the
   // start of SecLBRProfile for each Function's Profile and will keep it
   // in FuncOffsetTable.
   uint64_t SecLBRProfileStart = 0;
+  // Save the start of SecFuncMetadata so we can compute the offset to the
+  // start of SecFuncMetadata for each Function's metadata and will keep it
+  // in MetadataOffsetTable.
+  uint64_t SecMetadataStart = 0;
 
 private:
   void allocSecHdrTable();
   std::error_code writeSecHdrTable();
   virtual std::error_code
   writeHeader(const SampleProfileMap &ProfileMap) override;
   std::error_code compressAndOutput();
 
private:
   // populated in the writer. It may be different from the order in
   // SectionHdrLayout which specifies the sequence in which sections will
   // be read.
   std::vector<SecHdrTableEntry> SecHdrTable;
 
   // FuncOffsetTable maps function context to its profile offset in
   // SecLBRProfile section. It is used to load function profile on demand.
   MapVector<SampleContext, uint64_t> FuncOffsetTable;
+  // MetadataOffsetTable maps function context to its metadata offset in
+  // SecFuncMetadata section. It is used to load function metadata on demand.
+  MapVector<SampleContext, uint64_t> MetadataOffsetTable;
   // Whether to use MD5 to represent string.
   bool UseMD5 = false;
 
   /// CSNameTable maps function context to its offset in SecCSNameTable section.
   /// The offset will be used everywhere where the context is referenced.
   MapVector<SampleContext, uint32_t> CSNameTable;
 
   ProfileSymbolList *ProfSymList = nullptr;

llvm/lib/ProfileData/SampleProfReader.cpp

case SecLBRProfile:
     if (std::error_code EC = readFuncProfiles())
       return EC;
     break;
   case SecFuncOffsetTable:
     FuncOffsetsOrdered = hasSecFlag(Entry, SecFuncOffsetFlags::SecFlagOrdered);
     if (std::error_code EC = readFuncOffsetTable())
       return EC;
     break;
+  case SecMetadataOffsetTable:
+    if (std::error_code EC = readMetadataOffsetTable())
+      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;
for (uint32_t I = 0; I < *Size; ++I) {
     FuncOffsetTable[*FContext] = *Offset;
     if (FuncOffsetsOrdered)
       OrderedFuncOffsets->emplace_back(*FContext, *Offset);
   }
 
   return sampleprof_error::success;
 }
 
-std::error_code SampleProfileReaderExtBinaryBase::readFuncProfiles() {
-  // Collect functions used by current module if the Reader has been
-  // given a module.
+std::error_code SampleProfileReaderExtBinaryBase::readMetadataOffsetTable() {
+  MetadataOffsetTable.clear();
+
+  auto Size = readNumber<uint64_t>();
+  if (std::error_code EC = Size.getError())
+    return EC;
+
+  MetadataOffsetTable.reserve(*Size);
+
+  for (uint32_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;
+
+    MetadataOffsetTable[*FContext] = *Offset;
+  }
+
+  return sampleprof_error::success;
+}
+
+std::set<uint64_t> SampleProfileReaderExtBinaryBase::computeReadOffsets(
+    DenseMap<SampleContext, uint64_t> &OffsetTable,
+    std::vector<std::pair<SampleContext, uint64_t>> *OrderedOffsets) {
+  std::set<uint64_t> Offsets;
+
   // 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 (!collectFuncsFromModule())
+    return Offsets;
 
-  // 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");
-  } else {
-    // Load function profiles on demand.
-    if (Remapper) {
-      for (auto Name : FuncsToUse) {
-        Remapper->insert(Name);
-      }
     }
 
     if (ProfileIsCS) {
       DenseSet<uint64_t> FuncGuidsToUse;
       if (useMD5()) {
         for (auto Name : FuncsToUse)
           FuncGuidsToUse.insert(Function::getGUID(Name));
       }
 
       // For each function in current module, load all context profiles for
       // the function as well as their callee contexts which can help profile
       // guided importing for ThinLTO. This can be achieved by walking
       // through an ordered context container, where contexts are laid out
       // as if they were walked in preorder of a context trie. While
       // traversing the trie, a link to the highest common ancestor node is
       // kept so that all of its decendants will be loaded.
-      assert(OrderedFuncOffsets.get() &&
+      assert(OrderedOffsets &&
              "func offset table should always be sorted in CS profile");
       const SampleContext *CommonContext = nullptr;
-      for (const auto &NameOffset : *OrderedFuncOffsets) {
+      for (const auto &NameOffset : *OrderedOffsets) {
         const auto &FContext = NameOffset.first;
         auto FName = FContext.getName();
         // For function in the current module, keep its farthest ancestor
         // context. This can be used to load itself and its child and
         // sibling contexts.
         if ((useMD5() && FuncGuidsToUse.count(std::stoull(FName.data()))) ||
             (!useMD5() && (FuncsToUse.count(FName) ||
                            (Remapper && Remapper->exist(FName))))) {
           if (!CommonContext || !CommonContext->IsPrefixOf(FContext))
             CommonContext = &FContext;
         }
 
         if (CommonContext == &FContext ||
             (CommonContext && CommonContext->IsPrefixOf(FContext))) {
           // Load profile for the current context which originated from
           // the common ancestor.
-          const uint8_t *FuncProfileAddr = Start + NameOffset.second;
-          assert(FuncProfileAddr < End && "out of LBRProfile section");
-          if (std::error_code EC = readFuncProfile(FuncProfileAddr))
-            return EC;
+          Offsets.insert(NameOffset.second);
         }
       }
     } else {
       if (useMD5()) {
         for (auto Name : FuncsToUse) {
           auto GUID = std::to_string(MD5Hash(Name));
-          auto iter = FuncOffsetTable.find(StringRef(GUID));
-          if (iter == FuncOffsetTable.end())
+          auto Iter = OffsetTable.find(StringRef(GUID));
+          if (Iter == OffsetTable.end())
             continue;
-          const uint8_t *FuncProfileAddr = Start + iter->second;
-          assert(FuncProfileAddr < End && "out of LBRProfile section");
-          if (std::error_code EC = readFuncProfile(FuncProfileAddr))
-            return EC;
+          Offsets.insert(Iter->second);
         }
       } else {
-        for (auto NameOffset : FuncOffsetTable) {
+        for (auto NameOffset : OffsetTable) {
           SampleContext FContext(NameOffset.first);
           auto FuncName = FContext.getName();
           if (!FuncsToUse.count(FuncName) &&
               (!Remapper || !Remapper->exist(FuncName)))
             continue;
-          const uint8_t *FuncProfileAddr = Start + NameOffset.second;
-          assert(FuncProfileAddr < End && "out of LBRProfile section");
-          if (std::error_code EC = readFuncProfile(FuncProfileAddr))
-            return EC;
-        }
-      }
+          Offsets.insert(NameOffset.second);
+        }
+    return Offsets;
+}
+
+std::error_code SampleProfileReaderExtBinaryBase::readFuncProfiles() {
+  if (!M) {
+    // Collect functions used by current module if the Reader has been
+    // given a module.
+    while (Data < End) {
+      if (std::error_code EC = readFuncProfile(Data))
+        return EC;
+    }
+    assert(Data == End && "More data is read than expected");
+  } else {
+    auto Offsets =
+        computeReadOffsets(FuncOffsetTable, OrderedFuncOffsets.get());
+    const uint8_t *Start = Data;
+    for (auto Offset : Offsets) {
+      if (std::error_code EC = readFuncProfile(Start + Offset))
+        return EC;
     }
     Data = End;
   }
   assert((CSProfileCount == 0 || CSProfileCount == Profiles.size()) &&
          "Cannot have both context-sensitive and regular profile");
   assert((!CSProfileCount || ProfileIsCS) &&
          "Section flag should be consistent with actual profile");
   return sampleprof_error::success;
std::error_code SampleProfileReaderExtBinaryBase::decompressSection(
 
   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);
+  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;
 }
 
 std::error_code SampleProfileReaderExtBinaryBase::readImpl() {
   const uint8_t *BufStart =
std::error_code SampleProfileReaderExtBinaryBase::readCSNameTableSec() {
   // From this point the underlying object of CSNameTable should be immutable.
   CSNameTable.reset(PNameVec);
   return sampleprof_error::success;
 }
 
 std::error_code
 
 SampleProfileReaderExtBinaryBase::readFuncMetadata(bool ProfileHasAttribute,
+                                                   const uint8_t *Start,
                                                    FunctionSamples *FProfile) {
+  Data = Start;
   if (Data < End) {
     if (ProfileIsProbeBased) {
       auto Checksum = readNumber<uint64_t>();
       if (std::error_code EC = Checksum.getError())
         return EC;
       if (FProfile)
         FProfile->setFunctionHash(*Checksum);
     }
if (!ProfileIsCS) {
         FunctionSamples *CalleeProfile = nullptr;
         if (FProfile) {
           CalleeProfile = const_cast<FunctionSamples *>(
               &FProfile->functionSamplesAt(LineLocation(
                   *LineOffset,
                   *Discriminator))[std::string(FContext.get().getName())]);
         }
         if (std::error_code EC =
-                readFuncMetadata(ProfileHasAttribute, CalleeProfile))
+                readFuncMetadata(ProfileHasAttribute, Data, CalleeProfile))
           return EC;
       }
     }
   }
 
   return sampleprof_error::success;
 }
 
 std::error_code
 SampleProfileReaderExtBinaryBase::readFuncMetadata(bool ProfileHasAttribute) {
-  while (Data < End) {
+  // Collect functions used by current module if the Reader has been
+  // given a module. For now, we load metadata for all functions directly for CS
+  // flat profile since the metadata section there is as small as the metedata
+  // offset section.
+  bool LoadFuncsToBeUsed = M && !FunctionSamples::ProfileIsCS;
+  auto ReadMetadata = [&]() -> std::error_code {
     auto FContext(readSampleContextFromTable());
     if (std::error_code EC = FContext.getError())
       return EC;
     FunctionSamples *FProfile = nullptr;
     auto It = Profiles.find(*FContext);
     if (It != Profiles.end())
       FProfile = &It->second;
-
-    if (std::error_code EC = readFuncMetadata(ProfileHasAttribute, FProfile))
+    if (std::error_code EC =
+            readFuncMetadata(ProfileHasAttribute, Data, FProfile))
       return EC;
-  }
+    return sampleprof_error::success;
+  };
 
+  if (!LoadFuncsToBeUsed) {
+    // When LoadFuncsToBeUsed is false, load all the function profiles.
+    while (Data < End)
+      ReadMetadata();
     assert(Data == End && "More data is read than expected");
+  } else {
+    auto Offsets = computeReadOffsets(MetadataOffsetTable, nullptr);
+    const uint8_t *Start = Data;
+    for (auto Offset : Offsets) {
+      Data = Start + Offset;
+      ReadMetadata();
+    }
+    Data = End;
+  }
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileReaderCompactBinary::readNameTable() {
   auto Size = readNumber<uint64_t>();
   if (std::error_code EC = Size.getError())
     return EC;
   NameTable.reserve(*Size);

llvm/lib/ProfileData/SampleProfWriter.cpp

for (const auto &Entry : FuncOffsetTable) {
         return EC;
     }
   }
 
   FuncOffsetTable.clear();
   return sampleprof_error::success;
 }
 
+std::error_code SampleProfileWriterExtBinaryBase::writeMetadataOffsetTable() {
+  auto &OS = *OutputStream;
+
+  // Write out the table size.
+  encodeULEB128(MetadataOffsetTable.size(), OS);
+
+  // Write out MetadataOffsetTable.
+  auto WriteItem = [&](const SampleContext &Context, uint64_t Offset) {
+    if (std::error_code EC = writeContextIdx(Context))
+      return EC;
+    encodeULEB128(Offset, OS);
+    return (std::error_code)sampleprof_error::success;
+  };
+
+  for (const auto &Entry : MetadataOffsetTable) {
+    if (std::error_code EC = WriteItem(Entry.first, Entry.second))
+      return EC;
+  }
+
+  MetadataOffsetTable.clear();
+  return sampleprof_error::success;
+}
+
 std::error_code SampleProfileWriterExtBinaryBase::writeFuncMetadata(
     const FunctionSamples &FunctionProfile) {
   auto &OS = *OutputStream;
   if (std::error_code EC = writeContextIdx(FunctionProfile.getContext()))
     return EC;
 
   if (FunctionSamples::ProfileIsProbeBased)
     encodeULEB128(FunctionProfile.getFunctionHash(), OS);

 }
 
 std::error_code SampleProfileWriterExtBinaryBase::writeFuncMetadata(
     const SampleProfileMap &Profiles) {
   if (!FunctionSamples::ProfileIsProbeBased && !FunctionSamples::ProfileIsCS &&
       !FunctionSamples::ProfileIsPreInlined)
     return sampleprof_error::success;
   for (const auto &Entry : Profiles) {
+    uint64_t Offset = OutputStream->tell();
+    auto &Context = Entry.second.getContext();
+    MetadataOffsetTable[Context] = Offset - SecMetadataStart;
     if (std::error_code EC = writeFuncMetadata(Entry.second))
       return EC;
   }
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileWriterExtBinaryBase::writeNameTable() {
   if (!UseMD5)
case SecLBRProfile:
     SecLBRProfileStart = OutputStream->tell();
     if (std::error_code EC = writeFuncProfiles(ProfileMap))
       return EC;
     break;
   case SecFuncOffsetTable:
     if (auto EC = writeFuncOffsetTable())
       return EC;
     break;
+  case SecMetadataOffsetTable:
+    if (auto EC = writeMetadataOffsetTable())
+      return EC;
+    break;
   case SecFuncMetadata:
+    SecMetadataStart = OutputStream->tell();
     if (std::error_code EC = writeFuncMetadata(ProfileMap))
       return EC;
     break;
   case SecProfileSymbolList:
     if (auto EC = writeProfileSymbolListSection())
       return EC;
     break;
   default:
     if (auto EC = writeCustomSection(Type))
       return EC;
     break;
   }
   if (std::error_code EC = addNewSection(Type, LayoutIdx, SectionStart))
     return EC;
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileWriterExtBinary::writeDefaultLayout(
     const SampleProfileMap &ProfileMap) {
   // The const indices passed to writeOneSection below are specifying the
   // positions of the sections in SectionHdrLayout. Look at
-  // initSectionHdrLayout to find out where each section is located in
+  // ExtBinaryHdrLayoutTable to find out where each section is located in
   // SectionHdrLayout.
   if (auto EC = writeOneSection(SecProfSummary, 0, ProfileMap))
     return EC;
   if (auto EC = writeOneSection(SecNameTable, 1, ProfileMap))
     return EC;
   if (auto EC = writeOneSection(SecCSNameTable, 2, ProfileMap))
     return EC;
   if (auto EC = writeOneSection(SecLBRProfile, 4, ProfileMap))
     return EC;
   if (auto EC = writeOneSection(SecProfileSymbolList, 5, ProfileMap))
     return EC;
   if (auto EC = writeOneSection(SecFuncOffsetTable, 3, ProfileMap))
     return EC;
-  if (auto EC = writeOneSection(SecFuncMetadata, 6, ProfileMap))
+  if (auto EC = writeOneSection(SecFuncMetadata, 7, ProfileMap))
+    return EC;
+  if (auto EC = writeOneSection(SecMetadataOffsetTable, 6, ProfileMap))
     return EC;
   return sampleprof_error::success;
 }
 
 static void splitProfileMapToTwo(const SampleProfileMap &ProfileMap,
                                  SampleProfileMap &ContextProfileMap,
                                  SampleProfileMap &NoContextProfileMap) {
   for (const auto &I : ProfileMap) {

llvm/test/tools/llvm-profgen/cs-preinline.test

 ; CHECK-PREINL-NEST-NEXT: 3.2: 1
 ; CHECK-PREINL-NEST-NEXT: 65526: 14
 ; CHECK-PREINL-NEST-NEXT: 3.1: bar:84
 ; CHECK-PREINL-NEST-NEXT:  1: 14
 ; CHECK-PREINL-NEST-NEXT:  !Attributes: 3
 
 
 ; CHECK-PREINL-FLAG: ProfileSummarySection {{.*}} Flags: {{{.*}}preInlined}
+; CHECK-PREINL-FLAG: MetadtaOffsetTableSection