[llvm-objdump] - Print LMAs when dumping section headers.

[grimar]

Summary

When --section-headers is used, GNU objdump prints both LMA and VMA for sections.
llvm-objdump does not do that what makes it's output be slightly inconsistent.

Patch teaches llvm-objdump to print LMA/VMA for ELF file formats.
The behavior for other formats remains unchanged.

[jhenderson]

The code change looks basically fine, but I'm wondering if we really want this? For many (most?) use cases, the LMA is the same as the VMA, so the extra column is just useless noise. I know we want to broadly be consistent with GNU tools, but I wonder if that's the case when it doesn't make that much sense?

What do you think about the following approach:

1. If there are any segments with different p_vaddr and p_paddr, go with your suggestion.
2. If a user specifies a switch, e.g. --show-lma, also go with your suggestion.
3. Otherwise, only print the VMA.

The issue with this is that it might break parsers which are written against GNU objdump's behaviour. I'm not sure if this is an issue or not? The switch is designed to mitigate that problem.

It's probably worth getting some others to give their opinion on this.

test/tools/llvm-objdump/X86/phdrs-lma.test

24

Does yaml2obj provide the ability to specify a different LMA to VMA for segments? That would be better than a pre-built binary, if we can use it.

tools/llvm-objdump/ELFDump.cpp

142–143

I don't think we need to phrase this comment in the future tense. I think the following would be a better re-wording:

"Search for a PT_LOAD segment containing the requested section. Use this segment's p_addr to calculate the section's LMA".

149

Rather than saying we didn't find its LMA, let's be more precise by saying, "if it isn't in a PT_LOAD segment."

[grimar]

In D57146#1369140, @jhenderson wrote:

The code change looks basically fine, but I'm wondering if we really want this? For many (most?) use cases, the LMA is the same as the VMA, so the extra column is just useless noise. I know we want to broadly be consistent with GNU tools, but I wonder if that's the case when it doesn't make that much sense?

We had the same concern for-Map option in LLD. It did not print LMA initially but there were requests from embedded developers about adding it.
(https://reviews.llvm.org/D44899#1049497)

I also think it might be useful for writing some test cases. For example, I see that LLD's at.s test does not explicitly
shows/tests the sections LMAs: https://github.com/llvm-mirror/lld/blob/master/test/ELF/linkerscript/at.s
We probably might parse the -Map option output to improve it, but seems that having llvm-objdump output would be a more natural way to go probably.

I'll add Peter to this thread to see if he has any opinion on that too.

What do you think about the following approach:

1. If there are any segments with different p_vaddr and p_paddr, go with your suggestion.
2. If a user specifies a switch, e.g. --show-lma, also go with your suggestion.
3. Otherwise, only print the VMA.

The issue with this is that it might break parsers which are written against GNU objdump's behaviour. I'm not sure if this is an issue or not? The switch is designed to mitigate that problem.

It's probably worth getting some others to give their opinion on this.

Generally, your suggestion sounds OK to me. I'll also be happy to hear other opinions.

[peter.smith]

I've not got a strong opinion here, for what it is worth:

• The code changes look fine.
• I can see LMA being useful to embedded developers, or tools vendors, given a binary without access to or ability to generate a map file. Would they intuitively look for objdump for that information though? I don't know.
• gnu objdump also gives file offset and flag information which probably have more justification as they can't be derived from other options. If we are looking for output format compatibility then we ought to add those too. I don't think that there is any expectation of that at the moment though.
• If there is a command line option to print the LMA, then there is a risk that a good portion of people won't read far into the help to discover it exists. For that reason I quite like the idea of printing the column only when there are program headers that have different VMA and LMA.

tools/llvm-objdump/ELFDump.cpp

138

Perhaps PhdrsOrErr or PhdrRangeOrErr? My first thought was what will that call return if it is called on a relocatable object file with no program headers, is it going to give me an error? With PhdrsOrErr it more strongly implies a range.

[jakehehrlich]

In D57146#1369140, @jhenderson wrote:

The code change looks basically fine, but I'm wondering if we really want this? For many (most?) use cases, the LMA is the same as the VMA, so the extra column is just useless noise. I know we want to broadly be consistent with GNU tools, but I wonder if that's the case when it doesn't make that much sense?

What do you think about the following approach:

1. If there are any segments with different p_vaddr and p_paddr, go with your suggestion.
2. If a user specifies a switch, e.g. --show-lma, also go with your suggestion.
3. Otherwise, only print the VMA.

The issue with this is that it might break parsers which are written against GNU objdump's behaviour. I'm not sure if this is an issue or not? The switch is designed to mitigate that problem.

It's probably worth getting some others to give their opinion on this.

+1 for this proposal. I find the GNU format extremely dense and hard to mentally parse as is.

[grimar]

In D57146#1369377, @peter.smith wrote:

• If there is a command line option to print the LMA, then there is a risk that a good portion of people won't read far into the help to discover it exists. For that reason I quite like the idea of printing the column only when there are program headers that have different VMA and LMA.

I think James idea is to have both: (1) print the column when there are program headers that have different VMA and LMA and (2) have an option to force always printing the LMA. Having such an option which is an addition to (1) makes sense if you want to have a way to produce consistent output for parsers.

[jhenderson]

In D57146#1370886, @grimar wrote:

In D57146#1369377, @peter.smith wrote:

• If there is a command line option to print the LMA, then there is a risk that a good portion of people won't read far into the help to discover it exists. For that reason I quite like the idea of printing the column only when there are program headers that have different VMA and LMA.

I think James idea is to have both: (1) print the column when there are program headers that have different VMA and LMA and (2) have an option to force always printing the LMA. Having such an option which is an addition to (1) makes sense if you want to have a way to produce consistent output for parsers.

Yes, exactly. The switch means that those reliant on the output format can specify it, or to print LMA where for some specific instance the LMA and VMA happen to be the same, but that doesn't always mean it will be. Finally, having a single switch whose default can be toggled in downstream ports is easier to maintain than a private patch in the middle of the formatting code.

One further suggestion for 1) might be to change the header to VMA/LMA for the address column, to make it clearer. It might be less confusing to those used to GNU output?

[grimar]

In D57146#1370968, @jhenderson wrote:

One further suggestion for 1) might be to change the header to VMA/LMA for the address column, to make it clearer. It might be less confusing to those used to GNU output?

I thought about that too. Decided to not suggest it because if we hide a LMA column completely then probably no need to make people who are unfamiliar with it even to think about it?
I.e. This patch prints "VMA ... LMA" now and "Address" in another case. I supposed that just "Address" would look simpler then.

I am not sure what would be really better though honestly. Maybe mixing "VMA" and "Address" for different cases is also not a very good idea.

[jhenderson]

In D57146#1370988, @grimar wrote:

In D57146#1370968, @jhenderson wrote:

One further suggestion for 1) might be to change the header to VMA/LMA for the address column, to make it clearer. It might be less confusing to those used to GNU output?

I thought about that too. Decided to not suggest it because if we hide a LMA column completely then probably no need to make people who are unfamiliar with it even to think about it?
I.e. This patch prints "VMA ... LMA" now and "Address" in another case. I supposed that just "Address" would look simpler then.

I am not sure what would be really better though honestly. Maybe mixing "VMA" and "Address" for different cases is also not a very good idea.

Okay. I'd just stick with VMA when printing only that.

[peter.smith]

In D57146#1370968, @jhenderson wrote:

In D57146#1370886, @grimar wrote:

In D57146#1369377, @peter.smith wrote:

• If there is a command line option to print the LMA, then there is a risk that a good portion of people won't read far into the help to discover it exists. For that reason I quite like the idea of printing the column only when there are program headers that have different VMA and LMA.

I think James idea is to have both: (1) print the column when there are program headers that have different VMA and LMA and (2) have an option to force always printing the LMA. Having such an option which is an addition to (1) makes sense if you want to have a way to produce consistent output for parsers.

Yes, exactly. The switch means that those reliant on the output format can specify it, or to print LMA where for some specific instance the LMA and VMA happen to be the same, but that doesn't always mean it will be. Finally, having a single switch whose default can be toggled in downstream ports is easier to maintain than a private patch in the middle of the formatting code.

Thanks for the clarification. Makes sense.

[grimar]

• Addressed review comments.
• Updated implementation in according to the recent discussion.

[grimar]

test/tools/llvm-objdump/X86/phdrs-lma.test

24

Oh cool, I did not know yaml2obj is able to do that. Done.

[jhenderson]

test/tools/llvm-objdump/X86/phdrs-lma2.test

4–5

which has LMA different from VMA -> with different LMA to VMA

tools/llvm-objdump/llvm-objdump.cpp

183

Can this be static?

185

This should probably be in the documentation.

1495

It's more common to say "and/or" rather than "or/and".

[grimar]

tools/llvm-objdump/llvm-objdump.cpp

183

I think so. Probably all of cl::opt<bool> should be static in this file, though they are not now. I followed for consistency but seems that was not a good idea.

[grimar]

• Addressed review comments.

tools/llvm-objdump/llvm-objdump.cpp

185

I do not see any documentation files for llvm-objdump around or in the recent commits. Did you have something in mind? Seems we just do not have them =\

[grimar]

Will reupload.

[grimar]

• Uploaded the right diff.

[jhenderson]

LGTM.

tools/llvm-objdump/llvm-objdump.cpp

185

Oh well. No, I didn't have anything in mind. I just assumed it would be there alongside e.g. llvm-symbolizer's command guide.

test/MC/COFF/assoc-private.s

 # RUN: llvm-mc -triple x86_64-pc-win32 -filetype=obj %s | llvm-objdump - -h -t | FileCheck %s
 
 # PR38607: We assemble this, and make .CRT$XCU comdat with .rdata even though
 # .rdata isn't comdat. It's not clear what the semantics are, but we assemble
 # it anyway.
 
 # CHECK: Sections:
-# CHECK: Idx Name          Size      Address          Type
+# CHECK: Idx Name          Size     VMA              Type
 # CHECK:   3 .rdata        00000004 0000000000000000 DATA
 # CHECK:   4 .CRT$XCU      00000008 0000000000000000 DATA
 # CHECK: SYMBOL TABLE:
 # CHECK: [ 6](sec  4)(fl 0x00)(ty   0)(scl   3) (nx 1) 0x00000000 .rdata
 # CHECK: AUX scnlen 0x4 nreloc 0 nlnno 0 checksum 0x0 assoc 4 comdat 0
 # CHECK: [ 8](sec  5)(fl 0x00)(ty   0)(scl   3) (nx 1) 0x00000000 .CRT$XCU
 # CHECK: AUX scnlen 0x8 nreloc 1 nlnno 0 checksum 0x0 assoc 4 comdat 5
 # CHECK: [10](sec  0)(fl 0x00)(ty   0)(scl   2) (nx 0) 0x00000000 register_x

test/Object/objdump-no-sectionheaders.test

 ; RUN: llvm-objdump -h %p/Inputs/no-sections.elf-x86-64 \
 ; RUN:              | FileCheck %s
 
 ; CHECK: Sections:
-; CHECK: Idx Name          Size      Address          Type
+; CHECK: Idx Name          Size      VMA              Type
 ; CHECK-NOT: {{.}}

test/Object/objdump-sectionheaders.test

 ; RUN: llvm-objdump -h %p/Inputs/trivial-object-test.elf-x86-64 \
 ; RUN:              | FileCheck %s
 
 ; To verify this, use readelf -S, not objdump -h. Binutils objdump filters the
 ; results in a way that we don't emulate.
 
 ; CHECK: Sections:
-; CHECK: Idx Name          Size      Address          Type
+; CHECK: Idx Name          Size     VMA              Type
 ; CHECK:   0               00000000 0000000000000000
 ; CHECK:   1 .text         00000026 0000000000000000 TEXT
 ; CHECK:   2 .rodata.str1.1 0000000d 0000000000000026 DATA
 ; CHECK:   3 .note.GNU-stack 00000000 0000000000000033
 ; CHECK:   4 .rela.text    00000048 0000000000000038
 ; CHECK:   5 .symtab       000000c0 0000000000000080
 ; CHECK:   6 .strtab       00000033 0000000000000140
 ; CHECK:   7 .shstrtab     0000004b 0000000000000173

test/tools/llvm-objdump/X86/macho-section-headers.test

 RUN: llvm-objdump -macho -h %p/Inputs/hello.obj.macho-x86_64 | FileCheck %s
 
 CHECK: Sections:
-CHECK: Idx Name          Size      Address          Type
+CHECK: Idx Name          Size     VMA              Type
 CHECK:   0 __text        0000003b 0000000000000000 TEXT 
 CHECK:   1 __cstring     0000000d 000000000000003b DATA 
 CHECK:   2 __compact_unwind 00000020 0000000000000048 DATA 
 CHECK:   3 __eh_frame    00000040 0000000000000068 DATA 

test/tools/llvm-objdump/X86/phdrs-lma.test

+# RUN: yaml2obj %s > %t
+
+## Check we print both VMA and LMA correctly when dumping section headers.
+# RUN: llvm-objdump --section-headers %t | FileCheck %s
+
+# CHECK:      Sections:
+# CHECK-NEXT: Idx Name  Size     VMA              LMA              Type
+# CHECK-NEXT:   0       00000000 0000000000000000 0000000000000000
+# CHECK-NEXT:   1 .text 00000004 0000000000001000 0000000000002000 TEXT
+# CHECK-NEXT:   2 .init 00000004 0000000000001010 0000000000001010 TEXT
+# CHECK-NEXT:   3 .data 00000004 0000000000002000 0000000000003000 DATA
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Content:         "00000000"
+    Address:         0x00001000
+  - Name:            .init
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Content:         "00000000"
+    Address:         0x00001010
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Content:         "00000000"
+    Address:         0x00002000
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x00001000
+    PAddr: 0x00002000
+    Sections:
+      - Section: .text
+      - Section: .init
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x00002000
+    PAddr: 0x00003000
+    Sections:
+      - Section: .data

test/tools/llvm-objdump/X86/phdrs-lma2.test

+# RUN: yaml2obj %s > %t
+
+## If there are no sections which has LMA different
+## from VMA, we do not display LMA column.
+# RUN: llvm-objdump --section-headers %t | FileCheck %s
+
+# CHECK:      Sections:
+# CHECK-NEXT: Idx Name  Size     VMA              Type
+# CHECK-NEXT:   0       00000000 0000000000000000
+# CHECK-NEXT:   1 .text 00000004 0000000000001000 TEXT
+# CHECK-NEXT:   2 .init 00000004 0000000000001010 TEXT
+# CHECK-NEXT:   3 .data 00000004 0000000000002000 DATA
+
+## Check we can trigger displaying the LMA column with --show-lma.
+# RUN: llvm-objdump --section-headers --show-lma %t |\
+# RUN:   FileCheck %s --check-prefix=LMA
+
+# LMA:      Sections:
+# LMA-NEXT: Idx Name  Size     VMA              LMA              Type
+# LMA-NEXT:   0       00000000 0000000000000000 0000000000000000
+# LMA-NEXT:   1 .text 00000004 0000000000001000 0000000000001000 TEXT
+# LMA-NEXT:   2 .init 00000004 0000000000001010 0000000000001010 TEXT
+# LMA-NEXT:   3 .data 00000004 0000000000002000 0000000000002000 DATA
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Content:         "00000000"
+    Address:         0x00001000
+  - Name:            .init
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Content:         "00000000"
+    Address:         0x00001010
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Content:         "00000000"
+    Address:         0x00002000
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x00001000
+    PAddr: 0x00001000
+    Sections:
+      - Section: .text
+      - Section: .init
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x00002000
+    PAddr: 0x00002000
+    Sections:
+      - Section: .data

test/tools/llvm-objdump/wasm.txt

 # RUN: llvm-objdump -h %p/Inputs/trivial.obj.wasm | FileCheck %s
 
 # CHECK:      Sections:
-# CHECK-NEXT: Idx Name          Size      Address          Type
+# CHECK-NEXT: Idx Name          Size    VMA              Type
 # CHECK-NEXT:  0 TYPE          00000011 0000000000000000
 # CHECK-NEXT:  1 IMPORT        0000005d 0000000000000000
 # CHECK-NEXT:  2 FUNCTION      00000003 0000000000000000
 # CHECK-NEXT:  3 CODE          00000024 0000000000000000 TEXT
 # CHECK-NEXT:  4 DATA          0000001c 0000000000000000 DATA
 # CHECK-NEXT:  5 linking       0000006d 0000000000000000
 # CHECK-NEXT:  6 reloc.CODE    0000000f 0000000000000000
 

tools/llvm-objdump/ELFDump.cpp

if (auto *ELF64LE = dyn_cast<ELF64LEObjectFile>(Obj))
     return getRelocationValueString(ELF64LE, Rel, Result);
   if (auto *ELF32BE = dyn_cast<ELF32BEObjectFile>(Obj))
     return getRelocationValueString(ELF32BE, Rel, Result);
   auto *ELF64BE = cast<ELF64BEObjectFile>(Obj);
   return getRelocationValueString(ELF64BE, Rel, Result);
 }
 
 template <class ELFT>
+static uint64_t getSectionLMA(const ELFFile<ELFT> *Obj,
+                              const object::ELFSectionRef &Sec) {
+  auto PhdrRangeOrErr = Obj->program_headers();
+  if (!PhdrRangeOrErr)
+    report_fatal_error(errorToErrorCode(PhdrRangeOrErr.takeError()).message());
+
+  // Search for a PT_LOAD segment containing the requested section. Use this
+  // segment's p_addr to calculate the section's LMA.
+  for (const typename ELFFile<ELFT>::Elf_Phdr &Phdr : *PhdrRangeOrErr)
+    if ((Phdr.p_type == ELF::PT_LOAD) && (Phdr.p_vaddr <= Sec.getAddress()) &&
+        (Phdr.p_vaddr + Phdr.p_memsz > Sec.getAddress()))
+      return Sec.getAddress() - Phdr.p_vaddr + Phdr.p_paddr;
+
+  // Return section's VMA if it isn't in a PT_LOAD segment.
+  return Sec.getAddress();
+}
+
+uint64_t llvm::getELFSectionLMA(const object::ELFSectionRef &Sec) {
+  if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Sec.getObject()))
+    return getSectionLMA(ELFObj->getELFFile(), Sec);
+  else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Sec.getObject()))
+    return getSectionLMA(ELFObj->getELFFile(), Sec);
+  else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Sec.getObject()))
+    return getSectionLMA(ELFObj->getELFFile(), Sec);
+  const auto *ELFObj = cast<ELF64BEObjectFile>(Sec.getObject());
+  return getSectionLMA(ELFObj->getELFFile(), Sec);
+}
+
+template <class ELFT>
 void printDynamicSection(const ELFFile<ELFT> *Elf, StringRef Filename) {
   auto ProgramHeaderOrError = Elf->program_headers();
   if (!ProgramHeaderOrError)
     report_error(Filename, ProgramHeaderOrError.takeError());
 
   auto DynamicEntriesOrError = Elf->dynamicEntries();
   if (!DynamicEntriesOrError)
     report_error(Filename, DynamicEntriesOrError.takeError());

tools/llvm-objdump/llvm-objdump.h

 
 namespace llvm {
 class StringRef;
 
 namespace object {
 class COFFObjectFile;
 class COFFImportFile;
 class ELFObjectFileBase;
+class ELFSectionRef;
 class MachOObjectFile;
 class MachOUniversalBinary;
 class ObjectFile;
 class Archive;
 class RelocationRef;
 }
 
 extern cl::opt<std::string> TripleName;

 getWasmRelocationValueString(const object::WasmObjectFile *Obj,
                              const object::RelocationRef &RelRef,
                              llvm::SmallVectorImpl<char> &Result);
 std::error_code
 getMachORelocationValueString(const object::MachOObjectFile *Obj,
                               const object::RelocationRef &RelRef,
                               llvm::SmallVectorImpl<char> &Result);
 
+uint64_t getELFSectionLMA(const object::ELFSectionRef& Sec);
+
 void error(std::error_code ec);
 bool isRelocAddressLess(object::RelocationRef A, object::RelocationRef B);
 void parseInputMachO(StringRef Filename);
 void parseInputMachO(object::MachOUniversalBinary *UB);
 void printCOFFUnwindInfo(const object::COFFObjectFile *O);
 void printMachOUnwindInfo(const object::MachOObjectFile *O);
 void printMachOExportsTrie(const object::MachOObjectFile *O);
 void printMachORebaseTable(object::MachOObjectFile *O);

tools/llvm-objdump/llvm-objdump.cpp

static cl::alias SectionHeadersShort("headers",
                                      cl::desc("Alias for --section-headers"),
                                      cl::NotHidden,
                                      cl::aliasopt(SectionHeaders));
 static cl::alias SectionHeadersShorter("h",
                                        cl::desc("Alias for --section-headers"),
                                        cl::NotHidden,
                                        cl::aliasopt(SectionHeaders));
 
+cl::opt<bool>
+    ShowLMA("show-lma",
+            cl::desc("Display LMA column when dumping ELF section headers"));
+
 cl::list<std::string>
 llvm::FilterSections("section", cl::desc("Operate on the specified sections only. "
                                          "With -macho dump segment,section"));
 cl::alias static FilterSectionsj("j", cl::desc("Alias for --section"),
                                  cl::NotHidden,
                                  cl::aliasopt(llvm::FilterSections));
 
 cl::list<std::string>
for (const RelocationRef &Reloc : Section.relocations()) {
       Reloc.getTypeName(RelocName);
       error(getRelocationValueString(Reloc, ValueStr));
       outs() << format(Fmt.data(), Address) << " " << RelocName << " "
              << ValueStr << "\n";
     }
   }
 }
 
+// Returns true if we need to show LMA column when dumping section headers. We
+// show it only when the platform is ELF and either we have at least one section
+// whose VMA and LMA are different or/and when --show-lma flag is used.
+static bool shouldDisplayLMA(const ObjectFile *Obj) {
+  if (!Obj->isELF())
+    return false;
+  for (const SectionRef &S : ToolSectionFilter(*Obj))
+    if (S.getAddress() != getELFSectionLMA(S))
+      return true;
+  return ShowLMA;
+}
+
 void llvm::printSectionHeaders(const ObjectFile *Obj) {
+  bool HasLMAColumn = shouldDisplayLMA(Obj);
+  if (HasLMAColumn)
     outs() << "Sections:\n"
-            "Idx Name          Size      Address          Type\n";
+              "Idx Name          Size     VMA              LMA              "
+              "Type\n";
+  else
+    outs() << "Sections:\n"
+              "Idx Name          Size     VMA          Type\n";
+
   for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
     StringRef Name;
     error(Section.getName(Name));
-    uint64_t Address = Section.getAddress();
+    uint64_t VMA = Section.getAddress();
     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" : ""));
+
+    if (HasLMAColumn)
+      outs() << format("%3d %-13s %08" PRIx64 " %016" PRIx64 " %016" PRIx64
+                       " %s\n",
+                       (unsigned)Section.getIndex(), Name.str().c_str(), Size,
+                       VMA, getELFSectionLMA(Section), Type.c_str());
+    else
       outs() << format("%3d %-13s %08" PRIx64 " %016" PRIx64 " %s\n",
                        (unsigned)Section.getIndex(), Name.str().c_str(), Size,
-                     Address, Type.c_str());
+                       VMA, Type.c_str());
   }
   outs() << "\n";
 }
 
 void llvm::printSectionContents(const ObjectFile *Obj) {
   std::error_code EC;
   for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
     StringRef Name;