[PseudoProbe] Decode offset based pseudo probe.

[hoy]

Summary

This is the corresponding decoding change to D135912: [PseudoProbe] Replace relocation with offset for entry probe.. The change is downwards compatible as long as there's no mixed use of the old encoding and the new encoding.

[hoy]

Updating D135914: [PseudoProbe] Decode offset based pseudo probe.

[hoy]

Updating D135914: [PseudoProbe] Decode offset based pseudo probe.

[maksfb]

llvm/include/llvm/MC/MCPseudoProbe.h

343

360–361

You probably want to use DenseSet and DenseMap for these and then use type aliases for the interface.

[hoy]

Addressing comments.

llvm/include/llvm/MC/MCPseudoProbe.h

343

Good catch, thanks.

360–361

Sounds good, fixed.

[maksfb]

There are a couple more uses of std::*map<> left that could be converted to maps from LLVM's ADT.

[hoy]

In D135914#3876108, @maksfb wrote:

There are a couple more uses of std::*map<> left that could be converted to maps from LLVM's ADT.

Yes, std::map is used everywhere in llvm-profgen. Do you think ADT performs better than it? I can do a separate refactoring if you don't mind.

[maksfb]

In D135914#3876142, @hoy wrote:

Yes, std::map is used everywhere in llvm-profgen. Do you think ADT performs better than it? I can do a separate refactoring if you don't mind.

I had this diff in mind, but the refactoring sounds good too. ADT avoids malloc, more details at: https://llvm.org/docs/ProgrammersManual.html#map-like-containers-std-map-densemap-etc

[hoy]

In D135914#3876184, @maksfb wrote:

In D135914#3876142, @hoy wrote:

Yes, std::map is used everywhere in llvm-profgen. Do you think ADT performs better than it? I can do a separate refactoring if you don't mind.

I had this diff in mind, but the refactoring sounds good too. ADT avoids malloc, more details at: https://llvm.org/docs/ProgrammersManual.html#map-like-containers-std-map-densemap-etc

I see. Looks like it's great for small keys and values. I'll go through the code base and adjust existing std::map usage (not only for the ones introduced here). Will make a separate change.

[maksfb]

Sounds good.

[hoy]

In D135914#3876235, @maksfb wrote:

Sounds good.

Actually let me change the std::unordered_map introduced by this change to DenseMap. The refactoring will likely to take a bit longer.

[hoy]

Replacing std::unodered_map with DenseMap.

[hoy]

Renaming uint64_set to Uint64Set

[wenlei]

Sentinel probe case isn't covered for both encoding and decoding in any test cases, would be good to have some coverage.

llvm/lib/MC/MCPseudoProbe.cpp

419

nit: Cur == &DummyInlineRoot -> IsTopLevelFunc

476

Maybe I'm asking the same question as the one on previous patch, but why do we still have cases with absolute address encoded? I thought for main function body we have GUID -> symbol (reverse lookup) -> address; and we have similar way to get address for sentinel for split binary function. The rest should all be offset/delta.

[hoy]

In D135914#3881607, @wenlei wrote:

Sentinel probe case isn't covered for both encoding and decoding in any test cases, would be good to have some coverage.

Forgot to mention that the updated binary, i.e, inline-cs-pseudoprobe.perfbin, is built with the new encoding. The binary supports a dozen llvm-profgen tests and they all pass with the current decoding changes.

llvm/lib/MC/MCPseudoProbe.cpp

419

Done.

476

This is mainly for downwards-compatibility, i.e. to have new llvm-profgen handle old binaries.

[hoy]

Addressing feedbacks.

[wenlei]

In D135914#3882912, @hoy wrote:

In D135914#3881607, @wenlei wrote:

Sentinel probe case isn't covered for both encoding and decoding in any test cases, would be good to have some coverage.

Forgot to mention that the updated binary, i.e, inline-cs-pseudoprobe.perfbin, is built with the new encoding. The binary supports a dozen llvm-profgen tests and they all pass with the current decoding changes.

Do we have a split function case in the existing tests? I thought we don't, but if we have, that'd be good enough.

llvm/lib/MC/MCPseudoProbe.cpp

476

Ok, makes sense. Like I mentioned in the other patch, add a comment explaining this is for backward compatibility and a todo for removal?

[hoy]

In D135914#3883493, @wenlei wrote:

In D135914#3882912, @hoy wrote:

In D135914#3881607, @wenlei wrote:

Sentinel probe case isn't covered for both encoding and decoding in any test cases, would be good to have some coverage.

Forgot to mention that the updated binary, i.e, inline-cs-pseudoprobe.perfbin, is built with the new encoding. The binary supports a dozen llvm-profgen tests and they all pass with the current decoding changes.

Do we have a split function case in the existing tests? I thought we don't, but if we have, that'd be good enough.

Good point. The test binary func-split.perfbin is updated.

llvm/lib/MC/MCPseudoProbe.cpp

476

Done.

[hoy]

Updating D135914: [PseudoProbe] Decode offset based pseudo probe.

[wenlei]

lgtm, with a nit on naming.

llvm/lib/MC/MCPseudoProbe.cpp

470

nit: binary function -> split function

[hoy]

Updating D135914: [PseudoProbe] Decode offset based pseudo probe.

[hoy]

Closed by commit rGd5a963ab8b40

llvm/include/llvm/MC/MCPseudoProbe.h

void addPseudoProbe(MCSymbol *FuncSym, const MCPseudoProbe &Probe,
     MCProbeDivisions[FuncSym].addPseudoProbe(Probe, InlineStack);
   }
 
   // TODO: Sort by getOrdinal to ensure a determinstic section order
   using MCProbeDivisionMap = std::map<MCSymbol *, MCPseudoProbeInlineTree>;
 
 private:
   // A collection of MCPseudoProbe for each binary function. The MCPseudoProbes
-  // are grouped by GUIDs due to inlining that can bring probes from different functions into one function.
+  // are grouped by GUIDs due to inlining that can bring probes from different
+  // functions into one function.
   MCProbeDivisionMap MCProbeDivisions;
 
 public:
   const MCProbeDivisionMap &getMCProbes() const { return MCProbeDivisions; }
 
   bool empty() const { return MCProbeDivisions.empty(); }
 
   void emit(MCObjectStreamer *MCOS);
class MCPseudoProbeDecoder {
   MCDecodedPseudoProbeInlineTree DummyInlineRoot;
 
   /// Points to the current location in the buffer.
   const uint8_t *Data = nullptr;
 
   /// Points to the end of the buffer.
   const uint8_t *End = nullptr;
 
+  /// Whether encoding it based on a starting probe with absolute code address.
+  bool EncodingIsAddrBased = false;
+
   // Decoding helper function
   template <typename T> ErrorOr<T> readUnencodedNumber();
   template <typename T> ErrorOr<T> readUnsignedNumber();
   template <typename T> ErrorOr<T> readSignedNumber();
   ErrorOr<StringRef> readString(uint32_t Size);
 
 public:
   // Decode pseudo_probe_desc section to build GUID to PseudoProbeFuncDesc map.
   bool buildGUID2FuncDescMap(const uint8_t *Start, std::size_t Size);
 
-  // Decode pseudo_probe section to build address to probes map.
-  bool buildAddress2ProbeMap(const uint8_t *Start, std::size_t Size);
-
   // Decode pseudo_probe section to build address to probes map for specifed
   // functions only.
-  bool buildAddress2ProbeMap(const uint8_t *Start, std::size_t Size,
-                             std::unordered_set<uint64_t> &GuildFilter);
-
-  bool buildAddress2ProbeMap(MCDecodedPseudoProbeInlineTree *Cur,
-                             uint64_t &LastAddr,
-                             std::unordered_set<uint64_t> &GuildFilter);
+  bool buildAddress2ProbeMap(
+      const uint8_t *Start, std::size_t Size,
+      std::unordered_set<uint64_t> &GuildFilter,
+      const std::unordered_map<uint64_t, uint64_t> &FuncStartAddrs);
+
+  bool buildAddress2ProbeMap(
+      MCDecodedPseudoProbeInlineTree *Cur, uint64_t &LastAddr,
+      std::unordered_set<uint64_t> &GuildFilter,
+      const std::unordered_map<uint64_t, uint64_t> &FuncStartAddrs);
 
   // Print pseudo_probe_desc section info
   void printGUID2FuncDescMap(raw_ostream &OS);
 
   // Print pseudo_probe section info, used along with show-disassembly
   void printProbeForAddress(raw_ostream &OS, uint64_t Address);
 
   // do printProbeForAddress for all addresses

llvm/lib/MC/MCPseudoProbe.cpp

void MCPseudoProbe::emit(MCObjectStreamer *MCOS,
   // Type (bit 0 to 3), with bit 4 to 6 for attributes.
   // Flag (bit 7, 0 - code address, 1 - address delta). This indicates whether
   // the following field is a symbolic code address or an address delta.
   assert(Type <= 0xF && "Probe type too big to encode, exceeding 15");
   assert(Attributes <= 0x7 &&
          "Probe attributes too big to encode, exceeding 7");
   uint8_t PackedType = Type | (Attributes << 4);
   uint8_t Flag =
-      IsSentinel ? ((int8_t)MCPseudoProbeFlag::AddressDelta << 7) : 0;
+      !IsSentinel ? ((int8_t)MCPseudoProbeFlag::AddressDelta << 7) : 0;
   MCOS->emitInt8(Flag | PackedType);
 
   if (!IsSentinel) {
     // Emit the delta between the address label and LastProbe.
     const MCExpr *AddrDelta =
         buildSymbolDiff(MCOS, Label, LastProbe->getLabel());
     int64_t Delta;
     if (AddrDelta->evaluateAsAbsolute(Delta, MCOS->getAssemblerPtr())) {
while (Data < End) {
     GUID2FuncDescMap.emplace(GUID, MCPseudoProbeFuncDesc(GUID, Hash, Name));
   }
   assert(Data == End && "Have unprocessed data in pseudo_probe_desc section");
   return true;
 }
 
 bool MCPseudoProbeDecoder::buildAddress2ProbeMap(
     MCDecodedPseudoProbeInlineTree *Cur, uint64_t &LastAddr,
-    std::unordered_set<uint64_t> &GuildFilter) {
+    std::unordered_set<uint64_t> &GuidFilter,
+    const std::unordered_map<uint64_t, uint64_t> &FuncStartAddrs) {
   // The pseudo_probe section encodes an inline forest and each tree has a
-  // format like:
-  //  FUNCTION BODY (one for each uninlined function present in the text
-  //  section)
-  //     GUID (uint64)
-  //         GUID of the function
-  //     NPROBES (ULEB128)
-  //         Number of probes originating from this function.
-  //     NUM_INLINED_FUNCTIONS (ULEB128)
-  //         Number of callees inlined into this function, aka number of
-  //         first-level inlinees
-  //     PROBE RECORDS
-  //         A list of NPROBES entries. Each entry contains:
-  //           INDEX (ULEB128)
-  //           TYPE (uint4)
-  //             0 - block probe, 1 - indirect call, 2 - direct call
-  //           ATTRIBUTE (uint3)
-  //             1 - tail call, 2 - dangling
-  //           ADDRESS_TYPE (uint1)
-  //             0 - code address, 1 - address delta
-  //           CODE_ADDRESS (uint64 or ULEB128)
-  //             code address or address delta, depending on Flag
-  //     INLINED FUNCTION RECORDS
-  //         A list of NUM_INLINED_FUNCTIONS entries describing each of the
-  //         inlined callees.  Each record contains:
-  //           INLINE SITE
-  //             Index of the callsite probe (ULEB128)
-  //           FUNCTION BODY
-  //             A FUNCTION BODY entry describing the inlined function.
+  // format defined in MCPseudoProbe.h
 
   uint32_t Index = 0;
-  if (Cur == &DummyInlineRoot) {
+  bool IsTopLevelFunc = Cur == &DummyInlineRoot;
+  if (IsTopLevelFunc) {
     // Use a sequential id for top level inliner.
     Index = Cur->getChildren().size();
   } else {
     // Read inline site for inlinees
     auto ErrorOrIndex = readUnsignedNumber<uint32_t>();
     if (!ErrorOrIndex)
       return false;
     Index = std::move(*ErrorOrIndex);
   }
 
   // Read guid
   auto ErrorOrCurGuid = readUnencodedNumber<uint64_t>();
   if (!ErrorOrCurGuid)
     return false;
   uint64_t Guid = std::move(*ErrorOrCurGuid);
 
   // Decide if top-level node should be disgarded.
-  if (Cur == &DummyInlineRoot && !GuildFilter.empty() &&
-      !GuildFilter.count(Guid))
+  if (Cur == &DummyInlineRoot && !GuidFilter.empty() && !GuidFilter.count(Guid))
     Cur = nullptr;
 
   // If the incoming node is null, all its children nodes should be disgarded.
   if (Cur) {
     // Switch/add to a new tree node(inlinee)
     Cur = Cur->getOrAddNode(std::make_tuple(Guid, Index));
     Cur->Guid = Guid;
+    if (IsTopLevelFunc && !EncodingIsAddrBased)
+      if (FuncStartAddrs.count(Guid))
+        LastAddr = FuncStartAddrs.at(Guid);
   }
 
   // Read number of probes in the current node.
   auto ErrorOrNodeCount = readUnsignedNumber<uint32_t>();
   if (!ErrorOrNodeCount)
     return false;
   uint32_t NodeCount = std::move(*ErrorOrNodeCount);
   // Read number of direct inlinees
if (Value & 0x80) {
         return false;
       int64_t Offset = std::move(*ErrorOrOffset);
       Addr = LastAddr + Offset;
     } else {
       auto ErrorOrAddr = readUnencodedNumber<int64_t>();
       if (!ErrorOrAddr)
         return false;
       Addr = std::move(*ErrorOrAddr);
+      if (isSentinelProbe(Attr)) {
+        // For sentinel probe, the addr field actually stores the GUID of the
+        // binary function. Convert it to the real address.
+        auto GUID = Addr;
+        if (FuncStartAddrs.count(GUID))
+          Addr = FuncStartAddrs.at(GUID);
+      } else {
+        // For now we assume all probe encoding should be either based on
+        // leading probe address or function start address.
+        EncodingIsAddrBased = true;
+      }
     }
 
-    if (Cur) {
+    if (Cur && !isSentinelProbe(Attr)) {
       // Populate Address2ProbesMap
       auto &Probes = Address2ProbesMap[Addr];
       Probes.emplace_back(Addr, Cur->Guid, Index, PseudoProbeType(Kind), Attr,
                           Cur);
       Cur->addProbes(&Probes.back());
     }
     LastAddr = Addr;
   }
 
   uint32_t ChildrenToProcess = std::move(*ErrorOrCurChildrenToProcess);
   for (uint32_t I = 0; I < ChildrenToProcess; I++) {
-    buildAddress2ProbeMap(Cur, LastAddr, GuildFilter);
+    buildAddress2ProbeMap(Cur, LastAddr, GuidFilter, FuncStartAddrs);
   }
 
   return true;
 }
 
 bool MCPseudoProbeDecoder::buildAddress2ProbeMap(
     const uint8_t *Start, std::size_t Size,
-    std::unordered_set<uint64_t> &GuildFilter) {
+    std::unordered_set<uint64_t> &GuidFilter,
+    const std::unordered_map<uint64_t, uint64_t> &FuncStartAddrs) {
   Data = Start;
   End = Data + Size;
   uint64_t LastAddr = 0;
   while (Data < End)
-    buildAddress2ProbeMap(&DummyInlineRoot, LastAddr, GuildFilter);
+    buildAddress2ProbeMap(&DummyInlineRoot, LastAddr, GuidFilter,
+                          FuncStartAddrs);
   assert(Data == End && "Have unprocessed data in pseudo_probe section");
   return true;
 }
 
-bool MCPseudoProbeDecoder::buildAddress2ProbeMap(const uint8_t *Start,
-                                                 std::size_t Size) {
-  std::unordered_set<uint64_t> GuildFilter;
-  return buildAddress2ProbeMap(Start, Size, GuildFilter);
-}
-
 void MCPseudoProbeDecoder::printGUID2FuncDescMap(raw_ostream &OS) {
   OS << "Pseudo Probe Desc:\n";
   // Make the output deterministic
   std::map<uint64_t, MCPseudoProbeFuncDesc> OrderedMap(GUID2FuncDescMap.begin(),
                                                        GUID2FuncDescMap.end());
   for (auto &I : OrderedMap) {
     I.second.print(OS);
   }

llvm/test/tools/llvm-profgen/inline-force-dwarf.test

 ; RUN: llvm-profgen --format=text --ignore-stack-samples --use-dwarf-correlation --perfscript=%S/Inputs/inline-cs-pseudoprobe.perfscript --binary=%S/Inputs/inline-cs-pseudoprobe.perfbin --output=%t --profile-summary-cold-count=0
 ; RUN: FileCheck %s --input-file %t
 
 ; CHECK:     main:1109:0
 ; CHECK-NEXT: 0: 0
 ; CHECK-NEXT: 2: 0
 ; CHECK-NEXT: 1: foo:1109
 ; CHECK-NEXT:  2: 14
 ; CHECK-NEXT:  3: 15
 ; CHECK-NEXT:  4: 0
-; CHECK-NEXT:  65526: 14
-; CHECK-NEXT:  3: bar:224
+; CHECK-NEXT:  65525: 14
+; CHECK-NEXT:  3: bar:196
 ; CHECK-NEXT:   1: 14
-; CHECK-NEXT:   65533: 14
 
 
 ; clang -O3 -fuse-ld=lld -fpseudo-probe-for-profiling
 ; -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -Xclang -mdisable-tail-calls
 ; -g test.c  -o a.out
 
 #include <stdio.h>
 

llvm/tools/llvm-profgen/ProfileGenerator.cpp

void CSProfileGenerator::generateProfile() {
 
   if (Binary->getTrackFuncContextSize())
     computeSizeForProfiledFunctions();
 
   postProcessProfiles();
 }
 
 void CSProfileGenerator::computeSizeForProfiledFunctions() {
-  std::unordered_set<const BinaryFunction *> ProfiledFunctions;
   for (auto *Func : Binary->getProfiledFunctions())
     Binary->computeInlinedContextSizeForFunc(Func);
 
   // Flush the symbolizer to save memory.
   Binary->flushSymbolizer();
 }
 
 void CSProfileGenerator::updateFunctionSamples() {

llvm/tools/llvm-profgen/ProfiledBinary.h

class ProfiledBinary {
   std::set<std::pair<uint64_t, uint64_t>> TextSections;
 
   // A map of mapping function name to BinaryFunction info.
   std::unordered_map<std::string, BinaryFunction> BinaryFunctions;
 
   // A list of binary functions that have samples.
   std::unordered_set<const BinaryFunction *> ProfiledFunctions;
 
+  // GUID to Elf symbol start address map
+  std::unordered_map<uint64_t, uint64_t> SymbolStartAddrs;
+
+  // Start address to Elf symbol GUID map
+  std::unordered_multimap<uint64_t, uint64_t> StartAddrToSymMap;
+
   // An ordered map of mapping function's start address to function range
-  // relevant info. Currently to determine if the address of ELF is the start of
+  // relevant info. Currently to determine if the offset of ELF is the start of
   // a real function, we leverage the function range info from DWARF.
   std::map<uint64_t, FuncRange> StartAddrToFuncRangeMap;
 
   // Address to context location map. Used to expand the context.
   std::unordered_map<uint64_t, SampleContextFrameVector> AddressToLocStackMap;
 
   // Address to instruction size map. Also used for quick Address lookup.
   std::unordered_map<uint64_t, uint64_t> AddressToInstSizeMap;
class ProfiledBinary {
   void setupSymbolizer();
 
   // Load debug info of subprograms from DWARF section.
   void loadSymbolsFromDWARF(ObjectFile &Obj);
 
   // Load debug info from DWARF unit.
   void loadSymbolsFromDWARFUnit(DWARFUnit &CompilationUnit);
 
+  // Create elf symbol to its start address mapping.
+  void populateElfSymbolAddressList(const ELFObjectFileBase *O);
+
   // A function may be spilt into multiple non-continuous address ranges. We use
   // this to set whether start address of a function is the real entry of the
   // function and also set false to the non-function label.
   void setIsFuncEntry(uint64_t Address, StringRef RangeSymName);
 
   // Warn if no entry range exists in the function.
   void warnNoFuncEntry();
 

llvm/tools/llvm-profgen/ProfiledBinary.cpp

void ProfiledBinary::load() {
   // Current only support X86
   if (!TheTriple.isX86())
     exitWithError("unsupported target", TheTriple.getTriple());
   LLVM_DEBUG(dbgs() << "Loading " << Path << "\n");
 
   // Find the preferred load address for text sections.
   setPreferredTextSegmentAddresses(Obj);
 
-  checkPseudoProbe(Obj);
-
-  if (ShowDisassemblyOnly)
-    decodePseudoProbe(Obj);
-
   // Load debug info of subprograms from DWARF section.
   // If path of debug info binary is specified, use the debug info from it,
   // otherwise use the debug info from the executable binary.
   if (!DebugBinaryPath.empty()) {
     OwningBinary<Binary> DebugPath =
         unwrapOrError(createBinary(DebugBinaryPath), DebugBinaryPath);
     loadSymbolsFromDWARF(*cast<ObjectFile>(DebugPath.getBinary()));
   } else {
     loadSymbolsFromDWARF(*cast<ObjectFile>(&ExeBinary));
   }
 
+  DisassembleFunctionSet.insert(DisassembleFunctions.begin(),
+                                  DisassembleFunctions.end());
+
+  checkPseudoProbe(Obj);
+
+  if (UsePseudoProbes)
+    populateElfSymbolAddressList(Obj);
+
+  if (ShowDisassemblyOnly)
+    decodePseudoProbe(Obj);
+
   // Disassemble the text sections.
   disassemble(Obj);
 
   // Use function start and return address to infer prolog and epilog
   ProEpilogTracker.inferPrologAddresses(StartAddrToFuncRangeMap);
   ProEpilogTracker.inferEpilogAddresses(RetAddressSet);
 
   warnNoFuncEntry();
void ProfiledBinary::checkPseudoProbe(const ELFObjectFileBase *Obj) {
   // set UsePseudoProbes flag, used for PerfReader
   UsePseudoProbes = HasProbeDescSection && HasPseudoProbeSection;
 }
 
 void ProfiledBinary::decodePseudoProbe(const ELFObjectFileBase *Obj) {
   if (!UsePseudoProbes)
     return;
 
-  std::unordered_set<uint64_t> ProfiledGuids;
-  if (!ShowDisassemblyOnly)
-    for (auto *F : ProfiledFunctions)
-      ProfiledGuids.insert(Function::getGUID(F->FuncName));
+  std::unordered_set<uint64_t> GuidFilter;
+  std::unordered_map<uint64_t, uint64_t> FuncStartAddresses;
+  if (ShowDisassemblyOnly) {
+    if (DisassembleFunctionSet.empty()) {
+      FuncStartAddresses = SymbolStartAddrs;
+    } else {
+      for (auto& F : DisassembleFunctionSet) {
+        auto GUID = Function::getGUID(F.first());
+        if (SymbolStartAddrs.count(GUID)) {
+          auto StartAddr = SymbolStartAddrs[GUID];
+          FuncStartAddresses.emplace(GUID, StartAddr);
+          FuncRange& Range = StartAddrToFuncRangeMap[StartAddr];
+          GuidFilter.emplace(Function::getGUID(Range.getFuncName()));
+        }
+      }
+    }
+  } else {
+    for (auto *F : ProfiledFunctions) {
+      GuidFilter.insert(Function::getGUID(F->FuncName));
+      for (auto & Range : F->Ranges) {
+        auto GUIDs = StartAddrToSymMap.equal_range(Range.first);
+        for (auto I = GUIDs.first; I != GUIDs.second; ++I)
+          FuncStartAddresses.emplace(I->second, I->first);
+      }
+    }
+  }
 
   StringRef FileName = Obj->getFileName();
   for (section_iterator SI = Obj->section_begin(), SE = Obj->section_end();
        SI != SE; ++SI) {
     const SectionRef &Section = *SI;
     StringRef SectionName = unwrapOrError(Section.getName(), FileName);
 
     if (SectionName == ".pseudo_probe_desc") {
       StringRef Contents = unwrapOrError(Section.getContents(), FileName);
       if (!ProbeDecoder.buildGUID2FuncDescMap(
               reinterpret_cast<const uint8_t *>(Contents.data()),
               Contents.size()))
         exitWithError(
             "Pseudo Probe decoder fail in .pseudo_probe_desc section");
     } else if (SectionName == ".pseudo_probe") {
       StringRef Contents = unwrapOrError(Section.getContents(), FileName);
       if (!ProbeDecoder.buildAddress2ProbeMap(
               reinterpret_cast<const uint8_t *>(Contents.data()),
-              Contents.size(), ProfiledGuids))
+              Contents.size(), GuidFilter, FuncStartAddresses))
         exitWithError("Pseudo Probe decoder fail in .pseudo_probe section");
     }
   }
 
   // Build TopLevelProbeFrameMap to track size for optimized inlinees when probe
   // is available
   if (TrackFuncContextSize) {
     for (const auto &Child : ProbeDecoder.getDummyInlineRoot().getChildren()) {
for (const SymbolRef &Symbol : Obj->symbols()) {
     if (SecI != Obj->section_end())
       AllSymbols[*SecI].push_back(SymbolInfoTy(Addr, Name, ELF::STT_NOTYPE));
   }
 
   // Sort all the symbols. Use a stable sort to stabilize the output.
   for (std::pair<const SectionRef, SectionSymbolsTy> &SecSyms : AllSymbols)
     stable_sort(SecSyms.second);
 
-  DisassembleFunctionSet.insert(DisassembleFunctions.begin(),
-                                DisassembleFunctions.end());
   assert((DisassembleFunctionSet.empty() || ShowDisassemblyOnly) &&
          "Functions to disassemble should be only specified together with "
          "--show-disassembly-only");
 
   if (ShowDisassemblyOnly)
     outs() << "\nDisassembly of " << FileName << ":\n";
 
   // Dissassemble a text section.
for (std::size_t SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
       if (Symbols[SI].Name == FSDiscriminatorVar) {
         UseFSDiscriminator = true;
         return;
       }
     }
   }
 }
 
+void ProfiledBinary::populateElfSymbolAddressList(const ELFObjectFileBase *Obj) {
+  // Create a mapping from virtual address to symbol GUID and the other way around.
+  std::map<SectionRef, SectionSymbolsTy> AllSymbols;
+  StringRef FileName = Obj->getFileName();
+  for (const SymbolRef &Symbol : Obj->symbols()) {
+    const uint64_t Addr = unwrapOrError(Symbol.getAddress(), FileName);
+    const StringRef Name = unwrapOrError(Symbol.getName(), FileName);
+    uint64_t GUID = Function::getGUID(Name);
+    SymbolStartAddrs[GUID] = Addr;
+    StartAddrToSymMap.emplace(Addr, GUID);
+  }
+}
+
 void ProfiledBinary::loadSymbolsFromDWARFUnit(DWARFUnit &CompilationUnit) {
   for (const auto &DieInfo : CompilationUnit.dies()) {
     llvm::DWARFDie Die(&CompilationUnit, &DieInfo);
 
     if (!Die.isSubprogramDIE())
       continue;
     auto Name = Die.getName(llvm::DINameKind::LinkageName);
     if (!Name)