[llvm-profgen] Add switch to allow use of first loadable segment for calculating offset

[wenlei]

Summary

Adding -use-loadable-segment-as-base to allow use of first loadable segment for calculating offset. By default first executable segment is used for calculating offset. The switch helps compatibility with unsymbolized profile generated from older tools.

[hoy]

llvm/tools/llvm-profgen/PerfReader.cpp

32

Name it use-first-loadable-segment-as-base?

llvm/tools/llvm-profgen/ProfiledBinary.h

311

nit: add a const qualifier

[wenlei]

address comment

[hoy]

lgtm, thanks

[wlei]

llvm/tools/llvm-profgen/PerfReader.cpp

711

Wondering if we can avoid changing the code here.

I'm thinking like if we can refactor all getPreferredBaseAddress to getBaseAddress() or a new function.

Then we have code early in the binary to setBaseAddress like:

if (UseLoadableSegmentAsBase)
   setBaseAddress(getFirstLoadableAddress())
else
   setBaseAddress(getPreferredBaseAddress())

Then here Binary->offsetToVirtualAddr(..); will cover all the offset cases.

[wlei]

LGTM, thanks for the change!

llvm/tools/llvm-profgen/PerfReader.cpp

711

I realized we might not change getPreferredBaseAddress to getFirstLoadableAddress for disassembling, all the CallOffsets, RetOffsets,.. are based on that. Here It's only for the unsymbolized profile, should be fine. Feel free to ignore this comment.

[wenlei]

llvm/tools/llvm-profgen/PerfReader.cpp

711

That will make the definition of base address a bit inconsistent. The base address is supposed to be the address that aligns with mmap base, and we leverage that assumption. See code below.

// Drop the event if its image is loaded at the same address
  if (Event.Address == Binary->getBaseAddress()) {
    Binary->setIsLoadedByMMap(true);
    return;
  }

If we change base address for binary, while it make this translation easier, it could break mmap matching.

I'm leaning towards keep this as special case, because the offset computation is a bit weird and we do it really only for compatibility.

[wlei]

llvm/tools/llvm-profgen/PerfReader.cpp

711

That makes sense, thanks for the clarification!

[wenlei]

rebase

llvm/test/tools/llvm-profgen/inline-cs-pseudoprobe.test

 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/inline-cs-pseudoprobe.perfscript --binary=%S/Inputs/inline-cs-pseudoprobe.perfbin --output=%t --skip-symbolization --profile-summary-cold-count=0 --use-offset=0
 ; RUN: FileCheck %s --input-file %t --check-prefix=CHECK-UNWINDER
+; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/inline-cs-pseudoprobe.perfscript --binary=%S/Inputs/inline-cs-pseudoprobe.perfbin --output=%t --skip-symbolization --profile-summary-cold-count=0 --use-offset=1
+; RUN: FileCheck %s --input-file %t --check-prefix=CHECK-UNWINDER-OFFSET
+; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/inline-cs-pseudoprobe.perfscript --binary=%S/Inputs/inline-cs-pseudoprobe.perfbin --output=%t --skip-symbolization --profile-summary-cold-count=0 --use-offset=1 --use-first-loadable-segment-as-base=1
+; RUN: FileCheck %s --input-file %t --check-prefix=CHECK-UNWINDER-OFFSET2
 ; RUN: llvm-profgen --format=text --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:2 @ foo]:74:0
 ; CHECK-NEXT: 1: 0
 ; CHECK-NEXT: 2: 15
 ; CHECK-NEXT: 3: 15
 ; CHECK-NEXT: 4: 14

 ; CHECK-UNWINDER:      3
 ; CHECK-UNWINDER-NEXT: 201800-201858:1
 ; CHECK-UNWINDER-NEXT: 20180e-20182b:1
 ; CHECK-UNWINDER-NEXT: 20180e-201858:13
 ; CHECK-UNWINDER-NEXT: 2
 ; CHECK-UNWINDER-NEXT: 20182b->201800:1
 ; CHECK-UNWINDER-NEXT: 201858->20180e:15
 
+
+; CHECK-UNWINDER-OFFSET:      3
+; CHECK-UNWINDER-OFFSET-NEXT: 800-858:1
+; CHECK-UNWINDER-OFFSET-NEXT: 80e-82b:1
+; CHECK-UNWINDER-OFFSET-NEXT: 80e-858:13
+; CHECK-UNWINDER-OFFSET-NEXT: 2
+; CHECK-UNWINDER-OFFSET-NEXT: 82b->800:1
+; CHECK-UNWINDER-OFFSET-NEXT: 858->80e:15
+
+; CHECK-UNWINDER-OFFSET2:      3
+; CHECK-UNWINDER-OFFSET2-NEXT: 1800-1858:1
+; CHECK-UNWINDER-OFFSET2-NEXT: 180e-182b:1
+; CHECK-UNWINDER-OFFSET2-NEXT: 180e-1858:13
+; CHECK-UNWINDER-OFFSET2-NEXT: 2
+; CHECK-UNWINDER-OFFSET2-NEXT: 182b->1800:1
+; CHECK-UNWINDER-OFFSET2-NEXT: 1858->180e:15
+
 ; clang -O3 -fexperimental-new-pass-manager -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>
 
 int bar(int x, int y) {
   if (x % 3) {

llvm/tools/llvm-profgen/PerfReader.cpp

static cl::opt<bool> ShowMmapEvents("show-mmap-events", cl::init(false),
                                     cl::ZeroOrMore,
                                     cl::desc("Print binary load events."));
 
 static cl::opt<bool>
     UseOffset("use-offset", cl::init(true), cl::ZeroOrMore,
               cl::desc("Work with `--skip-symbolization` or "
                        "`--unsymbolized-profile` to write/read the "
                        "offset instead of virtual address."));
+
+static cl::opt<bool> UseLoadableSegmentAsBase(
+    "use-first-loadable-segment-as-base", cl::init(false), cl::ZeroOrMore,
+    cl::desc("Use first loadable segment address as base address "
+             "for offsets in unsymbolized profile. By default "
+             "first executable segment address is used"));
+
 static cl::opt<bool>
     IgnoreStackSamples("ignore-stack-samples", cl::init(false), cl::ZeroOrMore,
                        cl::desc("Ignore call stack samples for hybrid samples "
                                 "and produce context-insensitive profile."));
 cl::opt<bool> ShowDetailedWarning("show-detailed-warning", cl::init(false),
                                   cl::ZeroOrMore,
                                   cl::desc("Show detailed warning message."));
 
for (auto &CI : SampleCounters) {
     OrderedCounters[getContextKeyStr(CI.first.getPtr(), Binary)] = &CI.second;
   }
 
   auto SCounterPrinter = [&](RangeSample &Counter, StringRef Separator,
                              uint32_t Indent) {
     OS.indent(Indent);
     OS << Counter.size() << "\n";
     for (auto &I : Counter) {
-      uint64_t Start = UseOffset ? I.first.first
-                                 : Binary->offsetToVirtualAddr(I.first.first);
-      uint64_t End = UseOffset ? I.first.second
-                               : Binary->offsetToVirtualAddr(I.first.second);
+      uint64_t Start = I.first.first;
+      uint64_t End = I.first.second;
+
+      if (!UseOffset || (UseOffset && UseLoadableSegmentAsBase)) {
+        Start = Binary->offsetToVirtualAddr(Start);
+        End = Binary->offsetToVirtualAddr(End);
+      }
+
+      if (UseOffset && UseLoadableSegmentAsBase) {
+        Start -= Binary->getFirstLoadableAddress();
+        End -= Binary->getFirstLoadableAddress();
+      }
+
       OS.indent(Indent);
       OS << Twine::utohexstr(Start) << Separator << Twine::utohexstr(End) << ":"
          << I.second << "\n";
     }
   };
 
   for (auto &CI : OrderedCounters) {
     uint32_t Indent = 0;
while (Num--) {
 
       uint64_t Source = 0;
       uint64_t Target = 0;
       auto Range = LineSplit.first.split(Separator);
       if (Range.second.empty() || Range.first.getAsInteger(16, Source) ||
           Range.second.getAsInteger(16, Target))
         exitWithErrorForTraceLine(TraceIt);
 
-      if (!UseOffset) {
-        Source = Binary->virtualAddrToOffset(Source);
-        Target = Binary->virtualAddrToOffset(Target);
+      if (!UseOffset || (UseOffset && UseLoadableSegmentAsBase)) {
+        uint64_t BaseAddr = 0;
+        if (UseOffset && UseLoadableSegmentAsBase)
+          BaseAddr = Binary->getFirstLoadableAddress();
+
+        Source = Binary->virtualAddrToOffset(Source + BaseAddr);
+        Target = Binary->virtualAddrToOffset(Target + BaseAddr);
       }
 
       Counter[{Source, Target}] += Count;
       TraceIt.advance();
     }
   };
 
   ReadCounter(SCounters.RangeCounter, "-");

llvm/tools/llvm-profgen/ProfiledBinary.h

 
 class ProfiledBinary {
   // Absolute path of the binary.
   std::string Path;
   // The target triple.
   Triple TheTriple;
   // The runtime base address that the first executable segment is loaded at.
   uint64_t BaseAddress = 0;
+  // The runtime base address that the first loadabe segment is loaded at.
+  uint64_t FirstLoadableAddress = 0;
   // The preferred load address of each executable segment.
   std::vector<uint64_t> PreferredTextSegmentAddresses;
   // The file offset of each executable segment.
   std::vector<uint64_t> TextSegmentOffsets;
 
   // Mutiple MC component info
   std::unique_ptr<const MCRegisterInfo> MRI;
   std::unique_ptr<const MCAsmInfo> AsmInfo;
public:
   }
   StringRef getPath() const { return Path; }
   StringRef getName() const { return llvm::sys::path::filename(Path); }
   uint64_t getBaseAddress() const { return BaseAddress; }
   void setBaseAddress(uint64_t Address) { BaseAddress = Address; }
 
   // Return the preferred load address for the first executable segment.
   uint64_t getPreferredBaseAddress() const { return PreferredTextSegmentAddresses[0]; }
+  // Return the preferred load address for the first loadable segment.
+  uint64_t getFirstLoadableAddress() const { return FirstLoadableAddress; }
   // Return the file offset for the first executable segment.
   uint64_t getTextSegmentOffset() const { return TextSegmentOffsets[0]; }
   const std::vector<uint64_t> &getPreferredTextSegmentAddresses() const {
     return PreferredTextSegmentAddresses;
   }
   const std::vector<uint64_t> &getTextSegmentOffsets() const {
     return TextSegmentOffsets;
   }

llvm/tools/llvm-profgen/ProfiledBinary.cpp

 void ProfiledBinary::setPreferredTextSegmentAddresses(const ELFFile<ELFT> &Obj, StringRef FileName) {
   const auto &PhdrRange = unwrapOrError(Obj.program_headers(), FileName);
   // FIXME: This should be the page size of the system running profiling.
   // However such info isn't available at post-processing time, assuming
   // 4K page now. Note that we don't use EXEC_PAGESIZE from <linux/param.h>
   // because we may build the tools on non-linux.
   uint32_t PageSize = 0x1000;
   for (const typename ELFT::Phdr &Phdr : PhdrRange) {
-    if ((Phdr.p_type == ELF::PT_LOAD) && (Phdr.p_flags & ELF::PF_X)) {
+    if (Phdr.p_type == ELF::PT_LOAD) {
+      if (!FirstLoadableAddress)
+        FirstLoadableAddress = Phdr.p_vaddr & ~(PageSize - 1U);
+      if (Phdr.p_flags & ELF::PF_X) {
         // Segments will always be loaded at a page boundary.
         PreferredTextSegmentAddresses.push_back(Phdr.p_vaddr &
                                                 ~(PageSize - 1U));
         TextSegmentOffsets.push_back(Phdr.p_offset & ~(PageSize - 1U));
       }
     }
+  }
 
   if (PreferredTextSegmentAddresses.empty())
     exitWithError("no executable segment found", FileName);
 }
 
 void ProfiledBinary::setPreferredTextSegmentAddresses(const ELFObjectFileBase *Obj) {
   if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
     setPreferredTextSegmentAddresses(ELFObj->getELFFile(), Obj->getFileName());