[llvm-profgen] Switch to DWARF-based symbol and ranges

[wlei]

Summary

It happened a bug that some callsite name in the profile is not a real function, it turned out that there're some non-function symbol from the ELF text section, e.g. the global accessible branch label and also recalled that we can have one function being split into multiple ranges. We shouldn't count samples for those are not the entry of the real function.

So this change tried to fix this issue by switching to use the name or ranges from DWARF-based debug info, the range of which assure it's the real function start. For the split functions, we assume that the real entry function's DWARF name should always match the symbol table name.

The switching is also consistent with the body samples' symbol which is from DWARF.

[wlei]

Updating D112282: [llvm-profgen] Switch to DWARF-based symbol and ranges

[wlei]

tweak the comments

[hoy]

This work should improve the robustness of symbol correlation for cases where an original source function is implemented by multiple labeled binary code slices. Thanks for working on this.

llvm/tools/llvm-profgen/ProfileGenerator.cpp

355

typo: leverange

llvm/tools/llvm-profgen/ProfiledBinary.cpp

570

Is HighPC inclusive or not?

llvm/tools/llvm-profgen/ProfiledBinary.h

342–346

nit: getSymbolForStartOffset -> getDwarfSymbolForStartOffset ? Similar to findSymbolForOffset below.

356–364

assert Offset falls into the range started by the start address?

[wlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

355

Good catch, thanks!

llvm/tools/llvm-profgen/ProfiledBinary.cpp

570

it's inclusive, it's the same as the previous EndOffset in symbol table.

llvm/tools/llvm-profgen/ProfiledBinary.h

342–346

Fixed.

356–364

The upper_bound will assure Offset >= StartOffset.

Do you mean to assert (Offset <= EndOffset & "..."); ? This sounds a good place, with this, we don't need https://reviews.llvm.org/D111902 then.

[wlei]

Updating D112282: [llvm-profgen] Switch to DWARF-based symbol and ranges

[wlei]

check the range fall within [StartOffset, EndOffset]

[wlei]

llvm/tools/llvm-profgen/ProfiledBinary.h

356–364

I found that there're some lib code in the bottom of the section which will cause the assertion failure.

So I added the code below to filter out them.

if (Offset > I->second.EndOffset)
  return nullptr;

With this, it should guarantee the offset fall into the right range.

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

494

From the way ranges of a dwarf symbol are populated, EndOffset should not be a part of a range (exclusive). But computeInlinedContextSizeForRange expects the opposite.

llvm/tools/llvm-profgen/ProfiledBinary.cpp

336

why remove the equal compare? A label at the end of the text section has StartOffset == NextStartOffset.

570

I see. It actually means exclusive which means HighPC does not belong to the current function :). Otherwise FunctionSize should be Range.HighPC - FunctionStart + 1.

llvm/tools/llvm-profgen/ProfiledBinary.h

182

nit: different parts of a function

[wlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

494

Good point, I just changed EndOffset inclusive range.

uint64_t EndOffset = Range.HighPC - getPreferredBaseAddress() - 1;

llvm/tools/llvm-profgen/ProfiledBinary.cpp

336

this is because I saw some symbols has the same StartOffset but different name and mismatch its dwarf info. for example:

[0x01] main
[0x01] foo
[0x02] move ...       main:1

both main and foo's startoffset is [0x01], previously we will skip main, but in a rare case, the body of the function is actually from main not foo( main's the dwarf range is not zero), later we need to set main as the entry of the function. So here I tried to cover this case,the only cost is we process is the zero-size symbol for setting the entry of function.

570

I see, you're right. it's also not the next start offset. I saw in spec2017, the HighPC of main is 2058d7

<main>:
  ...
  2058cf: leal  (%rdx,%rdx), %eax                 cost_compare:11
  2058d2: addl  $-1, %eax                         cost_compare:11
  2058d5: popq  %rbp
  2058d6: retq
  2058d7: int3.    # HighPC
  2058d8: int3
  2058d9: int3
  2058da: int3
  2058db: int3
  2058dc: int3
  2058dd: int3
  2058de: int3
  2058df: int3

<spec_qsort>:
  2058e0: pushq %rbp                             spec_qsort:1
  2058e1: movq  %rsp, %rbp                        spec_qsort:1
  2058e4: pushq %r15

llvm/tools/llvm-profgen/ProfiledBinary.h

182

fixed, thanks!

[wlei]

addressing Hongtao's feedback

[dblaikie]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

494

(it might be best to use an exclusive end, like DWARF does - for consistency and to enable representing zero-length ranges (which do come up at the moment in LLVM's codegen - zero length functions can produce situations where lowpc == highpc, so if you use - 1 you might end up with a weird situation where highpc < lowpc which could be problematic)

[wlei]

use an exclusive end of the range, be consistent to DWARF

llvm/tools/llvm-profgen/ProfileGenerator.cpp

494

I see, -1 is indeed a weird case for this. Thanks for the suggestion!

[wenlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

362–363

Just double check, the warnings are not being removed, but moved and covered by a separate patch, right?

Not a big deal, but it would be good for review if you can either 1) still keep it for review, 2) make a stack on top of the other patch so the warning doesn't show up on left side at all..

llvm/tools/llvm-profgen/ProfiledBinary.cpp

322

nit:

if (Symbol->SymbolName == ELFSymbolName)
  Symbol->isEntryFunction = true;

llvm/tools/llvm-profgen/ProfiledBinary.h

75

This is a bit confusing - the name DWARFSymbol indicates this is 1:1 mapping to actual dwarf symbol, however for dwarf there's one symbol for one function, instead of one symbol for one range.

77

EntryFunction is a confusing name - usually that means entry point of a program. I guess what you meant here FunctionEntry?

78

If this is indeed dwarf symbol as the struct name suggests, all the ranges of a function would share the same name, and we'd be duplicating std::string in that case. If this is actual ELF symbol name, they'll be different, then we need to name it explicitly as ElfSymbolName.

82

As struct representation for a symbol, having EndOffset only but not start offset seem weird. I think we either "complete" it as a general symbol definition, or rename it to make it explicit that this is just some special purpose struct to specific bookkeeping map.

Also please comment if the end offset is inclusive or exclusive.

[wlei]

Updating D112282: [llvm-profgen] Switch to DWARF-based symbol and ranges

llvm/tools/llvm-profgen/ProfileGenerator.cpp

362–363

Good point. I actually intend to remove the warning here because I found some code in plt section which don't match any DWARF symbol will trigger this warning and it's a false positive. Added some comments to this.

llvm/tools/llvm-profgen/ProfiledBinary.cpp

322

This is because we can have multiple offset query the same function. String cmp is heavy, so skip if isEntryFunction is already set.

llvm/tools/llvm-profgen/ProfiledBinary.h

75

I see, understand it's not a clear name. It's not a function in dwarf, it's more like the range in ELF but it's not only the range and has other info. One function can have multiple ranges, I changed to ElfRangeInfo meaning a mixed info of the elf range. see if this looks good to you?

77

FunctionEntry sounds good

78

this is the Dwarf-based name, renamed and added the code to deduplicate the std::string

82

I added some comments to clarify this, i, e. this struct is always accessed by StartOffset2ElfRangeInfoMap whose key is the start offset so just skip it here. See if this's clearer, I'm also fine to add the "StartOffset" for good readability.

[hoy]

llvm/tools/llvm-profgen/ProfiledBinary.cpp

584

nit: Symbol -> RangeInfo

llvm/tools/llvm-profgen/ProfiledBinary.h

78

We are using both elf ranges and dwarf ranges as the terms. Should we stick to one, say DwarfRangeInfo and DWARFRangesVectorTy or the other way around?

342–346

nit: getElfRangeInfoForStartOffset -> findElfRangeInfoForStartOffset to be consistent with the function naming below.

[wenlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

362–363

because I found some code in plt section which don't match any DWARF symbol

But we're looking for elf symbol here, not dwarf symbol?

Regardless I'm hoping that we still have some sanity check for profiles so users would get a hint when they use mismatched profile and binary.

llvm/tools/llvm-profgen/ProfiledBinary.h

78

I would suggest we use FuncRange instead of tie this with dwarf/elf in the name. We don't support windows today, but nothing prevents us from supporting windows (PE/PDB) in the future.

Accordingly, we can have something like FuncSymName, RangeSymName. And for IsFunctionEntry, the two names would be the same. What do you think?

[wlei]

Rename to FuncRange and other refactorings

[wlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

362–363

But we're looking for elf symbol here, not dwarf symbol?

I think the name is misleading, here it's not the elf symbol. Sorry for the confusing. Changed to FuncRange as you suggested.

Regardless I'm hoping that we still have some sanity check for profiles so users would get a hint when they use mismatched profile and binary.

Yeah, I will pick up https://reviews.llvm.org/D111902 for the sanity check.

llvm/tools/llvm-profgen/ProfiledBinary.cpp

584

fixed, thanks!

llvm/tools/llvm-profgen/ProfiledBinary.h

78

Thanks for the suggestions. FuncRange is a better name, renamed all corresponding variable names.

We are using both elf ranges and dwarf ranges as the terms. Should we stick to one, say DwarfRangeInfo and DWARFRangesVectorTy or the other way around?

Changed to FuncRange or RangesTy

342–346

Fixed

[hoy]

LGTM.

llvm/tools/llvm-profgen/ProfileGenerator.cpp

362–363

Perhaps the sanity check can be done during the parsing of LBR traces so that errors will not be propagated too far.

[wenlei]

llvm/tools/llvm-profgen/ProfiledBinary.h

87

nit: IsFunctionEntry->isFuncEntry to be consistent.

183

Instead of using index to access all ranges of a function, how about using symbol name directly? we could have a map (function name -> function object, and function object contains a list of ranges).

Just trying to make the scattered data a bit more structured. Seems it would be cleaner if we have a proper abstraction for Function, which contains name and list of ranges. What do you think?

If this can lead to bigger change, we can also deal with it later in a separate patch.

185

Would rellocate invalidate the StringRef holding the underlying strings?

363

nit: getAllRangesOfOneFunc -> getAllRangesForFunc

[wlei]

some refactorings according to reviewer's suggestions

llvm/tools/llvm-profgen/ProfiledBinary.h

87

Fixed,thanks!

183

This is nice abstraction, not a big change, changed.

one thing is the Function is conflict with llvm::Function, then I changed to ProfFunction, see if this looks good?

185

Seems we all use this way to persist data for a reference type, like the context
std::unordered_set<SampleContextFrameVector, SampleContextFrameHash> Contexts;. I guess this should work.

[wlei]

fix typo in the comments

[hoy]

llvm/tools/llvm-profgen/ProfiledBinary.h

185

std::unordered_map is not a volatile container, unlike std::vector. It's more like std::list.

[wenlei]

lgtm, except two nits. thanks..

llvm/tools/llvm-profgen/ProfiledBinary.h

82

Now that we have a proper Function abstraction, I think it's better to have the start offset field for the ranges, so the structure is more complete.

183

Have a slight preference towards BinaryFunction (given it reflects the binary representation of the function, in terms of address ranges). Not a big deal though.

[wlei]

Addressing Wenlei's feedback.

llvm/tools/llvm-profgen/ProfileGenerator.cpp

 
 RangeSample
 ProfileGenerator::preprocessRangeCounter(const RangeSample &RangeCounter) {
   RangeSample Ranges(RangeCounter.begin(), RangeCounter.end());
   // For each range, we search for the range of the function it belongs to and
   // initialize it with zero count, so it remains zero if doesn't hit any
   // samples. This is to be consistent with compiler that interpret zero count
   // as unexecuted(cold).
+  // Note that a function can be spilt into multiple ranges, so we leverage
+  // DWARFSymbol's RangeIdx to look up all ranges for one entry.
   for (auto I : RangeCounter) {
     uint64_t RangeBegin = I.first.first;
-    uint64_t RangeEnd = I.first.second;
-    // Find the function offset range the current range begin belongs to.
-    auto FuncRange = Binary->findFuncOffsetRange(RangeBegin);
-    if (FuncRange.second == 0)
-      WithColor::warning()
-          << "[" << format("%8" PRIx64, RangeBegin) << " - "
-          << format("%8" PRIx64, RangeEnd)
-          << "]: Invalid range or disassembling error in profiled binary.\n";
-    else if (RangeEnd > FuncRange.second)
-      WithColor::warning() << "[" << format("%8" PRIx64, RangeBegin) << " - "
-                           << format("%8" PRIx64, RangeEnd)
-                           << "]: Range is across different functions.\n";
-    else
-      Ranges[FuncRange] += 0;
+
+    // Find the symbol the current range begin belongs to.
+    auto *Symbol = Binary->findDWARFSymbolForOffset(RangeBegin);
+    if (!Symbol)
+      continue;
+
+    for (const auto &Range : Binary->getDWARFRangeVectorForSymbol(Symbol))
+      Ranges[{Range.first, Range.second - 1}] += 0;
   }
   RangeSample DisjointRanges;
   findDisjointRanges(DisjointRanges, Ranges);
   return DisjointRanges;
 }
 
 void ProfileGenerator::populateBodySamplesForAllFunctions(
     const RangeSample &RangeCounter) {
while (IP.Address <= RangeEnd) {
                                             Count);
       }
       // Move to next IP within the range.
       IP.advance();
     }
   }
 }
 
-static bool isOutlinedFunction(StringRef CalleeName) {
-  // Check whether it's from hot-cold func split or coro split.
-  return CalleeName.find(".resume") != StringRef::npos ||
-         CalleeName.find(".cold") != StringRef::npos;
-}
-
 StringRef ProfileGeneratorBase::getCalleeNameForOffset(uint64_t TargetOffset) {
-  // Get the callee name by branch target if it's a call branch.
-  StringRef CalleeName = FunctionSamples::getCanonicalFnName(
-      Binary->getFuncFromStartOffset(TargetOffset));
+  // Get the DWARF-based symbol info by branch target if it's a call branch.
+  auto *DWARFSymbol = Binary->getDWARFSymbolForStartOffset(TargetOffset);
 
-  // We won't accumulate sample count againt outlined function.
-  if (CalleeName.size() == 0 || isOutlinedFunction(CalleeName))
+  // We won't accumulate sample count againt outlined function or inner labels.
+  if (!DWARFSymbol || !DWARFSymbol->isEntryFunction)
     return StringRef();
 
-  return CalleeName;
+  return FunctionSamples::getCanonicalFnName(DWARFSymbol->SymbolName);
 }
 
 void ProfileGenerator::populateBoundarySamplesForAllFunctions(
     const BranchSample &BranchCounters) {
   for (auto Entry : BranchCounters) {
     uint64_t SourceOffset = Entry.first.first;
     uint64_t TargetOffset = Entry.first.second;
     uint64_t Count = Entry.second;
if (Binary->usePseudoProbes()) {
     generateLineNumBasedProfile();
   }
   postProcessProfiles();
 }
 
 void CSProfileGenerator::computeSizeForProfiledFunctions() {
   // Hash map to deduplicate the function range and the item is a pair of
   // function start and end offset.
-  std::unordered_map<uint64_t, uint64_t> FuncRanges;
+  std::unordered_map<uint64_t, uint64_t> AggregatedRanges;
   // Go through all the ranges in the CS counters, use the start of the range to
   // look up the function it belongs and record the function range.
   for (const auto &CI : SampleCounters) {
     for (auto Item : CI.second.RangeCounter) {
       // FIXME: Filter the bogus crossing function range.
       uint64_t RangeStartOffset = Item.first.first;
-      auto FuncRange = Binary->findFuncOffsetRange(RangeStartOffset);
-      if (FuncRange.second != 0)
-        FuncRanges[FuncRange.first] = FuncRange.second;
+      auto *Symbol = Binary->findDWARFSymbolForOffset(RangeStartOffset);
+      if (!Symbol)
+        continue;
+
+      for (const auto &Range : Binary->getDWARFRangeVectorForSymbol(Symbol))
+        AggregatedRanges[Range.first] = Range.second;
     }
   }
 
-  for (auto I : FuncRanges) {
+  for (auto I : AggregatedRanges) {
     uint64_t StartOffset = I.first;
     uint64_t EndOffset = I.second;
     Binary->computeInlinedContextSizeForRange(StartOffset, EndOffset);
   }
 }
 
 void CSProfileGenerator::generateLineNumBasedProfile() {
   for (const auto &CI : SampleCounters) {
     const StringBasedCtxKey *CtxKey =
         dyn_cast<StringBasedCtxKey>(CI.first.getPtr());
     // Get or create function profile for the range

llvm/tools/llvm-profgen/ProfiledBinary.h

 //===-- ProfiledBinary.h - Binary decoder -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_PROFGEN_PROFILEDBINARY_H
 #define LLVM_TOOLS_LLVM_PROFGEN_PROFILEDBINARY_H
 
 #include "CallContext.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrInfo.h"
struct InstructionPointer {
   uint64_t Index = 0;
   InstructionPointer(const ProfiledBinary *Binary, uint64_t Address,
                      bool RoundToNext = false);
   void advance();
   void backward();
   void update(uint64_t Addr);
 };
 
+using DWARFRangesVectorTy = std::vector<std::pair<uint64_t, uint64_t>>;
+
+// Function symbol extracted from DWARF-based debug info. A function can be
+// split into multiple ranges, each range corresponds to one DWARFSymbol.
+struct DWARFSymbol {
+  bool isEntryFunction = false;
+  std::string SymbolName;
+  // Index to access AllDWARFRanges, used to look up all ranges of the
+  // function.
+  size_t RangesIdx;
+  uint64_t EndOffset;
+};
+
 // PrologEpilog offset tracker, used to filter out broken stack samples
 // Currently we use a heuristic size (two) to infer prolog and epilog
 // based on the start address and return address. In the future,
 // we will switch to Dwarf CFI based tracker
 struct PrologEpilogTracker {
   // A set of prolog and epilog offsets. Used by virtual unwinding.
   std::unordered_set<uint64_t> PrologEpilogSet;
   ProfiledBinary *Binary;
   PrologEpilogTracker(ProfiledBinary *Bin) : Binary(Bin){};
 
   // Take the two addresses from the start of function as prolog
-  void inferPrologOffsets(std::map<uint64_t, std::pair<std::string, uint64_t>>
-                              &FuncStartOffsetMap) {
+  void inferPrologOffsets(std::map<uint64_t, DWARFSymbol> &FuncStartOffsetMap) {
     for (auto I : FuncStartOffsetMap) {
       PrologEpilogSet.insert(I.first);
       InstructionPointer IP(Binary, I.first);
       IP.advance();
       PrologEpilogSet.insert(IP.Offset);
     }
   }
 
class ProfiledBinary {
   std::unique_ptr<const MCSubtargetInfo> STI;
   std::unique_ptr<const MCInstrInfo> MII;
   std::unique_ptr<MCDisassembler> DisAsm;
   std::unique_ptr<const MCInstrAnalysis> MIA;
   std::unique_ptr<MCInstPrinter> IPrinter;
   // A list of text sections sorted by start RVA and size. Used to check
   // if a given RVA is a valid code address.
   std::set<std::pair<uint64_t, uint64_t>> TextSections;
-  // An ordered map of mapping function's start offset to its name and
-  // end offset.
-  std::map<uint64_t, std::pair<std::string, uint64_t>> FuncStartOffsetMap;
+
+  // A vector of DWARF ranges used to quick lookup for all the ranges from
+  // different parts of function.
+  std::vector<DWARFRangesVectorTy> AllDWARFRanges;
+
+  // An ordered map of mapping function's start offset to its DWARF-base symbol.
+  std::map<uint64_t, DWARFSymbol> StartOffset2DWARFSymbolMap;
+
   // Offset to context location map. Used to expand the context.
   std::unordered_map<uint64_t, SampleContextFrameVector> Offset2LocStackMap;
 
   // Offset to instruction size map. Also used for quick offset lookup.
   std::unordered_map<uint64_t, uint64_t> Offset2InstSizeMap;
 
   // An array of offsets of all instructions sorted in increasing order. The
   // sorting is needed to fast advance to the next forward/backward instruction.
class ProfiledBinary {
   void setPreferredTextSegmentAddresses(const ELFFile<ELFT> &Obj, StringRef FileName);
 
   void decodePseudoProbe(const ELFObjectFileBase *Obj);
 
   // Set up disassembler and related components.
   void setUpDisassembler(const ELFObjectFileBase *Obj);
   void setupSymbolizer();
 
+  // Load debug info of subprograms from DWARF section.
+  void loadSymbolsFromDWARF(ObjectFile &Obj);
+
+  // A function may be spilt into multiple non-continuous address ranges. We use
+  // this to set whether start offset of a function is the real entry of the
+  // function and also set false to the non-function label.
+  void setIsEntryFunction(uint64_t StartOffset, StringRef ELFSymbolName);
+
   /// Dissassemble the text section and build various address maps.
   void disassemble(const ELFObjectFileBase *O);
 
   /// Helper function to dissassemble the symbol and extract info for unwinding
   bool dissassembleSymbol(std::size_t SI, ArrayRef<uint8_t> Bytes,
                           SectionSymbolsTy &Symbols, const SectionRef &Section);
   /// Symbolize a given instruction pointer and return a full call context.
   SampleContextFrameVector symbolize(const InstructionPointer &IP,
public:
   uint64_t getCallAddrFromFrameAddr(uint64_t FrameAddr) const {
     auto I = getIndexForAddr(FrameAddr);
     FrameAddr = I ? getAddressforIndex(I - 1) : 0;
     if (FrameAddr && addressIsCall(FrameAddr))
       return FrameAddr;
     return 0;
   }
 
-  StringRef getFuncFromStartOffset(uint64_t Offset) {
-    auto I = FuncStartOffsetMap.find(Offset);
-    if (I == FuncStartOffsetMap.end())
-      return StringRef();
-    return I->second.first;
+  DWARFSymbol *getDWARFSymbolForStartOffset(uint64_t Offset) {
+    auto I = StartOffset2DWARFSymbolMap.find(Offset);
+    if (I == StartOffset2DWARFSymbolMap.end())
+      return nullptr;
+    return &I->second;
   }
 
-  OffsetRange findFuncOffsetRange(uint64_t Offset) {
-    auto I = FuncStartOffsetMap.upper_bound(Offset);
-    if (I == FuncStartOffsetMap.begin())
-      return {0, 0};
+  // Binary search to find the first symbol whose range includes the input
+  // offset.
+  DWARFSymbol *findDWARFSymbolForOffset(uint64_t Offset) {
+    auto I = StartOffset2DWARFSymbolMap.upper_bound(Offset);
+    if (I == StartOffset2DWARFSymbolMap.begin())
+      return nullptr;
     I--;
-    return {I->first, I->second.second};
+
+    if (Offset >= I->second.EndOffset)
+      return nullptr;
+
+    return &I->second;
+  }
+
+  DWARFRangesVectorTy &getDWARFRangeVectorForSymbol(DWARFSymbol *Symbol) {
+    return AllDWARFRanges[Symbol->RangesIdx];
   }
 
   uint32_t getFuncSizeForContext(SampleContext &Context) {
     return FuncSizeTracker.getFuncSizeForContext(Context);
   }
 
   const SampleContextFrameVector &
   getFrameLocationStack(uint64_t Offset, bool UseProbeDiscriminator = false) {

llvm/tools/llvm-profgen/ProfiledBinary.cpp

void ProfiledBinary::load() {
   LLVM_DEBUG(dbgs() << "Loading " << Path << "\n");
 
   // Find the preferred load address for text sections.
   setPreferredTextSegmentAddresses(Obj);
 
   // Decode pseudo probe related section
   decodePseudoProbe(Obj);
 
+  // Load debug info of subprograms from DWARF section.
+  loadSymbolsFromDWARF(*dyn_cast<ObjectFile>(&Binary));
+
   // Disassemble the text sections.
   disassemble(Obj);
 
   // Track size for optimized inlinees when probe is available
   if (UsePseudoProbes && TrackFuncContextSize)
     FuncSizeTracker.trackInlineesOptimizedAway(ProbeDecoder);
 
   // Use function start and return address to infer prolog and epilog
-  ProEpilogTracker.inferPrologOffsets(FuncStartOffsetMap);
+  ProEpilogTracker.inferPrologOffsets(StartOffset2DWARFSymbolMap);
   ProEpilogTracker.inferEpilogOffsets(RetAddrs);
 
   // TODO: decode other sections.
 }
 
 bool ProfiledBinary::inlineContextEqual(uint64_t Address1, uint64_t Address2) {
   uint64_t Offset1 = virtualAddrToOffset(Address1);
   uint64_t Offset2 = virtualAddrToOffset(Address2);
if (SectionName == ".pseudo_probe_desc") {
       UsePseudoProbes = true;
     }
   }
 
   if (ShowPseudoProbe)
     ProbeDecoder.printGUID2FuncDescMap(outs());
 }
 
+void ProfiledBinary::setIsEntryFunction(uint64_t Offset,
+                                        StringRef ELFSymbolName) {
+  // Note that the start offset of ELF can be a non-function symbol, so we need
+  // to binary search for the first matched function symbol.
+  auto *Symbol = findDWARFSymbolForOffset(Offset);
+  if (!Symbol)
+    return;
+
+  // We set isEntryFunction to ture if the matched ELF function is equal to its
+  // DWARF subprogram name.
+  if (!Symbol->isEntryFunction && Symbol->SymbolName == ELFSymbolName)
+    Symbol->isEntryFunction = true;
+}
+
 bool ProfiledBinary::dissassembleSymbol(std::size_t SI, ArrayRef<uint8_t> Bytes,
                                         SectionSymbolsTy &Symbols,
                                         const SectionRef &Section) {
   std::size_t SE = Symbols.size();
   uint64_t SectionOffset = Section.getAddress() - getPreferredBaseAddress();
   uint64_t SectSize = Section.getSize();
   uint64_t StartOffset = Symbols[SI].Addr - getPreferredBaseAddress();
   uint64_t NextStartOffset =
       (SI + 1 < SE) ? Symbols[SI + 1].Addr - getPreferredBaseAddress()
                     : SectionOffset + SectSize;
-  if (StartOffset >= NextStartOffset)
+  if (StartOffset > NextStartOffset)
     return true;
 
   StringRef SymbolName =
       ShowCanonicalFnName
           ? FunctionSamples::getCanonicalFnName(Symbols[SI].Name)
           : Symbols[SI].Name;
   bool ShowDisassembly =
       ShowDisassemblyOnly && (DisassembleFunctionSet.empty() ||
bool ProfiledBinary::dissassembleSymbol(std::size_t SI, ArrayRef<uint8_t> Bytes,
   }
 
   if (InvalidInstLength)
     WarnInvalidInsts(Offset - InvalidInstLength, Offset - 1);
 
   if (ShowDisassembly)
     outs() << "\n";
 
-  FuncStartOffsetMap.emplace(StartOffset,
-                             std::make_pair(Symbols[SI].Name.str(), EndOffset));
+  setIsEntryFunction(StartOffset, Symbols[SI].Name);
+
   return true;
 }
 
 void ProfiledBinary::setUpDisassembler(const ELFObjectFileBase *Obj) {
   const Target *TheTarget = getTarget(Obj);
   std::string TripleName = TheTriple.getTriple();
   StringRef FileName = Obj->getFileName();
 
for (section_iterator SI = Obj->section_begin(), SE = Obj->section_end();
     // Disassemble symbol by symbol.
     for (std::size_t SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
       if (!dissassembleSymbol(SI, Bytes, Symbols, Section))
         exitWithError("disassembling error", FileName);
     }
   }
 }
 
+void ProfiledBinary::loadSymbolsFromDWARF(ObjectFile &Obj) {
+  auto DebugContext = llvm::DWARFContext::create(Obj);
+  if (!DebugContext)
+    exitWithError("Misssing debug info.", Path);
+
+  for (const auto &CompilationUnit : DebugContext->compile_units()) {
+    for (const auto &DieInfo : CompilationUnit->dies()) {
+      llvm::DWARFDie Die(CompilationUnit.get(), &DieInfo);
+
+      if (!Die.isSubprogramDIE())
+        continue;
+      auto Name = Die.getName(llvm::DINameKind::LinkageName);
+      if (!Name)
+        Name = Die.getName(llvm::DINameKind::ShortName);
+      if (!Name)
+        continue;
+
+      auto RangesOrError = Die.getAddressRanges();
+      if (!RangesOrError)
+        continue;
+      const DWARFAddressRangesVector &Ranges = RangesOrError.get();
+
+      if (Ranges.empty())
+        continue;
+
+      // A function may be spilt into multiple non-continuous address ranges.
+      // Sometimes we want to know all ranges for one function. So group the
+      // ranges, persist the them into AllDWARFRanges and it can be access by
+      // symbol's RangesIdx later.
+      AllDWARFRanges.push_back(DWARFRangesVectorTy());
+
+      for (const auto &Range : Ranges) {
+        uint64_t FunctionStart = Range.LowPC;
+        uint64_t FunctionSize = Range.HighPC - FunctionStart;
+
+        if (FunctionSize == 0 || FunctionStart < getPreferredBaseAddress())
+          continue;
+
+        uint64_t StartOffset = FunctionStart - getPreferredBaseAddress();
+        uint64_t EndOffset = Range.HighPC - getPreferredBaseAddress();
+
+        AllDWARFRanges.back().emplace_back(StartOffset, EndOffset);
+
+        auto R = StartOffset2DWARFSymbolMap.emplace(StartOffset, DWARFSymbol());
+        if (R.second) {
+          DWARFSymbol &Symbol = R.first->second;
+          Symbol.SymbolName = Name;
+          Symbol.RangesIdx = AllDWARFRanges.size() - 1;
+          Symbol.EndOffset = EndOffset;
+        } else {
+          WithColor::warning()
+              << "Duplicated symbol offset at "
+              << format("%8" PRIx64, StartOffset) << " "
+              << R.first->second.SymbolName << " and " << Name << "\n";
+        }
+      }
+    }
+  }
+  assert(!StartOffset2DWARFSymbolMap.empty() && "Misssing debug info.");
+}
+
 void ProfiledBinary::setupSymbolizer() {
   symbolize::LLVMSymbolizer::Options SymbolizerOpts;
   SymbolizerOpts.PrintFunctions =
       DILineInfoSpecifier::FunctionNameKind::LinkageName;
   SymbolizerOpts.Demangle = false;
   SymbolizerOpts.DefaultArch = TheTriple.getArchName().str();
   SymbolizerOpts.UseSymbolTable = false;
   SymbolizerOpts.RelativeAddresses = false;

 void ProfiledBinary::computeInlinedContextSizeForRange(uint64_t StartOffset,
                                                        uint64_t EndOffset) {
   uint32_t Index = getIndexForOffset(StartOffset);
   if (CodeAddrOffsets[Index] != StartOffset)
     WithColor::warning() << "Invalid start instruction at "
                          << format("%8" PRIx64, StartOffset) << "\n";
 
   uint64_t Offset = CodeAddrOffsets[Index];
-  while (Offset <= EndOffset) {
+  while (Offset < EndOffset) {
     const SampleContextFrameVector &SymbolizedCallStack =
         getFrameLocationStack(Offset, UsePseudoProbes);
     uint64_t Size = Offset2InstSizeMap[Offset];
 
     // Record instruction size for the corresponding context
     FuncSizeTracker.addInstructionForContext(SymbolizedCallStack, Size);
 
     Offset = CodeAddrOffsets[++Index];