[llvm-objdump][WIP] Make llvm-objdump -h compatible with GNU objdump.

[rupprecht]

Summary

Note: this patch is large and not intended for submission as-is. Instead, this patch presents a poor implementation that makes llvm-objdump GNU compatibile for this option (with all existing tests passing, but few added tests, hacky code, etc.), and will serve as context for smaller changes to be submitted separately with more careful review.

llvm-objdump -h was implemented to be similar to readelf -S (see rL141579). However, it is not completely compatible with that, and anyone that does want headers displayed that way can use llvm-readelf -S now that it exists. Make llvm-objdump compatible with GNU objdump instead.

A brief overview of changes:

• Add file offset (with implementations for all filetypes supported by llvm-readobj).
• Add 2**n section alignment column (with implementations for all filetypes supported by llvm-readobj).
• Section numbers are not the actual section numbers, but something different, corresponding to libbfd section numbers. llvm-readelf -s prints the actual section numbers if those are desired.
• Filter out certain sections like symtabs/strtabs/relocs. The actual logic is a lot more convoluted (and probably isn't fully compatibile, but is pretty close).

[rupprecht]

Note: herald added reviewers, but this patch is just to provide context. I'll send the real patches for review in the coming days.

clang/test/Modules/pch_container.m

 @import DependsOnModule;
 // REQUIRES: x86-registered-target
 // RUN: rm -rf %t-MachO %t-ELF %t-ELF_SPLIT %t-COFF %t-raw
 // RUN: %clang_cc1 -triple=x86_64-apple-darwin -fmodules -fmodule-format=obj -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t-MachO -F %S/Inputs %s
 // RUN: %clang_cc1 -triple=x86_64-linux-elf -fmodules -fmodule-format=obj -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t-ELF -F %S/Inputs %s
 // RUN: %clang_cc1 -triple=x86_64-windows-coff -fmodules -fmodule-format=obj -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t-COFF -F %S/Inputs %s
 // RUN: %clang_cc1 -triple=x86_64-apple-darwin -fmodules -fmodule-format=raw -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t-raw -F %S/Inputs %s
 
-
 // RUN: llvm-objdump --section-headers %t-MachO/DependsOnModule.pcm %t-ELF/DependsOnModule.pcm %t-COFF/DependsOnModule.pcm | FileCheck %s
 // CHECK: file format Mach-O 64-bit x86-64
-// CHECK: __clangast   {{[0-9a-f]+}} {{[0-9a-f]+}} DATA
+// CHECK: __clangast   {{[0-9a-f]+}} {{[0-9a-f]+}} {{[0-9a-f]+}} 2**{{[0-9]+}} DATA
 // CHECK: file format ELF64-x86-64
-// CHECK: __clangast   {{[0-9a-f]+}} {{[0-9a-f]+}} DATA
+// CHECK: __clangast   {{[0-9a-f]+}} {{[0-9a-f]+}} {{[0-9a-f]+}} 2**{{[0-9]+}} DATA
 // CHECK: file format COFF-x86-64
-// CHECK: clangast   {{[0-9a-f]+}} {{[0-9a-f]+}}
+// CHECK: clangast   {{[0-9a-f]+}} {{[0-9a-f]+}} {{[0-9a-f]+}} 2**{{[0-9]+}} DATA
 
 // RUN: not llvm-objdump --section-headers %t-raw/DependsOnModule.pcm
 
 // RUN: %clang_cc1 -split-dwarf-output t-split.dwo -triple=x86_64-linux-elf -fmodules -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t-ELF_SPLIT -F %S/Inputs %s -o %t-split.o

lld/test/ELF/bss-start-common.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: ld.lld %t -o %t2
 # RUN: llvm-objdump -t -section-headers %t2 | FileCheck %s
 
 ## Test __bss_start is defined at the start of .bss
 
 # CHECK: Sections:
-# CHECK: Idx Name          Size     VMA                 Type
-# CHECK:   2 .bss          00000004 [[ADDR:[0-za-f]+]]  BSS
+# CHECK: Idx Name          Size      VMA               File off        Algn Type
+# CHECK:   1 .bss          00000004 [[ADDR:[0-9a-f]+]] {{[0-9a-f]+}} 2**2 BSS
 # CHECK: SYMBOL TABLE:
 # CHECK: [[ADDR]]          .bss 00000000 __bss_start
 
 .global __bss_start
 .text
 _start:
 .comm sym1,4,4

lld/test/ELF/edata-etext.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-objdump -t -section-headers %t | FileCheck %s
 
 ## This checks that:
 ## 1) Address of _etext is the first location after the last read-only loadable segment.
 ## 2) Address of _edata points to the end of the last non SHT_NOBITS section.
 ##    That is how gold/bfd do. At the same time specs says: "If the address of _edata is
 ##    greater than the address of _etext, the address of _end is same as the address
 ##    of _edata." (https://docs.oracle.com/cd/E53394_01/html/E54766/u-etext-3c.html).
 ## 3) Address of _end is different from _edata because of 2.
 ## 4) Addresses of _edata == edata, _end == end and _etext == etext.
 # CHECK:      Sections:
-# CHECK-NEXT:  Idx Name          Size     VMA              Type
-# CHECK-NEXT:    0               00000000 0000000000000000
-# CHECK-NEXT:    1 .text         00000001 0000000000201158 TEXT
-# CHECK-NEXT:    2 .data         00000002 0000000000202159 DATA
-# CHECK-NEXT:    3 .bss          00000006 000000000020215c BSS
+# CHECK-NEXT: Idx Name          Size     VMA              File off         Algn  Type
+# CHECK-NEXT:   0 .text         00000001 0000000000201158 0000000000000158 2**2  TEXT
+# CHECK-NEXT:   1 .data         00000002 0000000000202159 0000000000000159 2**0  DATA
+# CHECK-NEXT:   2 .bss          00000006 000000000020215c 000000000000015b 2**2  BSS
 # CHECK:      SYMBOL TABLE:
 # CHECK-NEXT:  000000000020215b         .data 00000000 _edata
 # CHECK-NEXT:  0000000000202162         .bss  00000000 _end
 # CHECK-NEXT:  0000000000201159         .text 00000000 _etext
 # CHECK-NEXT:  0000000000201158         .text 00000000 _start
 # CHECK-NEXT:  000000000020215b         .data 00000000 edata
 # CHECK-NEXT:  0000000000202162         .bss  00000000 end
 # CHECK-NEXT:  0000000000201159         .text 00000000 etext

lld/test/ELF/edata-no-bss.s

 # REQUIRES: x86
 
 ## _edata points to the end of the last mapped initialized section.
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t --gc-sections
 # RUN: llvm-objdump -t -section-headers %t | FileCheck %s
 
-# CHECK: .data         00000008 000000000020215c DATA
+# CHECK: .data         00000008 000000000020215c 000000000000015c 2**0 DATA
 
 # CHECK: 0000000000202164         .data                 00000000 _edata
 
 .text
 .globl _start
 _start:
 .long .data - .
 
 .data
 .quad 0
 
 .globl _edata

lld/test/ELF/emit-relocs-gc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 
 ## Show that we emit .rela.bar and .rela.text when GC is disabled.
 # RUN: ld.lld --emit-relocs %t.o -o %t
-# RUN: llvm-objdump %t -section-headers | FileCheck %s --check-prefix=NOGC
+# RUN: llvm-readelf %t --sections | FileCheck %s --check-prefix=NOGC
 # NOGC: .rela.text
 # NOGC: .rela.bar
 
 ## GC collects .bar section and we exclude .rela.bar from output. We keep
 ## .rela.text because we keep .text.
 # RUN: ld.lld --gc-sections --emit-relocs --print-gc-sections %t.o -o %t \
 # RUN:   | FileCheck --check-prefix=MSG %s
 # MSG: removing unused section {{.*}}.o:(.bar)
 # MSG: removing unused section {{.*}}.o:(.rela.bar)
-# RUN: llvm-objdump %t -section-headers | FileCheck %s --check-prefix=GC
+# RUN: llvm-readelf %t --sections | FileCheck %s --check-prefix=GC
 # GC-NOT:  rela.bar
 # GC:      rela.text
 # GC-NOT:  rela.bar
 
 .section .bar,"a"
 .quad .bar
 
 .text
 relocs:
 .quad _start
 
 .global _start
 _start:
  nop

lld/test/ELF/gc-sections-metadata.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld --gc-sections %t.o -o %t
 # RUN: llvm-objdump -section-headers %t | FileCheck  %s
 
-# CHECK:      1 .foo1
+# CHECK:      0 .foo1
 # CHECK-NEXT:   bar1
 # CHECK-NEXT:   .zed1
 # CHECK-NEXT:   .text
 # CHECK-NEXT:   .comment
-# CHECK-NEXT:   .symtab
-# CHECK-NEXT:   .shstrtab
-# CHECK-NEXT:   .strtab
 
 .global _start
 _start:
 .quad .foo1
 
 .section .foo1,"a"
 .quad 0
 

lld/test/ELF/init_fini_priority.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 // RUN: llvm-objdump -section-headers %t | FileCheck %s --check-prefix=OBJ
 // RUN: ld.lld %t -o %t.exe
 // RUN: llvm-objdump -s %t.exe | FileCheck %s
 
-// OBJ:       3 .init_array
-// OBJ-NEXT:  4 .init_array.100
-// OBJ-NEXT:  5 .init_array.5
-// OBJ-NEXT:  6 .init_array
-// OBJ-NEXT:  7 .init_array
-// OBJ-NEXT:  8 .fini_array
-// OBJ-NEXT:  9 .fini_array.100
-// OBJ-NEXT: 10 .fini_array.5
-// OBJ-NEXT: 11 .fini_array
-// OBJ-NEXT: 12 .fini_array
+// OBJ:       1 .init_array
+// OBJ-NEXT:  2 .init_array.100
+// OBJ-NEXT:  3 .init_array.5
+// OBJ-NEXT:  4 .init_array
+// OBJ-NEXT:  5 .init_array
+// OBJ-NEXT:  6 .fini_array
+// OBJ-NEXT:  7 .fini_array.100
+// OBJ-NEXT:  8 .fini_array.5
+// OBJ-NEXT:  9 .fini_array
+// OBJ-NEXT: 10 .fini_array
 
 .globl _start
 _start:
   nop
 
 .section .init_array, "aw", @init_array, unique, 0
   .align 8
   .byte 1

lld/test/ELF/invalid-fde-rel.s

// the fde points to.
 
         .long 0x14
         .long 0x1c
         .long 0x0
         .long 0x0
         .long 0x0
         .long 0x0
 
-// CHECK:  1 .eh_frame     0000001c
+// CHECK:  0 .eh_frame     0000001c

lld/test/ELF/linkerscript/addr.test

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/addr.s -o %t
 # RUN: ld.lld %t --script %s -o %t1
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 
 # CHECK:      Sections:
-# CHECK-NEXT: Idx Name          Size     VMA              Type
-# CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 .text         00000000 0000000000001000 TEXT
-# CHECK-NEXT:   2 .foo.1        00000008 0000000000001000 DATA
-# CHECK-NEXT:   3 .foo.2        00000008 0000000000001100 DATA
-# CHECK-NEXT:   4 .foo.3        00000008 0000000000001108 DATA
+# CHECK-NEXT: Idx Name          Size     VMA              File off         Algn  Type
+# CHECK-NEXT:   0 .text         00000000 0000000000001000 0000000000001000 2**2  TEXT
+# CHECK-NEXT:   1 .foo.1        00000008 0000000000001000 0000000000001000 2**0  DATA
+# CHECK-NEXT:   2 .foo.2        00000008 0000000000001100 0000000000001100 2**0  DATA
+# CHECK-NEXT:   3 .foo.3        00000008 0000000000001108 0000000000001108 2**0  DATA
 
 SECTIONS {
   . = 0x1000;
   .text  : { *(.text*) }
   .foo.1 : { *(.foo.1) }
   .foo.2 ADDR(.foo.1) + 0x100 : { *(.foo.2) }
   .foo.3 : { *(.foo.3) }
 }

lld/test/ELF/linkerscript/align-empty.test

 # REQUIRES: x86
 # RUN: echo '.section foo, "a"; .byte 0' \
 # RUN:   | llvm-mc -filetype=obj -triple=x86_64-unknown-linux - -o %t.o
 
 # RUN: ld.lld -o %t1 --script %s %t.o -shared
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 
 SECTIONS {
   . = SIZEOF_HEADERS;
   abc : {}
   . = ALIGN(0x1000);
   foo : { *(foo) }
 }
 
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size     VMA
-# CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 .dynsym       00000018 0000000000000190
-# CHECK-NEXT:   2 .gnu.hash     0000001c 00000000000001a8
-# CHECK-NEXT:   3 .hash         00000010 00000000000001c4
-# CHECK-NEXT:   4 .dynstr       00000001 00000000000001d4
-# CHECK-NEXT:   5 foo           00000001 0000000000001000
+# CHECK-NEXT:   0 .dynsym       00000018 0000000000000190
+# CHECK-NEXT:   1 .gnu.hash     0000001c 00000000000001a8
+# CHECK-NEXT:   2 .hash         00000010 00000000000001c4
+# CHECK-NEXT:   3 .dynstr       00000001 00000000000001d4
+# CHECK-NEXT:   4 foo           00000001 0000000000001000

lld/test/ELF/linkerscript/align1.test

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/align.s -o %t.o
 # RUN: ld.lld -o %t --script %s %t.o
 # RUN: llvm-objdump -section-headers %t | FileCheck %s
 
 SECTIONS {
   . = 0x10000;
   .aaa : { *(.aaa) }
   . = ALIGN(4096);
   .bbb : { *(.bbb) }
   . = ALIGN(4096 * 4);
   .ccc : { *(.ccc) }
 }
 
 # CHECK:      Sections:
-# CHECK-NEXT: Idx Name          Size     VMA              Type
-# CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 .aaa          00000008 0000000000010000 DATA
-# CHECK-NEXT:   2 .bbb          00000008 0000000000011000 DATA
-# CHECK-NEXT:   3 .ccc          00000008 0000000000014000 DATA
+# CHECK-NEXT: Idx Name          Size     VMA              File off         Algn  Type
+# CHECK-NEXT:   0 .aaa          00000008 0000000000010000 0000000000001000 2**0  DATA
+# CHECK-NEXT:   1 .bbb          00000008 0000000000011000 0000000000002000 2**0  DATA
+# CHECK-NEXT:   2 .ccc          00000008 0000000000014000 0000000000005000 2**0  DATA
 
 ## Check that ALIGN zero do nothing and does not crash #1.
 # RUN: echo "SECTIONS { . = ALIGN(0x123, 0); .aaa : { *(.aaa) } }" > %t.script
 # RUN: ld.lld -o %t4 --script %t.script %t.o
 # RUN: llvm-objdump -section-headers %t4 | FileCheck %s -check-prefix=ZERO
 
 # ZERO:      Sections:
-# ZERO-NEXT: Idx Name          Size     VMA              Type
-# ZERO-NEXT:   0               00000000 0000000000000000
-# ZERO-NEXT:   1 .aaa          00000008 0000000000000123 DATA
+# ZERO-NEXT: Idx Name          Size     VMA              File off         Algn  Type
+# ZERO-NEXT:   0 .aaa          00000008 0000000000000123 0000000000000123 2**0  DATA
+# ZERO-NEXT:   1 .bbb          00000008 000000000000012b 000000000000012b 2**0  DATA
+# ZERO-NEXT:   2 .ccc          00000008 0000000000000133 0000000000000133 2**0  DATA
+
 
 ## Check that ALIGN zero do nothing and does not crash #2.
 # RUN: echo "SECTIONS { . = 0x123; . = ALIGN(0); .aaa : { *(.aaa) } }" > %t.script
 # RUN: ld.lld -o %t5 --script %t.script %t.o
 # RUN: llvm-objdump -section-headers %t5 | FileCheck %s -check-prefix=ZERO
 
 ## Test we fail gracefuly when alignment value is not a power of 2 (#1).
 # RUN: echo "SECTIONS { . = 0x123; . = ALIGN(0x123, 3); .aaa : { *(.aaa) } }" > %t.script
 # RUN: not ld.lld -o %t6 --script %t.script %t.o 2>&1 | FileCheck -check-prefix=ERR %s
 
 # RUN: echo "SECTIONS { . = 0x123; . = ALIGN(3); .aaa : { *(.aaa) } }" > %t.script
 # RUN: not ld.lld -o %t7 --script %t.script %t.o 2>&1 | FileCheck -check-prefix=ERR %s
 
 # ERR: {{.*}}.script:1: alignment must be power of 2

lld/test/ELF/linkerscript/align2.test

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/align.s -o %t.o
 # RUN: ld.lld -o %t --script %s %t.o
 # RUN: llvm-objdump -section-headers %t | FileCheck %s
 
 SECTIONS {
   . = ALIGN(0x1234, 0x10000);
   .aaa : { *(.aaa) }
   . = ALIGN(., 4096);
   .bbb : { *(.bbb) }
   . = ALIGN(., 4096 * 4);
   .ccc : { *(.ccc) }
 }
 
 # CHECK:      Sections:
-# CHECK-NEXT: Idx Name          Size     VMA              Type
-# CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 .aaa          00000008 0000000000010000 DATA
-# CHECK-NEXT:   2 .bbb          00000008 0000000000011000 DATA
-# CHECK-NEXT:   3 .ccc          00000008 0000000000014000 DATA
+# CHECK-NEXT: Idx Name          Size     VMA              File off         Algn Type
+# CHECK-NEXT:   0 .aaa          00000008 0000000000010000 0000000000001000 2**0 DATA
+# CHECK-NEXT:   1 .bbb          00000008 0000000000011000 0000000000002000 2**0 DATA
+# CHECK-NEXT:   2 .ccc          00000008 0000000000014000 0000000000005000 2**0 DATA

lld/test/ELF/linkerscript/align3.test

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/align.s -o %t.o
 # RUN: ld.lld -o %t --script %s %t.o
 # RUN: llvm-objdump -section-headers %t | FileCheck %s
 
 SECTIONS {
   . = 0x10000;
   .aaa : { *(.aaa) }
   .bbb : ALIGN(4096) { *(.bbb) }
   .ccc : ALIGN(4096 * 4) { *(.ccc) }
 }
 
 # CHECK:      Sections:
-# CHECK-NEXT: Idx Name          Size     VMA              Type
-# CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 .aaa          00000008 0000000000010000 DATA
-# CHECK-NEXT:   2 .bbb          00000008 0000000000011000 DATA
-# CHECK-NEXT:   3 .ccc          00000008 0000000000014000 DATA
+# CHECK-NEXT: Idx Name          Size     VMA              File off         Algn  Type
+# CHECK-NEXT:   0 .aaa          00000008 0000000000010000 0000000000004000 2**0  DATA
+# CHECK-NEXT:   1 .bbb          00000008 0000000000011000 0000000000005000 2**12  DATA
+# CHECK-NEXT:   2 .ccc          00000008 0000000000014000 0000000000008000 2**14  DATA

lld/test/ELF/linkerscript/at2.test

 # CHECK-NEXT:       PF_R
 # CHECK-NEXT:       PF_W
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Alignment: 4096
 # CHECK-NEXT:   }
 
 # SECTIONS:      Sections:
 # SECTIONS-NEXT: Idx Name          Size     VMA
-# SECTIONS-NEXT:   0               00000000 0000000000000000
-# SECTIONS-NEXT:   1 .foo1         00000008 0000000000002000
-# SECTIONS-NEXT:   2 .foo2         00000008 0000000000002008
-# SECTIONS-NEXT:   3 .text         00000000 0000000000002010
-# SECTIONS-NEXT:   4 .bar1         00000008 0000000000003000
-# SECTIONS-NEXT:   5 .bar2         00000008 0000000000003008
-# SECTIONS-NEXT:   6 .bar3         00000008 0000000000003010
+# SECTIONS-NEXT:   0 .foo1         00000008 0000000000002000
+# SECTIONS-NEXT:   1 .foo2         00000008 0000000000002008
+# SECTIONS-NEXT:   2 .text         00000000 0000000000002010
+# SECTIONS-NEXT:   3 .bar1         00000008 0000000000003000
+# SECTIONS-NEXT:   4 .bar2         00000008 0000000000003008
+# SECTIONS-NEXT:   5 .bar3         00000008 0000000000003010

lld/test/ELF/linkerscript/constructor.test

 # REQUIRES: x86
 # RUN: echo '.section foo, "a"; .byte 0' \
 # RUN:   | llvm-mc -filetype=obj -triple=x86_64-unknown-linux - -o %t.o
 # RUN: ld.lld -o %t1 --script %s %t.o
 
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size
-# CHECK-NEXT:   0               00000000
-# CHECK-NEXT:   1 foo           00000001
+# CHECK-NEXT:   0 foo           00000001
 
 SECTIONS {
   foo : {
     *(.foo)
     CONSTRUCTORS
   }
 }

lld/test/ELF/linkerscript/define.test

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/define.s -o %t.o
 # RUN: ld.lld -o %t --script %s %t.o
 # RUN: llvm-objdump -section-headers %t | FileCheck %s
 
 SECTIONS {
   . = DEFINED(defined) ? 0x11000 : .;
   .foo : { *(.foo*) }
   . = DEFINED(notdefined) ? 0x12000 : 0x13000;
   .bar : { *(.bar*) }
 }
 
-# CHECK: 1 .foo  00000008 0000000000011000 DATA
-# CHECK: 2 .bar  00000008 0000000000013000 DATA
-# CHECK: 3 .text 00000000 0000000000013008 TEXT
+# CHECK: 0 .foo  00000008 0000000000011000 0000000000001000 2**0 DATA
+# CHECK: 1 .bar  00000008 0000000000013000 0000000000003000 2**0 DATA
+# CHECK: 2 .text 00000000 0000000000013008 0000000000003008 2**2 TEXT

lld/test/ELF/linkerscript/double-bss.test

 # REQUIRES: x86
 # RUN: echo '.short 0; .bss; .zero 4; .comm q,128,8' \
 # RUN:   | llvm-mc -filetype=obj -triple=x86_64-unknown-linux - -o %t
 # RUN: ld.lld -o %t1 --script %s %t
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
-# CHECK:      .bss1          00000004 0000000000000122 BSS
-# CHECK-NEXT: .bss2          00000080 0000000000000128 BSS
+# CHECK:      .bss1          00000004 0000000000000122 0000000000000122 2**0 BSS
+# CHECK-NEXT: .bss2          00000080 0000000000000128 0000000000000122 2**3 BSS
 
 SECTIONS {
   . = SIZEOF_HEADERS;
   .text : { *(.text*) }
   .bss1 : { *(.bss) }
   .bss2 : { *(COMMON) }
 }

lld/test/ELF/linkerscript/eh-frame-emit-relocs.s

 # REQUIRES: x86
 # RUN: echo "SECTIONS { .foo : { *(.eh_frame) } }" > %t.script
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld --emit-relocs %t.o -T %t.script -o %t
-# RUN: llvm-objdump -section-headers %t | FileCheck %s
+# RUN: llvm-readelf --sections %t | FileCheck %s
 
 # CHECK-NOT: eh_frame
 # CHECK:     .rela.foo
 # CHECK-NOT: eh_frame
 
 .text
  .cfi_startproc
  .cfi_endproc

lld/test/ELF/linkerscript/emit-reloc-section-names.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: echo "SECTIONS { .text.zed : { *(.text.foo) } .text.qux : { *(.text.bar) } }" > %t.script
 # RUN: ld.lld -T %t.script --emit-relocs %t.o -o %t
-# RUN: llvm-objdump -section-headers %t | FileCheck %s
+# RUN: llvm-readelf --sections %t | FileCheck %s
 
 ## Check we name relocation sections in according to
 ## their target sections names.
 
 # CHECK: .text.zed
 # CHECK: .text.qux
 # CHECK: .rela.text.zed
 # CHECK: .rela.text.qux
 
 .section .text.foo,"ax"
 foo:
  mov $bar, %rax
 
 .section .text.bar,"ax"
 bar:
  mov $foo, %rax

lld/test/ELF/linkerscript/expr-sections.test

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux /dev/null -o %t.o
 # RUN: ld.lld -o %t.so --script %s %t.o -shared
 # RUN: llvm-objdump -t -h %t.so | FileCheck %s
 
 SECTIONS {
   . = . + 4;
   .text : {
     *(.text)
     foo1 = ADDR(.text) + 1; bar1 = 1 + ADDR(.text);
     foo2 = ADDR(.text) & 1; bar2 = 1 & ADDR(.text);
     foo3 = ADDR(.text) | 1; bar3 = 1 | ADDR(.text);
   }
 };
 
-# CHECK:  5 .text         00000000 000000000000014c
+# CHECK:  4 .text         00000000 000000000000014c
 
 # CHECK: 000000000000014d         .text    00000000 foo1
 # CHECK: 000000000000014d         .text    00000000 bar1
 # CHECK: 0000000000000000         .text    00000000 foo2
 # CHECK: 0000000000000000         .text    00000000 bar2
 # CHECK: 000000000000014d         .text    00000000 foo3
 # CHECK: 000000000000014d         .text    00000000 bar3

lld/test/ELF/linkerscript/input-sec-dup.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS {.foo : { *(.foo) *(.foo) } }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size
-# CHECK-NEXT:   0               00000000
-# CHECK-NEXT:   1 .foo          00000004
-# CHECK-NEXT:   2 .text         00000001
+# CHECK-NEXT:   0 .foo          00000004
+# CHECK-NEXT:   1 .text         00000001
 
 .global _start
 _start:
  nop
 
 .section .foo,"a"
  .long 0

lld/test/ELF/linkerscript/insert-after.test

 
 SECTIONS {
   .foo.text : { *(.foo.text) }
 } INSERT AFTER .text;
 
 # RUN: ld.lld %t1.o -o %t1 --script %p/Inputs/insert-after.script --script %s
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 # CHECK:      Sections:
-# CHECK-NEXT: Idx Name          Size     VMA              Type
-# CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 .text         00000008 0000000000000000 TEXT
-# CHECK-NEXT:   2 .foo.text     00000008 0000000000000008 TEXT
-# CHECK-NEXT:   3 .data         00000008 0000000000000010 DATA
-# CHECK-NEXT:   4 .foo.data     00000008 0000000000000018 DATA
+# CHECK-NEXT: Idx Name          Size     VMA              File off         Algn Type
+# CHECK-NEXT:   0 .text         00000008 0000000000000000 0000000000001000 2**2 TEXT
+# CHECK-NEXT:   1 .foo.text     00000008 0000000000000008 0000000000001008 2**0 TEXT
+# CHECK-NEXT:   2 .data         00000008 0000000000000010 0000000000001010 2**0 DATA
+# CHECK-NEXT:   3 .foo.data     00000008 0000000000000018 0000000000001018 2**0 DATA
 
 # RUN: not ld.lld %t1.o -o %t1 --script %s 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=ERR
 # ERR-DAG: error: unable to INSERT AFTER/BEFORE .text: section not defined
 # ERR-DAG: error: unable to INSERT AFTER/BEFORE .data: section not defined

lld/test/ELF/linkerscript/insert-before.test

 
 SECTIONS {
   .foo.text : { *(.foo.text) }
 } INSERT BEFORE .text;
 
 # RUN: ld.lld %t1.o -o %t1 --script %p/Inputs/insert-after.script --script %s
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 # CHECK:      Sections:
-# CHECK-NEXT: Idx Name          Size     VMA         Type
-# CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 .foo.text     00000008 0000000000000000 TEXT
-# CHECK-NEXT:   2 .text         00000008 0000000000000008 TEXT
-# CHECK-NEXT:   3 .foo.data     00000008 0000000000000010 DATA
-# CHECK-NEXT:   4 .data         00000008 0000000000000018 DATA
+# CHECK-NEXT: Idx Name          Size     VMA              File off         Algn Type
+# CHECK-NEXT:   0 .foo.text     00000008 0000000000000000 0000000000001000 2**0 TEXT
+# CHECK-NEXT:   1 .text         00000008 0000000000000008 0000000000001008 2**2 TEXT
+# CHECK-NEXT:   2 .foo.data     00000008 0000000000000010 0000000000001010 2**0 DATA
+# CHECK-NEXT:   3 .data         00000008 0000000000000018 0000000000001018 2**0 DATA
 
 # RUN: not ld.lld %t1.o -o %t1 --script %s 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=ERR
 # ERR-DAG: error: unable to INSERT AFTER/BEFORE .text: section not defined
 # ERR-DAG: error: unable to INSERT AFTER/BEFORE .data: section not defined

lld/test/ELF/linkerscript/memory-include.test

 # REQUIRES: x86
 
 # RUN: echo '.section .text,"ax"; .global _start; nop' > %t.s
 # RUN: echo '.section .data,"aw"; .quad 0' >> %t.s
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t.s -o %t.o
 
 # RUN: echo "RAM2 (rwx): ORIGIN = 0x3000, LENGTH = 0x100" > %t.inc
 # RUN: ld.lld -o %t.elf --script %s %t.o -L %T
 # RUN: llvm-objdump -section-headers %t.elf | FileCheck %s
-# CHECK: .data         00000008 0000000000002000 DATA
-# CHECK: .data2        00000008 0000000000003000 DATA
+# CHECK: .data         00000008 0000000000002000 0000000000002000 2**0 DATA
+# CHECK: .data2        00000008 0000000000003000 0000000000003000 2**0 DATA
 
 MEMORY {
   ROM (rwx): ORIGIN = 0x1000, LENGTH = 0x100
   RAM (rwx): ORIGIN = 0x2000, LENGTH = 0x100
   INCLUDE "memory-include.test.tmp.inc"
 }
 
 SECTIONS {
   .text : { *(.text*) } > ROM
   .data : { *(.data*) } > RAM
   .data2 : { QUAD(0) } > RAM2
 }

lld/test/ELF/linkerscript/memory.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 ## Check simple RAM-only memory region.
 
 # RUN: echo "MEMORY { ram (rwx) : ORIGIN = 0x8000, LENGTH = 256K } \
 # RUN: SECTIONS { \
 # RUN:   .text : { *(.text) } > ram \
 # RUN:   .data : { *(.data) } > ram \
 # RUN: }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix=RAM %s
 
-# RAM:       1 .text         00000001 0000000000008000 TEXT
-# RAM-NEXT:  2 .data         00001000 0000000000008001 DATA
+# RAM:       0 .text         00000001 0000000000008000 0000000000001000 2**2 TEXT
+# RAM-NEXT:  1 .data         00001000 0000000000008001 0000000000001001 2**0 DATA
 
 ## Check RAM and ROM memory regions.
 
 # RUN: echo "MEMORY { \
 # RUN:   ram (rwx) : ORIGIN = 0, LENGTH = 1024M \
 # RUN:   rom (rx) : org = (0x80 * 0x1000 * 0x1000), len = 64M \
 # RUN: } \
 # RUN: SECTIONS { \
 # RUN:   .text : { *(.text) } >rom \
 # RUN:   .data : { *(.data) } >ram \
 # RUN: }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix=RAMROM %s
 
-# RAMROM:       1 .text         00000001 0000000080000000 TEXT
-# RAMROM-NEXT:  2 .data         00001000 0000000000000000 DATA
+# RAMROM:       0 .text         00000001 0000000080000000 0000000000001000 2**2 TEXT
+# RAMROM-NEXT:  1 .data         00001000 0000000000000000 0000000000002000 2**0 DATA
 
 ## Check memory region placement by attributes.
 
 # RUN: echo "MEMORY { \
 # RUN:   ram (!rx) : ORIGIN = 0, LENGTH = 1024M \
 # RUN:   rom (rx) : o = 0x80000000, l = 64M \
 # RUN: } \
 # RUN: SECTIONS { \
 # RUN:   .text : { *(.text) } \
 # RUN:   .data : { *(.data) } > ram \
 # RUN: }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix=ATTRS %s
 
-# ATTRS:  1 .text         00000001 0000000080000000 TEXT
-# ATTRS:  2 .data         00001000 0000000000000000 DATA
+# ATTRS:  0 .text         00000001 0000000080000000 0000000000001000 2**2 TEXT
+# ATTRS:  1 .data         00001000 0000000000000000 0000000000002000 2**0 DATA
 
 ## Check bad `ORIGIN`.
 
 # RUN: echo "MEMORY { ram (rwx) : XYZ = 0x8000 } }" > %t.script
 # RUN: not ld.lld -o %t2 --script %t.script %t 2>&1 \
 # RUN:  | FileCheck -check-prefix=ERR1 %s
 # ERR1: {{.*}}.script:1: expected one of: ORIGIN, org, or o
 

lld/test/ELF/linkerscript/memory3.s

 # RUN:                ram2 (ax) : ORIGIN = 0x4000, LENGTH = 1K } \
 # RUN: SECTIONS {}" > %t2.script
 # RUN: ld.lld -o %t2 --script %t2.script %t
 # RUN: llvm-objdump -section-headers %t2 | FileCheck %s
 
 ## Check we place .text into first defined memory region with appropriate flags.
 # CHECK: Sections:
 # CHECK: Idx Name  Size     VMA
-# CHECK:   0       00000000 0000000000000000
-# CHECK:   1 .text 00000001 0000000000001000
+# CHECK:   0 .text 00000001 0000000000001000
 
 .section .text.foo,"ax",%progbits
 foo:
   nop

lld/test/ELF/linkerscript/memory4.test

 # REQUIRES: x86
 # RUN: echo ".section .text,\"ax\"; nop; .section .data,\"aw\"; nop;" \
 # RUN:   | llvm-mc -filetype=obj -triple=x86_64-pc-linux - -o %t.o
 # RUN: ld.lld -o %t.so --script %s %t.o
 # RUN: llvm-objdump -section-headers %t.so | FileCheck %s
 
-# CHECK:      1 .text         00000001 0000000000042000
-# CHECK-NEXT: 2 .data         00000001 0000000000042400
+# CHECK:      0 .text         00000001 0000000000042000
+# CHECK-NEXT: 1 .data         00000001 0000000000042400
 
 ## Test that address expressions changes the position in a memory region.
 
 MEMORY {
   ram (wxa) : ORIGIN = 0x42000, LENGTH = 0x100000
 }
 SECTIONS {
   .text : { *(.text*) }
   data_addr = ALIGN(1024); 
   .data data_addr : { *(.data*) }
 }

lld/test/ELF/linkerscript/memory5.test

 # REQUIRES: x86
 # RUN: echo ".section .text,\"ax\"; nop; .section .data,\"aw\"; nop;" \
 # RUN:   | llvm-mc -filetype=obj -triple=x86_64-pc-linux - -o %t.o
 # RUN: ld.lld -o %t.so --script %s %t.o
 # RUN: llvm-objdump -section-headers %t.so | FileCheck %s
 
-# CHECK:      1 .text         00000001 0000000000042000
-# CHECK-NEXT: 2 .data         00000001 0000000000042001
+# CHECK:      0 .text         00000001 0000000000042000
+# CHECK-NEXT: 1 .data         00000001 0000000000042001
 
 ## Test that assigning to Dot does not change the position in a memory region.
 
 MEMORY {
   ram (wxa) : ORIGIN = 0x42000, LENGTH = 0x100000
 }
 SECTIONS {
   .text : { *(.text*) }
   . += 0x2000;
   .data : { *(.data*) }
 }

lld/test/ELF/linkerscript/multi-sections-constraint.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: echo "SECTIONS { \
 # RUN:  .text : { *(.text) } \
 # RUN:  . = 0x1000; .aaa : ONLY_IF_RO { *(.aaa.*) } \
 # RUN:  . = 0x2000; .aaa : ONLY_IF_RW { *(.aaa.*) } } " > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 
 # CHECK:      Sections:
-# CHECK-NEXT: Idx Name          Size      VMA          Type
-# CHECK: .aaa          00000010 0000000000002000 DATA
+# CHECK-NEXT: Idx Name Size VMA File off Algn Type
+# CHECK: .aaa          00000010 0000000000002000 0000000000002000 2**0 DATA
 
 
 # RUN: echo "SECTIONS { \
 # RUN:  .text : { *(.text) } \
 # RUN:  . = 0x1000; .aaa : ONLY_IF_RW { *(.aaa.*) } \
 # RUN:  . = 0x2000; .aaa : ONLY_IF_RO { *(.aaa.*) } } " > %t2.script
 # RUN: ld.lld -o %t2 --script %t2.script %t
 # RUN: llvm-objdump -section-headers %t2 | FileCheck %s --check-prefix=REV
 
 # REV:      Sections:
-# REV-NEXT: Idx Name          Size       VMA          Type
-# REV:  .aaa          00000010 0000000000001000 DATA
+# REV-NEXT: Idx Name Size VMA File off Algn Type
+# REV:  .aaa          00000010 0000000000001000 0000000000002000 2**0 DATA
 
 .global _start
 _start:
  nop
 
 .section .aaa.1, "aw"
 .quad 1
 
 .section .aaa.2, "aw"
 .quad 1

lld/test/ELF/linkerscript/non-absolute2.test

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux /dev/null -o %t1.o
 # RUN: ld.lld -shared %t1.o --script %s -o %t
 # RUN: llvm-objdump -section-headers -t %t | FileCheck %s
 
 SECTIONS {
   A = . + 0x1;
   . += 0x1000;
 }
 
 # CHECK:       Sections:
 # CHECK-NEXT:  Idx Name          Size     VMA
-# CHECK-NEXT:    0               00000000 0000000000000000
-# CHECK-NEXT:    1 .dynsym       00000030 0000000000001000
-# CHECK:         5 .text         00000000 000000000000106c
+# CHECK-NEXT:    0 .dynsym       00000030 0000000000001000
+# CHECK:         4 .text         00000000 000000000000106c
 
 # CHECK: 0000000000000001         .dynsym            00000000 A

lld/test/ELF/linkerscript/numbers.s

 # RUN:  . = 2M;                 \
 # RUN:  .mega2 : { *(.mega.2) } \
 # RUN: }" > %t.script
 # RUN: ld.lld %t --script %t.script -o %t2
 # RUN: llvm-objdump -section-headers %t2 | FileCheck %s
 
 # CHECK:     Sections:
 # CHECK-NEXT: Idx Name          Size     VMA
-# CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 .hex1         00000008 0000000000001000
-# CHECK-NEXT:   2 .hex2         00000008 0000000000001010
-# CHECK-NEXT:   3 .kilo1        00000008 0000000000002800
-# CHECK-NEXT:   4 .kilo2        00000008 0000000000002c00
-# CHECK-NEXT:   5 .mega1        00000008 0000000000100000
-# CHECK-NEXT:   6 .mega2        00000008 0000000000200000
+# CHECK-NEXT:   0 .hex1         00000008 0000000000001000
+# CHECK-NEXT:   1 .hex2         00000008 0000000000001010
+# CHECK-NEXT:   2 .kilo1        00000008 0000000000002800
+# CHECK-NEXT:   3 .kilo2        00000008 0000000000002c00
+# CHECK-NEXT:   4 .mega1        00000008 0000000000100000
+# CHECK-NEXT:   5 .mega2        00000008 0000000000200000
 
 ## Mailformed number errors.
 # RUN: echo "SECTIONS { . = 0x11h; }" > %t2.script
 # RUN: not ld.lld %t --script %t2.script -o /dev/null 2>&1 | \
 # RUN:  FileCheck --check-prefix=ERR1 %s
 # ERR1: malformed number: 0x11h
 
 # RUN: echo "SECTIONS { . = 0x11k; }" > %t3.script

 # RUN: echo "SECTIONS { \
 # RUN:  .hex1 0x400 : { *(.hex.1) } \
 # RUN:  .hex2 0x500:{ *(.hex.2) } \
 # RUN: }" > %t8.script
 # RUN: ld.lld %t --script %t8.script -o %t6
 # RUN: llvm-objdump -section-headers %t6 | FileCheck -check-prefix=SECADDR %s
 # SECADDR:     Sections:
 # SECADDR-NEXT: Idx Name          Size     VMA
-# SECADDR-NEXT:   0               00000000 0000000000000000
-# SECADDR-NEXT:   1 .hex1         00000008 0000000000000400
-# SECADDR-NEXT:   2 .hex2         00000008 0000000000000500
+# SECADDR-NEXT:   0 .hex1         00000008 0000000000000400
+# SECADDR-NEXT:   1 .hex2         00000008 0000000000000500
 
 .globl _start
 _start:
 nop
 
 .section .hex.1, "a"
 .quad 0
 

lld/test/ELF/linkerscript/orphan.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: echo "SECTIONS {       \
 # RUN:  .text : { *(.text) }  \
 # RUN:  .rw1 : { *(.rw1) }    \
 # RUN:  .rw2 : { *(.rw2) }    \
 # RUN:  .rw3 : { *(.rw3) }    \
 # RUN: }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 
 ## .jcr is a relro section and should be placed before other RW sections.
 ## .bss is SHT_NOBITS section and should be last RW section, so some space
 ## in ELF file could be saved.
-# CHECK:       0               00000000 0000000000000000
-# CHECK-NEXT:  1 .text         00000000 0000000000000000 TEXT
-# CHECK-NEXT:  2 .jcr          00000008 0000000000000000 DATA
-# CHECK-NEXT:  3 .rw1          00000008 0000000000000008 DATA
-# CHECK-NEXT:  4 .rw2          00000008 0000000000000010 DATA
-# CHECK-NEXT:  5 .rw3          00000008 0000000000000018 DATA
-# CHECK-NEXT:  6 .bss          00000008 0000000000000020 BSS
+# CHECK:       0 .text         00000000 0000000000000000 0000000000001000 2**2 TEXT
+# CHECK-NEXT:  1 .jcr          00000008 0000000000000000 0000000000001000 2**0 DATA
+# CHECK-NEXT:  2 .rw1          00000008 0000000000000008 0000000000001008 2**0 DATA
+# CHECK-NEXT:  3 .rw2          00000008 0000000000000010 0000000000001010 2**0 DATA
+# CHECK-NEXT:  4 .rw3          00000008 0000000000000018 0000000000001018 2**0 DATA
+# CHECK-NEXT:  5 .bss          00000008 0000000000000020 0000000000001020 2**0 BSS
 
 .section .rw1, "aw"
  .quad 0
 
 .section .rw2, "aw"
  .quad 0
 
 .section .rw3, "aw"
  .quad 0
 
 .section .jcr, "aw"
  .quad 0
 
 .section .bss, "aw",@nobits
  .quad 0

lld/test/ELF/linkerscript/orphans.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS { .writable : { *(.writable) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=TEXTORPHAN %s
 
 # RUN: echo "SECTIONS { .text : { *(.text) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=WRITABLEORPHAN %s
 
 # TEXTORPHAN:      Sections:
 # TEXTORPHAN-NEXT: Idx Name
-# TEXTORPHAN-NEXT:   0
-# TEXTORPHAN-NEXT:   1 .text
-# TEXTORPHAN-NEXT:   2 .writable
+# TEXTORPHAN-NEXT:   0 .text
+# TEXTORPHAN-NEXT:   1 .writable
 
 # WRITABLEORPHAN:      Sections:
 # WRITABLEORPHAN-NEXT: Idx Name
-# WRITABLEORPHAN-NEXT:   0
-# WRITABLEORPHAN-NEXT:   1 .text
-# WRITABLEORPHAN-NEXT:   2 .writable
+# WRITABLEORPHAN-NEXT:   0 .text
+# WRITABLEORPHAN-NEXT:   1 .writable
 
 .global _start
 _start:
  nop
 
 .section .writable,"aw"
  .zero 4

lld/test/ELF/linkerscript/out-of-order-section-in-region.test

 # REQUIRES: x86
 
 # RUN: echo ".section .aaa, \"a\"; .quad 0; .section .bbb, \"a\"; .quad 0;" \
 # RUN:   | llvm-mc -filetype=obj -triple=x86_64-pc-linux - -o %t
 # RUN: ld.lld %t --script %s -o %t2
 
 # RUN: llvm-objdump -section-headers %t2 | FileCheck %s
-# CHECK: .aaa 00000008 0000000000001008 DATA
-# CHECK: .bbb 00000008 0000000000001000 DATA
+# CHECK: .aaa 00000008 0000000000001008 0000000000001008 2**0 DATA
+# CHECK: .bbb 00000008 0000000000001000 0000000000001000 2**0 DATA
 
 MEMORY {
   REGION (rwx) : ORIGIN = 0x1000, LENGTH = 0x100
 }
 
 SECTIONS {
   .aaa ORIGIN(REGION) + 0x8 : { *(.aaa) } > REGION
   _stext = .;
   .bbb ORIGIN(REGION) : { *(.bbb) } > REGION
   . = _stext;
 }

lld/test/ELF/linkerscript/out-of-order.s

 # .dynstr current address cursor, which is the end # of .dynsym and so
 # on for later sections.
 
 # Also note, it is absolutely *illegal* to have section addresses of
 # the same segment in none-increasing order, authors of linker scripts
 # must take responsibility to make sure this does not happen.
 
 # CHECK:      Sections:
-# CHECK-NEXT: Idx Name          Size     VMA              Type
-# CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 .dynamic      00000060 0000000000000000
-# CHECK-NEXT:   2 .data         00000008 0000000000004000
-# CHECK-NEXT:   3 .dynsym       00000018 0000000000002000
-# CHECK-NEXT:   4 .dynstr       00000001 0000000000002018
-# CHECK-NEXT:   5 .hash         00000010 000000000000201c
-# CHECK-NEXT:   6 .text         00000008 000000000000202c
+# CHECK-NEXT: Idx Name          Size     VMA              File off Algn Type
+# CHECK-NEXT:   0 .dynamic      00000060 0000000000000000
+# CHECK-NEXT:   1 .data         00000008 0000000000004000
+# CHECK-NEXT:   2 .dynsym       00000018 0000000000002000
+# CHECK-NEXT:   3 .dynstr       00000001 0000000000002018
+# CHECK-NEXT:   4 .hash         00000010 000000000000201c
+# CHECK-NEXT:   5 .text         00000008 000000000000202c
 
 .quad 0
 .data
 .quad 0
 

lld/test/ELF/linkerscript/output-section-include.test

 # REQUIRES: x86
 
 # RUN: echo '.section .text,"ax"; .global _start; nop' > %t.s
 # RUN: echo '.section .data,"aw"; .quad 0' >> %t.s
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t.s -o %t.o
 
 ## Empty include file.
 # RUN: echo "" > %t.inc
 # RUN: ld.lld -o %t.elf --script %s %t.o -L %T
 # RUN: llvm-objdump -section-headers %t.elf | FileCheck %s --check-prefix=CHECK1
-# CHECK1: .data         00000008 0000000000002000 DATA
+# CHECK1: .data         00000008 0000000000002000 0000000000002000 2**0 DATA
 
 ## Non-empty include file.
 # RUN: echo "QUAD(0)" > %t.inc
 # RUN: ld.lld -o %t.elf --script %s %t.o -L %T
 # RUN: llvm-objdump -section-headers %t.elf | FileCheck %s --check-prefix=CHECK2
-# CHECK2: .data         00000010 0000000000002000 DATA
+# CHECK2: .data         00000010 0000000000002000 0000000000002000 2**0 DATA
 
 MEMORY {
   ROM (rwx): ORIGIN = 0x1000, LENGTH = 0x100
   RAM (rwx): ORIGIN = 0x2000, LENGTH = 0x100
 }
 
 SECTIONS {
   .text : { *(.text*) } > ROM
   .data : {
     *(.data*)
     INCLUDE "output-section-include.test.tmp.inc"
   } > RAM
 }

lld/test/ELF/linkerscript/region-alias.s

 # RUN:  .data : { *(.data*) } > ALIAS_DATA             \
 # RUN: }" > %t.script
 
 ## .text to ROM, .data to RAM.
 # RUN: echo "REGION_ALIAS (\"ALIAS_TEXT\", ROM);" > %t.script.inc
 # RUN: echo "REGION_ALIAS (\"ALIAS_DATA\", RAM);" >> %t.script.inc
 # RUN: ld.lld %t --script %t.script -o %t2
 # RUN: llvm-objdump -section-headers %t2 | FileCheck %s
-# CHECK: .text       00000001 0000000000001000 TEXT
-# CHECK: .data       00000008 0000000000002000 DATA
+# CHECK: .text       00000001 0000000000001000 0000000000001000 2**2 TEXT
+# CHECK: .data       00000008 0000000000002000 0000000000002000 2**0 DATA
 
 ## All to ROM.
 # RUN: echo "REGION_ALIAS (\"ALIAS_TEXT\", ROM);" > %t.script.inc
 # RUN: echo "REGION_ALIAS (\"ALIAS_DATA\", ROM);" >> %t.script.inc
 # RUN: ld.lld %t --script %t.script -o %t2
 # RUN: llvm-objdump -section-headers %t2 | FileCheck %s --check-prefix=RAM
-# RAM: .text         00000001 0000000000001000 TEXT
-# RAM: .data         00000008 0000000000001001 DATA
+# RAM: .text         00000001 0000000000001000 0000000000001000 2**2 TEXT
+# RAM: .data         00000008 0000000000001001 0000000000001001 2**0 DATA
 
 ## Redefinition of region.
 # RUN: echo "REGION_ALIAS (\"ROM\", ROM);" > %t.script.inc
 # RUN: not ld.lld %t --script %t.script -o %t2 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=ERR1
 # ERR1: {{.*}}script.inc:1: redefinition of memory region 'ROM'
 
 ## Redefinition of alias.

lld/test/ELF/linkerscript/repsection-va.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS {.foo : {*(.foo.*)} }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 # CHECK:      Sections:
-# CHECK-NEXT: Idx Name          Size     VMA          Type
+# CHECK-NEXT: Idx Name Size VMA File off Algn Type
 # CHECK-NOT: .foo
 # CHECK:  .foo          00000008 {{.*}} DATA
 # CHECK-NOT: .foo
 
 
 .global _start
 _start:
  nop
 
 .section .foo.1,"a"
 foo1:
  .long 0
 
 .section .foo.2,"aw"
 foo2:
  .long 0

lld/test/ELF/linkerscript/section-include.test

 # REQUIRES: x86
 
 # RUN: echo '.section .text,"ax"; .global _start; nop' > %t.s
 # RUN: echo '.section .data,"aw"; .quad 0' >> %t.s
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t.s -o %t.o
 
 ## Empty include file.
 # RUN: echo "" > %t.inc
 # RUN: ld.lld -o %t.elf --script %s %t.o -L %T
 # RUN: llvm-objdump -section-headers %t.elf | FileCheck %s --check-prefix=CHECK1
-# CHECK1:      .data         00000008 0000000000002000 DATA
-# CHECK1-NEXT: .data3        00000008 0000000000002008 DATA
+# CHECK1:      .data         00000008 0000000000002000 0000000000002000 2**0 DATA
+# CHECK1-NEXT: .data3        00000008 0000000000002008 0000000000002008 2**0 DATA
 
 ## Non-empty include file.
 # RUN: echo ".data2 : { QUAD(0) } > RAM" > %t.inc
 # RUN: ld.lld -o %t.elf --script %s %t.o -L %T
 # RUN: llvm-objdump -section-headers %t.elf | FileCheck %s --check-prefix=CHECK2
-# CHECK2:      .data         00000008 0000000000002000 DATA
-# CHECK2-NEXT: .data2        00000008 0000000000002008 DATA
-# CHECK2-NEXT: .data3        00000008 0000000000002010 DATA
+# CHECK2:      .data         00000008 0000000000002000 0000000000002000 2**0 DATA
+# CHECK2-NEXT: .data2        00000008 0000000000002008 0000000000002008 2**0 DATA
+# CHECK2-NEXT: .data3        00000008 0000000000002010 0000000000002010 2**0 DATA
 
 MEMORY {
   ROM (rwx): ORIGIN = 0x1000, LENGTH = 0x100
   RAM (rwx): ORIGIN = 0x2000, LENGTH = 0x100
 }
 
 SECTIONS {
   .text : { *(.text*) } > ROM
   .data : { *(.data*) } > RAM
   INCLUDE "section-include.test.tmp.inc"
   .data3 : { QUAD(0) } > RAM
 }

lld/test/ELF/linkerscript/sections-constraint.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: echo "SECTIONS { \
 # RUN:  .writable : ONLY_IF_RW { *(.writable) } \
 # RUN:  .readable : ONLY_IF_RO { *(.readable) }}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | \
 # RUN:   FileCheck -check-prefix=BASE %s
 # BASE: Sections:
 # BASE-NEXT: Idx Name          Size
-# BASE-NEXT:   0               00000000
 # BASE:   .writable     00000004
 # BASE:   .readable     00000004
 
 # RUN: echo "SECTIONS { \
 # RUN:  .foo : ONLY_IF_RO { *(.foo.*) } \
 # RUN:  .writable : ONLY_IF_RW { *(.writable) } \
 # RUN:  .readable : ONLY_IF_RO { *(.readable) }}" > %t2.script
 # RUN: ld.lld -o %t2 --script %t2.script %t
 # RUN: llvm-objdump -section-headers %t2 | \
 # RUN:   FileCheck -check-prefix=NO1 %s
 # NO1: Sections:
 # NO1-NEXT: Idx Name          Size
-# NO1-NEXT: 0               00000000
 # NO1:  .writable     00000004
 # NO1:  .foo.2        00000004
 # NO1:  .readable     00000004
 # NO1:  .foo.1        00000004
 
 .global _start
 _start:
   nop

lld/test/ELF/linkerscript/sections-gc2.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: echo "SECTIONS { \
 # RUN:         used_in_reloc : { *(used_in_reloc) } \
 # RUN:         used_in_script : { *(used_in_script) } \
 # RUN:         .text : { *(.text) } \
 # RUN:       }" > %t.script
 # RUN: ld.lld -T %t.script -o %t.so %t.o --gc-sections
 # RUN: llvm-objdump -h %t.so | FileCheck %s
 
-# CHECK: Idx Name          Size      VMA          Type
-# CHECK-NEXT:  0
+# CHECK: Idx Name Size VMA File off Algn Type
 # CHECK-NEXT:    used_in_reloc
 # CHECK-NEXT:    .text
 # CHECK-NEXT:    .comment
-# CHECK-NEXT:    .symtab
-# CHECK-NEXT:    .shstrtab
-# CHECK-NEXT:    .strtab
 
         .global _start
 _start:
         .quad __start_used_in_reloc
 
         .section unused,"a"
         .quad 0
 
         .section used_in_script,"a"
         .quad __start_used_in_script
 
         .section used_in_reloc,"a"
         .quad 0

lld/test/ELF/linkerscript/sections-keep.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/keep.s -o %t1.o
 
 ## First check that section "keep" is garbage collected without using KEEP
 # RUN: echo "SECTIONS { \
 # RUN:  .text : { *(.text) } \
 # RUN:  .keep : { *(.keep) } \
 # RUN:  .temp : { *(.temp) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t --script %t.script %t.o
 # RUN: llvm-objdump -section-headers %t | \
 # RUN:   FileCheck -check-prefix=SECGC %s
 # SECGC:      Sections:
 # SECGC-NEXT: Idx Name          Size
-# SECGC-NEXT:   0               00000000
-# SECGC-NEXT:   1 .text         00000007
-# SECGC-NEXT:   2 .temp         00000004
+# SECGC-NEXT:   0 .text         00000007
+# SECGC-NEXT:   1 .temp         00000004
 
 ## Now apply KEEP command to preserve the section.
 # RUN: echo "SECTIONS { \
 # RUN:  .text : { *(.text) } \
 # RUN:  .keep : { KEEP(*(.keep)) } \
 # RUN:  .temp : { *(.temp) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t --script %t.script %t.o
 # RUN: llvm-objdump -section-headers %t | \
 # RUN:   FileCheck -check-prefix=SECNOGC %s
 # SECNOGC:      Sections:
 # SECNOGC-NEXT: Idx Name          Size
-# SECNOGC-NEXT:   0               00000000
-# SECNOGC-NEXT:   1 .text         00000007
-# SECNOGC-NEXT:   2 .keep         00000004
-# SECNOGC-NEXT:   3 .temp         00000004
+# SECNOGC-NEXT:   0 .text         00000007
+# SECNOGC-NEXT:   1 .keep         00000004
+# SECNOGC-NEXT:   2 .temp         00000004
 
 ## A section name matches two entries in the SECTIONS directive. The
 ## first one doesn't have KEEP, the second one does. If section that have
 ## KEEP is the first in order then section is NOT collected.
 # RUN: echo "SECTIONS { \
 # RUN:  . = SIZEOF_HEADERS; \
 # RUN:  .keep : { KEEP(*(.keep)) } \
 # RUN:  .nokeep : { *(.keep) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t --script %t.script %t.o
 # RUN: llvm-objdump -section-headers %t | FileCheck -check-prefix=MIXED1 %s
 # MIXED1:      Sections:
 # MIXED1-NEXT: Idx Name          Size
-# MIXED1-NEXT:   0               00000000
-# MIXED1-NEXT:   1 .keep         00000004
-# MIXED1-NEXT:   2 .temp         00000004 00000000000000ec
-# MIXED1-NEXT:   3 .text         00000007 00000000000000f0
-# MIXED1-NEXT:   4 .comment      00000008 0000000000000000
-# MIXED1-NEXT:   5 .symtab       00000060 0000000000000000
-# MIXED1-NEXT:   6 .shstrtab     00000036 0000000000000000
-# MIXED1-NEXT:   7 .strtab       00000012 0000000000000000
+# MIXED1-NEXT:   0 .keep         00000004
+# MIXED1-NEXT:   1 .temp         00000004 00000000000000ec
+# MIXED1-NEXT:   2 .text         00000007 00000000000000f0
+# MIXED1-NEXT:   3 .comment      00000008 0000000000000000
 
 ## The same, but now section without KEEP is at first place.
 ## gold and bfd linkers disagree here. gold collects .keep while
 ## bfd keeps it. Our current behavior is compatible with bfd although
 ## we can choose either way.
 # RUN: echo "SECTIONS { \
 # RUN:  . = SIZEOF_HEADERS; \
 # RUN:  .nokeep : { *(.keep) } \
 # RUN:  .keep : { KEEP(*(.keep)) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t --script %t.script %t.o
 # RUN: llvm-objdump -section-headers %t | FileCheck -check-prefix=MIXED2 %s
 # MIXED2:      Sections:
 # MIXED2-NEXT: Idx Name          Size
-# MIXED2-NEXT:   0               00000000
-# MIXED2-NEXT:   1 .nokeep       00000004 00000000000000e8
-# MIXED2-NEXT:   2 .temp         00000004 00000000000000ec
-# MIXED2-NEXT:   3 .text         00000007 00000000000000f0
-# MIXED2-NEXT:   4 .comment      00000008 0000000000000000
-# MIXED2-NEXT:   5 .symtab       00000060 0000000000000000
-# MIXED2-NEXT:   6 .shstrtab     00000038 0000000000000000
-# MIXED2-NEXT:   7 .strtab       00000012 0000000000000000
+# MIXED2-NEXT:   0 .nokeep       00000004 00000000000000e8
+# MIXED2-NEXT:   1 .temp         00000004 00000000000000ec
+# MIXED2-NEXT:   2 .text         00000007 00000000000000f0
+# MIXED2-NEXT:   3 .comment      00000008 0000000000000000
 
 # Check file pattern for kept sections.
 # RUN: echo "SECTIONS { \
 # RUN:  . = SIZEOF_HEADERS; \
 # RUN:  .keep : { KEEP(*1.o(.keep)) } \
 # RUN:  }" > %t.script
 # RUN: ld.lld --gc-sections -o %t --script %t.script %t1.o %t.o
 # RUN: llvm-objdump -s %t | FileCheck -check-prefix=FILEMATCH %s

lld/test/ELF/linkerscript/sections-sort.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 
 # RUN: echo "SECTIONS { .text : {*(.text)} foo : {*(foo)}}" > %t.script
 # RUN: ld.lld --hash-style=sysv -o %t --script %t.script %t.o -shared
 # RUN: llvm-objdump --section-headers %t | FileCheck  %s
 
 # Test the section order. This is a case where at least with libstdc++'s
 # stable_sort we used to get a different result.
 
 nop
 
 .section foo, "a"
 .byte 0
 
 # CHECK: Idx
-# CHECK-NEXT: 0
-# CHECK-NEXT: 1 .text
-# CHECK-NEXT: 2 .dynsym
-# CHECK-NEXT: 3 .hash
-# CHECK-NEXT: 4 .dynstr
-# CHECK-NEXT: 5 foo
-# CHECK-NEXT: 6 .dynamic
-# CHECK-NEXT: 7 .comment
-# CHECK-NEXT: 8 .symtab
-# CHECK-NEXT: 9 .shstrtab
-# CHECK-NEXT: 10 .strtab
+# CHECK-NEXT: 0 .text
+# CHECK-NEXT: 1 .dynsym
+# CHECK-NEXT: 2 .hash
+# CHECK-NEXT: 3 .dynstr
+# CHECK-NEXT: 4 foo
+# CHECK-NEXT: 5 .dynamic
+# CHECK-NEXT: 6 .comment

lld/test/ELF/linkerscript/sections.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # Empty SECTIONS command.
 # RUN: echo "SECTIONS {}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
-# RUN: llvm-objdump -section-headers %t1 | \
+# RUN: llvm-readelf --sections %t1 | \
 # RUN:   FileCheck -check-prefix=SEC-DEFAULT %s
 
 # SECTIONS command with the same order as default.
 # RUN: echo "SECTIONS { \
 # RUN:          .text : { *(.text) } \
 # RUN:          .data : { *(.data) } }" > %t.script
 # RUN: ld.lld -o %t2 --script %t.script %t
-# RUN: llvm-objdump -section-headers %t2 | \
+# RUN: llvm-readelf --sections %t2 | \
 # RUN:   FileCheck -check-prefix=SEC-DEFAULT %s
 
-#             Idx Name          Size
-# SEC-DEFAULT: 1 .text         0000000e {{[0-9a-f]*}} TEXT
-# SEC-DEFAULT: 2 .data         00000020 {{[0-9a-f]*}} DATA
-# SEC-DEFAULT: 3 other         00000003 {{[0-9a-f]*}} DATA
-# SEC-DEFAULT: 4 .bss          00000002 {{[0-9a-f]*}} BSS
-# SEC-DEFAULT: 5 .comment      00000008 {{[0-9a-f]*}}
-# SEC-DEFAULT: 6 .symtab       00000030 {{[0-9a-f]*}}
-# SEC-DEFAULT: 7 .shstrtab     0000003b {{[0-9a-f]*}}
-# SEC-DEFAULT: 8 .strtab       00000008 {{[0-9a-f]*}}
+#              [Nr] Name      Type     Address       Off           Size
+# SEC-DEFAULT: [ 1] .text     PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 00000e
+# SEC-DEFAULT: [ 2] .data     PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 000020
+# SEC-DEFAULT: [ 3] other     PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 000003
+# SEC-DEFAULT: [ 4] .bss      NOBITS   {{[0-9a-f]*}} {{[0-9a-f]*}} 000002
+# SEC-DEFAULT: [ 5] .comment  PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 000008
+# SEC-DEFAULT: [ 6] .symtab   SYMTAB   {{[0-9a-f]*}} {{[0-9a-f]*}} 000030
+# SEC-DEFAULT: [ 7] .shstrtab STRTAB   {{[0-9a-f]*}} {{[0-9a-f]*}} 00003b
+# SEC-DEFAULT: [ 8] .strtab   STRTAB   {{[0-9a-f]*}} {{[0-9a-f]*}} 000008
 
 # Sections are put in order specified in linker script, other than alloc
 # sections going first.
 # RUN: echo "SECTIONS { \
 # RUN:          .bss : { *(.bss) } \
 # RUN:          other : { *(other) } \
 # RUN:          .shstrtab : { *(.shstrtab) } \
 # RUN:          .symtab : { *(.symtab) } \
 # RUN:          .strtab : { *(.strtab) } \
 # RUN:          .data : { *(.data) } \
 # RUN:          .text : { *(.text) } }" > %t.script
 # RUN: ld.lld -o %t3 --script %t.script %t
-# RUN: llvm-objdump -section-headers %t3 | \
+# RUN: llvm-readelf --sections %t3 | \
 # RUN:   FileCheck -check-prefix=SEC-ORDER %s
 
-#           Idx Name          Size
-# SEC-ORDER: 1 .bss          00000002 {{[0-9a-f]*}} BSS
-# SEC-ORDER: 2 other         00000003 {{[0-9a-f]*}} DATA
-# SEC-ORDER: 3 .shstrtab     0000003b {{[0-9a-f]*}}
-# SEC-ORDER: 4 .symtab       00000030 {{[0-9a-f]*}}
-# SEC-ORDER: 5 .strtab       00000008 {{[0-9a-f]*}}
-# SEC-ORDER: 6 .comment      00000008 {{[0-9a-f]*}}
-# SEC-ORDER: 7 .data         00000020 {{[0-9a-f]*}} DATA
-# SEC-ORDER: 8 .text         0000000e {{[0-9a-f]*}} TEXT
+#            [Nr] Name      Type     Address       Off           Size
+# SEC-ORDER: [ 1] .bss      NOBITS   {{[0-9a-f]*}} {{[0-9a-f]*}} 000002
+# SEC-ORDER: [ 2] other     PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 000003
+# SEC-ORDER: [ 3] .shstrtab STRTAB   {{[0-9a-f]*}} {{[0-9a-f]*}} 00003b
+# SEC-ORDER: [ 4] .symtab   SYMTAB   {{[0-9a-f]*}} {{[0-9a-f]*}} 000030
+# SEC-ORDER: [ 5] .strtab   STRTAB   {{[0-9a-f]*}} {{[0-9a-f]*}} 000008
+# SEC-ORDER: [ 6] .comment  PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 000008
+# SEC-ORDER: [ 7] .data     PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 000020
+# SEC-ORDER: [ 8] .text     PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 00000e
 
 # .text and .data have swapped names but proper sizes and types.
 # RUN: echo "SECTIONS { \
 # RUN:          .data : { *(.text) } \
 # RUN:          .text : { *(.data) } }" > %t.script
 # RUN: ld.lld -o %t4 --script %t.script %t
-# RUN: llvm-objdump -section-headers %t4 | \
+# RUN: llvm-readelf --sections %t4 | \
 # RUN:   FileCheck -check-prefix=SEC-SWAP-NAMES %s
 
-#                Idx Name          Size
-# SEC-SWAP-NAMES: 1 .data         0000000e {{[0-9a-f]*}} TEXT
-# SEC-SWAP-NAMES: 2 .text         00000020 {{[0-9a-f]*}} DATA
-# SEC-SWAP-NAMES: 3 other         00000003 {{[0-9a-f]*}} DATA
-# SEC-SWAP-NAMES: 4 .bss          00000002 {{[0-9a-f]*}} BSS
-# SEC-SWAP-NAMES: 5 .comment      00000008 {{[0-9a-f]*}}
-# SEC-SWAP-NAMES: 6 .symtab       00000030 {{[0-9a-f]*}}
-# SEC-SWAP-NAMES: 7 .shstrtab     0000003b {{[0-9a-f]*}}
-# SEC-SWAP-NAMES: 8 .strtab       00000008 {{[0-9a-f]*}}
+#                 [Nr] Name      Type     Address       Off           Size
+# SEC-SWAP-NAMES: [ 1] .data     PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 00000e
+# SEC-SWAP-NAMES: [ 2] .text     PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 000020
+# SEC-SWAP-NAMES: [ 3] other     PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 000003
+# SEC-SWAP-NAMES: [ 4] .bss      NOBITS   {{[0-9a-f]*}} {{[0-9a-f]*}} 000002
+# SEC-SWAP-NAMES: [ 5] .comment  PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 000008
+# SEC-SWAP-NAMES: [ 6] .symtab   SYMTAB   {{[0-9a-f]*}} {{[0-9a-f]*}} 000030
+# SEC-SWAP-NAMES: [ 7] .shstrtab STRTAB   {{[0-9a-f]*}} {{[0-9a-f]*}} 00003b
+# SEC-SWAP-NAMES: [ 8] .strtab   STRTAB   {{[0-9a-f]*}} {{[0-9a-f]*}} 000008
 
 # Multiple SECTIONS command specifying additional input section descriptions
 # for the same output section description - input sections are merged into
 # one output section.
 # RUN: echo "SECTIONS { \
 # RUN:          .text : { *(.text) } \
 # RUN:          .data : { *(.data) } } \
 # RUN:       SECTIONS { \
 # RUN:          .data : { *(other) } }" > %t.script
 # RUN: ld.lld -o %t6 --script %t.script %t
-# RUN: llvm-objdump -section-headers %t6 | \
+# RUN: llvm-readelf --sections %t6 | \
 # RUN:   FileCheck -check-prefix=SEC-MULTI %s
 
-#           Idx Name          Size
-# SEC-MULTI:      1 .text         0000000e {{[0-9a-f]*}} TEXT
-# SEC-MULTI-NEXT:   .data         00000020 {{[0-9a-f]*}} DATA
-# SEC-MULTI-NEXT:   .data         00000003 {{[0-9a-f]*}} DATA
-# SEC-MULTI-NEXT:   .bss          00000002 {{[0-9a-f]*}} BSS
-# SEC-MULTI-NEXT:   .comment      00000008 {{[0-9a-f]*}}
-# SEC-MULTI-NEXT:   .symtab       00000030 {{[0-9a-f]*}}
-# SEC-MULTI-NEXT:   .shstrtab     00000035 {{[0-9a-f]*}}
-# SEC-MULTI-NEXT:   .strtab       00000008 {{[0-9a-f]*}}
+#                 [Nr] Name      Type     Address       Off           Size
+# SEC-MULTI:      [ 1] .text     PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 00000e
+# SEC-MULTI-NEXT: [ 2] .data     PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 000020
+# SEC-MULTI-NEXT: [ 3] .data     PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 000003
+# SEC-MULTI-NEXT: [ 4] .bss      NOBITS   {{[0-9a-f]*}} {{[0-9a-f]*}} 000002
+# SEC-MULTI-NEXT: [ 5] .comment  PROGBITS {{[0-9a-f]*}} {{[0-9a-f]*}} 000008
+# SEC-MULTI-NEXT: [ 6] .symtab   SYMTAB   {{[0-9a-f]*}} {{[0-9a-f]*}} 000030
+# SEC-MULTI-NEXT: [ 7] .shstrtab STRTAB   {{[0-9a-f]*}} {{[0-9a-f]*}} 000035
+# SEC-MULTI-NEXT: [ 8] .strtab   STRTAB   {{[0-9a-f]*}} {{[0-9a-f]*}} 000008
 
 # Input section pattern contains additional semicolon.
 # Case found in linux kernel script. Check we are able to parse it.
 # RUN: echo "SECTIONS { .text : { ;;*(.text);;S = 0;; } }" > %t.script
 # RUN: ld.lld -o /dev/null --script %t.script %t
 
 .globl _start
 _start:

lld/test/ELF/linkerscript/sizeof.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS { \
 # RUN:   .aaa         : { *(.aaa) } \
 # RUN:   .bbb         : { *(.bbb) } \
 # RUN:   .ccc         : { *(.ccc) } \
 # RUN:   _aaa = SIZEOF(.aaa); \
 # RUN:   _bbb = SIZEOF(.bbb); \
 # RUN:   _ccc = SIZEOF(.ccc); \
 # RUN: }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t -section-headers %t1 | FileCheck %s
 # CHECK:      Sections:
 # CHECK-NEXT:  Idx Name          Size
-# CHECK-NEXT:    0               00000000
-# CHECK-NEXT:    1 .aaa          00000008
-# CHECK-NEXT:    2 .bbb          00000010
-# CHECK-NEXT:    3 .ccc          00000018
+# CHECK-NEXT:    0 .aaa          00000008
+# CHECK-NEXT:    1 .bbb          00000010
+# CHECK-NEXT:    2 .ccc          00000018
 # CHECK:      SYMBOL TABLE:
 # CHECK-NEXT:                   .text 00000000 _start
 # CHECK-NEXT:  0000000000000008 *ABS* 00000000 _aaa
 # CHECK-NEXT:  0000000000000010 *ABS* 00000000 _bbb
 # CHECK-NEXT:  0000000000000018 *ABS* 00000000 _ccc
 
 ## SIZEOF(.nonexistent_section) should return 0.
 # RUN: echo "SECTIONS { \

lld/test/ELF/linkerscript/symbol-only.test

 # REQUIRES: x86
 # RUN: echo '.section bar, "a"' \
 # RUN:   | llvm-mc -filetype=obj -triple=x86_64-unknown-linux - -o %t
 # RUN: ld.lld -o %t1 --script %s %t -shared
 # RUN: llvm-objdump -section-headers -t %t1 | FileCheck %s
 
 SECTIONS {
   . = SIZEOF_HEADERS;
   abc : { foo = .; }
   . = ALIGN(0x1000);
   bar : { *(bar) }
 }
 
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size     VMA
-# CHECK-NEXT:   0               00000000 0000000000000000
 # CHECK:          abc           00000000 [[ADDR:[0-9a-f]*]]
 # CHECK:          bar           00000000 0000000000001000
 
 # CHECK: SYMBOL TABLE:
 # CHECK:     [[ADDR]]         abc                00000000 foo

lld/test/ELF/linkerscript/va.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS {}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size     VMA
-# CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 .foo          00000004 0000000000000000
-# CHECK-NEXT:   2 .boo          00000004 0000000000000004
-# CHECK-NEXT:   3 .text         00000001 0000000000000008
+# CHECK-NEXT:   0 .foo          00000004 0000000000000000
+# CHECK-NEXT:   1 .boo          00000004 0000000000000004
+# CHECK-NEXT:   2 .text         00000001 0000000000000008
 
 .global _start
 _start:
  nop
 
 .section .foo, "a"
 foo:
  .long 0
 
 .section .boo, "a"
 boo:
  .long 0

lld/test/ELF/linkerscript/wildcards.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 ## Default case: abc and abx included in text.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.abc .abx) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-DEFAULT %s
 # SEC-DEFAULT:      Sections:
 # SEC-DEFAULT-NEXT: Idx Name          Size
-# SEC-DEFAULT-NEXT:   0               00000000
-# SEC-DEFAULT-NEXT:   1 .text         00000008
-# SEC-DEFAULT-NEXT:   2 .abcd         00000004
-# SEC-DEFAULT-NEXT:   3 .ad           00000004
-# SEC-DEFAULT-NEXT:   4 .ag           00000004
-# SEC-DEFAULT-NEXT:   5 .comment      00000008 {{[0-9a-f]*}}
-# SEC-DEFAULT-NEXT:   6 .symtab       00000030
-# SEC-DEFAULT-NEXT:   7 .shstrtab     00000038
-# SEC-DEFAULT-NEXT:   8 .strtab       00000008
+# SEC-DEFAULT-NEXT:   0 .text         00000008
+# SEC-DEFAULT-NEXT:   1 .abcd         00000004
+# SEC-DEFAULT-NEXT:   2 .ad           00000004
+# SEC-DEFAULT-NEXT:   3 .ag           00000004
+# SEC-DEFAULT-NEXT:   4 .comment      00000008 {{[0-9a-f]*}}
 
 ## Now replace the symbol with '?' and check that results are the same.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.abc .ab?) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-DEFAULT %s
 
 ## Now see how replacing '?' with '*' will consume whole abcd.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.abc .ab*) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-ALL %s
 # SEC-ALL:      Sections:
 # SEC-ALL-NEXT: Idx Name          Size
-# SEC-ALL-NEXT:   0               00000000
-# SEC-ALL-NEXT:   1 .text         0000000c
-# SEC-ALL-NEXT:   2 .ad           00000004
-# SEC-ALL-NEXT:   3 .ag           00000004
-# SEC-ALL-NEXT:   4 .comment      00000008
-# SEC-ALL-NEXT:   5 .symtab       00000030
-# SEC-ALL-NEXT:   6 .shstrtab     00000032
-# SEC-ALL-NEXT:   7 .strtab       00000008
+# SEC-ALL-NEXT:   0 .text         0000000c
+# SEC-ALL-NEXT:   1 .ad           00000004
+# SEC-ALL-NEXT:   2 .ag           00000004
+# SEC-ALL-NEXT:   3 .comment      00000008
 
 ## All sections started with .a are merged.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.a*) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-NO %s
 # SEC-NO: Sections:
 # SEC-NO-NEXT: Idx Name          Size
-# SEC-NO-NEXT:   0               00000000
-# SEC-NO-NEXT:   1 .text         00000014
-# SEC-NO-NEXT:   2 .comment      00000008
-# SEC-NO-NEXT:   3 .symtab       00000030
-# SEC-NO-NEXT:   4 .shstrtab     0000002a
-# SEC-NO-NEXT:   5 .strtab       00000008
+# SEC-NO-NEXT:   0 .text         00000014
+# SEC-NO-NEXT:   1 .comment      00000008
 
 .text
 .section .abc,"ax",@progbits
 .long 0
 
 .text
 .section .abx,"ax",@progbits
 .long 0

lld/test/ELF/linkerscript/wildcards2.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 ## Check that aabc is not included in text.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.abc) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck %s
 # CHECK:      Sections:
 # CHECK-NEXT:  Idx Name          Size
-# CHECK-NEXT:    0               00000000
-# CHECK-NEXT:    1 .text         00000004
-# CHECK-NEXT:    2 aabc          00000004
+# CHECK-NEXT:    0 .text         00000004
+# CHECK-NEXT:    1 aabc          00000004
 
 .text
 .section .abc,"ax",@progbits
 .long 0
 
 .text
 .section aabc,"ax",@progbits
 .long 0
 
 .globl _start
 _start:

lld/test/ELF/relocatable-sections.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 # RUN: ld.lld -r %t1.o -o %t
-# RUN: llvm-objdump -section-headers %t | FileCheck %s
+# RUN: llvm-readelf --sections %t | FileCheck %s
 
 # CHECK:      .text
 # CHECK-NEXT: .rela.text
 # CHECK: .text._init
 # CHECK-NEXT: .rela.text._init
 # CHECK: .text._fini
 # CHECK-NEXT: .rela.text._fini
 

lld/test/ELF/relocatable.s

 # CHECK-NEXT:    0xE R_X86_64_32S y 0x0
 # CHECK-NEXT:    0x23 R_X86_64_32S xx 0x0
 # CHECK-NEXT:    0x2E R_X86_64_32S yy 0x0
 # CHECK-NEXT:    0x43 R_X86_64_32S xxx 0x0
 # CHECK-NEXT:    0x4E R_X86_64_32S yyy 0x0
 # CHECK-NEXT:  }
 
 # SECTION: Sections:
-# SECTION: Idx Name          Size     VMA              Type
-# SECTION:   0               00000000 0000000000000000
-# SECTION:   1 .text         00000056 0000000000000000 TEXT
-# SECTION:   2 .rela.text    00000090 0000000000000000
-# SECTION:   3 .bss          00000018 0000000000000000 BSS
-# SECTION:   4 .note.GNU-stack 00000000 0000000000000000
-# SECTION:   5 .symtab       00000168 0000000000000000
-# SECTION:   6 .shstrtab     00000041 0000000000000000
-# SECTION:   7 .strtab       0000002d 0000000000000000
+# SECTION: Idx Name          Size     VMA              File off         Algn  Type
+# SECTION:   0 .text         00000056 0000000000000000 0000000000000040 2**4  TEXT
+# SECTION:   1 .bss          00000018 0000000000000000 0000000000000128 2**2  BSS
+# SECTION:   2 .note.GNU-stack 00000000 0000000000000000 0000000000000128 2**0
 
 # CHECKTEXT:      Disassembly of section .text:
 # CHECKTEXT-EMPTY:
 # CHECKTEXT-NEXT: main:
 # CHECKTEXT-NEXT: 0: c7 04 25 00 00 00 00 05 00 00 00 movl $5, 0
 # CHECKTEXT-NEXT: b: c7 04 25 00 00 00 00 07 00 00 00 movl $7, 0
 # CHECKTEXT:      foo:
 # CHECKTEXT-NEXT: 20: c7 04 25 00 00 00 00 01 00 00 00 movl $1, 0

lld/test/ELF/relro-omagic.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t2.o
 # RUN: ld.lld -shared %t2.o -o %t2.so -soname relro-omagic.s.tmp2.so
 # RUN: ld.lld --hash-style=sysv -N %t.o -Bdynamic %t2.so -o %t
 # RUN: llvm-objdump -section-headers %t | FileCheck --check-prefix=NORELRO %s
 # RUN: llvm-readobj --program-headers %t | FileCheck --check-prefix=NOPHDRS %s
 
 # NORELRO:      Sections:
-# NORELRO-NEXT: Idx Name          Size     VMA              Type
-# NORELRO-NEXT:   0               00000000 0000000000000000
-# NORELRO-NEXT:   1 .dynsym       00000048 00000000002000e8
-# NORELRO-NEXT:   2 .hash         00000020 0000000000200130
-# NORELRO-NEXT:   3 .dynstr       00000021 0000000000200150
-# NORELRO-NEXT:   4 .rela.dyn     00000018 0000000000200178
-# NORELRO-NEXT:   5 .rela.plt     00000018 0000000000200190
-# NORELRO-NEXT:   6 .text         0000000a 00000000002001a8 TEXT
-# NORELRO-NEXT:   7 .plt          00000020 00000000002001c0 TEXT
-# NORELRO-NEXT:   8 .data         00000008 00000000002001e0 DATA
-# NORELRO-NEXT:   9 .foo          00000004 00000000002001e8 DATA
-# NORELRO-NEXT:  10 .dynamic      000000f0 00000000002001f0
-# NORELRO-NEXT:  11 .got          00000008 00000000002002e0 DATA
-# NORELRO-NEXT:  12 .got.plt      00000020 00000000002002e8 DATA
+# NORELRO-NEXT: Idx Name          Size     VMA              File off         Algn  Type
+# NORELRO-NEXT:   0 .dynsym       00000048 00000000002000e8 00000000000000e8 2**3
+# NORELRO-NEXT:   1 .hash         00000020 0000000000200130 0000000000000130 2**2
+# NORELRO-NEXT:   2 .dynstr       00000021 0000000000200150 0000000000000150 2**0
+# NORELRO-NEXT:   3 .rela.dyn     00000018 0000000000200178 0000000000000178 2**3
+# NORELRO-NEXT:   4 .rela.plt     00000018 0000000000200190 0000000000000190 2**3
+# NORELRO-NEXT:   5 .text         0000000a 00000000002001a8 00000000000001a8 2**2  TEXT
+# NORELRO-NEXT:   6 .plt          00000020 00000000002001c0 00000000000001c0 2**4  TEXT
+# NORELRO-NEXT:   7 .data         00000008 00000000002001e0 00000000000001e0 2**0  DATA
+# NORELRO-NEXT:   8 .foo          00000004 00000000002001e8 00000000000001e8 2**0  DATA
+# NORELRO-NEXT:   9 .dynamic      000000f0 00000000002001f0 00000000000001f0 2**3
+# NORELRO-NEXT:  10 .got          00000008 00000000002002e0 00000000000002e0 2**3  DATA
+# NORELRO-NEXT:  11 .got.plt      00000020 00000000002002e8 00000000000002e8 2**3  DATA
+# NORELRO-NEXT:  12 .comment      00000008 0000000000000000 0000000000000308 2**0
 
 # NOPHDRS:     ProgramHeaders [
 # NOPHDRS-NOT: PT_GNU_RELRO
 
 .long bar
 jmp *bar2@GOTPCREL(%rip)
 
 .section .data,"aw"
 .quad 0
 
 .section .foo,"aw"
 .zero 4

lld/test/ELF/section-name.s

 .byte 0
 .section .tbss.foo,"aGwT",@nobits,foo,comdat
 .byte 0
 .section .gcc_except_table.foo,"aG",@progbits,foo,comdat
 .byte 0
 .section .tdata.foo,"aGwT",@progbits,foo,comdat
 .byte 0
 
-// CHECK:  1 .rodata  00000002
-// CHECK:  2 .gcc_except_table 00000001
-// CHECK:  3 .text         00000002
-// CHECK:  4 .tdata        00000001
-// CHECK:  5 .tbss         00000001
-// CHECK:  6 .data.rel.ro  00000004
-// CHECK:  7 .data         00000002
-// CHECK:  8 .foo.a        00000001
-// CHECK:  9 .foo          00000001
-// CHECK: 10 .bss          00000002
-// CHECK: 11 .comment      00000008
-// CHECK: 12 .symtab       00000030
-// CHECK: 13 .shstrtab     00000075
-// CHECK: 14 .strtab       00000008
+// CHECK:  0 .rodata  00000002
+// CHECK:  1 .gcc_except_table 00000001
+// CHECK:  2 .text         00000002
+// CHECK:  3 .tdata        00000001
+// CHECK:  4 .tbss         00000001
+// CHECK:  5 .data.rel.ro  00000004
+// CHECK:  6 .data         00000002
+// CHECK:  7 .foo.a        00000001
+// CHECK:  8 .foo          00000001
+// CHECK:  9 .bss          00000002
+// CHECK: 10 .comment      00000008

lld/test/ELF/sectionstart-noallochdr.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld %t.o --section-start .data=0x20 \
 # RUN: --section-start .bss=0x30 --section-start .text=0x10 -o %t1
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 
 # CHECK:      Sections:
-# CHECK-NEXT:  Idx Name          Size     VMA              Type
-# CHECK-NEXT:    0               00000000 0000000000000000
-# CHECK-NEXT:    1 .text         00000001 0000000000000010 TEXT
-# CHECK-NEXT:    2 .data         00000004 0000000000000020 DATA
-# CHECK-NEXT:    3 .bss          00000004 0000000000000030 BSS
+# CHECK-NEXT:  Idx Name          Size     VMA              File off         Algn  Type
+# CHECK-NEXT:    0 .text         00000001 0000000000000010 0000000000001010 2**2  TEXT
+# CHECK-NEXT:    1 .data         00000004 0000000000000020 0000000000001020 2**0  DATA
+# CHECK-NEXT:    2 .bss          00000004 0000000000000030 0000000000001024 2**0  BSS
+
 
 .text
 .globl _start
 _start:
  nop
 
 .data
 .long 0
 
 .bss
 .zero 4

lld/test/ELF/sectionstart.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld %t.o --section-start .text=0x100000 \
 # RUN:   --section-start=.data=0x110000 --section-start .bss=0x200000 -o %t
 # 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         00000001 0000000000100000 TEXT
-# CHECK-NEXT:    2 .data         00000004 0000000000110000 DATA
-# CHECK-NEXT:    3 .bss          00000004 0000000000200000 BSS
+# CHECK-NEXT:  Idx Name          Size     VMA              File off         Algn  Type
+# CHECK-NEXT:    0 .text         00000001 0000000000100000 0000000000001000 2**2  TEXT
+# CHECK-NEXT:    1 .data         00000004 0000000000110000 0000000000002000 2**0  DATA
+# CHECK-NEXT:    2 .bss          00000004 0000000000200000 0000000000002004 2**0  BSS
 
 ## The same, but dropped "0x" prefix.
 # RUN: ld.lld %t.o --section-start .text=100000 \
 # RUN:   --section-start .data=110000 --section-start .bss=0x200000 -o %t1
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 
 ## Use -Ttext, -Tdata, -Tbss as replacement for --section-start:
 # RUN: ld.lld %t.o -Ttext=0x100000 -Tdata=0x110000 -Tbss=0x200000 -o %t4

lld/test/ELF/strip-all.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t1
-#RUN: llvm-objdump -section-headers %t1 | FileCheck %s -check-prefix BEFORE
+#RUN: llvm-readelf --sections %t1 | FileCheck %s -check-prefix BEFORE
 #BEFORE:       .symtab
 #BEFORE-NEXT:  .shstrtab
 #BEFORE-NEXT:  .strtab
 
 #RUN: ld.lld %t.o --strip-all -o %t1
-#RUN: llvm-objdump -section-headers %t1 | FileCheck %s -check-prefix AFTER
+#RUN: llvm-readelf --sections %t1 | FileCheck %s -check-prefix AFTER
 #AFTER-NOT: .symtab
 #AFTER:     .shstrtab
 #AFTER-NOT: .strtab
 
 # Ignore --strip-all if -r is specified
 #RUN: ld.lld %t.o --strip-all -r -o %t1
-#RUN: llvm-objdump -section-headers %t1 | FileCheck %s -check-prefix BEFORE
+#RUN: llvm-readelf --sections %t1 | FileCheck %s -check-prefix BEFORE
 
 # Test alias -s
 #RUN: ld.lld %t.o -s -o %t1
-#RUN: llvm-objdump -section-headers %t1 | FileCheck %s -check-prefix AFTER
+#RUN: llvm-readelf --sections %t1 | FileCheck %s -check-prefix AFTER
 
 # RUN: not ld.lld %t.o --strip-all --emit-relocs -o /dev/null 2>&1 | FileCheck --check-prefix=ERR %s
 # ERR: error: --strip-all and --emit-relocs may not be used together
 
 # exits with return code 42 on linux
 .globl _start
 _start:
   mov $60, %rax
   mov $42, %rdi
   syscall

lld/test/ELF/synthetic-got.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { }" > %t0.script
 # RUN: ld.lld --hash-style=sysv -shared %t.o -o %t0.out --script %t0.script
 # RUN: llvm-objdump -section-headers %t0.out | FileCheck %s --check-prefix=GOT
 # RUN: llvm-objdump -s -section=.got -section=.got.plt %t0.out \
 # RUN:   | FileCheck %s --check-prefix=GOTDATA
 
 # GOT:     Sections:
-# GOT:       9 .got         00000008 00000000000001b0 DATA
-# GOT:      10 .got.plt     00000020 00000000000001b8 DATA
+# GOT:       8 .got         00000008 00000000000001b0 00000000000011b0 2**3 DATA
+# GOT:       9 .got.plt     00000020 00000000000001b8 00000000000011b8 2**3 DATA
 # GOTDATA:      Contents of section .got:
 # GOTDATA-NEXT:  01b0 00000000 00000000
 # GOTDATA-NEXT: Contents of section .got.plt:
 # GOTDATA-NEXT:  01b8 e0000000 00000000 00000000 00000000
 # GOTDATA-NEXT:  01c8 00000000 00000000 d6000000 00000000
 
 # RUN: echo "SECTIONS { .mygot : { *(.got) *(.got.plt) } }" > %t1.script
 # RUN: ld.lld --hash-style=sysv -shared %t.o -o %t1.out --script %t1.script
 # RUN: llvm-objdump -section-headers %t1.out | FileCheck %s --check-prefix=MYGOT
 # RUN: llvm-objdump -s -section=.mygot %t1.out | FileCheck %s --check-prefix=MYGOTDATA
 
 # MYGOT:     Sections:
-# MYGOT:      8  .mygot     00000028 00000000000000e0 DATA
+# MYGOT:      7  .mygot     00000028 00000000000000e0 00000000000010e0 2**3 DATA
 # MYGOT-NOT:  .got
 # MYGOT-NOT:  .got.plt
 # MYGOTDATA:      00e0 00000000 00000000 08010000 00000000
 # MYGOTDATA-NEXT: 00f0 00000000 00000000 00000000 00000000
 # MYGOTDATA-NEXT: 0100 d6000000 00000000
 
 mov bar@gotpcrel(%rip), %rax
 call foo@plt

llvm/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     VMA              Type
-# CHECK:   3 .rdata        00000004 0000000000000000 DATA
-# CHECK:   4 .CRT$XCU      00000008 0000000000000000 DATA
+# CHECK: Idx Name          Size     VMA              File off         Algn Type
+# CHECK:   3 .rdata        00000004 0000000000000000 00000000000000dc 2**2 DATA
+# CHECK:   4 .CRT$XCU      00000008 0000000000000000 00000000000000e0 2**3 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
 
   .section  .rdata,"dr"
   .p2align  2               # @x
 .Lprivate:
   .long 0                       # 0x0
 
   .section  .CRT$XCU,"dr",associative,.Lprivate
   .p2align  3
   .quad register_x
 

llvm/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      VMA              Type
+; CHECK: Idx Name Size VMA File off Algn Type
 ; CHECK-NOT: {{.}}

llvm/test/Object/objdump-sectionheaders.test

 # RUN: yaml2obj %s > %t.elf-x86-64
 # RUN: llvm-objdump -h %t.elf-x86-64 | 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     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    00000000 0000000000000038
-# CHECK:   5 .symtab       00000018 0000000000000000
-# CHECK:   6 .strtab       00000001 0000000000000000
-# CHECK:   7 .shstrtab     00000045 0000000000000000
+# CHECK: Idx Name          Size     VMA              File off         Algn Type
+# CHECK:   0 .text         00000026 0000000000000000 0000000000000040 2**0 TEXT
+# CHECK:   1 .rodata.str1.1 0000000d 0000000000000026 0000000000000066 2**0 DATA
+# CHECK:   2 .note.GNU-stack 00000000 0000000000000033 0000000000000073 2**0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:

llvm/test/ObjectYAML/CodeView/sections.yaml

 # CHECK:     SectionDefinition:
 # CHECK:       Length:          108
 # CHECK:       NumberOfRelocations: 0
 # CHECK:       NumberOfLinenumbers: 0
 # CHECK:       CheckSum:        2189213922
 # CHECK:       Number:          1
 # CHECK: ...
 
-# HEADERS:   0 .debug$T      00000040 0000000000000000 DATA
-# HEADERS:   1 .debug$H      00000030 0000000000000000 DATA
+# HEADERS:   0 .debug$T      00000040 0000000000000000 0000000000000064 2**0 DATA
+# HEADERS:   1 .debug$H      00000030 0000000000000000 00000000000000a4 2**2 DATA

llvm/test/tools/llvm-objcopy/ELF/symtab-error-on-remove-strtab.test

 # RUN: yaml2obj %s > %t
 # RUN: not llvm-objcopy -R .strtab %t %t2 2>&1 >/dev/null | FileCheck %s --check-prefix=ERR1 -DINPUT=%t
 # RUN: cp %t %t3
 # RUN: not llvm-strip --no-strip-all -R .strtab %t3 2>&1 >/dev/null | FileCheck %s --check-prefix=ERR2 -DINPUT=%t3
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 
 # ERR1: error: '[[INPUT]]': string table '.strtab' cannot be removed because it is referenced by the symbol table '.symtab'
 # ERR2: error: '[[INPUT]]': string table '.strtab' cannot be removed because it is referenced by the symbol table '.symtab'
 
 # RUN: llvm-objcopy --allow-broken-links -R .strtab %t %t4
-# RUN: llvm-objdump --section-headers %t4 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.strtab
+# RUN: llvm-readelf --section-headers %t4 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.strtab
 # RUN: cp %t %t5
 # RUN: llvm-strip --no-strip-all --allow-broken-links -R .strtab %t %t5
-# RUN: llvm-objdump --section-headers %t5 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.strtab
+# RUN: llvm-readelf --section-headers %t5 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.strtab
 
 # SECTIONS: .symtab

llvm/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:      Sections:
-# NOADJUST-NEXT: Idx Name           Size     VMA              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
+# NOADJUST-NEXT: Idx Name          Size     VMA              File off         Algn  Type
+# NOADJUST-NEXT:   0 .text         00000002 0000000000000000 0000000000000040 2**2  TEXT
+# NOADJUST-NEXT:   1 .debug_str    00000004 0000000000000000 0000000000000042 2**0
+# NOADJUST-NEXT:   2 .data         00000004 0000000000000000 0000000000000060 2**0  DATA
 
 # ADJUST:        Sections:
-# ADJUST-NEXT:   Idx Name           Size     VMA              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
+# ADJUST-NEXT: Idx Name          Size     VMA              File off         Algn  Type
+# ADJUST-NEXT:   0 .text         00000002 0000000000123000 0000000000000040 2**2  TEXT
+# ADJUST-NEXT:   1 .debug_str    00000004 0000000000000000 0000000000000042 2**0
+# ADJUST-NEXT:   2 .data         00000004 0000000000123000 0000000000000060 2**0  DATA
 
 # 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
 
 # NOADJUST:      0000000000000000 sym:
 # NOADJUST-NEXT:   0: {{.*}}  nop

llvm/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     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 
+CHECK: Idx Name          Size     VMA              File off         Algn  Type
+CHECK:   0 __text        0000003b 0000000000000000 0000000000000210 2**4  TEXT
+CHECK:   1 __cstring     0000000d 000000000000003b 000000000000024b 2**0  DATA
+CHECK:   2 __compact_unwind 00000020 0000000000000048 0000000000000258 2**3  DATA
+CHECK:   3 __eh_frame    00000040 0000000000000068 0000000000000278 2**3  DATA

llvm/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
+# CHECK-NEXT: Idx Name  Size     VMA              LMA              File off         Algn Type
+# CHECK-NEXT:   0 .text 00000004 0000000000001000 0000000000002000 00000000000000b0 2**0 TEXT
+# CHECK-NEXT:   1 .init 00000004 0000000000001010 0000000000001010 00000000000000b4 2**0 TEXT
+# CHECK-NEXT:   2 .data 00000004 0000000000002000 0000000000003000 00000000000000b8 2**0 DATA
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:

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

 # RUN: yaml2obj %s > %t
 
 ## If there are no sections with different LMA to 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-NEXT: Idx Name  Size     VMA              File off         Algn Type
+# CHECK-NEXT:   0 .text 00000004 0000000000001000 00000000000000b0 2**0 TEXT
+# CHECK-NEXT:   1 .init 00000004 0000000000001010 00000000000000b4 2**0 TEXT
+# CHECK-NEXT:   2 .data 00000004 0000000000002000 00000000000000b8 2**0 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
+# LMA-NEXT: Idx Name  Size     VMA              LMA              File off         Algn Type
+# LMA-NEXT:   0 .text 00000004 0000000000001000 0000000000001000 00000000000000b0 2**0 TEXT
+# LMA-NEXT:   1 .init 00000004 0000000000001010 0000000000001010 00000000000000b4 2**0 TEXT
+# LMA-NEXT:   2 .data 00000004 0000000000002000 0000000000002000 00000000000000b8 2**0 DATA
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:

llvm/test/tools/llvm-objdump/X86/section-index.s

 # RUN: llvm-mc %s -filetype=obj -triple=x86_64-pc-linux -o %t
 
 # RUN: llvm-objdump -section-headers %t | FileCheck %s
 # CHECK:     Idx Name
-# CHECK:      3  .foo
-# CHECK-NEXT: 4  .bar
-# CHECK-NEXT: 5  .zed
+# CHECK:      1  .foo
+# CHECK-NEXT: 2  .bar
+# CHECK-NEXT: 3  .zed
 
 ## Check we report the valid section index
 ## when requesting a specific section.
 # RUN: llvm-objdump -section-headers -section=.bar %t \
 # RUN:   | FileCheck %s --check-prefix=BAR
 # BAR:      Idx Name
-# BAR-NEXT:  4  .bar
+# BAR-NEXT:  2  .bar
 # BAR-NOT:  foo
 # BAR-NOT:  zed
 
 .section .foo, "ax", %progbits
 nop
 
 .section .bar, "ax", %progbits
 nop
 
 .section .zed, "ax", %progbits
 nop

llvm/test/tools/llvm-objdump/section-filter.test

 ## Test that --section works correctly for -h.
 ## We test the LMA here too, because the code at the time of writing uses the 
 ## value of --section when looking up section LMAs.
 # RUN: yaml2obj %s --docnum=1 -o %t.h.elf
 # RUN: llvm-objdump -h %t.h.elf -j=.text --section=.bss \
 # RUN:   | FileCheck %s --check-prefix=SHDRS --implicit-check-not=.data --implicit-check-not=.text2
 
-# SHDRS: Name  Size     VMA              LMA
-# SHDRS: .text 00000001 0000000000000400 0000000000001000
-# SHDRS: .bss  00000001 0000000000000420 0000000000003000
+# SHDRS: Name  Size     VMA              LMA              File off         Algn  Type
+# SHDRS: .text 00000001 0000000000000400 0000000000001000 00000000000000f0 2**4  TEXT
+# SHDRS: .bss  00000001 0000000000000420 0000000000003000 0000000000000110 2**4  BSS
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:

 # RUN: cmp %t.full %t.5
 # RUN: cmp %t.full %t.6
 
 ## Test that an unknown section name causes all section output to be suppressed.
 # RUN: llvm-objdump %t.h.elf -h --section foobar \
 # RUN:   | FileCheck %s --check-prefix=NO-SECTION
 
 # NO-SECTION:      Sections:
-# NO-SECTION-NEXT: Idx Name Size VMA Type
+# NO-SECTION-NEXT: Idx Name Size VMA File off Algn Type
 # NO-SECTION-NOT:  {{.}}

llvm/test/tools/llvm-objdump/wasm.txt

 # RUN: llvm-objdump -h %p/Inputs/trivial.obj.wasm | FileCheck %s
 
 # CHECK:      Sections:
-# 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
+# CHECK-NEXT: Idx Name          Size     VMA              File off         Algn Type
+# CHECK-NEXT:   0 TYPE          00000011 0000000000000000 0000000000000008 2**0
+# CHECK-NEXT:   1 IMPORT        0000005d 0000000000000000 000000000000001f 2**0
+# CHECK-NEXT:   2 FUNCTION      00000003 0000000000000000 0000000000000082 2**0
+# CHECK-NEXT:   3 CODE          00000024 0000000000000000 000000000000008b 2**0 TEXT
+# CHECK-NEXT:   4 DATA          0000001c 0000000000000000 00000000000000b5 2**0 DATA
+# CHECK-NEXT:   5 linking       0000006d 0000000000000000 00000000000000d7 2**0
+# CHECK-NEXT:   6 reloc.CODE    0000000f 0000000000000000 0000000000000152 2**0
 
 # RUN: llvm-objdump -p %p/Inputs/trivial.obj.wasm | FileCheck %s -check-prefix CHECK-HEADER
 
 # CHECK-HEADER: Program Header:
 # CHECK-HEADER: Version: 0x1
 
 # RUN: llvm-objdump -s --section=CODE %p/Inputs/trivial.obj.wasm | FileCheck %s -check-prefix CHECK-SECTIONS
 
 # CHECK-SECTIONS: Contents of section CODE:
 # CHECK-SECTIONS: 0000 02170041 80808080 00108080 8080001a  ...A............
 # CHECK-SECTIONS: 0010 10838080 80004100 0b0a0041 00108180  ......A....A....
 # CHECK-SECTIONS: 0020 8080000b                             ....

llvm/test/tools/llvm-objdump/xcoff-section-headers.test

 # RUN: llvm-objdump --section-headers %p/Inputs/xcoff-section-headers.o | \
 # RUN: FileCheck %s
 
 # RUN: llvm-objdump --section-headers %p/Inputs/xcoff-long-sec-names.o | \
 # RUN: FileCheck --check-prefix=LONG %s
 
 # RUN: not llvm-objdump --section-headers 2>&1 \
 # RUN: %p/Inputs/xcoff-section-headers-truncate.o | FileCheck \
 # RUN: --check-prefix=ERROR %s
 
 # ERROR: The end of the file was unexpectedly encountered
 
 # CHECK: xcoff-section-headers.o:      file format aixcoff-rs6000
 # CHECK: Sections:
-# CHECK: Idx Name          Size     VMA          Type
-# CHECK:   1 .text         00000080 0000000000000000 TEXT
-# CHECK:   2 .data         00000024 0000000000000080 DATA
-# CHECK:   3 .bss          00000004 00000000000000a4 BSS
-# CHECK:   4 .tdata        00000008 0000000000000000 DATA
-# CHECK:   5 .tbss         00000004 0000000000000008 BSS
+# CHECK: Idx Name          Size     VMA              File off         Algn  Type
+# CHECK:   0 .text         00000080 0000000000000000 0000000000000200 2**0  TEXT
+# CHECK:   1 .data         00000024 0000000000000080 0000000000000280 2**0  DATA
+# CHECK:   2 .bss          00000004 00000000000000a4 0000000000000000 2**0  BSS
+# CHECK:   3 .tdata        00000008 0000000000000000 00000000000002a4 2**0  DATA
+# CHECK:   4 .tbss         00000004 0000000000000008 0000000000000000 2**0  BSS
 
 # xcoff-section-headers.o Compiled with IBM XL C/C++ for AIX, V16.1.0
 # test.c:
 # int a;
 # int b = 12345;
 # __thread int c;
 # __thread double d = 3.14159;
 #
 # int func(void)  {
 #   return a;
 # }
 
 # LONG: xcoff-long-sec-names.o:      file format aixcoff-rs6000
 # LONG: Sections:
-# LONG: Idx Name          Size     VMA          Type
-# LONG: 1 .dwarnge      00000004 0000000000000000
-# LONG: 2 .dwpbnms      00000004 0000000000000000
-# LONG: 3 .dwpbtyp      00000004 0000000000000000
+# LONG: Idx Name          Size     VMA              File off         Algn  Type
+# LONG:   0 .dwarnge      00000004 0000000000000000 000000000000008c 2**0
+# LONG:   1 .dwpbnms      00000004 0000000000000000 0000000000000090 2**0
+# LONG:   2 .dwpbtyp      00000004 0000000000000000 0000000000000094 2**0
 
 # xcoff-long-sec-names.o was generated by assembling the following .s file:
 #  .dwsect 0x30000 # .dwpbnms section
 #  .dwsect 0x40000 # .dwpbtyp section
 #  .dwsect 0x50000 # .dwarnge section

llvm/tools/llvm-objdump/llvm-objdump.h

public:
   }
 
 private:
   FilterPredicate Predicate;
   llvm::object::ObjectFile const &Object;
 };
 
 // Various helper functions.
-SectionFilter ToolSectionFilter(llvm::object::ObjectFile const &O);
+struct ToolFilterOptions {
+  // Start at -1 so that it's 0 the first time we increment & return it.
+  int Idx = -1;
+  bool SkipSpecialELFSections = false;
+};
+SectionFilter ToolSectionFilter(llvm::object::ObjectFile const &O,
+                                ToolFilterOptions *Opts = nullptr);
 
 Error getELFRelocationValueString(const object::ELFObjectFileBase *Obj,
                                   const object::RelocationRef &Rel,
                                   llvm::SmallVectorImpl<char> &Result);
 Error getCOFFRelocationValueString(const object::COFFObjectFile *Obj,
                                    const object::RelocationRef &Rel,
                                    llvm::SmallVectorImpl<char> &Result);
 Error getWasmRelocationValueString(const object::WasmObjectFile *Obj,

llvm/tools/llvm-objdump/llvm-objdump.cpp

 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/Wasm.h"
+#include "llvm/Object/XCOFFObjectFile.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/GraphWriter.h"
static cl::extrahelp
     HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
 
 static StringSet<> DisasmFuncsSet;
 static StringSet<> FoundSectionSet;
 static StringRef ToolName;
 
 typedef std::vector<std::tuple<uint64_t, StringRef, uint8_t>> SectionSymbolsTy;
 
-static bool shouldKeep(object::SectionRef S) {
-  if (FilterSections.empty())
-    return true;
-
+static bool shouldKeep(object::SectionRef S,
+                       ToolFilterOptions *Opts = nullptr) {
   Expected<StringRef> SecNameOrErr = S.getName();
   if (!SecNameOrErr) {
     consumeError(SecNameOrErr.takeError());
-    return false;
+    // FIXME: clarify this case. This is for Object/invalid.test which tests a
+    // bad .shstrtab section type.
+    return FilterSections.empty();
   }
   StringRef SecName = *SecNameOrErr;
 
-  // StringSet does not allow empty key so avoid adding sections with
-  // no name (such as the section with index 0) here.
-  if (!SecName.empty())
-    FoundSectionSet.insert(SecName);
+  // Always skip the null section
+  // FIXME: check if this is still necessary after checking for SHT_NULL below.
+  if (SecName.empty())
+    return false;
+
+  if (Opts && Opts->SkipSpecialELFSections) {
+    // TODO: this is ELF specific, but could easily crash if
+    // SkipSpecialELFSections is set when Obj->isELF() is false.
+    // This whole ELF-specific part of the loop should probably be extracted
+    // anyway.
+    ELFSectionRef ELFSection = static_cast<ELFSectionRef>(S);
+    switch (ELFSection.getType()) {
+    case ELF::SHT_NULL:
+    case ELF::SHT_SYMTAB:
+    case ELF::SHT_SYMTAB_SHNDX:
+      return false;
+    case ELF::SHT_REL:
+    case ELF::SHT_RELA:
+      // Discard reloc sections that don't look like reloc sections:
+      // 1. sh_link should point to a symbol table.
+      // 2. sh_info should point to a non-reloc section.
+      // See http://www.sco.com/developers/gabi/latest/ch4.sheader.html#sh_link.
+      // TODO: templatize this for other ELF types
+      if (const ELF64LEObjectFile *ELFObj =
+              dyn_cast<ELF64LEObjectFile>(S.getObject())) {
+        using Elf_Shdr = typename ELF64LE::Shdr;
+        const Elf_Shdr *ElfShdr = ELFObj->getSection(S.getRawDataRefImpl());
+        bool FoundSymtab = false;
+        bool FoundRelTarget = false;
+        // TODO: remove this loop which makes things O(n^2)
+        for (SectionRef OtherSection : S.getObject()->sections()) {
+          const Elf_Shdr *OtherShdr =
+              ELFObj->getSection(OtherSection.getRawDataRefImpl());
+          if (ElfShdr->sh_link == OtherSection.getIndex()) {
+            FoundSymtab = (OtherShdr->sh_type == ELF::SHT_SYMTAB);
+          }
+          if (ElfShdr->sh_info == OtherSection.getIndex()) {
+            FoundRelTarget = (OtherShdr->sh_type != ELF::SHT_REL &&
+                              OtherShdr->sh_type != ELF::SHT_RELA);
+          }
+        }
+        if (FoundSymtab && FoundRelTarget) {
+          return false;
+        } else {
+          ++Opts->Idx;
+          return true;
+        }
+      } else {
+        // TODO: remove fallback
+        return false;
+      }
+      return true;
+    case ELF::SHT_STRTAB:
+      // We want to keep sections like ".dynstr", so only discard sections like
+      // ".strtab" or ".shstrtab".
+      if (SecName.endswith("strtab")) {
+        return false;
+      } else {
+        ++Opts->Idx;
+        return true;
+      }
+    }
+  }
+
+  if (Opts)
+    ++Opts->Idx;
+
+  if (FilterSections.empty())
+    return true;
+
+  // StringSet does not allow empty key so avoid adding sections with no name
+  // (such as the null section with index 0 for ELF files) here. This is
+  // checked above.
   return is_contained(FilterSections, SecName);
 }
 
-SectionFilter ToolSectionFilter(object::ObjectFile const &O) {
-  return SectionFilter([](object::SectionRef S) { return shouldKeep(S); }, O);
+SectionFilter ToolSectionFilter(llvm::object::ObjectFile const &O,
+                                ToolFilterOptions *Opts) {
+  return SectionFilter(
+      [Opts](object::SectionRef S) { return shouldKeep(S, Opts); }, O);
 }
 
 std::string getFileNameForError(const object::Archive::Child &C,
                                 unsigned Index) {
   Expected<StringRef> NameOrErr = C.getName();
   if (NameOrErr)
     return NameOrErr.get();
   // If we have an error getting the name then we print the index of the archive
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;
 }
 
+static uint64_t getFileOffset(const ObjectFile *Obj,
+                              const SectionRef &Section) {
+  if (Obj->isELF())
+    return ELFSectionRef(Section).getOffset();
+  if (Obj->isMachO()) {
+    auto *MachOObj = dyn_cast<MachOObjectFile>(Obj);
+    return MachOObj->is64Bit()
+               ? MachOObj->getSection64(Section.getRawDataRefImpl()).offset
+               : MachOObj->getSection(Section.getRawDataRefImpl()).offset;
+  }
+  if (Obj->isWasm()) {
+    // FIXME: the file offset here agree with llvm-readobj, but not GNU objdump.
+    auto *WasmObj = dyn_cast<WasmObjectFile>(Obj);
+    return WasmObj->getWasmSection(Section).Offset;
+  }
+  if (Obj->isXCOFF()) {
+    auto *XCoffObj = dyn_cast<XCOFFObjectFile>(Obj);
+    // FIXME: This seems very unsafe
+    return XCoffObj->is64Bit() ? XCoffObj->sections64()[Section.getIndex() - 1]
+                                     .FileOffsetToRawData
+                               : XCoffObj->sections32()[Section.getIndex() - 1]
+                                     .FileOffsetToRawData;
+  }
+  if (Obj->isCOFF()) {
+    auto *CoffObj = dyn_cast<COFFObjectFile>(Obj);
+    return CoffObj->getCOFFSection(Section)->PointerToRawData;
+  }
+  // TODO: crash here if unsupported?
+  return 0;
+}
+
 void printSectionHeaders(const ObjectFile *Obj) {
   bool HasLMAColumn = shouldDisplayLMA(Obj);
   if (HasLMAColumn)
     outs() << "Sections:\n"
               "Idx Name          Size     VMA              LMA              "
-              "Type\n";
+              "File off         Algn  Type\n";
   else
     outs() << "Sections:\n"
-              "Idx Name          Size     VMA          Type\n";
+              "Idx Name          Size     VMA              File off         "
+              "Algn  Type\n";
 
-  for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
+  ToolFilterOptions FilterOpts;
+  FilterOpts.SkipSpecialELFSections = Obj->isELF();
+  for (const SectionRef &Section : ToolSectionFilter(*Obj, &FilterOpts)) {
     StringRef Name = unwrapOrError(Section.getName(), Obj->getFileName());
     uint64_t VMA = Section.getAddress();
     if (shouldAdjustVA(Section))
       VMA += AdjustVMA;
 
     uint64_t Size = Section.getSize();
     bool Text = Section.isText();
     bool Data = Section.isData();
     bool BSS = Section.isBSS();
+    // Note: GNU objdump prints CONTENTS, ALLOC, LOAD, READONLY, CODE etc. here
+    // instead.
     std::string Type = (std::string(Text ? "TEXT " : "") +
                         (Data ? "DATA " : "") + (BSS ? "BSS" : ""));
 
+    uint64_t FileOffset = getFileOffset(Obj, Section);
+    // FIXME: what happens if an object has an invalid alignment (i.e. 3, 5, or
+    // any other value not 2^n)? Test that case.
+
+    // Note: alignment = 0 is a "valid" alignment but not considered so for
+    // llvm::Align. So use valueOrOne() to be nice in that case.
+    llvm::Align SectionAlign =
+        llvm::MaybeAlign(Section.getAlignment()).valueOrOne();
+
+    if (Obj->isXCOFF()) {
+      // FIXME: XCOFF alignment value looks wrong. See:
+      // llvm/test/tools/llvm-objdump/Inputs/xcoff-section-headers.o.
+      // Ignore our current implementation and print "2**0" instead of something
+      // bogus to get tests stable; but revise before committing.
+      SectionAlign = llvm::Align();
+    }
+
     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,
-                       VMA, Type.c_str());
+                       " %016" PRIx64 " 2**%d  %s\n",
+                       FilterOpts.Idx, Name.str().c_str(), Size, VMA,
+                       getELFSectionLMA(Section), FileOffset,
+                       Log2(SectionAlign), Type.c_str());
+    else
+      outs() << format("%3d %-13s %08" PRIx64 " %016" PRIx64 " %016" PRIx64
+                       " 2**%d  %s\n",
+                       FilterOpts.Idx, Name.str().c_str(), Size, VMA,
+                       FileOffset, Log2(SectionAlign), Type.c_str());
   }
   outs() << "\n";
 }
 
 void printSectionContents(const ObjectFile *Obj) {
   for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
     StringRef Name = unwrapOrError(Section.getName(), Obj->getFileName());
     uint64_t BaseAddr = Section.getAddress();