[llvm-profgen] Fix inconsistent loading address issues

[wlei]

Summary

This is to fix two issues related with loading address:

1. When multiple MMAPs occur and their loading address are different, before it only used the first MMap as base address, all perf address after it used the wrong base address.

2. For pseudo probe profile, the address is always based on preferred loading address. If the base address is not equal to the preferred loading address, the pseudo probe address query will be wrong.

Solution: Instead of converting the address to offset lazily, right now all the address after parsing are converted on the fly based on preferred loading address in the parsing time. There is no "offset" used in profile generator any more.

[wenlei]

llvm/tools/llvm-profgen/PerfReader.cpp

1204

Where do we use getBaseAddress in probe queries? Can we use getPreferredBaseAddress directly there? Ideally there should be one definition for base address which is the actual executable segment load address, and changing it here makes it inconsistent.

llvm/tools/llvm-profgen/PerfReader.h

374 ↗

(On Diff #433547)

Perhaps AddrBasedCtxKey as name is just fine? This is in contrast with StringBasedCtxKey, so Addr as a general term isn't a big deal, I don't have strong opinion though..

[hoy]

llvm/tools/llvm-profgen/PerfReader.cpp

1204

Agreed that setBaseAddress should be called once to be consistent. Pseudo probe decoding is based on the preferred address. I think a reasonable fix could be

1. make the decoding offset-based. This will require a change to the bolt code. base; or
2. do an offset to preferred addr translation for every probe look up in llvm-profgen. This is being done in some places, eg, extractPrefixContextStack.

#2 sounds more practical. WDYT?

[wlei]

llvm/tools/llvm-profgen/PerfReader.cpp

1204

Hmm, I found it's very tricky case.

Where do we use getBaseAddress in probe queries?

We call it in Binary->offsetToVirtualAddr.

However, we call IP.advance() to iterate all the address in the range, in IP it will convert the Address back to offset using the base address. like Offset + preferred Address - Mmap loading address. That's another inconsistency.. Then we need to change code inside of the IP. but IP also used in PerfReader

llvm/tools/llvm-profgen/PerfReader.h

374 ↗

(On Diff #433547)

Sounds good.

[wlei]

llvm/tools/llvm-profgen/PerfReader.cpp

1204

Or can we use virtual address(Offset + preferred Address) for all the code(PerfReader and ProfileGenerator)? to do this, we can convert the address at the very beginning of PerfReader. like Address = PhysicalAddress - Mmap loading address + PreferredAddress

[hoy]

llvm/tools/llvm-profgen/PerfReader.cpp

1204

I see. This is complicated. How about we always use preferred address when doing this offset to virtual addr conversion, and we rebase all LBR and stack sample addresses to be on the preferred load address in the the perf reader ?

[wlei]

changed all offset usage to preferred address based virtual address

[hoy]

In D126827#3613023, @wlei wrote:

changed all offset usage to preferred address based virtual address

Thanks for the work! It should be more reliable and also looks cleaner.

llvm/tools/llvm-profgen/PerfReader.cpp

746

I'm a bit confused here. What is the semantics of using both offset and LoadableSegmentAsBase?

[wlei]

llvm/tools/llvm-profgen/PerfReader.cpp

746

I think this is to be compatible to our internal old tool where some services use offset and the FirstLoadableAddress as the output of unsymbolized profile.

The original patch is https://reviews.llvm.org/D113727.

[hoy]

llvm/tools/llvm-profgen/PerfReader.cpp

746

Do we still need this now? The offset here is computed by subtracting the runtime base address from preferred-based virtual address. This seems different from what previous computed, ie., subtracting the runtime base address from runtime virtual address.

[wlei]

llvm/tools/llvm-profgen/PerfReader.cpp

746

It should be the same behavior as previous offset computation.

This is about how we define the "offset": Assuming MMAP loading address is missing or just equal to preferred-based-address, then the virtual address = offset + preferred-based-address. and for this two branches, if it's UseLoadableSegmentAsBase is False, then the offset is virtual address - preferred-based-address --> offset + preferred-based-address - preferred-based-address which is the original "offset". but when UseLoadableSegmentAsBase is True, the offset is virtual address - FirstLoadableAddress -->offset + preferred-based-address - FirstLoadableAddress
so the offset is not the offset as we defined before. However, even it's "wrong", if depends on the source of input, our internal tool which just produced this "wrong" offset, so llvm-profgen also need to use the same way to recover it.

Yeah, but if we won't use the old tool anymore, I think we can remove all the UseLoadableSegmentAsBase code.

[hoy]

llvm/tools/llvm-profgen/PerfReader.cpp

746

so the offset is not the offset as we defined before. However, even it's "wrong",

Could the "wrong" offsets now cause trouble for pseudo probes which always have the "correct" offset? It should work fine previously?

Yeah, but if we won't use the old tool anymore, I think we can remove all the UseLoadableSegmentAsBase code.

Agreed.

[hoy]

llvm/tools/llvm-profgen/PerfReader.cpp

746

I looked a bit deeper. The "wrong" offsets should work. getFirstLoadableAddress stands for the preferred first load address, not the runtime one where I got the impression from its definition.

// The runtime base address that the first loadabe segment is loaded at.
uint64_t FirstLoadableAddress = 0;

Then we no longer need to remove the feature in this change.

[wenlei]

Agreed that having everything canonicalized to use preferred load address as base is clean and practical. Thanks for making the changes. LGTM with a nit.

llvm/tools/llvm-profgen/ProfiledBinary.h

347

nit: canonicalizeVirtualAddress is probably a better name.

[wlei]

rebase and rename convertAddress --> canonicalizeVirtualAddress

llvm/test/tools/llvm-profgen/Inputs/noinline-cs-pseudoprobe.perfscript

-PERF_RECORD_MMAP2 1243676/1243676: [0x201000(0x1000) @ 0 00:1d 224517108 1044165]: r-xp /home/noinline-cs-pseudoprobe.perfbin
+PERF_RECORD_MMAP2 1243676/1243676: [0x301000(0x1000) @ 0 00:1d 224517108 1044165]: r-xp /home/noinline-cs-pseudoprobe.perfbin
 
-            20179e
-            2017f9
+            30179e
+            3017f9
       7f83e84e7793
   5541f689495641d7
- 0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0
+ 0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0
 
-            2017c4
-            2017f9
+            3017c4
+            3017f9
       7f83e84e7793
   5541f689495641d7
- 0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0
+ 0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0
 
-            2017c4
-            2017f9
+            3017c4
+            3017f9
       7f83e84e7793
   5541f689495641d7
- 0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0  0x2017bf/0x201760/P/-/-/0  0x2017cf/0x20179e/P/-/-/0  0x20177f/0x2017c4/P/-/-/0
+ 0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0  0x3017bf/0x301760/P/-/-/0  0x3017cf/0x30179e/P/-/-/0  0x30177f/0x3017c4/P/-/-/0

llvm/test/tools/llvm-profgen/inline-noprobe2.test

 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/artificial-branch.perfscript --binary=%S/Inputs/inline-noprobe2.perfbin --output=%t  --skip-symbolization --use-offset=0
 ; RUN: FileCheck %s --input-file %t --check-prefix=CHECK-EXT-ADDR
 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/inline-noprobe2.perfscript --binary=%S/Inputs/inline-noprobe2.perfbin --output=%t  --skip-symbolization --use-offset=0
 ; RUN: FileCheck %s --input-file %t --check-prefix=CHECK-RAW-PROFILE
 ; RUN: llvm-profgen --format=text --unsymbolized-profile=%t --binary=%S/Inputs/inline-noprobe2.perfbin --output=%t1 --use-offset=0
 ; RUN: FileCheck %s --input-file %t1 --check-prefix=CHECK
 
 ; RUN: llvm-profgen --format=extbinary --perfscript=%S/Inputs/inline-noprobe2.perfscript --binary=%S/Inputs/inline-noprobe2.perfbin --output=%t --populate-profile-symbol-list=1
 ; RUN: llvm-profdata show -show-prof-sym-list -sample %t | FileCheck %s --check-prefix=CHECK-SYM-LIST
 
 ; CHECK-EXT-ADDR:      2
 ; CHECK-EXT-ADDR-NEXT: 400870-400870:2
 ; CHECK-EXT-ADDR-NEXT: 400875-4008bf:1
 ; CHECK-EXT-ADDR-NEXT: 2
-; CHECK-EXT-ADDR-NEXT: 4008bf->400870:2
 ; Value 1 is external address
 ; CHECK-EXT-ADDR-NEXT: 1->400875:1
+; CHECK-EXT-ADDR-NEXT: 4008bf->400870:2
+
 
 ; CHECK-SYM-LIST: Dump profile symbol list
 ; CHECK-SYM-LIST: main
 ; CHECK-SYM-LIST: partition_pivot_first
 ; CHECK-SYM-LIST: partition_pivot_last
 ; CHECK-SYM-LIST: quick_sort
 ; CHECK-SYM-LIST: swap
 

llvm/test/tools/llvm-profgen/invalid-range.test

 ; CS-NEXT:   20179e-2017bf:5
 ; CS-NEXT:   2017c4-2017cf:5
 ; CS-NEXT:   2017c4-2017d8:1
 ; CS-NEXT:   4
 ; CS-NEXT:   20177f->2017c4:6
 ; CS-NEXT:   2017bf->201760:6
 ; CS-NEXT:   2017cf->20179e:6
 ; CS-NEXT:   2017d8->2017e3:1
-; CS-NEXT: [0x7f4]
+; CS-NEXT: [0x2017f4]
 ; CS-NEXT:   1
 ; CS-NEXT:   2017c4-2017cf:1
 ; CS-NEXT:   2
 ; CS-NEXT:   2017bf->201760:1
 ; CS-NEXT:   2017cf->20179e:2
-; CS-NEXT: [0x7f4 @ 0x7bf]
+; CS-NEXT: [0x2017f4 @ 0x2017bf]
 ; CS-NEXT:   1
 ; CS-NEXT:   201760-20177f:1
 ; CS-NEXT:   1
 ; CS-NEXT:   20177f->2017c4:1
 
 ; 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

llvm/test/tools/llvm-profgen/pseudoprobe-decoding.test

 ; CHECK: Hash: 72617220756
 
 
 
 ; CHECK:      <bar>:
 
 ; CHECK:       [Probe]: FUNC: bar Index: 1  Type: Block
 ; CHECK-NEXT:  [Probe]: FUNC: bar Index: 4  Type: Block
-; CHECK-NEXT:      754: imull $2863311531, %edi, %eax
+; CHECK-NEXT:   201754: imull $2863311531, %edi, %eax
 
 ; CHECK:      <foo>:
 ; CHECK:       [Probe]: FUNC: foo Index: 1  Type: Block
 ; CHECK-NEXT:  [Probe]: FUNC: foo Index: 2  Type: Block
-; CHECK-NEXT:      770: movl  $1, %ecx
+; CHECK-NEXT:   201770: movl  $1, %ecx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 5  Type: Block
-; CHECK-NEXT:      780: addl  $30, %esi
+; CHECK-NEXT:    201780: addl  $30, %esi
 ; CHECK:       [Probe]: FUNC: foo Index: 6  Type: Block
 ; CHECK-NEXT:  [Probe]: FUNC: foo Index: 2  Type: Block
-; CHECK-NEXT:      783: addl  $1, %ecx
+; CHECK-NEXT:   201783: addl  $1, %ecx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 3  Type: Block
-; CHECK-NEXT:      78e: movl  %ecx, %edx
+; CHECK-NEXT:   20178e: movl  %ecx, %edx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 4  Type: Block
 ; CHECK-NEXT:  [Probe]: FUNC: bar Index: 1  Type: Block  Inlined: @ foo:8
 ; CHECK-NEXT:  [Probe]: FUNC: bar Index: 4  Type: Block  Inlined: @ foo:8
-; CHECK-NEXT:      7bf: addl  %ecx, %edx
+; CHECK-NEXT:   2017bf: addl  %ecx, %edx
 
 
 ; CHECK:       [Probe]: FUNC: foo Index: 6  Type: Block
 ; CHECK-NEXT:  [Probe]: FUNC: foo Index: 2  Type: Block
-; CHECK-NEXT:      7cf: addl  $1, %ecx
+; CHECK-NEXT:   2017cf: addl  $1, %ecx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 7  Type: Block
-; CHECK-NEXT:      7de: movl  $2098432, %edi
+; CHECK-NEXT:   2017de: movl  $2098432, %edi
 
 ; CHECK:       [Probe]: FUNC: foo Index: 9  Type: DirectCall
-; CHECK-NEXT:      7e5: callq 0x930
+; CHECK-NEXT:   2017e5: callq 0x201930
 
 
 ; CHECK:      <main>:
 ; CHECK:       [Probe]: FUNC: main Index: 1  Type: Block
 ; CHECK-NEXT:  [Probe]: FUNC: foo Index: 1  Type: Block  Inlined: @ main:2
 ; CHECK-NEXT:  [Probe]: FUNC: foo Index: 2  Type: Block  Inlined: @ main:2
-; CHECK-NEXT:      7f0: movl  $1, %ecx
+; CHECK-NEXT:   2017f0: movl  $1, %ecx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 5  Type: Block  Inlined: @ main:2
-; CHECK-NEXT:      800: addl  $30, %esi
+; CHECK-NEXT:   201800: addl  $30, %esi
 ; CHECK:       [Probe]: FUNC: foo Index: 6  Type: Block  Inlined: @ main:2
 ; CHECK-NEXT:  [Probe]: FUNC: foo Index: 2  Type: Block  Inlined: @ main:2
-; CHECK-NEXT:      803: addl  $1, %ecx
+; CHECK-NEXT:   201803: addl  $1, %ecx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 3  Type: Block  Inlined: @ main:2
-; CHECK-NEXT:      80e: movl  %ecx, %edx
+; CHECK-NEXT:   20180e: movl  %ecx, %edx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 4  Type: Block  Inlined: @ main:2
 ; CHECK-NEXT:  [Probe]: FUNC: bar Index: 1  Type: Block  Inlined: @ main:2 @ foo:8
 ; CHECK-NEXT:  [Probe]: FUNC: bar Index: 4  Type: Block  Inlined: @ main:2 @ foo:8
-; CHECK-NEXT:      83f: addl  %ecx, %edx
+; CHECK-NEXT:   20183f: addl  %ecx, %edx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 6  Type: Block  Inlined: @ main:2
 ; CHECK-NEXT:  [Probe]: FUNC: foo Index: 2  Type: Block  Inlined: @ main:2
-; CHECK-NEXT:      84f: addl  $1, %ecx
+; CHECK-NEXT:   20184f: addl  $1, %ecx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 7  Type: Block  Inlined: @ main:2
-; CHECK-NEXT:      85e: movl  $2098432, %edi
+; CHECK-NEXT:   20185e: movl  $2098432, %edi
 
 ; CHECK:       [Probe]: FUNC: foo Index: 9  Type: DirectCall  Inlined: @ main:2
-; CHECK-NEXT:      865: callq 0x930
+; CHECK-NEXT:   201865: callq 0x201930
 
 ; SYM-NOT: <bar>:
 ; SYM: <foo>:
 ; SYM: <main>:
 
 
 
 ; clang -O3 -fuse-ld=lld -fpseudo-probe-for-profiling

llvm/tools/llvm-profgen/PerfReader.cpp

if (End == ExternalAddr || Target == ExternalAddr) {
     // traces contains a standalone external address failing to pair another
     // one, likely due to interrupt jmp or broken perf script. Set the
     // state to invalid.
     NumUnpairedExtAddr++;
     State.setInvalid();
     return;
   }
 
-  if (!isValidFallThroughRange(Binary->virtualAddrToOffset(Target),
-                               Binary->virtualAddrToOffset(End), Binary)) {
+  if (!isValidFallThroughRange(Target, End, Binary)) {
     // Skip unwinding the rest of LBR trace when a bogus range is seen.
     State.setInvalid();
     return;
   }
 
   if (Binary->usePseudoProbes()) {
     // We don't need to top frame probe since it should be extracted
     // from the range.
void VirtualUnwinder::collectSamplesFromFrame(UnwindState::ProfiledFrame *Cur,
   if (Cur->RangeSamples.empty() && Cur->BranchSamples.empty())
     return;
 
   std::shared_ptr<ContextKey> Key = Stack.getContextKey();
   if (Key == nullptr)
     return;
   auto Ret = CtxCounterMap->emplace(Hashable<ContextKey>(Key), SampleCounter());
   SampleCounter &SCounter = Ret.first->second;
-  for (auto &Item : Cur->RangeSamples) {
-    uint64_t StartOffset = Binary->virtualAddrToOffset(std::get<0>(Item));
-    uint64_t EndOffset = Binary->virtualAddrToOffset(std::get<1>(Item));
-    SCounter.recordRangeCount(StartOffset, EndOffset, std::get<2>(Item));
-  }
+  for (auto &I : Cur->RangeSamples)
+    SCounter.recordRangeCount(std::get<0>(I), std::get<1>(I), std::get<2>(I));
 
-  for (auto &Item : Cur->BranchSamples) {
-    uint64_t SourceOffset = Binary->virtualAddrToOffset(std::get<0>(Item));
-    uint64_t TargetOffset = Binary->virtualAddrToOffset(std::get<1>(Item));
-    SCounter.recordBranchCount(SourceOffset, TargetOffset, std::get<2>(Item));
-  }
+  for (auto &I : Cur->BranchSamples)
+    SCounter.recordBranchCount(std::get<0>(I), std::get<1>(I), std::get<2>(I));
 }
 
 template <typename T>
 void VirtualUnwinder::collectSamplesFromFrameTrie(
     UnwindState::ProfiledFrame *Cur, T &Stack) {
   if (!Cur->isDummyRoot()) {
     // Truncate the context for external frame since this isn't a real call
     // context the compiler will see.
static std::string getContextKeyStr(ContextKey *K,
                                     const ProfiledBinary *Binary) {
   if (const auto *CtxKey = dyn_cast<StringBasedCtxKey>(K)) {
     return SampleContext::getContextString(CtxKey->Context);
   } else if (const auto *CtxKey = dyn_cast<AddrBasedCtxKey>(K)) {
     std::ostringstream OContextStr;
     for (uint32_t I = 0; I < CtxKey->Context.size(); I++) {
       if (OContextStr.str().size())
         OContextStr << " @ ";
+      uint64_t Address = CtxKey->Context[I];
+      if (UseOffset) {
+        if (UseLoadableSegmentAsBase)
+          Address -= Binary->getFirstLoadableAddress();
+        else
+          Address -= Binary->getPreferredBaseAddress();
+      }
       OContextStr << "0x"
-                  << utohexstr(
-                         Binary->virtualAddrToOffset(CtxKey->Context[I]),
+                  << utohexstr(Address,
                                /*LowerCase=*/true);
     }
     return OContextStr.str();
   } else {
     llvm_unreachable("unexpected key type");
   }
 }
 
 void HybridPerfReader::unwindSamples() {
while (Index < Records.size()) {
 
     // Stop at broken LBR records.
     if (Addresses.size() < 2 || Addresses[0].substr(2).getAsInteger(16, Src) ||
         Addresses[1].substr(2).getAsInteger(16, Dst)) {
       WarnInvalidLBR(TraceIt);
       break;
     }
 
+    // Canonicalize to use preferred load address as base address.
+    Src = Binary->canonicalizeVirtualAddress(Src);
+    Dst = Binary->canonicalizeVirtualAddress(Dst);
     bool SrcIsInternal = Binary->addressIsCode(Src);
     bool DstIsInternal = Binary->addressIsCode(Dst);
     if (!SrcIsInternal)
       Src = ExternalAddr;
     if (!DstIsInternal)
       Dst = ExternalAddr;
     // Filter external-to-external case to reduce LBR trace size.
     if (!SrcIsInternal && !DstIsInternal)
while (!TraceIt.isAtEoF() && !TraceIt.getCurrentLine().startswith(" 0x")) {
     uint64_t FrameAddr = 0;
     if (FrameStr.getAsInteger(16, FrameAddr)) {
       // We might parse a non-perf sample line like empty line and comments,
       // skip it
       TraceIt.advance();
       return false;
     }
     TraceIt.advance();
+
+    FrameAddr = Binary->canonicalizeVirtualAddress(FrameAddr);
     // Currently intermixed frame from different binaries is not supported.
     if (!Binary->addressIsCode(FrameAddr)) {
       if (CallStack.empty())
         NumLeafExternalFrame++;
       // Push a special value(ExternalAddr) for the external frames so that
       // unwinder can still work on this with artificial Call/Return branch.
       // After unwinding, the context will be truncated for external frame.
       // Also deduplicate the consecutive external addresses.
void PerfScriptReader::writeUnsymbolizedProfile(raw_fd_ostream &OS) {
   auto SCounterPrinter = [&](RangeSample &Counter, StringRef Separator,
                              uint32_t Indent) {
     OS.indent(Indent);
     OS << Counter.size() << "\n";
     for (auto &I : Counter) {
       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) {
+      if (UseOffset) {
+        if (UseLoadableSegmentAsBase) {
           Start -= Binary->getFirstLoadableAddress();
           End -= Binary->getFirstLoadableAddress();
+        } else {
+          Start -= Binary->getPreferredBaseAddress();
+          End -= Binary->getPreferredBaseAddress();
+        }
       }
 
       OS.indent(Indent);
       OS << Twine::utohexstr(Start) << Separator << Twine::utohexstr(End) << ":"
          << I.second << "\n";
     }
   };
 
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 || (UseOffset && UseLoadableSegmentAsBase)) {
-        uint64_t BaseAddr = 0;
-        if (UseOffset && UseLoadableSegmentAsBase)
-          BaseAddr = Binary->getFirstLoadableAddress();
-
-        Source = Binary->virtualAddrToOffset(Source + BaseAddr);
-        Target = Binary->virtualAddrToOffset(Target + BaseAddr);
+      if (UseOffset) {
+        if (UseLoadableSegmentAsBase) {
+          Source += Binary->getFirstLoadableAddress();
+          Target += Binary->getFirstLoadableAddress();
+        } else {
+          Source += Binary->getPreferredBaseAddress();
+          Target += Binary->getPreferredBaseAddress();
+        }
       }
 
       Counter[{Source, Target}] += Count;
       TraceIt.advance();
     }
   };
 
   ReadCounter(SCounters.RangeCounter, "-");

 
 void UnsymbolizedProfileReader::parsePerfTraces() {
   readUnsymbolizedProfile(PerfTraceFile);
 }
 
 void PerfScriptReader::computeCounterFromLBR(const PerfSample *Sample,
                                              uint64_t Repeat) {
   SampleCounter &Counter = SampleCounters.begin()->second;
-  uint64_t EndOffeset = 0;
+  uint64_t EndAddress = 0;
   for (const LBREntry &LBR : Sample->LBRStack) {
-    uint64_t SourceOffset = Binary->virtualAddrToOffset(LBR.Source);
-    uint64_t TargetOffset = Binary->virtualAddrToOffset(LBR.Target);
+    uint64_t SourceAddress = LBR.Source;
+    uint64_t TargetAddress = LBR.Target;
 
-    // Record the branch if its sourceOffset is external. It can be the case an
+    // Record the branch if its SourceAddress is external. It can be the case an
     // external source call an internal function, later this branch will be used
     // to generate the function's head sample.
-    if (Binary->offsetIsCode(TargetOffset)) {
-      Counter.recordBranchCount(SourceOffset, TargetOffset, Repeat);
+    if (Binary->addressIsCode(TargetAddress)) {
+      Counter.recordBranchCount(SourceAddress, TargetAddress, Repeat);
     }
 
     // If this not the first LBR, update the range count between TO of current
     // LBR and FROM of next LBR.
-    uint64_t StartOffset = TargetOffset;
-    if (Binary->offsetIsCode(StartOffset) && Binary->offsetIsCode(EndOffeset) &&
-        isValidFallThroughRange(StartOffset, EndOffeset, Binary))
-      Counter.recordRangeCount(StartOffset, EndOffeset, Repeat);
-    EndOffeset = SourceOffset;
+    uint64_t StartAddress = TargetAddress;
+    if (Binary->addressIsCode(StartAddress) &&
+        Binary->addressIsCode(EndAddress) &&
+        isValidFallThroughRange(StartAddress, EndAddress, Binary))
+      Counter.recordRangeCount(StartAddress, EndAddress, Repeat);
+    EndAddress = SourceAddress;
   }
 }
 
 void LBRPerfReader::parseSample(TraceStream &TraceIt, uint64_t Count) {
   std::shared_ptr<PerfSample> Sample = std::make_shared<PerfSample>();
   // Parsing LBR stack and populate into PerfSample.LBRStack
   if (extractLBRStack(TraceIt, Sample->LBRStack)) {
     warnIfMissingMMap();

 void PerfScriptReader::warnInvalidRange() {
   std::unordered_map<std::pair<uint64_t, uint64_t>, uint64_t,
                      pair_hash<uint64_t, uint64_t>>
       Ranges;
 
   for (const auto &Item : AggregatedSamples) {
     const PerfSample *Sample = Item.first.getPtr();
     uint64_t Count = Item.second;
-    uint64_t EndOffeset = 0;
+    uint64_t EndAddress = 0;
     for (const LBREntry &LBR : Sample->LBRStack) {
-      uint64_t SourceOffset = Binary->virtualAddrToOffset(LBR.Source);
-      uint64_t StartOffset = Binary->virtualAddrToOffset(LBR.Target);
-      if (EndOffeset != 0)
-        Ranges[{StartOffset, EndOffeset}] += Count;
-      EndOffeset = SourceOffset;
+      uint64_t SourceAddress = LBR.Source;
+      uint64_t StartAddress = LBR.Target;
+      if (EndAddress != 0)
+        Ranges[{StartAddress, EndAddress}] += Count;
+      EndAddress = SourceAddress;
     }
   }
 
   if (Ranges.empty()) {
     WithColor::warning() << "No samples in perf script!\n";
     return;
   }
 
-  auto WarnInvalidRange =
-      [&](uint64_t StartOffset, uint64_t EndOffset, StringRef Msg) {
-        if (!ShowDetailedWarning)
-          return;
-        WithColor::warning()
-            << "["
-            << format("%8" PRIx64, Binary->offsetToVirtualAddr(StartOffset))
-            << ","
-            << format("%8" PRIx64, Binary->offsetToVirtualAddr(EndOffset))
-            << "]: " << Msg << "\n";
-      };
+  auto WarnInvalidRange = [&](uint64_t StartAddress, uint64_t EndAddress,
+                              StringRef Msg) {
+    WithColor::warning() << "[" << format("%8" PRIx64, StartAddress) << ","
+                         << format("%8" PRIx64, EndAddress) << "]: " << Msg
+                         << "\n";
 
   const char *EndNotBoundaryMsg = "Range is not on instruction boundary, "
                                   "likely due to profile and binary mismatch.";
   const char *DanglingRangeMsg = "Range does not belong to any functions, "
                                  "likely from PLT, .init or .fini section.";
   const char *RangeCrossFuncMsg =
       "Fall through range should not cross function boundaries, likely due to "
       "profile and binary mismatch.";
   const char *BogusRangeMsg = "Range start is after or too far from range end.";
 
   uint64_t TotalRangeNum = 0;
   uint64_t InstNotBoundary = 0;
   uint64_t UnmatchedRange = 0;
   uint64_t RangeCrossFunc = 0;
   uint64_t BogusRange = 0;
 
   for (auto &I : Ranges) {
-    uint64_t StartOffset = I.first.first;
-    uint64_t EndOffset = I.first.second;
+    uint64_t StartAddress = I.first.first;
+    uint64_t EndAddress = I.first.second;
     TotalRangeNum += I.second;
 
-    if (!Binary->offsetIsCode(StartOffset) ||
-        !Binary->offsetIsTransfer(EndOffset)) {
+    if (!Binary->addressIsCode(StartAddress) &&
+        !Binary->addressIsCode(EndAddress))
+      continue;
+
+    if (!Binary->addressIsCode(StartAddress) ||
+        !Binary->addressIsTransfer(EndAddress)) {
       InstNotBoundary += I.second;
-      WarnInvalidRange(StartOffset, EndOffset, EndNotBoundaryMsg);
+      WarnInvalidRange(StartAddress, EndAddress, EndNotBoundaryMsg);
     }
 
-    auto *FRange = Binary->findFuncRangeForOffset(StartOffset);
+    auto *FRange = Binary->findFuncRange(StartAddress);
     if (!FRange) {
       UnmatchedRange += I.second;
-      WarnInvalidRange(StartOffset, EndOffset, DanglingRangeMsg);
+      WarnInvalidRange(StartAddress, EndAddress, DanglingRangeMsg);
       continue;
     }
 
-    if (EndOffset >= FRange->EndOffset) {
+    if (EndAddress >= FRange->EndAddress) {
       RangeCrossFunc += I.second;
-      WarnInvalidRange(StartOffset, EndOffset, RangeCrossFuncMsg);
+      WarnInvalidRange(StartAddress, EndAddress, RangeCrossFuncMsg);
     }
 
-    if (!isValidFallThroughRange(StartOffset, EndOffset, Binary)) {
+    if (Binary->addressIsCode(StartAddress) &&
+        Binary->addressIsCode(EndAddress) &&
+        !isValidFallThroughRange(StartAddress, EndAddress, Binary)) {
       BogusRange += I.second;
-      WarnInvalidRange(StartOffset, EndOffset, BogusRangeMsg);
+      WarnInvalidRange(StartAddress, EndAddress, BogusRangeMsg);
     }
   }
 
   emitWarningSummary(
       InstNotBoundary, TotalRangeNum,
       "of samples are from ranges that are not on instruction boundary.");
   emitWarningSummary(
       UnmatchedRange, TotalRangeNum,
void PerfScriptReader::parsePerfTraces() {
   warnTruncatedStack();
   warnInvalidRange();
   generateUnsymbolizedProfile();
   AggregatedSamples.clear();
 
   if (SkipSymbolization)
     writeUnsymbolizedProfile(OutputFilename);
 }
 
 } // end namespace sampleprof
 } // end namespace llvm

llvm/tools/llvm-profgen/ProfileGenerator.h

void updateBodySamplesforFunctionProfile(FunctionSamples &FunctionProfile,
                                            uint64_t Count);
 
   void updateFunctionSamples();
 
   void updateTotalSamples();
 
   void updateCallsiteSamples();
 
-  StringRef getCalleeNameForOffset(uint64_t TargetOffset);
+  StringRef getCalleeNameForAddress(uint64_t TargetAddress);
 
   void computeSummaryAndThreshold(SampleProfileMap &ProfileMap);
 
   void calculateAndShowDensity(const SampleProfileMap &Profiles);
 
   double calculateDensity(const SampleProfileMap &Profiles,
                           uint64_t HotCntThreshold);
 

llvm/tools/llvm-profgen/ProfileGenerator.cpp

bool ProfileGeneratorBase::collectFunctionsFromRawProfile(
     std::unordered_set<const BinaryFunction *> &ProfiledFunctions) {
   if (!SampleCounters)
     return false;
   // Go through all the stacks, ranges and branches in sample counters, use
   // the start of the range to look up the function it belongs and record the
   // function.
   for (const auto &CI : *SampleCounters) {
     if (const auto *CtxKey = dyn_cast<AddrBasedCtxKey>(CI.first.getPtr())) {
-      for (auto Addr : CtxKey->Context) {
-        if (FuncRange *FRange = Binary->findFuncRangeForOffset(
-                Binary->virtualAddrToOffset(Addr)))
+      for (auto StackAddr : CtxKey->Context) {
+        if (FuncRange *FRange = Binary->findFuncRange(StackAddr))
           ProfiledFunctions.insert(FRange->Func);
       }
     }
 
     for (auto Item : CI.second.RangeCounter) {
-      uint64_t StartOffset = Item.first.first;
-      if (FuncRange *FRange = Binary->findFuncRangeForOffset(StartOffset))
+      uint64_t StartAddress = Item.first.first;
+      if (FuncRange *FRange = Binary->findFuncRange(StartAddress))
         ProfiledFunctions.insert(FRange->Func);
     }
 
     for (auto Item : CI.second.BranchCounter) {
-      uint64_t SourceOffset = Item.first.first;
-      uint64_t TargetOffset = Item.first.first;
-      if (FuncRange *FRange = Binary->findFuncRangeForOffset(SourceOffset))
+      uint64_t SourceAddress = Item.first.first;
+      uint64_t TargetAddress = Item.first.first;
+      if (FuncRange *FRange = Binary->findFuncRange(SourceAddress))
         ProfiledFunctions.insert(FRange->Func);
-      if (FuncRange *FRange = Binary->findFuncRangeForOffset(TargetOffset))
+      if (FuncRange *FRange = Binary->findFuncRange(TargetAddress))
         ProfiledFunctions.insert(FRange->Func);
     }
   }
   return true;
 }
 
 bool ProfileGenerator::collectFunctionsFromLLVMProfile(
     std::unordered_set<const BinaryFunction *> &ProfiledFunctions) {
for (const auto &PI : ProbeCounter) {
     if (Probe->isEntry())
       FunctionProfile.addHeadSamples(Count);
   }
 }
 
 void ProfileGenerator::populateBoundarySamplesWithProbesForAllFunctions(
     const BranchSample &BranchCounters) {
   for (const auto &Entry : BranchCounters) {
-    uint64_t SourceOffset = Entry.first.first;
-    uint64_t TargetOffset = Entry.first.second;
+    uint64_t SourceAddress = Entry.first.first;
+    uint64_t TargetAddress = Entry.first.second;
     uint64_t Count = Entry.second;
     assert(Count != 0 && "Unexpected zero weight branch");
 
-    StringRef CalleeName = getCalleeNameForOffset(TargetOffset);
+    StringRef CalleeName = getCalleeNameForAddress(TargetAddress);
     if (CalleeName.size() == 0)
       continue;
 
-    uint64_t SourceAddress = Binary->offsetToVirtualAddr(SourceOffset);
     const MCDecodedPseudoProbe *CallProbe =
         Binary->getCallProbeForAddr(SourceAddress);
     if (CallProbe == nullptr)
       continue;
 
     // Record called target sample and its count.
     SampleContextFrameVector FrameVec;
     Binary->getInlineContextForProbe(CallProbe, FrameVec, true);
for (auto &FuncI : Binary->getAllBinaryFunctions()) {
       }
     }
   } else {
     // For each range, we search for all ranges 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).
     for (const auto &I : RangeCounter) {
-      uint64_t StartOffset = I.first.first;
-      for (const auto &Range : Binary->getRangesForOffset(StartOffset))
+      uint64_t StartAddress = I.first.first;
+      for (const auto &Range : Binary->getRanges(StartAddress))
         Ranges[{Range.first, Range.second - 1}] += 0;
     }
   }
   RangeSample DisjointRanges;
   findDisjointRanges(DisjointRanges, Ranges);
   return DisjointRanges;
 }
 
 void ProfileGenerator::populateBodySamplesForAllFunctions(
     const RangeSample &RangeCounter) {
   for (const auto &Range : preprocessRangeCounter(RangeCounter)) {
-    uint64_t RangeBegin = Binary->offsetToVirtualAddr(Range.first.first);
-    uint64_t RangeEnd = Binary->offsetToVirtualAddr(Range.first.second);
+    uint64_t RangeBegin = Range.first.first;
+    uint64_t RangeEnd = Range.first.second;
     uint64_t Count = Range.second;
 
     InstructionPointer IP(Binary, RangeBegin, true);
     // Disjoint ranges may have range in the middle of two instr,
     // e.g. If Instr1 at Addr1, and Instr2 at Addr2, disjoint range
     // can be Addr1+1 to Addr2-1. We should ignore such range.
     if (IP.Address > RangeEnd)
       continue;
 
     do {
-      uint64_t Offset = Binary->virtualAddrToOffset(IP.Address);
       const SampleContextFrameVector &FrameVec =
-          Binary->getFrameLocationStack(Offset);
+          Binary->getFrameLocationStack(IP.Address);
       if (!FrameVec.empty()) {
         // FIXME: As accumulating total count per instruction caused some
         // regression, we changed to accumulate total count per byte as a
         // workaround. Tuning hotness threshold on the compiler side might be
         // necessary in the future.
         FunctionSamples &FunctionProfile = getLeafProfileAndAddTotalSamples(
-            FrameVec, Count * Binary->getInstSize(Offset));
+            FrameVec, Count * Binary->getInstSize(IP.Address));
         updateBodySamplesforFunctionProfile(FunctionProfile, FrameVec.back(),
                                             Count);
       }
     } while (IP.advance() && IP.Address <= RangeEnd);
   }
 }
 
-StringRef ProfileGeneratorBase::getCalleeNameForOffset(uint64_t TargetOffset) {
+StringRef
+ProfileGeneratorBase::getCalleeNameForAddress(uint64_t TargetAddress) {
   // Get the function range by branch target if it's a call branch.
-  auto *FRange = Binary->findFuncRangeForStartOffset(TargetOffset);
+  auto *FRange = Binary->findFuncRangeForStartAddr(TargetAddress);
 
   // We won't accumulate sample count for a range whose start is not the real
   // function entry such as outlined function or inner labels.
   if (!FRange || !FRange->IsFuncEntry)
     return StringRef();
 
   return FunctionSamples::getCanonicalFnName(FRange->getFuncName());
 }
 
 void ProfileGenerator::populateBoundarySamplesForAllFunctions(
     const BranchSample &BranchCounters) {
   for (const auto &Entry : BranchCounters) {
-    uint64_t SourceOffset = Entry.first.first;
-    uint64_t TargetOffset = Entry.first.second;
+    uint64_t SourceAddress = Entry.first.first;
+    uint64_t TargetAddress = Entry.first.second;
     uint64_t Count = Entry.second;
     assert(Count != 0 && "Unexpected zero weight branch");
 
-    StringRef CalleeName = getCalleeNameForOffset(TargetOffset);
+    StringRef CalleeName = getCalleeNameForAddress(TargetAddress);
     if (CalleeName.size() == 0)
       continue;
     // Record called target sample and its count.
     const SampleContextFrameVector &FrameVec =
-        Binary->getFrameLocationStack(SourceOffset);
+        Binary->getFrameLocationStack(SourceAddress);
     if (!FrameVec.empty()) {
       FunctionSamples &FunctionProfile =
           getLeafProfileAndAddTotalSamples(FrameVec, 0);
       FunctionProfile.addCalledTargetSamples(
           FrameVec.back().Location.LineOffset,
           getBaseDiscriminator(FrameVec.back().Location.Discriminator),
           CalleeName, Count);
     }

 
 void CSProfileGenerator::populateBodySamplesForFunction(
     FunctionSamples &FunctionProfile, const RangeSample &RangeCounter) {
   // Compute disjoint ranges first, so we can use MAX
   // for calculating count for each location.
   RangeSample Ranges;
   findDisjointRanges(Ranges, RangeCounter);
   for (const auto &Range : Ranges) {
-    uint64_t RangeBegin = Binary->offsetToVirtualAddr(Range.first.first);
-    uint64_t RangeEnd = Binary->offsetToVirtualAddr(Range.first.second);
+    uint64_t RangeBegin = Range.first.first;
+    uint64_t RangeEnd = Range.first.second;
     uint64_t Count = Range.second;
     // Disjoint ranges have introduce zero-filled gap that
     // doesn't belong to current context, filter them out.
     if (Count == 0)
       continue;
 
     InstructionPointer IP(Binary, RangeBegin, true);
     // Disjoint ranges may have range in the middle of two instr,
     // e.g. If Instr1 at Addr1, and Instr2 at Addr2, disjoint range
     // can be Addr1+1 to Addr2-1. We should ignore such range.
     if (IP.Address > RangeEnd)
       continue;
 
     do {
-      uint64_t Offset = Binary->virtualAddrToOffset(IP.Address);
-      auto LeafLoc = Binary->getInlineLeafFrameLoc(Offset);
+      auto LeafLoc = Binary->getInlineLeafFrameLoc(IP.Address);
       if (LeafLoc) {
         // Recording body sample for this specific context
         updateBodySamplesforFunctionProfile(FunctionProfile, *LeafLoc, Count);
         FunctionProfile.addTotalSamples(Count);
       }
     } while (IP.advance() && IP.Address <= RangeEnd);
   }
 }
 
 void CSProfileGenerator::populateBoundarySamplesForFunction(
     ContextTrieNode *Node, const BranchSample &BranchCounters) {
 
   for (const auto &Entry : BranchCounters) {
-    uint64_t SourceOffset = Entry.first.first;
-    uint64_t TargetOffset = Entry.first.second;
+    uint64_t SourceAddress = Entry.first.first;
+    uint64_t TargetAddress = Entry.first.second;
     uint64_t Count = Entry.second;
     assert(Count != 0 && "Unexpected zero weight branch");
 
-    StringRef CalleeName = getCalleeNameForOffset(TargetOffset);
+    StringRef CalleeName = getCalleeNameForAddress(TargetAddress);
     if (CalleeName.size() == 0)
       continue;
 
     ContextTrieNode *CallerNode = Node;
     LineLocation CalleeCallSite(0, 0);
     if (CallerNode != &getRootContext()) {
       // Record called target sample and its count
-      auto LeafLoc = Binary->getInlineLeafFrameLoc(SourceOffset);
+      auto LeafLoc = Binary->getInlineLeafFrameLoc(SourceAddress);
       if (LeafLoc) {
         CallerNode->getFunctionSamples()->addCalledTargetSamples(
             LeafLoc->Location.LineOffset,
             getBaseDiscriminator(LeafLoc->Location.Discriminator), CalleeName,
             Count);
         // Record head sample for called target(callee)
         CalleeCallSite = LeafLoc->Location;
       }
void ProfileGeneratorBase::extractProbesFromRange(
   const RangeSample *PRanges = &RangeCounter;
   RangeSample Ranges;
   if (FindDisjointRanges) {
     findDisjointRanges(Ranges, RangeCounter);
     PRanges = &Ranges;
   }
 
   for (const auto &Range : *PRanges) {
-    uint64_t RangeBegin = Binary->offsetToVirtualAddr(Range.first.first);
-    uint64_t RangeEnd = Binary->offsetToVirtualAddr(Range.first.second);
+    uint64_t RangeBegin = Range.first.first;
+    uint64_t RangeEnd = Range.first.second;
     uint64_t Count = Range.second;
 
     InstructionPointer IP(Binary, RangeBegin, true);
     // Disjoint ranges may have range in the middle of two instr,
     // e.g. If Instr1 at Addr1, and Instr2 at Addr2, disjoint range
     // can be Addr1+1 to Addr2-1. We should ignore such range.
     if (IP.Address > RangeEnd)
       continue;
 
     do {
       const AddressProbesMap &Address2ProbesMap =
           Binary->getAddress2ProbesMap();
       auto It = Address2ProbesMap.find(IP.Address);
       if (It != Address2ProbesMap.end()) {
         for (const auto &Probe : It->second) {
           ProbeCounter[&Probe] += Count;
         }
       }
     } while (IP.advance() && IP.Address <= RangeEnd);
   }
 }
 
-static void
-extractPrefixContextStack(SampleContextFrameVector &ContextStack,
-                          const SmallVectorImpl<uint64_t> &Addresses,
+static void extractPrefixContextStack(SampleContextFrameVector &ContextStack,
+                                      const SmallVectorImpl<uint64_t> &AddrVec,
                                       ProfiledBinary *Binary) {
   SmallVector<const MCDecodedPseudoProbe *, 16> Probes;
-  for (auto Addr : reverse(Addresses)) {
-    const MCDecodedPseudoProbe *CallProbe = Binary->getCallProbeForAddr(Addr);
+  for (auto Address : reverse(AddrVec)) {
+    const MCDecodedPseudoProbe *CallProbe =
+        Binary->getCallProbeForAddr(Address);
     // These could be the cases when a probe is not found at a calliste. Cutting
     // off the context from here since the inliner will not know how to consume
     // a context with unknown callsites.
     // 1. for functions that are not sampled when
     // --decode-probe-for-profiled-functions-only is on.
     // 2. for a merged callsite. Callsite merging may cause the loss of original
     // probe IDs.
     // 3. for an external callsite.
for (auto *FunctionProfile : I.second) {
       }
     }
   }
 }
 
 void CSProfileGenerator::populateBoundarySamplesWithProbes(
     const BranchSample &BranchCounter, SampleContextFrames ContextStack) {
   for (const auto &BI : BranchCounter) {
-    uint64_t SourceOffset = BI.first.first;
-    uint64_t TargetOffset = BI.first.second;
+    uint64_t SourceAddress = BI.first.first;
+    uint64_t TargetAddress = BI.first.second;
     uint64_t Count = BI.second;
-    uint64_t SourceAddress = Binary->offsetToVirtualAddr(SourceOffset);
     const MCDecodedPseudoProbe *CallProbe =
         Binary->getCallProbeForAddr(SourceAddress);
     if (CallProbe == nullptr)
       continue;
     FunctionSamples &FunctionProfile =
         getFunctionProfileForLeafProbe(ContextStack, CallProbe);
     FunctionProfile.addBodySamples(CallProbe->getIndex(), 0, Count);
     FunctionProfile.addTotalSamples(Count);
-    StringRef CalleeName = getCalleeNameForOffset(TargetOffset);
+    StringRef CalleeName = getCalleeNameForAddress(TargetAddress);
     if (CalleeName.size() == 0)
       continue;
     FunctionProfile.addCalledTargetSamples(CallProbe->getIndex(), 0, CalleeName,
                                            Count);
   }
 }
 
 ContextTrieNode *CSProfileGenerator::getContextNodeForLeafProbe(

llvm/tools/llvm-profgen/ProfiledBinary.h

 
 namespace llvm {
 namespace sampleprof {
 
 class ProfiledBinary;
 
 struct InstructionPointer {
   const ProfiledBinary *Binary;
-  union {
-    // Offset of the executable segment of the binary.
-    uint64_t Offset = 0;
-    // Also used as address in unwinder
-    uint64_t Address;
-  };
+  // Address of the executable segment of the binary.
   // Index to the sorted code address array of the binary.
   uint64_t Index = 0;
   InstructionPointer(const ProfiledBinary *Binary, uint64_t Address,
                      bool RoundToNext = false);
   bool advance();
   bool backward();
   void update(uint64_t Addr);
 };
uint64_t getFuncSize() {
     }
     return Sum;
   }
 };
 
 // Info about function range. A function can be split into multiple
 // non-continuous ranges, each range corresponds to one FuncRange.
 struct FuncRange {
-  uint64_t StartOffset;
-  // EndOffset is an exclusive bound.
-  uint64_t EndOffset;
+  uint64_t StartAddress;
+  // EndAddress is an exclusive bound.
+  uint64_t EndAddress;
   // Function the range belongs to
   BinaryFunction *Func;
-  // Whether the start offset is the real entry of the function.
+  // Whether the start address is the real entry of the function.
   bool IsFuncEntry = false;
 
   StringRef getFuncName() { return Func->FuncName; }
 };
 
-// PrologEpilog offset tracker, used to filter out broken stack samples
+// PrologEpilog address 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.
+  // A set of prolog and epilog addresses. 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, FuncRange> &FuncStartOffsetMap) {
-    for (auto I : FuncStartOffsetMap) {
+  void
+  inferPrologAddresses(std::map<uint64_t, FuncRange> &FuncStartAddressMap) {
+    for (auto I : FuncStartAddressMap) {
       PrologEpilogSet.insert(I.first);
       InstructionPointer IP(Binary, I.first);
       if (!IP.advance())
         break;
-      PrologEpilogSet.insert(IP.Offset);
+      PrologEpilogSet.insert(IP.Address);
     }
   }
 
   // Take the last two addresses before the return address as epilog
-  void inferEpilogOffsets(std::unordered_set<uint64_t> &RetAddrs) {
+  void inferEpilogAddresses(std::unordered_set<uint64_t> &RetAddrs) {
     for (auto Addr : RetAddrs) {
       PrologEpilogSet.insert(Addr);
       InstructionPointer IP(Binary, Addr);
       if (!IP.backward())
         break;
-      PrologEpilogSet.insert(IP.Offset);
+      PrologEpilogSet.insert(IP.Address);
     }
   }
 };
 
 // Track function byte size under different context (outlined version as well as
 // various inlined versions). It also provides query support to get function
 // size with the best matching context, which is used to help pre-inliner use
 // accurate post-optimization size to make decisions.
private:
   // Root node for context trie tree, node that this is a reverse context trie
   // with callee as parent and caller as child. This way we can traverse from
   // root to find the best/longest matching context if an exact match does not
   // exist. It gives us the best possible estimate for function's post-inline,
   // post-optimization byte size.
   ContextTrieNode RootContext;
 };
 
-using OffsetRange = std::pair<uint64_t, uint64_t>;
+using AddressRange = std::pair<uint64_t, uint64_t>;
 
 class ProfiledBinary {
   // Absolute path of the executable binary.
   std::string Path;
   // Path of the debug info binary.
   std::string DebugBinaryPath;
   // Path of symbolizer path which should be pointed to binary with debug info.
   StringRef SymbolizerPath;
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;
 
-  // An ordered map of mapping function's start offset to function range
-  // relevant info. Currently to determine if the offset of ELF is the start of
+  // 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
   // a real function, we leverage the function range info from DWARF.
-  std::map<uint64_t, FuncRange> StartOffset2FuncRangeMap;
+  std::map<uint64_t, FuncRange> StartAddrToFuncRangeMap;
 
-  // Offset to context location map. Used to expand the context.
-  std::unordered_map<uint64_t, SampleContextFrameVector> Offset2LocStackMap;
+  // Address to context location map. Used to expand the context.
+  std::unordered_map<uint64_t, SampleContextFrameVector> AddressToLocStackMap;
 
-  // Offset to instruction size map. Also used for quick offset lookup.
-  std::unordered_map<uint64_t, uint64_t> Offset2InstSizeMap;
+  // Address to instruction size map. Also used for quick Address lookup.
+  std::unordered_map<uint64_t, uint64_t> AddressToInstSizeMap;
 
-  // An array of offsets of all instructions sorted in increasing order. The
+  // An array of Addresses of all instructions sorted in increasing order. The
   // sorting is needed to fast advance to the next forward/backward instruction.
-  std::vector<uint64_t> CodeAddrOffsets;
-  // A set of call instruction offsets. Used by virtual unwinding.
-  std::unordered_set<uint64_t> CallOffsets;
-  // A set of return instruction offsets. Used by virtual unwinding.
-  std::unordered_set<uint64_t> RetOffsets;
-  // An ordered set of unconditional branch instruction offsets.
-  std::set<uint64_t> UncondBranchOffsets;
-  // A set of branch instruction offsets.
-  std::unordered_set<uint64_t> BranchOffsets;
+  std::vector<uint64_t> CodeAddressVec;
+  // A set of call instruction addresses. Used by virtual unwinding.
+  std::unordered_set<uint64_t> CallAddressSet;
+  // A set of return instruction addresses. Used by virtual unwinding.
+  std::unordered_set<uint64_t> RetAddressSet;
+  // An ordered set of unconditional branch instruction addresses.
+  std::set<uint64_t> UncondBranchAddrSet;
+  // A set of branch instruction addresses.
+  std::unordered_set<uint64_t> BranchAddressSet;
 
   // Estimate and track function prolog and epilog ranges.
   PrologEpilogTracker ProEpilogTracker;
 
   // Track function sizes under different context
   BinarySizeContextTracker FuncSizeTracker;
 
   // The symbolizer used to get inline context for an instruction.
class ProfiledBinary {
 
   // Load debug info of subprograms from DWARF section.
   void loadSymbolsFromDWARF(ObjectFile &Obj);
 
   // Load debug info from DWARF unit.
   void loadSymbolsFromDWARFUnit(DWARFUnit &CompilationUnit);
 
   // 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
+  // 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 Offset, StringRef RangeSymName);
+  void setIsFuncEntry(uint64_t Address, StringRef RangeSymName);
 
   // Warn if no entry range exists in the function.
   void warnNoFuncEntry();
 
   /// 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
ProfiledBinary(const StringRef ExeBinPath, const StringRef DebugBinPath)
     // Point to executable binary if debug info binary is not specified.
     SymbolizerPath = DebugBinPath.empty() ? ExeBinPath : DebugBinPath;
     setupSymbolizer();
     load();
   }
 
   void decodePseudoProbe();
 
-  uint64_t virtualAddrToOffset(uint64_t VirtualAddress) const {
-    return VirtualAddress - BaseAddress;
-  }
-  uint64_t offsetToVirtualAddr(uint64_t Offset) const {
-    return Offset + BaseAddress;
-  }
   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; }
 
+  // Canonicalize to use preferred load address as base address.
+  uint64_t canonicalizeVirtualAddress(uint64_t Address) {
+    return Address - BaseAddress + getPreferredBaseAddress();
+  }
   // 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;
   }
 
-  uint64_t getInstSize(uint64_t Offset) const {
-    auto I = Offset2InstSizeMap.find(Offset);
-    if (I == Offset2InstSizeMap.end())
+  uint64_t getInstSize(uint64_t Address) const {
+    auto I = AddressToInstSizeMap.find(Address);
+    if (I == AddressToInstSizeMap.end())
       return 0;
     return I->second;
   }
 
-  bool offsetIsCode(uint64_t Offset) const {
-    return Offset2InstSizeMap.find(Offset) != Offset2InstSizeMap.end();
-  }
   bool addressIsCode(uint64_t Address) const {
-    uint64_t Offset = virtualAddrToOffset(Address);
-    return offsetIsCode(Offset);
+    return AddressToInstSizeMap.find(Address) != AddressToInstSizeMap.end();
   }
+
   bool addressIsCall(uint64_t Address) const {
-    uint64_t Offset = virtualAddrToOffset(Address);
-    return CallOffsets.count(Offset);
+    return CallAddressSet.count(Address);
   }
   bool addressIsReturn(uint64_t Address) const {
-    uint64_t Offset = virtualAddrToOffset(Address);
-    return RetOffsets.count(Offset);
+    return RetAddressSet.count(Address);
   }
   bool addressInPrologEpilog(uint64_t Address) const {
-    uint64_t Offset = virtualAddrToOffset(Address);
-    return ProEpilogTracker.PrologEpilogSet.count(Offset);
+    return ProEpilogTracker.PrologEpilogSet.count(Address);
   }
 
-  bool offsetIsTransfer(uint64_t Offset) {
-    return BranchOffsets.count(Offset) || RetOffsets.count(Offset) ||
-           CallOffsets.count(Offset);
+  bool addressIsTransfer(uint64_t Address) {
+    return BranchAddressSet.count(Address) || RetAddressSet.count(Address) ||
+           CallAddressSet.count(Address);
   }
 
   bool rangeCrossUncondBranch(uint64_t Start, uint64_t End) {
     if (Start >= End)
       return false;
-    auto R = UncondBranchOffsets.lower_bound(Start);
-    return R != UncondBranchOffsets.end() && *R < End;
+    auto R = UncondBranchAddrSet.lower_bound(Start);
+    return R != UncondBranchAddrSet.end() && *R < End;
   }
 
   uint64_t getAddressforIndex(uint64_t Index) const {
-    return offsetToVirtualAddr(CodeAddrOffsets[Index]);
+    return CodeAddressVec[Index];
   }
 
-  size_t getCodeOffsetsSize() const { return CodeAddrOffsets.size(); }
+  size_t getCodeAddrVecSize() const { return CodeAddressVec.size(); }
 
   bool usePseudoProbes() const { return UsePseudoProbes; }
   bool useFSDiscriminator() const { return UseFSDiscriminator; }
-  // Get the index in CodeAddrOffsets for the address
+  // Get the index in CodeAddressVec for the address
   // As we might get an address which is not the code
   // here it would round to the next valid code address by
   // using lower bound operation
-  uint32_t getIndexForOffset(uint64_t Offset) const {
-    auto Low = llvm::lower_bound(CodeAddrOffsets, Offset);
-    return Low - CodeAddrOffsets.begin();
-  }
   uint32_t getIndexForAddr(uint64_t Address) const {
-    uint64_t Offset = virtualAddrToOffset(Address);
-    return getIndexForOffset(Offset);
+    auto Low = llvm::lower_bound(CodeAddressVec, Address);
+    return Low - CodeAddressVec.begin();
   }
 
   uint64_t getCallAddrFromFrameAddr(uint64_t FrameAddr) const {
     if (FrameAddr == ExternalAddr)
       return ExternalAddr;
     auto I = getIndexForAddr(FrameAddr);
     FrameAddr = I ? getAddressforIndex(I - 1) : 0;
     if (FrameAddr && addressIsCall(FrameAddr))
       return FrameAddr;
     return 0;
   }
 
-  FuncRange *findFuncRangeForStartOffset(uint64_t Offset) {
-    auto I = StartOffset2FuncRangeMap.find(Offset);
-    if (I == StartOffset2FuncRangeMap.end())
+  FuncRange *findFuncRangeForStartAddr(uint64_t Address) {
+    auto I = StartAddrToFuncRangeMap.find(Address);
+    if (I == StartAddrToFuncRangeMap.end())
       return nullptr;
     return &I->second;
   }
 
-  // Binary search the function range which includes the input offset.
-  FuncRange *findFuncRangeForOffset(uint64_t Offset) {
-    auto I = StartOffset2FuncRangeMap.upper_bound(Offset);
-    if (I == StartOffset2FuncRangeMap.begin())
+  // Binary search the function range which includes the input address.
+  FuncRange *findFuncRange(uint64_t Address) {
+    auto I = StartAddrToFuncRangeMap.upper_bound(Address);
+    if (I == StartAddrToFuncRangeMap.begin())
       return nullptr;
     I--;
 
-    if (Offset >= I->second.EndOffset)
+    if (Address >= I->second.EndAddress)
       return nullptr;
 
     return &I->second;
   }
 
   // Get all ranges of one function.
-  RangesTy getRangesForOffset(uint64_t Offset) {
-    auto *FRange = findFuncRangeForOffset(Offset);
+  RangesTy getRanges(uint64_t Address) {
+    auto *FRange = findFuncRange(Address);
     // Ignore the range which falls into plt section or system lib.
     if (!FRange)
       return RangesTy();
 
     return FRange->Func->Ranges;
   }
 
   const std::unordered_map<std::string, BinaryFunction> &
public:
   uint32_t getFuncSizeForContext(const ContextTrieNode *ContextNode) {
     return FuncSizeTracker.getFuncSizeForContext(ContextNode);
   }
 
   // Load the symbols from debug table and populate into symbol list.
   void populateSymbolListFromDWARF(ProfileSymbolList &SymbolList);
 
   const SampleContextFrameVector &
-  getFrameLocationStack(uint64_t Offset, bool UseProbeDiscriminator = false) {
-    auto I = Offset2LocStackMap.emplace(Offset, SampleContextFrameVector());
+  getFrameLocationStack(uint64_t Address, bool UseProbeDiscriminator = false) {
+    auto I = AddressToLocStackMap.emplace(Address, SampleContextFrameVector());
     if (I.second) {
-      InstructionPointer IP(this, Offset);
+      InstructionPointer IP(this, Address);
       I.first->second = symbolize(IP, true, UseProbeDiscriminator);
     }
     return I.first->second;
   }
 
-  Optional<SampleContextFrame> getInlineLeafFrameLoc(uint64_t Offset) {
-    const auto &Stack = getFrameLocationStack(Offset);
+  Optional<SampleContextFrame> getInlineLeafFrameLoc(uint64_t Address) {
+    const auto &Stack = getFrameLocationStack(Address);
     if (Stack.empty())
       return {};
     return Stack.back();
   }
 
   void flushSymbolizer() { Symbolizer.reset(); }
 
   // Compare two addresses' inline context
   bool inlineContextEqual(uint64_t Add1, uint64_t Add2);
 
   // Get the full context of the current stack with inline context filled in.
-  // It will search the disassembling info stored in Offset2LocStackMap. This is
-  // used as the key of function sample map
+  // It will search the disassembling info stored in AddressToLocStackMap. This
+  // is used as the key of function sample map
   SampleContextFrameVector
   getExpandedContext(const SmallVectorImpl<uint64_t> &Stack,
                      bool &WasLeafInlined);
   // Go through instructions among the given range and record its size for the
   // inline context.
-  void computeInlinedContextSizeForRange(uint64_t StartOffset,
-                                         uint64_t EndOffset);
+  void computeInlinedContextSizeForRange(uint64_t StartAddress,
+                                         uint64_t EndAddress);
 
   void computeInlinedContextSizeForFunc(const BinaryFunction *Func);
 
   const MCDecodedPseudoProbe *getCallProbeForAddr(uint64_t Address) const {
     return ProbeDecoder.getCallProbeForAddr(Address);
   }
 
   void getInlineContextForProbe(const MCDecodedPseudoProbe *Probe,

llvm/tools/llvm-profgen/ProfiledBinary.cpp

 
 void ProfiledBinary::warnNoFuncEntry() {
   uint64_t NoFuncEntryNum = 0;
   for (auto &F : BinaryFunctions) {
     if (F.second.Ranges.empty())
       continue;
     bool hasFuncEntry = false;
     for (auto &R : F.second.Ranges) {
-      if (FuncRange *FR = findFuncRangeForStartOffset(R.first)) {
+      if (FuncRange *FR = findFuncRangeForStartAddr(R.first)) {
         if (FR->IsFuncEntry) {
           hasFuncEntry = true;
           break;
         }
       }
     }
 
     if (!hasFuncEntry) {
void ProfiledBinary::load() {
   } else {
     loadSymbolsFromDWARF(*cast<ObjectFile>(&ExeBinary));
   }
 
   // Disassemble the text sections.
   disassemble(Obj);
 
   // Use function start and return address to infer prolog and epilog
-  ProEpilogTracker.inferPrologOffsets(StartOffset2FuncRangeMap);
-  ProEpilogTracker.inferEpilogOffsets(RetOffsets);
+  ProEpilogTracker.inferPrologAddresses(StartAddrToFuncRangeMap);
+  ProEpilogTracker.inferEpilogAddresses(RetAddressSet);
 
   warnNoFuncEntry();
 
   // TODO: decode other sections.
 }
 
 bool ProfiledBinary::inlineContextEqual(uint64_t Address1, uint64_t Address2) {
-  uint64_t Offset1 = virtualAddrToOffset(Address1);
-  uint64_t Offset2 = virtualAddrToOffset(Address2);
-  const SampleContextFrameVector &Context1 = getFrameLocationStack(Offset1);
-  const SampleContextFrameVector &Context2 = getFrameLocationStack(Offset2);
+  const SampleContextFrameVector &Context1 = getFrameLocationStack(Address1);
+  const SampleContextFrameVector &Context2 = getFrameLocationStack(Address2);
   if (Context1.size() != Context2.size())
     return false;
   if (Context1.empty())
     return false;
   // The leaf frame contains location within the leaf, and it
   // needs to be remove that as it's not part of the calling context
   return std::equal(Context1.begin(), Context1.begin() + Context1.size() - 1,
                     Context2.begin(), Context2.begin() + Context2.size() - 1);
 }
 
 SampleContextFrameVector
 ProfiledBinary::getExpandedContext(const SmallVectorImpl<uint64_t> &Stack,
                                    bool &WasLeafInlined) {
   SampleContextFrameVector ContextVec;
   if (Stack.empty())
     return ContextVec;
   // Process from frame root to leaf
   for (auto Address : Stack) {
-    uint64_t Offset = virtualAddrToOffset(Address);
     const SampleContextFrameVector &ExpandedContext =
-        getFrameLocationStack(Offset);
+        getFrameLocationStack(Address);
     // An instruction without a valid debug line will be ignored by sample
     // processing
     if (ExpandedContext.empty())
       return SampleContextFrameVector();
     // Set WasLeafInlined to the size of inlined frame count for the last
     // address which is leaf
     WasLeafInlined = (ExpandedContext.size() > 1);
     ContextVec.append(ExpandedContext);

 
 void ProfiledBinary::decodePseudoProbe() {
   OwningBinary<Binary> OBinary = unwrapOrError(createBinary(Path), Path);
   Binary &ExeBinary = *OBinary.getBinary();
   auto *Obj = dyn_cast<ELFObjectFileBase>(&ExeBinary);
   decodePseudoProbe(Obj);
 }
 
-void ProfiledBinary::setIsFuncEntry(uint64_t Offset, StringRef RangeSymName) {
-  // Note that the start offset of each ELF section can be a non-function
+void ProfiledBinary::setIsFuncEntry(uint64_t Address, StringRef RangeSymName) {
+  // Note that the start address of each ELF section can be a non-function
   // symbol, we need to binary search for the start of a real function range.
-  auto *FuncRange = findFuncRangeForOffset(Offset);
+  auto *FuncRange = findFuncRange(Address);
   // Skip external function symbol.
   if (!FuncRange)
     return;
 
   // Set IsFuncEntry to ture if there is only one range in the function or the
   // RangeSymName from ELF is equal to its DWARF-based function name.
   if (FuncRange->Func->Ranges.size() == 1 ||
       (!FuncRange->IsFuncEntry && FuncRange->getFuncName() == RangeSymName))
     FuncRange->IsFuncEntry = 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 SectionAddress = Section.getAddress();
   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;
-  setIsFuncEntry(StartOffset,
+  uint64_t StartAddress = Symbols[SI].Addr;
+  uint64_t NextStartAddress =
+      (SI + 1 < SE) ? Symbols[SI + 1].Addr : SectionAddress + SectSize;
+  setIsFuncEntry(StartAddress,
                  FunctionSamples::getCanonicalFnName(Symbols[SI].Name));
 
   StringRef SymbolName =
       ShowCanonicalFnName
           ? FunctionSamples::getCanonicalFnName(Symbols[SI].Name)
           : Symbols[SI].Name;
   bool ShowDisassembly =
       ShowDisassemblyOnly && (DisassembleFunctionSet.empty() ||
                               DisassembleFunctionSet.count(SymbolName));
   if (ShowDisassembly)
     outs() << '<' << SymbolName << ">:\n";
 
   auto WarnInvalidInsts = [](uint64_t Start, uint64_t End) {
     WithColor::warning() << "Invalid instructions at "
                          << format("%8" PRIx64, Start) << " - "
                          << format("%8" PRIx64, End) << "\n";
   };
 
-  uint64_t Offset = StartOffset;
-  // Size of a consecutive invalid instruction range starting from Offset -1
+  uint64_t Address = StartAddress;
+  // Size of a consecutive invalid instruction range starting from Address -1
   // backwards.
   uint64_t InvalidInstLength = 0;
-  while (Offset < NextStartOffset) {
+  while (Address < NextStartAddress) {
     MCInst Inst;
     uint64_t Size;
     // Disassemble an instruction.
-    bool Disassembled =
-        DisAsm->getInstruction(Inst, Size, Bytes.slice(Offset - SectionOffset),
-                               Offset + getPreferredBaseAddress(), nulls());
+    bool Disassembled = DisAsm->getInstruction(
+        Inst, Size, Bytes.slice(Address - SectionAddress), Address, nulls());
     if (Size == 0)
       Size = 1;
 
     if (ShowDisassembly) {
       if (ShowPseudoProbe) {
-        ProbeDecoder.printProbeForAddress(outs(),
-                                          Offset + getPreferredBaseAddress());
+        ProbeDecoder.printProbeForAddress(outs(), Address);
       }
-      outs() << format("%8" PRIx64 ":", Offset + getPreferredBaseAddress());
+      outs() << format("%8" PRIx64 ":", Address);
       size_t Start = outs().tell();
       if (Disassembled)
-        IPrinter->printInst(&Inst, Offset + Size, "", *STI.get(), outs());
+        IPrinter->printInst(&Inst, Address + Size, "", *STI.get(), outs());
       else
         outs() << "\t<unknown>";
       if (ShowSourceLocations) {
         unsigned Cur = outs().tell() - Start;
         if (Cur < 40)
           outs().indent(40 - Cur);
-        InstructionPointer IP(this, Offset);
+        InstructionPointer IP(this, Address);
         outs() << getReversedLocWithContext(
             symbolize(IP, ShowCanonicalFnName, ShowPseudoProbe));
       }
       outs() << "\n";
     }
 
     if (Disassembled) {
       const MCInstrDesc &MCDesc = MII->get(Inst.getOpcode());
 
       // Record instruction size.
-      Offset2InstSizeMap[Offset] = Size;
+      AddressToInstSizeMap[Address] = Size;
 
       // Populate address maps.
-      CodeAddrOffsets.push_back(Offset);
+      CodeAddressVec.push_back(Address);
       if (MCDesc.isCall()) {
-        CallOffsets.insert(Offset);
-        UncondBranchOffsets.insert(Offset);
+        CallAddressSet.insert(Address);
+        UncondBranchAddrSet.insert(Address);
       } else if (MCDesc.isReturn()) {
-        RetOffsets.insert(Offset);
-        UncondBranchOffsets.insert(Offset);
+        RetAddressSet.insert(Address);
+        UncondBranchAddrSet.insert(Address);
       } else if (MCDesc.isBranch()) {
         if (MCDesc.isUnconditionalBranch())
-          UncondBranchOffsets.insert(Offset);
-        BranchOffsets.insert(Offset);
+          UncondBranchAddrSet.insert(Address);
+        BranchAddressSet.insert(Address);
       }
 
       if (InvalidInstLength) {
-        WarnInvalidInsts(Offset - InvalidInstLength, Offset - 1);
+        WarnInvalidInsts(Address - InvalidInstLength, Address - 1);
         InvalidInstLength = 0;
       }
     } else {
       InvalidInstLength += Size;
     }
 
-    Offset += Size;
+    Address += Size;
   }
 
   if (InvalidInstLength)
-    WarnInvalidInsts(Offset - InvalidInstLength, Offset - 1);
+    WarnInvalidInsts(Address - InvalidInstLength, Address - 1);
 
   if (ShowDisassembly)
     outs() << "\n";
 
   return true;
 }
 
 void ProfiledBinary::setUpDisassembler(const ELFObjectFileBase *Obj) {
void ProfiledBinary::disassemble(const ELFObjectFileBase *Obj) {
   // Dissassemble a text section.
   for (section_iterator SI = Obj->section_begin(), SE = Obj->section_end();
        SI != SE; ++SI) {
     const SectionRef &Section = *SI;
     if (!Section.isText())
       continue;
 
     uint64_t ImageLoadAddr = getPreferredBaseAddress();
-    uint64_t SectionOffset = Section.getAddress() - ImageLoadAddr;
+    uint64_t SectionAddress = Section.getAddress() - ImageLoadAddr;
     uint64_t SectSize = Section.getSize();
     if (!SectSize)
       continue;
 
     // Register the text section.
-    TextSections.insert({SectionOffset, SectSize});
+    TextSections.insert({SectionAddress, SectSize});
 
     StringRef SectionName = unwrapOrError(Section.getName(), FileName);
 
     if (ShowDisassemblyOnly) {
       outs() << "\nDisassembly of section " << SectionName;
       outs() << " [" << format("0x%" PRIx64, Section.getAddress()) << ", "
              << format("0x%" PRIx64, Section.getAddress() + SectSize)
              << "]:\n\n";
for (const auto &DieInfo : CompilationUnit.dies()) {
     // Different DWARF symbols can have same function name, search or create
     // BinaryFunction indexed by the name.
     auto Ret = BinaryFunctions.emplace(Name, BinaryFunction());
     auto &Func = Ret.first->second;
     if (Ret.second)
       Func.FuncName = Ret.first->first;
 
     for (const auto &Range : Ranges) {
-      uint64_t FuncStart = Range.LowPC;
-      uint64_t FuncSize = Range.HighPC - FuncStart;
+      uint64_t StartAddress = Range.LowPC;
+      uint64_t EndAddress = Range.HighPC;
 
-      if (FuncSize == 0 || FuncStart < getPreferredBaseAddress())
+      if (EndAddress <= StartAddress ||
+          StartAddress < getPreferredBaseAddress())
         continue;
 
-      uint64_t StartOffset = FuncStart - getPreferredBaseAddress();
-      uint64_t EndOffset = Range.HighPC - getPreferredBaseAddress();
-
       // We may want to know all ranges for one function. Here group the
       // ranges and store them into BinaryFunction.
-      Func.Ranges.emplace_back(StartOffset, EndOffset);
+      Func.Ranges.emplace_back(StartAddress, EndAddress);
 
-      auto R = StartOffset2FuncRangeMap.emplace(StartOffset, FuncRange());
+      auto R = StartAddrToFuncRangeMap.emplace(StartAddress, FuncRange());
       if (R.second) {
         FuncRange &FRange = R.first->second;
         FRange.Func = &Func;
-        FRange.StartOffset = StartOffset;
-        FRange.EndOffset = EndOffset;
+        FRange.StartAddress = StartAddress;
+        FRange.EndAddress = EndAddress;
       } else {
         WithColor::warning()
             << "Duplicated symbol start address at "
-            << format("%8" PRIx64, StartOffset + getPreferredBaseAddress())
-            << " " << R.first->second.getFuncName() << " and " << Name << "\n";
+            << format("%8" PRIx64, StartAddress) << " "
+            << R.first->second.getFuncName() << " and " << Name << "\n";
       }
     }
   }
 }
 
 void ProfiledBinary::loadSymbolsFromDWARF(ObjectFile &Obj) {
   auto DebugContext = llvm::DWARFContext::create(
       Obj, DWARFContext::ProcessDebugRelocations::Process, nullptr, DWPPath);
void ProfiledBinary::loadSymbolsFromDWARF(ObjectFile &Obj) {
 
   if (BinaryFunctions.empty())
     WithColor::warning() << "Loading of DWARF info completed, but no binary "
                             "functions have been retrieved.\n";
 }
 
 void ProfiledBinary::populateSymbolListFromDWARF(
     ProfileSymbolList &SymbolList) {
-  for (auto &I : StartOffset2FuncRangeMap)
+  for (auto &I : StartAddrToFuncRangeMap)
     SymbolList.add(I.second.getFuncName());
 }
 
 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;
   SymbolizerOpts.DWPName = DWPPath;
   Symbolizer = std::make_unique<symbolize::LLVMSymbolizer>(SymbolizerOpts);
 }
 
 SampleContextFrameVector ProfiledBinary::symbolize(const InstructionPointer &IP,
                                                    bool UseCanonicalFnName,
                                                    bool UseProbeDiscriminator) {
   assert(this == IP.Binary &&
          "Binary should only symbolize its own instruction");
-  auto Addr = object::SectionedAddress{IP.Offset + getPreferredBaseAddress(),
+  auto Addr = object::SectionedAddress{IP.Address,
                                        object::SectionedAddress::UndefSection};
   DIInliningInfo InlineStack = unwrapOrError(
       Symbolizer->symbolizeInlinedCode(SymbolizerPath.str(), Addr),
       SymbolizerPath);
 
   SampleContextFrameVector CallStack;
   for (int32_t I = InlineStack.getNumberOfFrames() - 1; I >= 0; I--) {
     const auto &CallerFrame = InlineStack.getFrame(I);
for (int32_t I = InlineStack.getNumberOfFrames() - 1; I >= 0; I--) {
     LineLocation Line(LineOffset, Discriminator);
     auto It = NameStrings.insert(FunctionName.str());
     CallStack.emplace_back(*It.first, Line);
   }
 
   return CallStack;
 }
 
-void ProfiledBinary::computeInlinedContextSizeForRange(uint64_t StartOffset,
-                                                       uint64_t EndOffset) {
-  uint64_t RangeBegin = offsetToVirtualAddr(StartOffset);
-  uint64_t RangeEnd = offsetToVirtualAddr(EndOffset);
+void ProfiledBinary::computeInlinedContextSizeForRange(uint64_t RangeBegin,
+                                                       uint64_t RangeEnd) {
   InstructionPointer IP(this, RangeBegin, true);
 
   if (IP.Address != RangeBegin)
     WithColor::warning() << "Invalid start instruction at "
                          << format("%8" PRIx64, RangeBegin) << "\n";
 
   if (IP.Address >= RangeEnd)
     return;
 
   do {
-    uint64_t Offset = virtualAddrToOffset(IP.Address);
     const SampleContextFrameVector &SymbolizedCallStack =
-        getFrameLocationStack(Offset, UsePseudoProbes);
-    uint64_t Size = Offset2InstSizeMap[Offset];
+        getFrameLocationStack(IP.Address, UsePseudoProbes);
+    uint64_t Size = AddressToInstSizeMap[IP.Address];
 
     // Record instruction size for the corresponding context
     FuncSizeTracker.addInstructionForContext(SymbolizedCallStack, Size);
 
   } while (IP.advance() && IP.Address < RangeEnd);
 }
 
 void ProfiledBinary::computeInlinedContextSizeForFunc(

 
 InstructionPointer::InstructionPointer(const ProfiledBinary *Binary,
                                        uint64_t Address, bool RoundToNext)
     : Binary(Binary), Address(Address) {
   Index = Binary->getIndexForAddr(Address);
   if (RoundToNext) {
     // we might get address which is not the code
     // it should round to the next valid address
-    if (Index >= Binary->getCodeOffsetsSize())
+    if (Index >= Binary->getCodeAddrVecSize())
       this->Address = UINT64_MAX;
     else
       this->Address = Binary->getAddressforIndex(Index);
   }
 }
 
 bool InstructionPointer::advance() {
   Index++;
-  if (Index >= Binary->getCodeOffsetsSize()) {
+  if (Index >= Binary->getCodeAddrVecSize()) {
     Address = UINT64_MAX;
     return false;
   }
   Address = Binary->getAddressforIndex(Index);
   return true;
 }
 
 bool InstructionPointer::backward() {