[llvm-objdump] - Implement the --adjust-vma option.

[grimar]

Summary

GNU objdump's help says: "--adjust-vma: Add OFFSET to all displayed section addresses"
In real life what it does is a bit more complicated
(and IMO not always reasonable. For example, GNU objdump prints not only VMA, but also LMA
for sections. And with --adjust-vma it adjusts LMA, but only when a section has relocations.
llvm-objsump does not seem to support printing LMAs yet, but GNU's logic anyways does not
make sense for me here).

This patch tries to adjust VMA. I tried to implement a reasonable approach.
I am not adjusting sections that are not allocatable. As, for example, adjusting debug sections
VA's and rel[a] sections VA's should not make sense. This behavior seems to be GNU compatible.

[jhenderson]

I'm a little confused as to what the purpose of this option is? I think it can be used to produce disassembly that can then be grepped when loading at a variable address (e.g. due to ASLR), but am wondering if that's the intent?

I am adjusting sections that are not allocatable. As, for example, adjusting debug sections VA's and rel[a] sections VA's should not make sense.

Do you mean you are NOT adjusting non-alloc sections (i.e. what your patch actually does)?

test/tools/llvm-objdump/X86/adjust-vma.test

33

a -> are

tools/llvm-objdump/llvm-objdump.cpp

74

AdjustVma -> AdjustVMA (since it's an abbreviation)

75

I'd rephrase this as "Increase the displayed address by the specified offset"

878

adjust the non-allocatable -> adjust non-allocatable

880

targets -> file formats

1048–1050

This seems to be done rather early given its use-site. Could it be moved closer?

I'm not a fan of the variable name, as it isn't really a noun. Perhaps VMAAdjustment would be better?

1433

used update -> used, update

[grimar]

In D57051#1367734, @jhenderson wrote:

I'm a little confused as to what the purpose of this option is? I think it can be used to produce disassembly that can then be grepped when loading at a variable address (e.g. due to ASLR), but am wondering if that's the intent?

Yes, I was thinking that it can be used for printing DSO dumps for example when you know their load addresses. My real intention was a bit different though. Recently I compared differences between GNU objdump and llvm-objdump,
and found we do not support this option though it looked potentially useful to me. So I tried to improve compatibility with the GNU objdump command line.

I am adjusting sections that are not allocatable. As, for example, adjusting debug sections VA's and rel[a] sections VA's should not make sense.

Do you mean you are NOT adjusting non-alloc sections (i.e. what your patch actually does)?

Oh, right. I updated the description.

[grimar]

• Addressed review comments.

[jhenderson]

LGTM.

tools/llvm-objdump/llvm-objdump.cpp

1429

Unrelated nit: There are a couple of issues with this comment, namely it uses a stale variable name, and "address" instead of "offset".

[grimar]

tools/llvm-objdump/llvm-objdump.cpp

1429

Fixed in rl352348.

test/tools/llvm-objdump/X86/adjust-vma.test

+# RUN: yaml2obj %s > %t
+# RUN: llvm-objdump --all-headers -D -z %t | FileCheck %s --check-prefixes=COMMON,NOADJUST
+# RUN: llvm-objdump --all-headers -D -z --adjust-vma=0x0 %t | FileCheck %s --check-prefixes=COMMON,NOADJUST
+# RUN: llvm-objdump --all-headers -D -z --adjust-vma=0x123000 %t | FileCheck %s --check-prefixes=COMMON,ADJUST
+
+# NOADJUST:      Disassembly of section .text:
+# NOADJUST-NEXT: 0000000000000000 sym:
+# NOADJUST-NEXT:   0: {{.*}}  nop
+# NOADJUST:      0000000000000001 func:
+# NOADJUST-NEXT:   1: {{.*}}  retq
+
+# ADJUST:        Disassembly of section .text:
+# ADJUST-NEXT:   0000000000123000 sym:
+# ADJUST-NEXT:     123000: {{.*}} nop
+# ADJUST:        0000000000123001 func:
+# ADJUST-NEXT:     123001: {{.*}} retq
+
+# NOADJUST:      Disassembly of section .debug_str:
+# NOADJUST-NEXT: 0000000000000000 .debug_str:
+# NOADJUST-NEXT:   0: {{.*}}  %al, (%rax)
+# NOADJUST-NEXT:      0000000000000001:  R_X86_64_32  .text
+# NOADJUST-NEXT:   2: {{.*}}  addb    %al, (%rax)
+
+# ADJUST:        Disassembly of section .debug_str:
+# ADJUST-NEXT:   0000000000000000 .debug_str:
+# ADJUST-NEXT:     0: {{.*}}  %al, (%rax)
+# ADJUST-NEXT:        0000000000123001:  R_X86_64_32  .text
+# ADJUST-NEXT:     2: {{.*}}  addb    %al, (%rax)
+
+# COMMON:        Disassembly of section .rela.debug_str:
+# COMMON-NEXT:   0000000000000000    .rela.debug_str:
+# COMMON-NEXT:     0: {{.*}}  addl %eax, (%rax)
+## ... There a more lines here. We do not care.
+
+# NOADJUST:      Disassembly of section .data:
+# NOADJUST-NEXT: 0000000000000000  .data:
+# NOADJUST-NEXT:  0: {{.*}} addb    %al, (%rax)
+# NOADJUST-NEXT: 0000000000000000: R_X86_64_32  .text
+# NOADJUST-NEXT:  2: {{.*}} addb    %al, (%rax)
+
+# ADJUST:        Disassembly of section .data:
+# ADJUST-NEXT:   0000000000123000  .data:
+# ADJUST-NEXT:    123000: {{.*}}  addb    %al, (%rax)
+# ADJUST-NEXT:   0000000000123000: R_X86_64_32  .text
+# ADJUST-NEXT:    123002: {{.*}}  addb    %al, (%rax)
+
+# COMMON:        Disassembly of section .rela.data:
+# COMMON-NEXT:   0000000000000000   .rela.data:
+# COMMON-NEXT:    0: {{.*}} addb %al, (%rax)
+## ... There are more lines here. We do not care.
+
+# NOADJUST:      Sections:
+# NOADJUST-NEXT: Idx Name           Size     Address          Type
+# NOADJUST-NEXT:  0                 00000000 0000000000000000
+# NOADJUST-NEXT:  1 .text           00000002 0000000000000000 TEXT
+# NOADJUST-NEXT:  2 .debug_str      00000004 0000000000000000
+# NOADJUST-NEXT:  3 .rela.debug_str 00000018 0000000000000000
+# NOADJUST-NEXT:  4 .data           00000004 0000000000000000 DATA
+# NOADJUST-NEXT:  5 .rela.data      00000018 0000000000000000
+# NOADJUST-NEXT:  6 .symtab         00000060 0000000000000000
+# NOADJUST-NEXT:  7 .strtab         00000010 0000000000000000
+# NOADJUST-NEXT:  8 .shstrtab       0000003c 0000000000000000
+
+# ADJUST:        Sections:
+# ADJUST-NEXT:   Idx Name           Size     Address          Type
+# ADJUST-NEXT:    0                 00000000 0000000000000000
+# ADJUST-NEXT:    1 .text           00000002 0000000000123000 TEXT
+# ADJUST-NEXT:    2 .debug_str      00000004 0000000000000000
+# ADJUST-NEXT:    3 .rela.debug_str 00000018 0000000000000000
+# ADJUST-NEXT:    4 .data           00000004 0000000000123000 DATA
+# ADJUST-NEXT:    5 .rela.data      00000018 0000000000000000
+# ADJUST-NEXT:    6 .symtab         00000060 0000000000000000
+# ADJUST-NEXT:    7 .strtab         00000010 0000000000000000
+# ADJUST-NEXT:    8 .shstrtab       0000003c 0000000000000000
+
+# COMMON:      SYMBOL TABLE:
+# COMMON-NEXT:  0000000000000001  l F .text 00000000 func
+# COMMON-NEXT:  0000000000000000      .text 00000000 sym
+# COMMON-NEXT:  0000000000000000  l d .text 00000000 .text
+
+--- !ELF
+FileHeader:      
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:        
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         90C3
+  - Name:            .debug_str
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_MERGE, SHF_STRINGS ]
+    AddressAlign:    0x0000000000000001
+    Content:         '00000000'
+  - Name:            .rela.debug_str
+    Type:            SHT_RELA
+    Link:            .symtab
+    AddressAlign:    0x0000000000000008
+    Info:            .debug_str
+    Relocations:     
+      - Offset:          0x0000000000000001
+        Symbol:          .text
+        Type:            R_X86_64_32
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         '00000000'
+  - Name:            .rela.data
+    Type:            SHT_RELA
+    Link:            .symtab
+    AddressAlign:    0x0000000000000008
+    Info:            .data
+    Relocations:     
+      - Offset:      0x0000000000000000
+        Symbol:      .text
+        Type:        R_X86_64_32
+Symbols:
+  Local:
+    - Name:            func
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000001
+    - Name:            sym
+      Section:         .text
+    - Name:            .text
+      Type:            STT_SECTION
+      Section:         .text

tools/llvm-objdump/llvm-objdump.cpp

 #include <cstring>
 #include <system_error>
 #include <unordered_map>
 #include <utility>
 
 using namespace llvm;
 using namespace object;
 
+cl::opt<unsigned long long>
+    AdjustVma("adjust-vma",
+              cl::desc("Offset the addressed displayed by a value"),
+              cl::value_desc("offset"), cl::init(0));
+
 cl::opt<bool>
     llvm::AllHeaders("all-headers",
                      cl::desc("Display all available header information"));
 static cl::alias AllHeadersShort("x", cl::desc("Alias for --all-headers"),
                                  cl::NotHidden, cl::aliasopt(AllHeaders));
 
 static cl::list<std::string>
 InputFilenames(cl::Positional, cl::desc("<input object files>"),cl::ZeroOrMore);
static size_t countSkippableZeroBytes(ArrayRef<uint8_t> Buf) {
   if (N < 8)
     return 0;
 
   // We skip zeroes in multiples of 4 because do not want to truncate an
   // instruction if it starts with a zero byte.
   return N & ~0x3;
 }
 
+// Used for --adjust-vma to check if address should be adjusted by the
+// specified value for a given section.
+// For ELF we do not adjust the non-allocatable sections like debug ones,
+// because they are not loadable.
+// TODO: implement for other targets.
+static bool shouldAdjustVA(const SectionRef &Section) {
+  const ObjectFile *Obj = Section.getObject();
+  if (isa<object::ELFObjectFileBase>(Obj))
+    return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC;
+  return false;
+}
+
 static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
   if (StartAddress > StopAddress)
     error("Start address should be less than stop address");
 
   const Target *TheTarget = getTarget(Obj);
 
   // Package up features to be passed to target/subtarget
   SubtargetFeatures Features = Obj->getFeatures();
for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
     if (!DisassembleAll && (!Section.isText() || Section.isVirtual()))
       continue;
 
     uint64_t SectionAddr = Section.getAddress();
     uint64_t SectSize = Section.getSize();
     if (!SectSize)
       continue;
 
+    uint64_t AddVMA = 0;
+    if (shouldAdjustVA(Section))
+      AddVMA = AdjustVma;
+
     // Get the list of all the symbols in this section.
     SectionSymbolsTy &Symbols = AllSymbols[Section];
     std::vector<uint64_t> DataMappingSymsAddr;
     std::vector<uint64_t> TextMappingSymsAddr;
     if (isArmElf(Obj)) {
       for (const auto &Symb : Symbols) {
         uint64_t Address = std::get<0>(Symb);
         StringRef Name = std::get<1>(Symb);
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
           while (End > Limit &&
             *reinterpret_cast<const support::ulittle32_t*>(&Bytes[End - 4]) == 0)
             End -= 4;
         }
       }
 
       outs() << '\n';
       if (!NoLeadingAddr)
-        outs() << format("%016" PRIx64 " ", SectionAddr + Start);
+        outs() << format("%016" PRIx64 " ", SectionAddr + Start + AddVMA);
 
       StringRef SymbolName = std::get<1>(Symbols[SI]);
       if (Demangle)
         outs() << demangle(SymbolName) << ":\n";
       else
         outs() << SymbolName << ":\n";
 
       // Don't print raw contents of a virtual section. A virtual section
#endif
         // provided
         bool Disassembled = DisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
                                                    SectionAddr + Index, DebugOut,
                                                    CommentStream);
         if (Size == 0)
           Size = 1;
 
         PIP.printInst(*IP, Disassembled ? &Inst : nullptr,
-                      Bytes.slice(Index, Size), SectionAddr + Index, outs(), "",
-                      *STI, &SP, &Rels);
+                      Bytes.slice(Index, Size), SectionAddr + Index + AddVMA,
+                      outs(), "", *STI, &SP, &Rels);
         outs() << CommentStream.str();
         Comments.clear();
 
         // Try to resolve the target of a call, tail call, etc. to a specific
         // symbol.
         if (MIA && (MIA->isCall(Inst) || MIA->isUnconditionalBranch(Inst) ||
                     MIA->isConditionalBranch(Inst))) {
           uint64_t Target;
#endif
             SmallString<32> Val;
 
             // If this relocation is hidden, skip it.
             if (getHidden(*RelCur) || ((SectionAddr + Addr) < StartAddress)) {
               ++RelCur;
               continue;
             }
 
             // Stop when rel_cur's address is past the current instruction.
             if (Addr >= Index + Size)
               break;
+            
+            // When --adjust-vma is used update the address printed.
+            if (RelCur->getSymbol() != Obj->symbol_end()) {
+              Expected<section_iterator> SymSI =
+                  RelCur->getSymbol()->getSection();
+              if (SymSI && *SymSI != Obj->section_end() &&
+                  (shouldAdjustVA(**SymSI)))
+                Addr += AdjustVma;
+            }
+
             RelCur->getTypeName(Name);
             error(getRelocationValueString(*RelCur, Val));
             outs() << format(Fmt.data(), SectionAddr + Addr) << Name << "\t"
                    << Val << "\n";
             ++RelCur;
           }
       }
     }

 }
 
 void llvm::printSectionHeaders(const ObjectFile *Obj) {
   outs() << "Sections:\n"
             "Idx Name          Size      Address          Type\n";
   for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
     StringRef Name;
     error(Section.getName(Name));
+
     uint64_t Address = Section.getAddress();
+    if (shouldAdjustVA(Section))
+      Address += AdjustVma;
+
     uint64_t Size = Section.getSize();
     bool Text = Section.isText();
     bool Data = Section.isData();
     bool BSS = Section.isBSS();
     std::string Type = (std::string(Text ? "TEXT " : "") +
                         (Data ? "DATA " : "") + (BSS ? "BSS" : ""));
     outs() << format("%3d %-13s %08" PRIx64 " %016" PRIx64 " %s\n",
                      (unsigned)Section.getIndex(), Name.str().c_str(), Size,