Add a "--load-address <addr>" option to llvm-gsymutil.

[clayborg]

Summary

This option allows clients to set the load address for a GSYM file which will override the BaseAddress in the GSYM header. GSYM files are easily relocatable by modifying just the base address. This allows GSYM to be used for symbolication much easier by allowing clients to specify the load address of the binary and then do lookups using PC values from a live process.

This option can be used when dumping a full GSYM file, or can also be used when doing lookups via the "--address <addr>" option, or "--addresses-from-stdin" option.

[clayborg]

The basic flow from the command line is similar to atos:

$ llvm-gsymutil --load-address=0x800000 --address=0x800391 /path/to/a.gsym

[jhenderson]

I don't know anything about GSYM or llvm-gsymutil really, but this sounds a lot like llvm-symbolizer's --adjust-vma option, but rather than being an offset, it sets the address outright. I guess it doesn't really make sense to follow llvm-symbolizer's option name and behaviour instead of this?

As an aside, I note that llvm-gsymutil doesn't appear to have any CommandGuide documentation in llvm/docs/CommandGuide. Perhaps worth adding at some point...

llvm/include/llvm/DebugInfo/GSYM/GsymReader.h

57

Is the term not "symbolizing" rather than "symbolicating" or is that something else?

232

Ditto.

llvm/test/tools/llvm-gsymutil/X86/elf-dwarf.yaml

6

Nit.

Also, these lines are getting very long. Perhaps it would be worth splitting them up e.g.

# RUN: echo -e ... | \
# RUN:   llvm-gsymutil ... |
# RUN:   FileCheck ...

llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp

537

Has been what? Looks like the comment is incomplete to me.

[clayborg]

• Changed "symbolicating" to "symbolizing" in comments.
• Changed default value of LoadAddress to be UINT64_MAX to allow clients to be able to specify zero as a load address, and UINT64_MAX would never be a valid load addrss for a binary. Modified a test to test this feature as well.
• Re-indent the tests ibn elf-dwarf.yaml so the lines are not as long

[clayborg]

In D135984#3861527, @jhenderson wrote:

I don't know anything about GSYM or llvm-gsymutil really, but this sounds a lot like llvm-symbolizer's --adjust-vma option, but rather than being an offset, it sets the address outright. I guess it doesn't really make sense to follow llvm-symbolizer's option name and behaviour instead of this?

It makes more sense to match the "-l" option to atos. Most symbolizing happens on crash logs that either contain load addresses of each shared library and unadjusted PC values, or they contain offsets. I modified the "--load-address" option to be able to have zero set as the value. This allows offsets to be symbolized if "--load-address=0" is set.

As an aside, I note that llvm-gsymutil doesn't appear to have any CommandGuide documentation in llvm/docs/CommandGuide. Perhaps worth adding at some point...

Definitely! I will submit a follow on patch.

[jhenderson]

You probably should get someone with more knowledge of GSYM/llvm-gsymutil to review the rest of this patch. I've got only one other minor comment.

llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp

123

It's probably fine doing this for the "not specified" value, but I'm not a massive fan of it. Is there a cl::opt method that tells you whether an option has actually been specified or not? (If there isn't, or it's not particularly clean, then this is fine)

llvm/include/llvm/DebugInfo/GSYM/GsymReader.h

class GsymReader {
   std::unique_ptr<MemoryBuffer> MemBuffer;
   StringRef GsymBytes;
   llvm::support::endianness Endian;
   const Header *Hdr = nullptr;
   ArrayRef<uint8_t> AddrOffsets;
   ArrayRef<uint32_t> AddrInfoOffsets;
   ArrayRef<FileEntry> Files;
   StringTable StrTab;
+  // Users can change the base address of a GSYM file manually when
+  // symbolizing which allows clients to do lookups using addresses from a
+  // process that loaded the object file at a different base address.
+  Optional<uint64_t> BaseAddressOverride;
   /// When the GSYM file's endianness doesn't match the host system then
   /// we must decode all data structures that need to be swapped into
   /// local storage and set point the ArrayRef objects above to these swapped
   /// copies.
   struct SwappedData {
     Header Hdr;
     std::vector<uint8_t> AddrOffsets;
     std::vector<uint32_t> AddrInfoOffsets;
public:
 
   /// Get the number of addresses in this Gsym file.
   uint32_t getNumAddresses() const {
     return Hdr->NumAddresses;
   }
 
   /// Gets an address from the address table.
   ///
-  /// Addresses are stored as offsets frrom the gsym::Header::BaseAddress.
+  /// Addresses are stored as offsets from the GSYM base address.
   ///
   /// \param Index A index into the address table.
   /// \returns A resolved virtual address for adddress in the address table
   /// or llvm::None if Index is out of bounds.
   Optional<uint64_t> getAddress(size_t Index) const;
 
+  /// Gets the base address of this GSYM file.
+  ///
+  /// The base address is built into the GSYM file's header, but the user might
+  /// want to override the default base address. Fetch the appropriate base
+  /// address for this GSYM file.
+  ///
+  /// \returns The base address of the GSYM file, which will be from the GSYM
+  /// header unless the user has manually set the base address.
+  uint64_t getBaseAddress() const {
+    if (BaseAddressOverride)
+      return *BaseAddressOverride;
+    else
+      return Hdr->BaseAddress;
+  }
+
+  /// Sets the base address of this GSYM file.
+  ///
+  /// All addresses in a GSYM file are based off of the base address from the
+  /// GSYM header. When symbolizing addresses, the object file is often loaded
+  /// at a load address that doesn't match the base address in the header. If we
+  /// set the base address, we can relocate all symbols in the GSYM file and
+  /// then do lookups with load addresses from a process.
+  ///
+  /// \param Addr The base address of the GSYM file.
+  void setBaseAddress(uint64_t Addr) { BaseAddressOverride = Addr; }
+
 protected:
 
   /// Get an appropriate address info offsets array.
   ///
   /// The address table in the GSYM file is stored as array of 1, 2, 4 or 8
-  /// byte offsets from the The gsym::Header::BaseAddress. The table is stored
+  /// byte offsets from the The GSYM base address. The table is stored
   /// internally as a array of bytes that are in the correct endianness. When
   /// we access this table we must get an array that matches those sizes. This
   /// templatized helper function is used when accessing address offsets in the
   /// AddrOffsets member variable.
   ///
   /// \returns An ArrayRef of an appropriate address offset size.
   template <class T> ArrayRef<T>
   getAddrOffsets() const {
     return ArrayRef<T>(reinterpret_cast<const T *>(AddrOffsets.data()),
                        AddrOffsets.size()/sizeof(T));
   }
 
   /// Get an appropriate address from the address table.
   ///
   /// The address table in the GSYM file is stored as array of 1, 2, 4 or 8
-  /// byte address offsets from the The gsym::Header::BaseAddress. The table is
+  /// byte address offsets from the The GSYM base address. The table is
   /// stored internally as a array of bytes that are in the correct endianness.
   /// In order to extract an address from the address table we must access the
   /// address offset using the correct size and then add it to the BaseAddress
   /// in the header.
   ///
   /// \param Index An index into the AddrOffsets array.
   /// \returns An virtual address that matches the original object file for the
   /// address as the specified index, or llvm::None if Index is out of bounds.
   template <class T> Optional<uint64_t>
   addressForIndex(size_t Index) const {
     ArrayRef<T> AIO = getAddrOffsets<T>();
     if (Index < AIO.size())
-      return AIO[Index] + Hdr->BaseAddress;
+      return AIO[Index] + getBaseAddress();
     return llvm::None;
   }
   /// Lookup an address offset in the AddrOffsets table.
   ///
   /// Given an address offset, look it up using a binary search of the
   /// AddrOffsets table.
   ///
   /// \param AddrOffset An address offset, that has already been computed by
-  /// subtracting the gsym::Header::BaseAddress.
+  /// subtracting the GSYM base address.
   /// \returns The matching address offset index. This index will be used to
   /// extract the FunctionInfo data's offset from the AddrInfoOffsets array.
   template <class T>
   llvm::Optional<uint64_t> getAddressOffsetIndex(const uint64_t AddrOffset) const {
     ArrayRef<T> AIO = getAddrOffsets<T>();
     const auto Begin = AIO.begin();
     const auto End = AIO.end();
     auto Iter = std::lower_bound(Begin, End, AddrOffset);
-    // Watch for addresses that fall between the gsym::Header::BaseAddress and
+    // Watch for addresses that fall between the GSYM base address and
     // the first address offset.
     if (Iter == Begin && AddrOffset < *Begin)
       return llvm::None;
     if (Iter == End || AddrOffset < *Iter)
       --Iter;
     return std::distance(Begin, Iter);
   }
 

llvm/lib/DebugInfo/GSYM/GsymReader.cpp

Optional<uint64_t> GsymReader::getAddressInfoOffset(size_t Index) const {
   const auto NumAddrInfoOffsets = AddrInfoOffsets.size();
   if (Index < NumAddrInfoOffsets)
     return AddrInfoOffsets[Index];
   return llvm::None;
 }
 
 Expected<uint64_t>
 GsymReader::getAddressIndex(const uint64_t Addr) const {
-  if (Addr >= Hdr->BaseAddress) {
-    const uint64_t AddrOffset = Addr - Hdr->BaseAddress;
+  const uint64_t BaseAddress = getBaseAddress();
+  if (Addr >= BaseAddress) {
+    const uint64_t AddrOffset = Addr - BaseAddress;
     Optional<uint64_t> AddrOffsetIndex;
     switch (Hdr->AddrOffSize) {
     case 1:
       AddrOffsetIndex = getAddressOffsetIndex<uint8_t>(AddrOffset);
       break;
     case 2:
       AddrOffsetIndex = getAddressOffsetIndex<uint16_t>(AddrOffset);
       break;

llvm/test/tools/llvm-gsymutil/X86/elf-dwarf.yaml

 ## Test loading an ELF file with DWARF. First we make the ELF file from yaml,
 ## then we convert the ELF file to GSYM, then we do lookups on the newly
 ## created GSYM, and finally we dump the entire GSYM.
 
 # RUN: yaml2obj %s -o %t
-# RUN: llvm-gsymutil --convert %t -o %t.gsym 2>&1 | FileCheck %s --check-prefix=CONVERT
-# RUN: llvm-gsymutil --address=0x400391 --address=0x4004cd %t.gsym 2>&1 | FileCheck %s --check-prefix=ADDR
-# RUN: echo -e "0x400391 %/t.gsym\n0x4004cd %/t.gsym" | llvm-gsymutil --addresses-from-stdin  2>&1 | FileCheck %s --check-prefix=ADDRI --dump-input=always
-# RUN: llvm-gsymutil --address=0x400391 --address=0x4004cd --verbose %t.gsym 2>&1 | FileCheck %s --check-prefix=ADDRV --dump-input=always
-# RUN: llvm-gsymutil --address=0x400391 --address=0x4004cd --verbose %t.gsym 2>&1 | FileCheck %s --check-prefix=ADDRV --dump-input=always
+# RUN: llvm-gsymutil --convert %t -o %t.gsym 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONVERT
+# RUN: llvm-gsymutil --address=0x400391 --address=0x4004cd %t.gsym 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ADDR
+# RUN: llvm-gsymutil --address=0x800391 --address=0x8004cd --load-address=0x800000 %t.gsym 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ADDR_BASE
+# RUN: echo -e "0x400391 %/t.gsym\n0x4004cd %/t.gsym" | \
+# RUN:   llvm-gsymutil --addresses-from-stdin  2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ADDRI --dump-input=always
+# RUN: echo -e "0x800391 %/t.gsym\n0x8004cd %/t.gsym" | \
+# RUN:   llvm-gsymutil --load-address=0x800000 --addresses-from-stdin  2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ADDRI_BASE --dump-input=always
+# RUN: llvm-gsymutil --address=0x400391 --address=0x4004cd --verbose %t.gsym 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ADDRV --dump-input=always
+# RUN: llvm-gsymutil --address=0x800391 --address=0x8004cd --load-address=0x800000 --verbose %t.gsym 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ADDRV_BASE --dump-input=always
 # RUN: llvm-gsymutil %t.gsym 2>&1 | FileCheck %s --check-prefix=DUMP
+# RUN: llvm-gsymutil --load-address=0 %t.gsym 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=DUMP_BASE
 
 # ADDR: Looking up addresses in "{{.*\.yaml\.tmp\.gsym}}":
 # ADDR: 0x0000000000400391: _init
 # ADDR: 0x00000000004004cd: main @ /tmp/main.cpp:1
 
+# ADDR_BASE: Looking up addresses in "{{.*\.yaml\.tmp\.gsym}}":
+# ADDR_BASE: 0x0000000000800391: _init
+# ADDR_BASE: 0x00000000008004cd: main @ /tmp/main.cpp:1
+
 # ADDRI: 0x0000000000400391: _init
 # ADDRI-EMPTY:
 # ADDRI: 0x00000000004004cd: main @ /tmp/main.cpp:1
 # ADDRI-EMPTY:
 
+# ADDRI_BASE: 0x0000000000800391: _init
+# ADDRI_BASE-EMPTY:
+# ADDRI_BASE: 0x00000000008004cd: main @ /tmp/main.cpp:1
+# ADDRI_BASE-EMPTY:
+
 # ADDRV: Looking up addresses in "{{.*\.yaml\.tmp\.gsym}}":
 # ADDRV: FunctionInfo for 0x0000000000400391:
 # ADDRV: [0x0000000000400390 - 0x0000000000400390) "_init"
 # ADDRV: LookupResult for 0x0000000000400391:
 # ADDRV: 0x0000000000400391: _init
 # ADDRV: FunctionInfo for 0x00000000004004cd:
 # ADDRV: [0x00000000004004cd - 0x00000000004004df) "main"
 # ADDRV: LineTable:
 # ADDRV:   0x00000000004004cd /tmp/main.cpp:1
 # ADDRV:   0x00000000004004d8 /tmp/main.cpp:2
 # ADDRV:   0x00000000004004dd /tmp/main.cpp:3
 # ADDRV: LookupResult for 0x00000000004004cd:
 # ADDRV: 0x00000000004004cd: main @ /tmp/main.cpp:1
 
+# ADDRV_BASE: Looking up addresses in "{{.*\.yaml\.tmp\.gsym}}":
+# ADDRV_BASE: FunctionInfo for 0x0000000000800391:
+# ADDRV_BASE: [0x0000000000800390 - 0x0000000000800390) "_init"
+# ADDRV_BASE: LookupResult for 0x0000000000800391:
+# ADDRV_BASE: 0x0000000000800391: _init
+# ADDRV_BASE: FunctionInfo for 0x00000000008004cd:
+# ADDRV_BASE: [0x00000000008004cd - 0x00000000008004df) "main"
+# ADDRV_BASE: LineTable:
+# ADDRV_BASE:   0x00000000008004cd /tmp/main.cpp:1
+# ADDRV_BASE:   0x00000000008004d8 /tmp/main.cpp:2
+# ADDRV_BASE:   0x00000000008004dd /tmp/main.cpp:3
+# ADDRV_BASE: LookupResult for 0x00000000008004cd:
+# ADDRV_BASE: 0x00000000008004cd: main @ /tmp/main.cpp:1
+
 # CONVERT: Input file: {{.*\.yaml\.tmp}}
 # CONVERT: Output file (x86_64): {{.*\.yaml\.tmp\.gsym}}
 # CONVERT: Loaded 1 functions from DWARF.
 # CONVERT: Loaded 9 functions from symbol table.
 # CONVERT: Pruned 0 functions, ended with 10 total
 
 # DUMP:      Header:
 # DUMP-NEXT:   Magic        = 0x4753594d

 # DUMP:      FunctionInfo @ 0x00000174: [0x00000000004004cd - 0x00000000004004df) "main"
 # DUMP-NEXT: LineTable:
 # DUMP-NEXT:   0x00000000004004cd /tmp/main.cpp:1
 # DUMP-NEXT:   0x00000000004004d8 /tmp/main.cpp:2
 # DUMP-NEXT:   0x00000000004004dd /tmp/main.cpp:3
 # DUMP:      FunctionInfo @ 0x00000194: [0x00000000004004e0 - 0x0000000000400545) "__libc_csu_init"
 # DUMP:      FunctionInfo @ 0x000001a4: [0x0000000000400550 - 0x0000000000400552) "__libc_csu_fini"
 # DUMP:      FunctionInfo @ 0x000001b4: [0x0000000000400554 - 0x000000000040055d) "_fini"
+
+# DUMP_BASE:      Header:
+# DUMP_BASE-NEXT:   Magic        = 0x4753594d
+# DUMP_BASE-NEXT:   Version      = 0x0001
+# DUMP_BASE-NEXT:   AddrOffSize  = 0x02
+# DUMP_BASE-NEXT:   UUIDSize     = 0x14
+# DUMP_BASE-NEXT:   BaseAddress  = 0x0000000000400000
+# DUMP_BASE-NEXT:   NumAddresses = 0x0000000a
+# DUMP_BASE-NEXT:   StrtabOffset = 0x00000080
+# DUMP_BASE-NEXT:   StrtabSize   = 0x00000091
+# DUMP_BASE-NEXT:   UUID         = 0e62be89cad89206110ed1375b618656f32ac906
+
+# DUMP_BASE:      Address Table:
+# DUMP_BASE-NEXT: INDEX  OFFSET16 (ADDRESS)
+# DUMP_BASE-NEXT: ====== ===============================
+# DUMP_BASE-NEXT: [   0] 0x0390 (0x0000000000000390)
+# DUMP_BASE-NEXT: [   1] 0x03e0 (0x00000000000003e0)
+# DUMP_BASE-NEXT: [   2] 0x0410 (0x0000000000000410)
+# DUMP_BASE-NEXT: [   3] 0x0440 (0x0000000000000440)
+# DUMP_BASE-NEXT: [   4] 0x0480 (0x0000000000000480)
+# DUMP_BASE-NEXT: [   5] 0x04a0 (0x00000000000004a0)
+# DUMP_BASE-NEXT: [   6] 0x04cd (0x00000000000004cd)
+# DUMP_BASE-NEXT: [   7] 0x04e0 (0x00000000000004e0)
+# DUMP_BASE-NEXT: [   8] 0x0550 (0x0000000000000550)
+# DUMP_BASE-NEXT: [   9] 0x0554 (0x0000000000000554)
+
+# DUMP_BASE:      Address Info Offsets:
+# DUMP_BASE-NEXT: INDEX  Offset
+# DUMP_BASE-NEXT: ====== ==========
+# DUMP_BASE-NEXT: [   0] 0x00000114
+# DUMP_BASE-NEXT: [   1] 0x00000124
+# DUMP_BASE-NEXT: [   2] 0x00000134
+# DUMP_BASE-NEXT: [   3] 0x00000144
+# DUMP_BASE-NEXT: [   4] 0x00000154
+# DUMP_BASE-NEXT: [   5] 0x00000164
+# DUMP_BASE-NEXT: [   6] 0x00000174
+# DUMP_BASE-NEXT: [   7] 0x00000194
+# DUMP_BASE-NEXT: [   8] 0x000001a4
+# DUMP_BASE-NEXT: [   9] 0x000001b4
+
+# DUMP_BASE:      Files:
+# DUMP_BASE-NEXT: INDEX  DIRECTORY  BASENAME   PATH
+# DUMP_BASE-NEXT: ====== ========== ========== ==============================
+# DUMP_BASE-NEXT: [   0] 0x00000000 0x00000000
+# DUMP_BASE-NEXT: [   1] 0x00000006 0x0000000b /tmp/main.cpp
+
+# DUMP_BASE:      String table:
+# DUMP_BASE-NEXT: 0x00000000: ""
+# DUMP_BASE-NEXT: 0x00000001: "main"
+# DUMP_BASE-NEXT: 0x00000006: "/tmp"
+# DUMP_BASE-NEXT: 0x0000000b: "main.cpp"
+# DUMP_BASE-NEXT: 0x00000014: "deregister_tm_clones"
+# DUMP_BASE-NEXT: 0x00000029: "register_tm_clones"
+# DUMP_BASE-NEXT: 0x0000003c: "__do_global_dtors_aux"
+# DUMP_BASE-NEXT: 0x00000052: "frame_dummy"
+# DUMP_BASE-NEXT: 0x0000005e: "__libc_csu_fini"
+# DUMP_BASE-NEXT: 0x0000006e: "_fini"
+# DUMP_BASE-NEXT: 0x00000074: "__libc_csu_init"
+# DUMP_BASE-NEXT: 0x00000084: "_start"
+# DUMP_BASE-NEXT: 0x0000008b: "_init"
+# DUMP_BASE:      FunctionInfo @ 0x00000114: [0x0000000000000390 - 0x0000000000000390) "_init"
+# DUMP_BASE:      FunctionInfo @ 0x00000124: [0x00000000000003e0 - 0x00000000000003e0) "_start"
+# DUMP_BASE:      FunctionInfo @ 0x00000134: [0x0000000000000410 - 0x0000000000000410) "deregister_tm_clones"
+# DUMP_BASE:      FunctionInfo @ 0x00000144: [0x0000000000000440 - 0x0000000000000440) "register_tm_clones"
+# DUMP_BASE:      FunctionInfo @ 0x00000154: [0x0000000000000480 - 0x0000000000000480) "__do_global_dtors_aux"
+# DUMP_BASE:      FunctionInfo @ 0x00000164: [0x00000000000004a0 - 0x00000000000004a0) "frame_dummy"
+# DUMP_BASE:      FunctionInfo @ 0x00000174: [0x00000000000004cd - 0x00000000000004df) "main"
+# DUMP_BASE-NEXT: LineTable:
+# DUMP_BASE-NEXT:   0x00000000000004cd /tmp/main.cpp:1
+# DUMP_BASE-NEXT:   0x00000000000004d8 /tmp/main.cpp:2
+# DUMP_BASE-NEXT:   0x00000000000004dd /tmp/main.cpp:3
+# DUMP_BASE:      FunctionInfo @ 0x00000194: [0x00000000000004e0 - 0x0000000000000545) "__libc_csu_init"
+# DUMP_BASE:      FunctionInfo @ 0x000001a4: [0x0000000000000550 - 0x0000000000000552) "__libc_csu_fini"
+# DUMP_BASE:      FunctionInfo @ 0x000001b4: [0x0000000000000554 - 0x000000000000055d) "_fini"
+
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
   Entry:           0x00000000004003E0
 Sections:

llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp

 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstring>
 #include <inttypes.h>
 #include <iostream>
 #include <map>
+#include <stdint.h>
 #include <string>
 #include <system_error>
 #include <vector>
 
 #include "llvm/DebugInfo/GSYM/DwarfTransformer.h"
 #include "llvm/DebugInfo/GSYM/FunctionInfo.h"
 #include "llvm/DebugInfo/GSYM/GsymCreator.h"
 #include "llvm/DebugInfo/GSYM/GsymReader.h"
static opt<bool>
     Quiet("quiet", desc("Do not output warnings about the debug information"),
           cat(ConversionOptions));
 
 static list<uint64_t> LookupAddresses("address",
                                       desc("Lookup an address in a GSYM file"),
                                       cl::value_desc("addr"),
                                       cat(LookupOptions));
 
+static opt<uint64_t>
+    LoadAddress("load-address",
+                desc("Set the load address of the binary. Any addresses "
+                "displayed in output will be relocated using the new address."),
+                cl::value_desc("l"), cat(GeneralOptions), cl::init(UINT64_MAX));
+
+static alias LoadAddressAlias("l", desc("Alias for --load-address"),
+                              aliasopt(LoadAddress), cl::NotHidden);
+
 static opt<bool> LookupAddressesFromStdin(
     "addresses-from-stdin",
     desc("Lookup addresses in a GSYM file that are read from stdin\nEach input "
          "line is expected to be of the following format: <addr> <gsym-path>"),
     cat(LookupOptions));
 
 } // namespace
 /// @}
while (std::getline(std::cin, InputLine)) {
       std::tie(AddrStr, GSYMPath) =
           llvm::StringRef{StrippedInputLine}.split(' ');
 
       if (GSYMPath != CurrentGSYMPath) {
         CurrentGsym = GsymReader::openFile(GSYMPath);
         if (!*CurrentGsym)
           error(GSYMPath, CurrentGsym->takeError());
         CurrentGSYMPath = GSYMPath;
+        // Set the load address if it has been set as an option.
+        if (LoadAddress != UINT64_MAX)
+          (**CurrentGsym).setBaseAddress(LoadAddress);
       }
 
       uint64_t Addr;
       if (AddrStr.getAsInteger(0, Addr)) {
         OS << "error: invalid address " << AddrStr
            << ", expected: Address GsymFile.\n";
         return 1;
       }
 
       doLookup(**CurrentGsym, Addr, OS);
 
       OS << "\n";
       OS.flush();
     }
 
     return EXIT_SUCCESS;
   }
 
   // Dump or access data inside GSYM files
   for (const auto &GSYMPath : InputFilenames) {
     auto Gsym = GsymReader::openFile(GSYMPath);
     if (!Gsym)
       error(GSYMPath, Gsym.takeError());
 
+    // Set the load address if it has been set as an option.
+    if (LoadAddress != UINT64_MAX)
+      Gsym->setBaseAddress(LoadAddress);
+
     if (LookupAddresses.empty()) {
       Gsym->dump(outs());
       continue;
     }
 
     // Lookup an address in a GSYM file and print any matches.
     OS << "Looking up addresses in \"" << GSYMPath << "\":\n";
     for (auto Addr : LookupAddresses) {
       doLookup(*Gsym, Addr, OS);
     }
   }
   return EXIT_SUCCESS;
 }