[SampleFDO] Add profile remapping support for profile on-demand loading used by ExtBinary format profile

[wmi]

Summary

profile on-demand loading was added for ExtBinary format profile in https://reviews.llvm.org/rL374233, but currently profile on-demand loading doesn't work well with profile remapping. The patch adds the support.

Suppose a function in the current module has outline instance in the profile. The function name in the module is different from the name of the outline instance, but remapper knows the two names are equal. When loading profile on-demand, the outline instance has to be loaded with remapper's help.

Before the patch, the steps to read the profile is as follows:

• create the profile reader
• profile reader read the profile.
• create the profile remapper
• remapper set the underlying reader.
• reset the profile reader to remapper.

With the patch, the steps to read the profile is changed to:

• create the profile reader
• create the profile remapper
• profile reader set the underlying remapper.
• profile reader read the profile.
• remapper set the underlying reader.
• reset the profile reader to remapper.

[wenlei]

llvm/include/llvm/ProfileData/SampleProfReader.h

658

while turning this Remappings object into unique_ptr decouples things a bit and enables moving error handling of reading remapping file earlier, there's now one more thing to check, Remappings could be null.

660

Check/assert clean state at the beginning? e.g. disallow setting/updating underlying reader repeatedly - was guaranteed when this was done in ctor.

llvm/lib/ProfileData/SampleProfReader.cpp

1213–1214

nit: assert(getFormat() != SPF_None && "UnderlyingReader must be setup before remapper reads")

llvm/lib/Transforms/IPO/SampleProfile.cpp

1718–1720

Wondering if we can move this up to line 1705, by forwarding SampleProfileReaderItaniumRemapper's read(), getProfileSymbolList(), etc. to the underlying reader.

If we can do that, we would be able to avoid the interleaved structure of setting up RemapReader, Reader, and let client of Reader to call read(), etc., then swap the two readers. Without that interleaved structure, we could hide this complexity inside SampleProfileReader::create by letting it take profile file name, as well as remapping file name, and return SampleProfileReaderItaniumRemapper (proxy) or a regular reader depending on whether remapping file is used.

[davidxl]

llvm/lib/Transforms/IPO/SampleProfile.cpp

1705

Better to move line 1705 together with block 1678 to 1693 and make block a helper function 'createRemapper' which does the following

1. create the remapper
2. set reader for the remapper
3. set remapper for the reader.

The call to createRemapper can be moved to line 1705.

[wmi]

Thanks Wenlei and David for the reviews.

It is a good suggestion to try to make remapper and reader less interleaving. That leads me to find a more fundamental problem. Current mechanism to make SampleProfileReaderItaniumRemapper a proxy of underlying reader is easy to have bugs. Currently, some internal data structures like Profiles and NameTables of underlyingReader have been transfered to SampleProfileReaderItaniumRemapper in order for SampleProfileReaderItaniumRemapper to function as a normal reader. However, for every virtual function in SampleProfileReader, we need to have an override function in SampleProfileReaderItaniumRemapper and delegate the function to the underlying reader, otherwise, it will call the wrong version in SampleProfileReader. It is confusing and it is easy to have bugs -- the underlying reader is ExtBinary format but SampleProfileReaderItaniumRemapper behaves like a SampleProfileReader.

So I plan to make SampleProfileReaderItaniumRemapper a helper inside SampleProfileReader instead of a proxy. From what I already saw that will simplify the code a lot. Will update the patch when it is done.

[wmi]

Address Wenlei and David's comments.
Change SampleProfileReaderItaniumRemapper from a proxy of SampleProfileReader to a helper object inside of SampleProfileReader, and it is used in two places: one in SampleProfileReader::getSamplesFor for looking up a function sample and one in SampleProfileReaderExtBinary::readFuncProfiles for loading profiles on demand.

[wenlei]

llvm/include/llvm/ProfileData/SampleProfReader.h

300–306

If client calls getSamplesFor before reading profile, RemappingApplied would be set without doing anything. Then even if client later calls read followed by getSamplesFor, remapping will never be applied. Probably not a big deal though as it's kind of corner case. But alternatively we could eliminate that possibility by calling applyRemapping right after reading profile, e.g. have read from base class call something like readImpl and applyRemapping, and different readers only override readImpl instead of read.

llvm/lib/ProfileData/SampleProfReader.cpp

1315

comment needs update for the new parameter (there're a few other places too).

[wmi]

Address Wenlei's comment.

llvm/include/llvm/ProfileData/SampleProfReader.h

300–306

Good point. Done.

llvm/lib/ProfileData/SampleProfReader.cpp

1315

Done.

[wenlei]

Thanks for making the changes, LGTM!

llvm/include/llvm/ProfileData/SampleProfReader.h

 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 
 namespace sampleprof {
 
+class SampleProfileReaderItaniumRemapper;
+
 /// Sample-based profile reader.
 ///
 /// Each profile contains sample counts for all the functions
 /// executed. Inside each function, statements are annotated with the
 /// collected samples on all the instructions associated with that
 /// statement.
 ///
 /// For this to produce meaningful data, the program needs to be
FunctionSamples *getSamplesFor(const Function &F) {
     // a helper to (optionally) strip off suffixes so that we can
     // match against the original function name in the profile.
     StringRef CanonName = FunctionSamples::getCanonicalFnName(F);
     return getSamplesFor(CanonName);
   }
 
   /// Return the samples collected for function \p F.
   virtual FunctionSamples *getSamplesFor(StringRef Fname) {
     std::string FGUID;
     Fname = getRepInFormat(Fname, getFormat(), FGUID);
     auto It = Profiles.find(Fname);
     if (It != Profiles.end())
       return &It->second;
     return nullptr;
   }
 
   /// Return all the profiles.
   StringMap<FunctionSamples> &getProfiles() { return Profiles; }
 
   /// Report a parse error message.
   void reportError(int64_t LineNumber, Twine Msg) const {
     Ctx.diagnose(DiagnosticInfoSampleProfile(Buffer->getBufferIdentifier(),
                                              LineNumber, Msg));
virtual std::unique_ptr<ProfileSymbolList> getProfileSymbolList() {
     return nullptr;
   };
 
   /// It includes all the names that have samples either in outline instance
   /// or inline instance.
   virtual std::vector<StringRef> *getNameTable() { return nullptr; }
   virtual bool dumpSectionInfo(raw_ostream &OS = dbgs()) { return false; };
 
+  void setRemapper(SampleProfileReaderItaniumRemapper *R) { Remapper = R; }
+
 protected:
   /// Map every function to its associated profile.
   ///
   /// The profile of every function executed at runtime is collected
   /// in the structure FunctionSamples. This maps function objects
   /// to their corresponding profiles.
   StringMap<FunctionSamples> Profiles;
 
protected:
   static std::unique_ptr<ProfileSummary>
   takeSummary(SampleProfileReader &Reader) {
     return std::move(Reader.Summary);
   }
 
   /// Compute summary for this profile.
   void computeSummary();
 
+  SampleProfileReaderItaniumRemapper *Remapper = nullptr;
+
   /// \brief The format of sample.
   SampleProfileFormat Format = SPF_None;
 };
 
 class SampleProfileReaderText : public SampleProfileReader {
 public:
   SampleProfileReaderText(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
       : SampleProfileReader(std::move(B), C, SPF_Text) {}
protected:
   static const uint32_t GCOVTagAFDOFunction = 0xac000000;
 };
 
 /// A profile data reader proxy that remaps the profile data from another
 /// sample profile data reader, by applying a provided set of equivalences
 /// between components of the symbol names in the profile.
 class SampleProfileReaderItaniumRemapper : public SampleProfileReader {
 public:
-  SampleProfileReaderItaniumRemapper(
-      std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
-      std::unique_ptr<SampleProfileReader> Underlying)
-      : SampleProfileReader(std::move(B), C, Underlying->getFormat()) {
+  SampleProfileReaderItaniumRemapper(std::unique_ptr<SymbolRemappingReader> R,
+                                     std::unique_ptr<MemoryBuffer> B,
+                                     LLVMContext &C)
+      : SampleProfileReader(std::move(B), C, SPF_None),
+        Remappings(std::move(R)) {}
+
+  void setUnderlyingReader(std::unique_ptr<SampleProfileReader> Underlying) {
+    Format = Underlying->getFormat();
     Profiles = std::move(Underlying->getProfiles());
     Summary = takeSummary(*Underlying);
     // Keep the underlying reader alive; the profile data may contain
     // StringRefs referencing names in its name table.
     UnderlyingReader = std::move(Underlying);
   }
 
-  /// Create a remapped sample profile from the given remapping file and
-  /// underlying samples.
-  static ErrorOr<std::unique_ptr<SampleProfileReader>>
-  create(const Twine &Filename, LLVMContext &C,
-         std::unique_ptr<SampleProfileReader> Underlying);
+  /// Create a remapped sample profile from the given remapping file.
+  static ErrorOr<std::unique_ptr<SampleProfileReaderItaniumRemapper>>
+  create(const Twine &Filename, LLVMContext &C);
+
+  /// Create a remapped sample profile from the given Buffer.
+  static ErrorOr<std::unique_ptr<SampleProfileReaderItaniumRemapper>>
+  create(std::unique_ptr<MemoryBuffer> B, LLVMContext &C);
 
   /// Read and validate the file header.
   std::error_code readHeader() override { return sampleprof_error::success; }
 
-  /// Read remapping file and apply it to the sample profile.
+  /// Apply remappings to the sample profile.
   std::error_code read() override;
 
+  /// Insert function name into remapper.
+  void insert(StringRef FunctionName) { Remappings->insert(FunctionName); }
+
+  /// Query whether there is equivalent in the remapper which has been
+  /// inserted.
+  bool exist(StringRef FunctionName) {
+    return Remappings->lookup(FunctionName);
+  }
+
   /// Return the samples collected for function \p F.
   FunctionSamples *getSamplesFor(StringRef FunctionName) override;
   using SampleProfileReader::getSamplesFor;
 
 private:
-  SymbolRemappingReader Remappings;
+  std::unique_ptr<SymbolRemappingReader> Remappings;
   DenseMap<SymbolRemappingReader::Key, FunctionSamples*> SampleMap;
   std::unique_ptr<SampleProfileReader> UnderlyingReader;
 };
 
 } // end namespace sampleprof
 
 } // end namespace llvm
 
 #endif // LLVM_PROFILEDATA_SAMPLEPROFREADER_H

llvm/lib/ProfileData/SampleProfReader.cpp

if (UseAllFuncs) {
     while (Data < End) {
       if (std::error_code EC = readFuncProfile(Data))
         return EC;
     }
     assert(Data == End && "More data is read than expected");
     return sampleprof_error::success;
   }
 
+  if (Remapper) {
     for (auto Name : FuncsToUse) {
-    auto iter = FuncOffsetTable.find(Name);
-    if (iter == FuncOffsetTable.end())
+      Remapper->insert(Name);
+    }
+  }
+
+  for (auto NameOffset : FuncOffsetTable) {
+    auto FuncName = NameOffset.first;
+    if (!FuncsToUse.count(FuncName) &&
+        (!Remapper || !Remapper->exist(FuncName)))
       continue;
-    const uint8_t *FuncProfileAddr = Start + iter->second;
+    const uint8_t *FuncProfileAddr = Start + NameOffset.second;
     assert(FuncProfileAddr < End && "out of LBRProfile section");
     if (std::error_code EC = readFuncProfile(FuncProfileAddr))
       return EC;
   }
+
   Data = End;
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileReaderExtBinary::readProfileSymbolList() {
   if (!ProfSymList)
     ProfSymList = std::make_unique<ProfileSymbolList>();
 

 }
 
 bool SampleProfileReaderGCC::hasFormat(const MemoryBuffer &Buffer) {
   StringRef Magic(reinterpret_cast<const char *>(Buffer.getBufferStart()));
   return Magic == "adcg*704";
 }
 
 std::error_code SampleProfileReaderItaniumRemapper::read() {
+  if (getFormat() == SPF_None)
+    llvm_unreachable("UnderlyingReader must be setup before remapper reads");
+
   // If the underlying data is in compact format, we can't remap it because
   // we don't know what the original function names were.
   if (getFormat() == SPF_Compact_Binary) {
     Ctx.diagnose(DiagnosticInfoSampleProfile(
         Buffer->getBufferIdentifier(),
         "Profile data remapping cannot be applied to profile data "
         "in compact format (original mangled names are not available).",
         DS_Warning));
     return sampleprof_error::success;
   }
 
-  if (Error E = Remappings.read(*Buffer)) {
-    handleAllErrors(
-        std::move(E), [&](const SymbolRemappingParseError &ParseError) {
-          reportError(ParseError.getLineNum(), ParseError.getMessage());
-        });
-    return sampleprof_error::malformed;
-  }
-
   for (auto &Sample : getProfiles())
-    if (auto Key = Remappings.insert(Sample.first()))
+    if (auto Key = Remappings->insert(Sample.first()))
       SampleMap.insert({Key, &Sample.second});
 
   return sampleprof_error::success;
 }
 
 FunctionSamples *
 SampleProfileReaderItaniumRemapper::getSamplesFor(StringRef Fname) {
-  if (auto Key = Remappings.lookup(Fname))
+  if (auto Key = Remappings->lookup(Fname))
     return SampleMap.lookup(Key);
   return SampleProfileReader::getSamplesFor(Fname);
 }
 
 /// Prepare a memory buffer for the contents of \p Filename.
 ///
 /// \returns an error code indicating the status of the buffer.
 static ErrorOr<std::unique_ptr<MemoryBuffer>>

 
 /// Create a sample profile remapper from the given input, to remap the
 /// function names in the given profile data.
 ///
 /// \param Filename The file to open.
 ///
 /// \param C The LLVM context to use to emit diagnostics.
 ///
-/// \param Underlying The underlying profile data reader to remap.
-///
 /// \returns an error code indicating the status of the created reader.
-ErrorOr<std::unique_ptr<SampleProfileReader>>
-SampleProfileReaderItaniumRemapper::create(
-    const Twine &Filename, LLVMContext &C,
-    std::unique_ptr<SampleProfileReader> Underlying) {
+ErrorOr<std::unique_ptr<SampleProfileReaderItaniumRemapper>>
+SampleProfileReaderItaniumRemapper::create(const Twine &Filename,
+                                           LLVMContext &C) {
   auto BufferOrError = setupMemoryBuffer(Filename);
   if (std::error_code EC = BufferOrError.getError())
     return EC;
+  return create(std::move(BufferOrError.get()), C);
+}
+
+/// Create a sample profile remapper from the given input, to remap the
+/// function names in the given profile data.
+///
+/// \param B The memory buffer to create the reader from (assumes ownership).
+///
+/// \param C The LLVM context to use to emit diagnostics.
+///
+/// \returns an error code indicating the status of the created reader.
+ErrorOr<std::unique_ptr<SampleProfileReaderItaniumRemapper>>
+SampleProfileReaderItaniumRemapper::create(std::unique_ptr<MemoryBuffer> B,
+                                           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(BufferOrError.get()), C, std::move(Underlying));
+      std::move(Remappings), std::move(B), C);
 }
 
 /// Create a sample profile reader based on the format of the input data.
 ///
 /// \param B The memory buffer to create the reader from (assumes ownership).
 ///
 /// \param C The LLVM context to use to emit diagnostics.
 ///
 /// \returns an error code indicating the status of the created reader.
 ErrorOr<std::unique_ptr<SampleProfileReader>>
 SampleProfileReader::create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C) {

llvm/lib/Transforms/IPO/SampleProfile.cpp

 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(ProfileSummaryInfoWrapperPass)
 INITIALIZE_PASS_END(SampleProfileLoaderLegacyPass, "sample-profile",
                     "Sample Profile loader", false, false)
 
 bool SampleProfileLoader::doInitialization(Module &M) {
   auto &Ctx = M.getContext();
+
+  std::unique_ptr<SampleProfileReaderItaniumRemapper> RemapReader;
+  if (!RemappingFilename.empty()) {
+    // Apply profile remappings to the loaded profile data if requested.
+    // For now, we only support remapping symbols encoded using the Itanium
+    // C++ ABI's name mangling scheme.
+    auto ReaderOrErr =
+        SampleProfileReaderItaniumRemapper::create(RemappingFilename, Ctx);
+    if (std::error_code EC = ReaderOrErr.getError()) {
+      std::string Msg =
+          "Could not read profile remapping file: " + EC.message();
+      Ctx.diagnose(DiagnosticInfoSampleProfile(Filename, Msg));
+      return false;
+    }
+    RemapReader = std::move(ReaderOrErr.get());
+  }
+
   auto ReaderOrErr = SampleProfileReader::create(Filename, Ctx);
   if (std::error_code EC = ReaderOrErr.getError()) {
     std::string Msg = "Could not open profile: " + EC.message();
     Ctx.diagnose(DiagnosticInfoSampleProfile(Filename, Msg));
     return false;
   }
   Reader = std::move(ReaderOrErr.get());
   Reader->collectFuncsFrom(M);
+  // Set up Remapper before read because on demand profile loading may need
+  // to compare name in the module with name in the profile using Remapper.
+  Reader->setRemapper(RemapReader.get());
   ProfileIsValid = (Reader->read() == sampleprof_error::success);
   PSL = Reader->getProfileSymbolList();
 
   // While profile-sample-accurate is on, ignore symbol list.
   ProfAccForSymsInList =
       ProfileAccurateForSymsInList && PSL && !ProfileSampleAccurate;
   if (ProfAccForSymsInList) {
     NamesInProfile.clear();
     if (auto NameTable = Reader->getNameTable())
       NamesInProfile.insert(NameTable->begin(), NameTable->end());
   }
 
-  if (!RemappingFilename.empty()) {
-    // Apply profile remappings to the loaded profile data if requested.
-    // For now, we only support remapping symbols encoded using the Itanium
-    // C++ ABI's name mangling scheme.
-    ReaderOrErr = SampleProfileReaderItaniumRemapper::create(
-        RemappingFilename, Ctx, std::move(Reader));
-    if (std::error_code EC = ReaderOrErr.getError()) {
-      std::string Msg = "Could not open profile remapping file: " + EC.message();
-      Ctx.diagnose(DiagnosticInfoSampleProfile(Filename, Msg));
-      return false;
-    }
-    Reader = std::move(ReaderOrErr.get());
+  if (RemapReader) {
+    RemapReader->setUnderlyingReader(std::move(Reader));
+    Reader = std::move(RemapReader);
     ProfileIsValid = (Reader->read() == sampleprof_error::success);
   }
   return true;
 }
 
 ModulePass *llvm::createSampleProfileLoaderPass() {
   return new SampleProfileLoaderLegacyPass();
 }

llvm/test/Transforms/SampleProfile/remap.ll

 ; RUN: opt %s -passes=sample-profile -sample-profile-file=%S/Inputs/remap.prof -sample-profile-remapping-file=%S/Inputs/remap.map | opt -analyze -branch-prob | FileCheck %s
-
+;
+; Check whether profile remapping work with loading profile on demand used by extbinary format profile.
+; RUN: llvm-profdata merge -sample -extbinary %S/Inputs/remap.prof -o %t.extbinary.afdo
+; RUN: opt %s -passes=sample-profile -sample-profile-file=%S/Inputs/remap.prof -sample-profile-remapping-file=%S/Inputs/remap.map | opt -analyze -branch-prob | FileCheck %s
+;
 ; Reduced from branch.ll
 
 declare i1 @foo()
 
 define void @_ZN3foo3barERKN1M1XINS_6detail3quxEEE() !dbg !2 {
 ; CHECK: Printing analysis 'Branch Probability Analysis' for function '_ZN3foo3barERKN1M1XINS_6detail3quxEEE':
 
 entry:

llvm/unittests/ProfileData/SampleProfTest.cpp

void testRoundTrip(SampleProfileFormat Format, bool Remap) {
 
     StringRef BazName("_Z3bazi");
     FunctionSamples BazSamples;
     BazSamples.setName(BazName);
     BazSamples.addTotalSamples(12557);
     BazSamples.addHeadSamples(1257);
     BazSamples.addBodySamples(1, 0, 12557);
 
-    Module M("my_module", Context);
-    FunctionType *fn_type =
-        FunctionType::get(Type::getVoidTy(Context), {}, false);
-    M.getOrInsertFunction(FooName, fn_type);
-    M.getOrInsertFunction(BarName, fn_type);
+    StringRef BooName("_Z3booi");
+    FunctionSamples BooSamples;
+    BooSamples.setName(BooName);
+    BooSamples.addTotalSamples(1232);
+    BooSamples.addHeadSamples(1);
+    BooSamples.addBodySamples(1, 0, 1232);
 
     StringMap<FunctionSamples> Profiles;
     Profiles[FooName] = std::move(FooSamples);
     Profiles[BarName] = std::move(BarSamples);
     Profiles[BazName] = std::move(BazSamples);
+    Profiles[BooName] = std::move(BooSamples);
+
+    Module M("my_module", Context);
+    FunctionType *fn_type =
+        FunctionType::get(Type::getVoidTy(Context), {}, false);
+
+    std::unique_ptr<SampleProfileReaderItaniumRemapper> RemapReader;
+    if (Remap) {
+      auto MemBuffer = llvm::MemoryBuffer::getMemBuffer(R"(
+        # Types 'int' and 'long' are equivalent
+        type i l
+        # Function names 'foo' and 'faux' are equivalent
+        name 3foo 4faux
+      )");
+      auto ReaderOrErr = SampleProfileReaderItaniumRemapper::create(
+          std::move(MemBuffer), Context);
+      ASSERT_TRUE(NoError(ReaderOrErr.getError()));
+      RemapReader = std::move(ReaderOrErr.get());
+
+      FooName = "_Z4fauxi";
+      BarName = "_Z3barl";
+    }
+
+    M.getOrInsertFunction(FooName, fn_type);
+    M.getOrInsertFunction(BarName, fn_type);
+    M.getOrInsertFunction(BooName, fn_type);
 
     ProfileSymbolList List;
     if (Format == SampleProfileFormat::SPF_Ext_Binary) {
       List.add("zoo", true);
       List.add("moo", true);
     }
     Writer->setProfileSymbolList(&List);
 
     std::error_code EC;
     EC = Writer->write(Profiles);
     ASSERT_TRUE(NoError(EC));
 
     Writer->getOutputStream().flush();
 
     readProfile(M, Profile);
-
+    // Set up Remapper before read because on demand profile loading may need
+    // to compare name in the module with name in the profile using Remapper.
+    Reader->setRemapper(RemapReader.get());
     EC = Reader->read();
     ASSERT_TRUE(NoError(EC));
 
     if (Format == SampleProfileFormat::SPF_Ext_Binary) {
       std::unique_ptr<ProfileSymbolList> ReaderList =
           Reader->getProfileSymbolList();
       ReaderList->contains("zoo");
       ReaderList->contains("moo");
     }
 
     if (Remap) {
-      auto MemBuffer = llvm::MemoryBuffer::getMemBuffer(R"(
-        # Types 'int' and 'long' are equivalent
-        type i l
-        # Function names 'foo' and 'faux' are equivalent
-        name 3foo 4faux
-      )");
-      Reader.reset(new SampleProfileReaderItaniumRemapper(
-          std::move(MemBuffer), Context, std::move(Reader)));
-      FooName = "_Z4fauxi";
-      BarName = "_Z3barl";
+      RemapReader->setUnderlyingReader(std::move(Reader));
+      Reader = std::move(RemapReader);
 
       EC = Reader->read();
       ASSERT_TRUE(NoError(EC));
     }
 
     FunctionSamples *ReadFooSamples = Reader->getSamplesFor(FooName);
     ASSERT_TRUE(ReadFooSamples != nullptr);
     if (Format != SampleProfileFormat::SPF_Compact_Binary) {
void testRoundTrip(SampleProfileFormat Format, bool Remap) {
 
     // Because _Z3bazi is not defined in module M, expect _Z3bazi's profile
     // is not loaded when the profile is ExtBinary or Compact format because
     // these formats support loading function profiles on demand.
     FunctionSamples *ReadBazSamples = Reader->getSamplesFor(BazName);
     if (Format == SampleProfileFormat::SPF_Ext_Binary ||
         Format == SampleProfileFormat::SPF_Compact_Binary) {
       ASSERT_TRUE(ReadBazSamples == nullptr);
-      ASSERT_EQ(2u, Reader->getProfiles().size());
+      ASSERT_EQ(3u, Reader->getProfiles().size());
     } else {
       ASSERT_TRUE(ReadBazSamples != nullptr);
       ASSERT_EQ(12557u, ReadBazSamples->getTotalSamples());
-      ASSERT_EQ(3u, Reader->getProfiles().size());
+      ASSERT_EQ(4u, Reader->getProfiles().size());
     }
 
+    FunctionSamples *ReadBooSamples = Reader->getSamplesFor(BooName);
+    ASSERT_TRUE(ReadBooSamples != nullptr);
+    ASSERT_EQ(1232u, ReadBooSamples->getTotalSamples());
+
     std::string MconstructGUID;
     StringRef MconstructRep =
         getRepInFormat(MconstructName, Format, MconstructGUID);
     std::string StringviewGUID;
     StringRef StringviewRep =
         getRepInFormat(StringviewName, Format, StringviewGUID);
     ASSERT_EQ(1000u, CTMap.get()[MconstructRep]);
     ASSERT_EQ(437u, CTMap.get()[StringviewRep]);
 
     auto VerifySummary = [](ProfileSummary &Summary) mutable {
       ASSERT_EQ(ProfileSummary::PSK_Sample, Summary.getKind());
-      ASSERT_EQ(136160u, Summary.getTotalCount());
-      ASSERT_EQ(7u, Summary.getNumCounts());
-      ASSERT_EQ(3u, Summary.getNumFunctions());
+      ASSERT_EQ(137392u, Summary.getTotalCount());
+      ASSERT_EQ(8u, Summary.getNumCounts());
+      ASSERT_EQ(4u, Summary.getNumFunctions());
       ASSERT_EQ(1437u, Summary.getMaxFunctionCount());
       ASSERT_EQ(60351u, Summary.getMaxCount());
 
       uint32_t Cutoff = 800000;
       auto Predicate = [&Cutoff](const ProfileSummaryEntry &PE) {
         return PE.Cutoff == Cutoff;
       };
       std::vector<ProfileSummaryEntry> &Details = Summary.getDetailedSummary();