[llvm-objdump] --syms: print "%016" PRIx64 instead of "%08" PRIx64 for 64-bit objects

[MaskRay]

Summary

This is GNU objdump's behavior and it is reasonable to match.

[grimar]

LGTM with ELF32 and ELF64.

llvm/test/tools/llvm-objdump/symbol-table-elf.test

4

Lets use ELF32 and ELF64 as it is more common?

19

I guess it is fine for this patch.

But FTR, it seems this test might be improved. Probably 64 bit values also should be used
to demonstrate we can dump them. And testing of symbol sizes would also probably be not harmful.

[MaskRay]

I will fix/improve the lld/test/ELF tests. Some should use llvm-readelf -s instead of llvm-objdump -t. The BFD flags (g and l) in llvm-objdump output may cause another change. The llvm-readelf -s output is stable.

[MaskRay]

Fix lld/test/ELF tests

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: SYMBOL TABLE:
-# CHECK: [[ADDR]]          .bss 00000000 __bss_start
+# CHECK: [[ADDR]]          .bss 0000000000000000 __bss_start
 
 .global __bss_start
 .text
 _start:
 .comm sym1,4,4

lld/test/ELF/edata-etext.s

 ## 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:      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
+# CHECK-NEXT:  000000000020215b         .data 0000000000000000 _edata
+# CHECK-NEXT:  0000000000202162         .bss  0000000000000000 _end
+# CHECK-NEXT:  0000000000201159         .text 0000000000000000 _etext
+# CHECK-NEXT:  0000000000201158         .text 0000000000000000 _start
+# CHECK-NEXT:  000000000020215b         .data 0000000000000000 edata
+# CHECK-NEXT:  0000000000202162         .bss  0000000000000000 end
+# CHECK-NEXT:  0000000000201159         .text 0000000000000000 etext
 
 # RUN: ld.lld -r %t.o -o %t2
 # RUN: llvm-objdump -t %t2 | FileCheck %s --check-prefix=RELOCATABLE
-# RELOCATABLE:       0000000000000000 *UND* 00000000 _edata
-# RELOCATABLE-NEXT:  0000000000000000 *UND* 00000000 _end
-# RELOCATABLE-NEXT:  0000000000000000 *UND* 00000000 _etext
+# RELOCATABLE:       0000000000000000 *UND* 0000000000000000 _edata
+# RELOCATABLE-NEXT:  0000000000000000 *UND* 0000000000000000 _end
+# RELOCATABLE-NEXT:  0000000000000000 *UND* 0000000000000000 _etext
 
 .global _start,_end,_etext,_edata,end,etext,edata
 .text
 _start:
   nop
 .data
   .word 1
 .bss
   .align 4
   .space 6

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: 0000000000202164         .data                 00000000 _edata
+# CHECK: 0000000000202164         .data  0000000000000000 _edata
 
 .text
 .globl _start
 _start:
 .long .data - .
 
 .data
 .quad 0
 
 .globl _edata

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

 # REQUIRES: x86
 # LINK_ORDER cnamed sections are not kept alive by the __start_* reference.
 
 # 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 %t | FileCheck  %s
 
 # CHECK: Sections:
 # CHECK-NOT: yy
 # CHECK: xx {{.*}} DATA
 # CHECK-NOT: yy
 
 # CHECK: SYMBOL TABLE:
-# CHECK:   xx    00000000 .protected __start_xx
-# CHECK: w *UND* 00000000 __start_yy
+# CHECK:   xx    0000000000000000 .protected __start_xx
+# CHECK: w *UND* 0000000000000000 __start_yy
 
 .weak __start_xx
 .weak __start_yy
 
 .global _start
 _start:
 .quad __start_xx
 .quad __start_yy

lld/test/ELF/icf7.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: ld.lld %t -o %t2 --icf=all --print-icf-sections | FileCheck %s
 # RUN: llvm-objdump -t %t2 | FileCheck -check-prefix=ALIGN %s
 
 # CHECK: selected section {{.*}}:(.text.f1)
 # CHECK:   removing identical section {{.*}}:(.text.f2)
 
-# ALIGN: .text 00000000 _start
-# ALIGN: .text 00000000 f1
+# ALIGN: .text 0000000000000000 _start
+# ALIGN: .text 0000000000000000 f1
 
 .globl _start, f1, f2
 _start:
   ret
 
 .section .text.f1, "ax"
   .align 1
 f1:

lld/test/ELF/linkerscript/absolute2.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 
 # RUN: echo "SECTIONS { .text : { *(.text) } foo = ABSOLUTE(_start) + _start; };" > %t.script
 # RUN: ld.lld -o %t --script %t.script %t.o
 # RUN: llvm-objdump -t %t | FileCheck %s
 
 # RUN: echo "SECTIONS { .text : { *(.text) } foo = _start + ABSOLUTE(_start); };" > %t.script
 # RUN: ld.lld -o %t --script %t.script %t.o
 # RUN: llvm-objdump -t %t | FileCheck %s
 
-# CHECK: 0000000000000001         .text           00000000 _start
-# CHECK: 0000000000000002         .text           00000000 foo
+# CHECK: 0000000000000001         .text  0000000000000000 _start
+# CHECK: 0000000000000002         .text  0000000000000000 foo
 
         .global _start
         nop
 _start:

lld/test/ELF/linkerscript/align4.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 -t %t | FileCheck %s
 
 # CHECK-LABEL: SYMBOL TABLE:
-# CHECK-NEXT: 0000000000014008         .text           00000000 _start
-# CHECK-NEXT: 0000000000010000         *ABS*           00000000 __code_base__
-# CHECK-NEXT: 0000000000001000         *ABS*           00000000 VAR
-# CHECK-NEXT: 0000000000011000         .bbb            00000000 __start_bbb
-# CHECK-NEXT: 0000000000012000         .bbb            00000000 __end_bbb
+# CHECK-NEXT: 0000000000014008         .text  0000000000000000 _start
+# CHECK-NEXT: 0000000000010000         *ABS*  0000000000000000 __code_base__
+# CHECK-NEXT: 0000000000001000         *ABS*  0000000000000000 VAR
+# CHECK-NEXT: 0000000000011000         .bbb   0000000000000000 __start_bbb
+# CHECK-NEXT: 0000000000012000         .bbb   0000000000000000 __end_bbb
 
 VAR = 0x1000;
 __code_base__ = 0x10000;
 
 SECTIONS {
   . = __code_base__;
   .aaa : { *(.aaa) }
   .bbb : ALIGN(VAR) { *(.bbb) }
   . = ALIGN(., VAR * 4);
   .ccc : { *(.ccc) }
   __start_bbb = ADDR(.bbb);
   __end_bbb = ALIGN(__start_bbb + SIZEOF(.bbb), VAR);
 }

lld/test/ELF/linkerscript/align5.test

.aaa : {
     zed1 = ALIGN(., 0x100) + 1;
     zed2 = ALIGN(., 0x100) - 1;
   }
   .bbb : { *(.bbb); }
   .ccc : { *(.ccc); }
   .text : { *(.text); }
 }
 
-# CHECK: 0000000000001000 .aaa 00000000 foo
-# CHECK: 0000000000001000 .aaa 00000000 bar
-# CHECK: 0000000000001001 .aaa 00000000 zed1
-# CHECK: 0000000000000fff .aaa 00000000 zed2
+# CHECK: 0000000000001000 .aaa 0000000000000000 foo
+# CHECK: 0000000000001000 .aaa 0000000000000000 bar
+# CHECK: 0000000000001001 .aaa 0000000000000000 zed1
+# CHECK: 0000000000000fff .aaa 0000000000000000 zed2

lld/test/ELF/linkerscript/data-commands-gc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { .text : { *(.text*) QUAD(bar) } }" > %t.script
 # RUN: ld.lld --gc-sections -o %t %t.o --script %t.script
 # RUN: llvm-objdump -t %t | FileCheck %s
 
-# CHECK: 0000000000000008         .rodata                 00000000 bar
+# CHECK: 0000000000000008         .rodata  0000000000000000 bar
 
 .section .rodata.bar
 .quad 0x1122334455667788
 .global bar
 bar:
 
 .section .text
 .global _start
 _start:
   nop

lld/test/ELF/linkerscript/loadaddr.s

 # RUN:  ddd_lma = LOADADDR(.ddd);  \
 # RUN:  txt_lma = LOADADDR(.text); \
 # RUN: }" > %t.script
 # RUN: ld.lld %t --script %t.script -o %t2
 # RUN: llvm-objdump -t %t2 | FileCheck %s
 # RUN: echo "SECTIONS { v = LOADADDR(.zzz); }" > %t.script
 # RUN: not ld.lld %t --script %t.script -o /dev/null 2>&1 | FileCheck --check-prefix=ERROR %s
 
-# CHECK:      0000000000002000         *ABS*     00000000 aaa_lma
-# CHECK-NEXT: 0000000000002008         *ABS*     00000000 bbb_lma
-# CHECK-NEXT: 0000000000003000         *ABS*     00000000 ccc_lma
-# CHECK-NEXT: 0000000000004000         *ABS*     00000000 ddd_lma
-# CHECK-NEXT: 0000000000004008         *ABS*     00000000 txt_lma
+# CHECK:      0000000000002000         *ABS*  0000000000000000 aaa_lma
+# CHECK-NEXT: 0000000000002008         *ABS*  0000000000000000 bbb_lma
+# CHECK-NEXT: 0000000000003000         *ABS*  0000000000000000 ccc_lma
+# CHECK-NEXT: 0000000000004000         *ABS*  0000000000000000 ddd_lma
+# CHECK-NEXT: 0000000000004008         *ABS*  0000000000000000 txt_lma
 # ERROR: {{.*}}.script:1: undefined section .zzz
 
 .global _start
 _start:
  nop
 
 .section .aaa, "a"
 .quad 0

lld/test/ELF/linkerscript/merge-nonalloc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { .text : { *(.text) *(.nonalloc) } }" > %t.script
 # RUN: ld.lld -shared -o %t.exe %t.script %t.o
 # RUN: llvm-objdump -syms %t.exe | FileCheck %s
 
-# CHECK: .text 00000000 nonalloc_start
+# CHECK: .text 0000000000000000 nonalloc_start
 
 _start:
   nop
 
 .section .nonalloc,"",@progbits
 nonalloc_start:
   .long 0xcafe

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

 
 # 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
+# CHECK:     [[ADDR]]         abc  0000000000000000 foo

lld/test/ELF/linkerscript/symbol-reserved.s

 # REQUIRES: x86
 
 ## Test linker synthesized symbols (e.g. __ehdr_start, _end) can be used in linker scripts.
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: echo "PROVIDE_HIDDEN(newsym = __ehdr_start + 5);" > %t.script
 # RUN: ld.lld -o %t1 %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck %s
 
-# CHECK: 0000000000200005 .text 00000000 .hidden newsym
+# CHECK: 0000000000200005 .text 0000000000000000 .hidden newsym
 
 # RUN: ld.lld -o %t1.so %t.script %t -shared
 # RUN: llvm-objdump -t %t1.so | FileCheck --check-prefix=SHARED %s
 
-# SHARED: 0000000000000005 .dynsym 00000000 .hidden newsym
+# SHARED: 0000000000000005 .dynsym 0000000000000000 .hidden newsym
 
 # RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(__ehdr_start, CONSTANT(MAXPAGESIZE)) + 5);" > %t.script
 # RUN: ld.lld -o %t1 %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=ALIGNED %s
 
-# ALIGNED: 0000000000200005 .text 00000000 .hidden newsym
+# ALIGNED: 0000000000200005 .text 0000000000000000 .hidden newsym
 
 # RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(3, 8) + 10);" > %t.script
 # RUN: ld.lld -o %t1 %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=ALIGN-ADD %s
-# ALIGN-ADD: 0000000000000012 *ABS* 00000000 .hidden newsym
+# ALIGN-ADD: 0000000000000012 *ABS* 0000000000000000 .hidden newsym
 
 # RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(11, 8) - 10);" > %t.script
 # RUN: ld.lld -o %t1 %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=ALIGN-SUB %s
-# ALIGN-SUB: 0000000000000006 *ABS* 00000000 .hidden newsym
+# ALIGN-SUB: 0000000000000006 *ABS* 0000000000000000 .hidden newsym
 
 # RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(_end, CONSTANT(MAXPAGESIZE)) + 5);" > %t.script
 # RUN: ld.lld -o %t1 %t %t.script
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=RELATIVE %s
-# RELATIVE: 0000000000202005 .text 00000000 .hidden newsym
-# RELATIVE: 0000000000201127 .text 00000000 _end
+# RELATIVE: 0000000000202005 .text 0000000000000000 .hidden newsym
+# RELATIVE: 0000000000201127 .text 0000000000000000 _end
 
 # RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(_end, CONSTANT(MAXPAGESIZE)) + 5);" > %t.script
 # RUN: ld.lld -o %t1 --script %p/Inputs/symbol-reserved.script %t %t.script
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=RELATIVE-ADD %s
-# RELATIVE-ADD: 0000000000001005 .text 00000000 .hidden newsym
-# RELATIVE-ADD: 0000000000000007 .text 00000000 .hidden _end
+# RELATIVE-ADD: 0000000000001005 .text 0000000000000000 .hidden newsym
+# RELATIVE-ADD: 0000000000000007 .text 0000000000000000 .hidden _end
 
 # RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(_end, CONSTANT(MAXPAGESIZE)) - 5);" > %t.script
 # RUN: ld.lld -o %t1 --script %p/Inputs/symbol-reserved.script %t %t.script
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=RELATIVE-SUB %s
-# RELATIVE-SUB: 0000000000000ffb .text 00000000 .hidden newsym
-# RELATIVE-SUB: 0000000000000007 .text 00000000 .hidden _end
+# RELATIVE-SUB: 0000000000000ffb .text 0000000000000000 .hidden newsym
+# RELATIVE-SUB: 0000000000000007 .text 0000000000000000 .hidden _end
 
 .global _start
 _start:
   lea newsym(%rip),%rax

lld/test/ELF/linkerscript/symbolreferenced.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # Provide new symbol. The value should be 1, like set in PROVIDE()
 # RUN: echo "SECTIONS { PROVIDE(newsym = 1);}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=PROVIDE1 %s
-# PROVIDE1: 0000000000000001         *ABS*    00000000 newsym
+# PROVIDE1: 0000000000000001         *ABS*  0000000000000000 newsym
 
 # Provide new symbol (hidden). The value should be 1
 # RUN: echo "SECTIONS { PROVIDE_HIDDEN(newsym = 1);}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=HIDDEN1 %s
-# HIDDEN1: 0000000000000001         *ABS*    00000000 .hidden newsym
+# HIDDEN1: 0000000000000001         *ABS*  0000000000000000 .hidden newsym
 
 .global _start
 _start:
  nop
 
 .globl patatino
 patatino:
   movl newsym, %eax

lld/test/ELF/linkerscript/symbols-non-alloc.test

 # REQUIRES: x86
 # RUN: echo '.section .nonalloc,""; .quad 0' \
 # RUN:   | llvm-mc -filetype=obj -triple=x86_64-unknown-linux - -o %t
 # RUN: ld.lld -o %t2 --script %s %t
 # RUN: llvm-objdump -section-headers -t %t2 | FileCheck %s
 
 # CHECK: Sections:
 # CHECK:  .nonalloc     00000008 0000000000000000
 
 # CHECK: SYMBOL TABLE:
-# CHECK:  0000000000000008 .nonalloc 00000000 Sym
+# CHECK:  0000000000000008 .nonalloc 0000000000000000 Sym
 
 SECTIONS {
   . = SIZEOF_HEADERS;
   .text : { *(.text) }
   .nonalloc : { *(.nonalloc) }
   Sym = .;
 }

lld/test/ELF/linkerscript/symbols.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # Simple symbol assignment. Should raise conflict in case we
 # have duplicates in any input section, but currently simply
 # replaces the value.
 # RUN: echo "SECTIONS {.text : {*(.text.*)} text_end = .;}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=SIMPLE %s
-# SIMPLE:                               .text    00000000 text_end
+# SIMPLE: .text  0000000000000000 text_end
 
 # The symbol is not referenced. Don't provide it.
 # RUN: echo "SECTIONS { PROVIDE(newsym = 1);}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=DONTPROVIDE %s
 # DONTPROVIDE-NOT: newsym
 
 # The symbol is not referenced. Don't provide it.
 # RUN: echo "SECTIONS { PROVIDE_HIDDEN(newsym = 1);}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=DONTPROVIDE %s
 
 # Provide existing symbol. The value should be 0, even though we
 # have value of 1 in PROVIDE()
 # RUN: echo "SECTIONS { PROVIDE(somesym = 1);}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=PROVIDE2 %s
-# PROVIDE2: 0000000000000000         *ABS*    00000000 somesym
+# PROVIDE2: 0000000000000000         *ABS*  0000000000000000 somesym
 
 # Provide existing symbol. The value should be 0, even though we
 # have value of 1 in PROVIDE_HIDDEN(). Visibility should not change
 # RUN: echo "SECTIONS { PROVIDE_HIDDEN(somesym = 1);}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=HIDDEN2 %s
-# HIDDEN2: 0000000000000000         *ABS*    00000000 somesym
+# HIDDEN2: 0000000000000000         *ABS*  0000000000000000 somesym
 
 # Hidden symbol assignment.
 # RUN: echo "SECTIONS { HIDDEN(newsym = 1);}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=HIDDEN3 %s
-# HIDDEN3: 0000000000000001         *ABS*    00000000 .hidden newsym
+# HIDDEN3: 0000000000000001         *ABS*  0000000000000000 .hidden newsym
 
 # The symbol is not referenced. Don't provide it.
 # RUN: echo "PROVIDE(newsym = 1);" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=DONTPROVIDE %s
 
 # The symbol is not referenced. Don't provide it.
 # RUN: echo "PROVIDE_HIDDEN(newsym = 1);" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=DONTPROVIDE %s
 
 # Provide existing symbol. The value should be 0, even though we
 # have value of 1 in PROVIDE()
 # RUN: echo "PROVIDE(somesym = 1);" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=PROVIDE5 %s
-# PROVIDE5: 0000000000000000         *ABS*    00000000 somesym
+# PROVIDE5: 0000000000000000         *ABS*  0000000000000000 somesym
 
 # Provide existing symbol. The value should be 0, even though we
 # have value of 1 in PROVIDE_HIDDEN(). Visibility should not change
 # RUN: echo "PROVIDE_HIDDEN(somesym = 1);" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=HIDDEN5 %s
-# HIDDEN5: 0000000000000000         *ABS*    00000000 somesym
+# HIDDEN5: 0000000000000000         *ABS*  0000000000000000 somesym
 
 # Simple symbol assignment. All three symbols should have the
 # same value.
 # RUN: echo "foo = 0x100; SECTIONS { bar = foo; } baz = bar;" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=SIMPLE2 %s
-# SIMPLE2: 0000000000000100         *ABS*    00000000 foo
-# SIMPLE2: 0000000000000100         *ABS*    00000000 bar
-# SIMPLE2: 0000000000000100         *ABS*    00000000 baz
+# SIMPLE2: 0000000000000100         *ABS*  0000000000000000 foo
+# SIMPLE2: 0000000000000100         *ABS*  0000000000000000 bar
+# SIMPLE2: 0000000000000100         *ABS*  0000000000000000 baz
 
 .global _start
 _start:
  nop
 
 .global somesym
 somesym = 0

lld/test/ELF/linkerscript/synthetic-symbols1.test

.eh_frame_hdr : {
      *(.eh_frame_hdr)
      __eh_frame_hdr_end = .;
      __eh_frame_hdr_end2 = ABSOLUTE(ALIGN(0x10));
   }
 
   .eh_frame : {}
 }
 
-# CHECK:      0000000000000128         .foo    00000000 .hidden _end_sec
-# CHECK-NEXT: 0000000000000120         .foo    00000000 _begin_sec
-# CHECK-NEXT: 0000000000000128         *ABS*   00000000 _end_sec_abs
-# CHECK-NEXT: 000000000000104c         .text   00000000 _start
-# CHECK-NEXT: 0000000000000120         .foo    00000000 begin_foo
-# CHECK-NEXT: 0000000000000128         .foo    00000000 end_foo
-# CHECK-NEXT: 0000000000000008         *ABS*   00000000 size_foo_1
-# CHECK-NEXT: 0000000000000008         *ABS*   00000000 size_foo_1_abs
-# CHECK-NEXT: 0000000000001000         .foo    00000000 begin_bar
-# CHECK-NEXT: 0000000000001004         .foo    00000000 end_bar
-# CHECK-NEXT: 0000000000000ee4         *ABS*   00000000 size_foo_2
-# CHECK-NEXT: 0000000000000ee4         *ABS*   00000000 size_foo_3
-# CHECK-NEXT: 0000000000001004         .eh_frame_hdr     00000000 __eh_frame_hdr_start
-# CHECK-NEXT: 0000000000001010         *ABS*             00000000 __eh_frame_hdr_start2
-# CHECK-NEXT: 0000000000001018         .eh_frame_hdr     00000000 __eh_frame_hdr_end
-# CHECK-NEXT: 0000000000001020         *ABS*             00000000 __eh_frame_hdr_end2
+# CHECK:      0000000000000128         .foo   0000000000000000 .hidden _end_sec
+# CHECK-NEXT: 0000000000000120         .foo   0000000000000000 _begin_sec
+# CHECK-NEXT: 0000000000000128         *ABS*  0000000000000000 _end_sec_abs
+# CHECK-NEXT: 000000000000104c         .text  0000000000000000 _start
+# CHECK-NEXT: 0000000000000120         .foo   0000000000000000 begin_foo
+# CHECK-NEXT: 0000000000000128         .foo   0000000000000000 end_foo
+# CHECK-NEXT: 0000000000000008         *ABS*  0000000000000000 size_foo_1
+# CHECK-NEXT: 0000000000000008         *ABS*  0000000000000000 size_foo_1_abs
+# CHECK-NEXT: 0000000000001000         .foo   0000000000000000 begin_bar
+# CHECK-NEXT: 0000000000001004         .foo   0000000000000000 end_bar
+# CHECK-NEXT: 0000000000000ee4         *ABS*  0000000000000000 size_foo_2
+# CHECK-NEXT: 0000000000000ee4         *ABS*  0000000000000000 size_foo_3
+# CHECK-NEXT: 0000000000001004         .eh_frame_hdr  0000000000000000 __eh_frame_hdr_start
+# CHECK-NEXT: 0000000000001010         *ABS*          0000000000000000 __eh_frame_hdr_start2
+# CHECK-NEXT: 0000000000001018         .eh_frame_hdr  0000000000000000 __eh_frame_hdr_end
+# CHECK-NEXT: 0000000000001020         *ABS*          0000000000000000 __eh_frame_hdr_end2

lld/test/ELF/linkerscript/synthetic-symbols3.test

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/synthetic-symbols.s -o %t
 # RUN: ld.lld -o %t.exe --eh-frame-hdr --script %s %t
 # RUN: llvm-objdump -t %t.exe | FileCheck %s
 
 # Check that we can specify synthetic symbols without defining SECTIONS.
 PROVIDE_HIDDEN(_begin_sec = _start);
 PROVIDE_HIDDEN(_end_sec = ADDR(.text) + SIZEOF(.text));
 
-# CHECK:       00000000002011ac         .text     00000000 .hidden _begin_sec
-# CHECK-NEXT:  00000000002011ad         .text     00000000 .hidden _end_sec
+# CHECK:       00000000002011ac         .text  0000000000000000 .hidden _begin_sec
+# CHECK-NEXT:  00000000002011ad         .text  0000000000000000 .hidden _end_sec

lld/test/ELF/linkerscript/synthetic-symbols4.test

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/synthetic-symbols.s -o %t.o
 # RUN: ld.lld -o %t --eh-frame-hdr --script %s %t.o
 # RUN: llvm-objdump -t %t | FileCheck %s
 
 SECTIONS {
   . = 0x201000;
   .text : { *(.text) }
   PROVIDE_HIDDEN(_begin_sec = ADDR(.text));
   PROVIDE_HIDDEN(_end_sec = ADDR(.text) + SIZEOF(.text));
 }
 
-# CHECK:       0000000000201054         .text     00000000 .hidden _begin_sec
-# CHECK-NEXT:  0000000000201055         .text     00000000 .hidden _end_sec
+# CHECK:       0000000000201054         .text  0000000000000000 .hidden _begin_sec
+# CHECK-NEXT:  0000000000201055         .text  0000000000000000 .hidden _end_sec

lld/test/ELF/mips-64-got.s

 # REQUIRES: mips
 # Check MIPS N64 ABI GOT relocations
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux \
 # RUN:         %p/Inputs/mips-pic.s -o %t.so.o
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.exe.o
 # RUN: echo "SECTIONS { . = 0x30000; .text : { *(.text) } }" > %t.script
 # RUN: ld.lld %t.so.o -shared -soname=t.so -o %t.so
 # RUN: ld.lld %t.exe.o --script %t.script %t.so -o %t.exe
 # RUN: llvm-objdump -d -t --no-show-raw-insn %t.exe | FileCheck %s
 # RUN: llvm-readelf -r -s -A %t.exe | FileCheck -check-prefix=GOT %s
 
-# CHECK: {{[0-9a-f]+}}1c8  .text  00000000 foo
+# CHECK: {{[0-9a-f]+}}1c8  .text  0000000000000000 foo
 
 # CHECK:      __start:
 # CHECK-NEXT:    {{.*}}  ld      $2, -32736($gp)
 # CHECK-NEXT:    {{.*}}  daddiu  $2,  $2, 456
 # CHECK-NEXT:    {{.*}}  addiu   $2,  $2, -32704
 # CHECK-NEXT:    {{.*}}  addiu   $2,  $2, -32720
 # CHECK-NEXT:    {{.*}}  addiu   $2,  $2, -32712
 

lld/test/ELF/mips-64-rels.s

 # REQUIRES: mips
 # Check handling multiple MIPS N64 ABI relocations packed
 # into the single relocation record.
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { \
 # RUN:         . = 0x20000; .text ALIGN(0x1000) : { *(.text) } \
 # RUN:         . = 0x30000; .got : { *(.got)  } \
 # RUN:       }" > %t.script
 # RUN: ld.lld %t.o --script %t.script -o %t.exe
 # RUN: llvm-objdump -d -s -t --print-imm-hex --no-show-raw-insn %t.exe | FileCheck %s
 # RUN: llvm-readobj -r %t.exe | FileCheck -check-prefix=REL %s
 
-# CHECK: 0000000000037ff0   .got    00000000 .hidden _gp
+# CHECK: 0000000000037ff0   .got  0000000000000000 .hidden _gp
 
 # CHECK:      Contents of section .rodata:
 # CHECK-NEXT:  {{[0-9a-f]+}} ffffffff fffe9014
 #                            ^-- 0x21004 - 0x37ff0 = 0xfffffffffffe9014
 
 # CHECK:      __start:
 # CHECK-NEXT:    21000:  lui     $gp, 0x1
 #                                     ^-- 0x21000 - 0x37ff0

lld/test/ELF/mips-64.s

 # REQUIRES: mips
 # Check R_MIPS_64 relocation calculation.
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.o
 # RUN: ld.lld -shared %t.o -o %t.so
 # RUN: llvm-objdump -s -t %t.so | FileCheck -check-prefix=SYM %s
 # RUN: llvm-readelf -r -s --dynamic-table -A %t.so | FileCheck %s
 
   .data
   .globl v2
 v1:
   .quad v2+8 # R_MIPS_64 target v2 addend 8
 v2:
   .quad v1   # R_MIPS_64 target v1 addend 0
 
 # SYM: SYMBOL TABLE:
-# SYM: 00000000[[V1:[0-9a-f]+]]  .data  00000000 v1
+# SYM: 00000000[[V1:[0-9a-f]+]]  .data  0000000000000000 v1
 
 # SYM: Contents of section .data:
 # SYM-NEXT:  {{.*}} 00000000 00000008 00000000 [[V1]]
 
 # CHECK: Relocation section
 # CHECK: [[V2:[0-9a-f]+]]  {{.*}} R_MIPS_REL32/R_MIPS_64/R_MIPS_NONE
 # CHECK: [[V1:[0-9a-f]+]]  {{.*}} R_MIPS_REL32/R_MIPS_64/R_MIPS_NONE [[V2]] v2
 

lld/test/ELF/mips-tls-64.s

 # RUN:   | FileCheck -check-prefix=DIS %s
 # RUN: llvm-readobj -r -A %t.exe | FileCheck %s
 
 # RUN: ld.lld -shared %t.o %t.so -script %t.script -o %t-out.so
 # RUN: llvm-objdump -d -s -t --no-show-raw-insn %t-out.so \
 # RUN:   | FileCheck -check-prefix=DIS-SO %s
 # RUN: llvm-readobj -r -A %t-out.so | FileCheck -check-prefix=SO %s
 
-# DIS: 0000000000000000 l     O .tdata          00000000 loc
-# DIS: 0000000000000004 g     O .tdata          00000000 bar
-# DIS: 0000000000000000 g     O *UND*           00000000 foo
+# DIS: 0000000000000000 l     O .tdata  0000000000000000 loc
+# DIS: 0000000000000004 g     O .tdata  0000000000000000 bar
+# DIS: 0000000000000000 g     O *UND*   0000000000000000 foo
 
 # DIS:      Contents of section .got:
 # DIS-NEXT:  30000 00000000 00000000 80000000 00000000
 # DIS-NEXT:  30010 00000000 00000000 ffffffff ffff9004
 # DIS-NEXT:  30020 00000000 00000000 00000000 00000000
 # DIS-NEXT:  30030 00000000 00000001 00000000 00000000
 # DIS-NEXT:  30040 00000000 00000001 ffffffff ffff8004
 

lld/test/ELF/mips-tls-static-64.s

 # REQUIRES: mips
 # Check handling TLS related relocations and symbols when linking
 # a 64-bit static executable.
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t
 # RUN: ld.lld -static %t -o %t.exe
 # RUN: llvm-objdump -s -t %t.exe | FileCheck %s
 
 # CHECK: SYMBOL TABLE:
-# CHECK: [[TGA:[0-9a-f]{8}]]        .text           00000000 __tls_get_addr
-# CHECK:    0000000000000000 g    O .tdata          00000000 tls1
+# CHECK: [[TGA:[0-9a-f]{8}]]        .text  0000000000000000 __tls_get_addr
+# CHECK:    0000000000000000 g    O .tdata 0000000000000000 tls1
 #
 # CHECK:      Contents of section .data:
 # CHECK-NEXT:  {{.*}} [[TGA]] ffffffff ffff8004 ffffffff
 # CHECK-NEXT:  {{.*}} ffff9004
 
   .text
   .global __start
 __start:

lld/test/ELF/relocation-common.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 -d %t | FileCheck %s
 
 .global _start
 _start:
   movl $1, sym1(%rip)
 
 .global sym1
 .comm sym1,4,4
 
-# CHECK: 0000000000202164 g     O .bss            00000004 sym1
+# CHECK: 0000000000202164 g     O .bss   0000000000000004 sym1
 # CHECK: 201158: {{.*}} movl    $1, 4098(%rip)

lld/test/ELF/sht-group-gold-r.test

 # REQUIRES: x86
 # GNU gold 1.14 (the newest version as of July 2017) seems to create
 # non-standard-compliant SHT_GROUP sections when the -r option is given.
 #
 # Such SHT_GROUP sections use section names as their signatures
 # instead of symbols pointed by sh_link field. Since it is prevalent,
 # we accept such nonstandard sections.
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld %p/Inputs/sht-group-gold-r.elf %t.o -o %t.exe
 # RUN: llvm-objdump -t %t.exe | FileCheck %s
 
-# CHECK: .text 00000000 bar
-# CHECK: .text 00000000 foo
+# CHECK: .text 0000000000000000 bar
+# CHECK: .text 0000000000000000 foo
 
 .globl _start
 _start:
   ret

lld/test/ELF/wrap-no-real.s

 // CHECK: _start:
 // CHECK-NEXT: movl $0x11010, %edx
 // CHECK-NEXT: movl $0x11010, %edx
 // CHECK-NEXT: movl $0x11000, %edx
 
 // RUN: llvm-objdump -t %t | FileCheck -check-prefix=SYM %s
 
 
-// SYM:      {{.*}}            .dynamic  00000000 .hidden _DYNAMIC
-// SYM-NEXT: 0000000000011000  *ABS*     00000000 __real_foo
-// SYM-NEXT: 0000000000011010  *ABS*     00000000 __wrap_foo
-// SYM-NEXT: {{.*}}            .text     00000000 _start
-// SYM-NEXT: 0000000000011000  *ABS*     00000000 foo
+// SYM:      {{.*}}            .dynamic 0000000000000000 .hidden _DYNAMIC
+// SYM-NEXT: 0000000000011000  *ABS*    0000000000000000 __real_foo
+// SYM-NEXT: 0000000000011010  *ABS*    0000000000000000 __wrap_foo
+// SYM-NEXT: {{.*}}            .text    0000000000000000 _start
+// SYM-NEXT: 0000000000011000  *ABS*    0000000000000000 foo
 
 .global _start
 _start:
   movl $foo, %edx
   movl $__wrap_foo, %edx
   movl $__real_foo, %edx

llvm/test/MC/AArch64/inst-directive.s

 // CHECK-ASM:        .inst   0x5e104020
 
 // CHECK-OBJ: Section {
 // CHECK-OBJ:   Name: .inst.aarch64_inst
 // CHECK-OBJ:   SectionData (
 // CHECK-OBJ-NEXT: 0000: 2040105E
 // CHECK-OBJ-NEXT: )
 
-// CHECK-SYMS-NOT: 0000000000000000         .inst.aarch64_inst              00000000 $d
-// CHECK-SYMS:     0000000000000000         .inst.aarch64_inst              00000000 $x
-// CHECK-SYMS-NOT: 0000000000000000         .inst.aarch64_inst              00000000 $d
+// CHECK-SYMS-NOT: 0000000000000000 .inst.aarch64_inst 0000000000000000 $d
+// CHECK-SYMS:     0000000000000000 .inst.aarch64_inst 0000000000000000 $x
+// CHECK-SYMS-NOT: 0000000000000000 .inst.aarch64_inst 0000000000000000 $d

llvm/test/MC/AArch64/mapping-across-sections.s

// Changing back to .text should not emit a redundant $x
         add w0, w0, w0
 
 // With all those constraints, we want:
 //   + .text to have $x at 0 and no others
 //   + .wibble to have $x at 0
 //   + .starts_data to have $d at 0
 
 
-// CHECK: 00000000 .starts_data 00000000 $d
-// CHECK-NEXT: 00000000 .text 00000000 $x
-// CHECK-NEXT: 00000000 .wibble 00000000 $x
+// CHECK:      0000000000000000 .starts_data 0000000000000000 $d
+// CHECK-NEXT: 0000000000000000 .text        0000000000000000 $x
+// CHECK-NEXT: 0000000000000000 .wibble      0000000000000000 $x
 // CHECK-NOT: ${{[adtx]}}
 

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

 # ADJUST-NEXT:    3 .rela.debug_str 00000018 0000000000000000
 # ADJUST-NEXT:    4 .data           00000004 0000000000123000 DATA
 # ADJUST-NEXT:    5 .rela.data      00000018 0000000000000000
 # ADJUST-NEXT:    6 .symtab         00000060 0000000000000000
 # ADJUST-NEXT:    7 .strtab         00000010 0000000000000000
 # ADJUST-NEXT:    8 .shstrtab       0000003c 0000000000000000
 
 # COMMON:      SYMBOL TABLE:
-# COMMON-NEXT:  0000000000000001  l F .text 00000000 func
-# COMMON-NEXT:  0000000000000000      .text 00000000 sym
-# COMMON-NEXT:  0000000000000000  l d .text 00000000 .text
+# COMMON-NEXT:  0000000000000001  l F .text 0000000000000000 func
+# COMMON-NEXT:  0000000000000000      .text 0000000000000000 sym
+# COMMON-NEXT:  0000000000000000  l d .text 0000000000000000 .text
 
 # NOADJUST:      0000000000000000 sym:
 # NOADJUST-NEXT:   0: {{.*}}  nop
 # NOADJUST:      0000000000000001 func:
 # NOADJUST-NEXT:   1: {{.*}}  retq
 
 # ADJUST:        0000000000123000 sym:
 # ADJUST-NEXT:     123000: {{.*}} nop

llvm/test/tools/llvm-objdump/X86/demangle.s

 # RUN: llvm-mc %s -filetype=obj -triple=x86_64-pc-linux -o %t
 # RUN: llvm-objdump -t -r --demangle %t | FileCheck %s
 
 ## Check we demangle symbols when printing symbol table.
 # CHECK:      SYMBOL TABLE:
-# CHECK-NEXT: 0000000000000000 g     F .text           00000000 foo()
+# CHECK-NEXT: 0000000000000000 g     F .text           0000000000000000 foo()
 
 ## Check we demangle symbols when printing relocations.
 # CHECK:      000000000000001 R_X86_64_PLT32 foo()-0x4
 
 ## Check the case when relocations are inlined into disassembly.
 # RUN: llvm-objdump -d -r --demangle %t | FileCheck %s --check-prefix=INLINE
 # INLINE:      foo():
 # INLINE-NEXT:  0: {{.*}}  callq   0 <_Z3foov+0x5>
 # INLINE-NEXT:  0000000000000001:  R_X86_64_PLT32 foo()-0x4
 
 .text
 .globl _Z3foov
 .type _Z3foov,@function
 _Z3foov:
  callq _Z3foov@PLT

llvm/test/tools/llvm-objdump/symbol-table-elf.test

-# RUN: yaml2obj %s -o %t
-# RUN: llvm-objdump --syms %t > %t1
-# RUN: llvm-objdump -t     %t > %t2
-# RUN: cmp %t1 %t2
-# RUN: FileCheck %s --input-file=%t1
+# RUN: yaml2obj -D BITS=32 %s -o %t.32
+# RUN: llvm-objdump --syms %t.32 > %t.32.txt
+# RUN: llvm-objdump -t %t.32 | cmp - %t.32.txt
+# RUN: FileCheck --check-prefix=ELF32 %s --input-file=%t.32.txt
 
-# CHECK:      SYMBOL TABLE:
-# CHECK-NEXT: 0000000000001004 l     F .text     00000000 lfoo
-# CHECK-NEXT: 0000000000001008 l     O .text     00000000 lbar
-# CHECK-NEXT: 0000000000001004 g     F .text     00000000 foo
-# CHECK-NEXT: 0000000000001008 g     O .text     00000000 bar
+# RUN: yaml2obj -D BITS=64 %s -o %t.64
+# RUN: llvm-objdump --syms %t.64 | FileCheck --check-prefix=ELF64 %s
+
+# ELF32:      SYMBOL TABLE:
+# ELF32-NEXT: 00001004 l     F .text     00000000 lfoo
+# ELF32-NEXT: 00001008 l     O .text     00000000 lbar
+# ELF32-NEXT: 00001004 g     F .text     00000000 foo
+# ELF32-NEXT: 00001008 g     O .text     00000000 bar
+
+# ELF64:      SYMBOL TABLE:
+# ELF64-NEXT: 0000000000001004 l     F .text     0000000000000000 lfoo
+# ELF64-NEXT: 0000000000001008 l     O .text     0000000000000000 lbar
+# ELF64-NEXT: 0000000000001004 g     F .text     0000000000000000 foo
+# ELF64-NEXT: 0000000000001008 g     O .text     0000000000000000 bar
 
 !ELF
 FileHeader:
-  Class:           ELFCLASS64
+  Class:           ELFCLASS[[BITS]]
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
   - Name:            .bss
     Type:            SHT_NOBITS
     Flags:           [ SHF_ALLOC ]
     AddressAlign:    0x0000000000000010

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

if (Absolute) {
       StringRef SectionName =
           unwrapOrError(Section->getName(), O->getFileName());
       outs() << SectionName;
     }
 
     if (Common || isa<ELFObjectFileBase>(O)) {
       uint64_t Val =
           Common ? Symbol.getAlignment() : ELFSymbolRef(Symbol).getSize();
-      outs() << format("\t%08" PRIx64, Val);
+      outs() << '\t' << format(Fmt, Val);
     }
 
     if (isa<ELFObjectFileBase>(O)) {
       uint8_t Other = ELFSymbolRef(Symbol).getOther();
       switch (Other) {
       case ELF::STV_DEFAULT:
         break;
       case ELF::STV_INTERNAL: