[llvm-objdump] Prefix memory operand addresses with '0x'

[ikudrin]

Summary

This helps to avoid ambiguity when the address contains only digits 0..9.

[jhenderson]

No objections from me. Best give others a chance to comment though.

[hvdijk]

I like the 0x, but the addresses at the start of the lines get printed without it so it introduces an inconsistency. I personally would prefer it if either both used 0x, or both leave out 0x. Is it possible to change both or does that introduce compatibility issues?

[ikudrin]

In D104909#2841189, @hvdijk wrote:

I like the 0x, but the addresses at the start of the lines get printed without it so it introduces an inconsistency. I personally would prefer it if either both used 0x, or both leave out 0x. Is it possible to change both or does that introduce compatibility issues?

In fact, this patch fixes some inconsistencies in printing instructions and their comments. Hexadecimal constants are already prefixed with 0x (see, for example, lld/test/ELF/x86-64-gotpc-relax-nopic.s), as well as targets of branch instructions (lld/test/ELF/symver.s), etc.

As for addresses of the instructions, personally, I do not believe they need to be prefixed. They are printed as a sequence, so there are for sure some "letter" digits among them, and thus the actual format is easily recognized. In any case, I guess that that is something unrelated to this patch, and should be done separately, if decided.

[hvdijk]

In D104909#2842182, @ikudrin wrote:

In fact, this patch fixes some inconsistencies in printing instructions and their comments. Hexadecimal constants are already prefixed with 0x (see, for example, lld/test/ELF/x86-64-gotpc-relax-nopic.s), as well as targets of branch instructions (lld/test/ELF/symver.s), etc.

As for addresses of the instructions, personally, I do not believe they need to be prefixed. They are printed as a sequence, so there are for sure some "letter" digits among them, and thus the actual format is easily recognized. In any case, I guess that that is something unrelated to this patch, and should be done separately, if decided.

They are closer in meaning to the addresses at the start of the line, not just instructions but data as well, than to anything else though. When we want to see what e.g. pushq 8346(%rip) # 203280 actually refers to, we look for the line that starts with 203280. Yes, I have actually looked things up this way, this isn't hypothetical.

[ikudrin]

In D104909#2842368, @hvdijk wrote:

They are closer in meaning to the addresses at the start of the line, not just instructions but data as well, than to anything else though. When we want to see what e.g. pushq 8346(%rip) # 203280 actually refers to, we look for the line that starts with 203280.

Thanks. pushq 8346(%rip) # 203280 is the perfect example of why this patch is useful. The offset here is decimal while the calculated address is hexadecimal, but that is not obvious.

Yes, I have actually looked things up this way, this isn't hypothetical.

Well, in that case, would you like to prepare the corresponding patch? You seem to be able to substantiate it. Note that the disassembler already prints target addresses of jump/branch instructions with the '0x' prefix.

[MaskRay]

LGTM.

[int3]

I like this :)

lld/test/ELF/symver.s

 # CHECK3-NEXT:  3: {{.*}} NOTYPE GLOBAL DEFAULT [[#]] foo_v1
 # CHECK3-EMPTY:
 
 # DIS3-LABEL: <.text>:
 # DIS3-NEXT:    callq 0x1380 <foo@plt>
 # DIS3-COUNT-3: int3
 # DIS3-NEXT:    callq 0x1390 <foo@plt>
 # DIS3-LABEL: <foo@plt>:
-# DIS3-NEXT:    jmpq *{{.*}}(%rip) # 34a8
+# DIS3-NEXT:    jmpq *{{.*}}(%rip) # 0x34a8
 # DIS3-LABEL: <foo@plt>:
-# DIS3-NEXT:    jmpq *{{.*}}(%rip) # 34b0
+# DIS3-NEXT:    jmpq *{{.*}}(%rip) # 0x34b0
 
 ## Then, test the interaction with versioned definitions in shared objects.
 
 ## TODO Both foo and foo@v1 are undefined. Ideally we should not create two .dynsym entries.
 # RUN: ld.lld -shared --soname=t --version-script=%t/ver %t/ref.o %t/ref1.o %t/def1.so -o %t4
 # RUN: llvm-readelf --dyn-syms %t4 | FileCheck %s --check-prefix=CHECK4
 
 # CHECK4:       1: {{.*}} NOTYPE GLOBAL DEFAULT UND   foo@v1

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

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/wrap-no-real.s -o %t2.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/wrap-no-real2.s -o %t3.o
 // RUN: ld.lld -o %t3.so -shared --soname=t3 %t3.o
 
 // RUN: ld.lld -o %t %t1.o %t2.o -wrap foo
 // RUN: llvm-objdump -d %t | FileCheck %s
 // RUN: llvm-readelf -s -x .got %t | FileCheck --check-prefix=READELF --implicit-check-not=__real_ %s
 
 // CHECK: <_start>:
-// CHECK-NEXT: movq {{.*}}(%rip), %rax  # 2021a8
-// CHECK-NEXT: movq {{.*}}(%rip), %rbx  # 2021a8
-// CHECK-NEXT: movq {{.*}}(%rip), %rcx  # 2021b0
+// CHECK-NEXT: movq {{.*}}(%rip), %rax  # 0x2021a8
+// CHECK-NEXT: movq {{.*}}(%rip), %rbx  # 0x2021a8
+// CHECK-NEXT: movq {{.*}}(%rip), %rcx  # 0x2021b0
 
 // READELF:      0000000000011000  0 NOTYPE GLOBAL DEFAULT ABS foo
 // READELF:      0000000000011010  0 NOTYPE GLOBAL DEFAULT ABS __wrap_foo
 // READELF:      Hex dump of section '.got':
 // READELF-NEXT: 0x[[#%x,ADDR:]] 10100100 00000000 00100100 00000000
 
 // RUN: ld.lld -o %t2 %t1.o %t2.o %t3.so --wrap foo
 // RUN: llvm-objdump -d %t2 | FileCheck --check-prefix=CHECK2 %s
 // RUN: llvm-readelf -s -x .got %t2 | FileCheck --check-prefix=READELF --implicit-check-not=__real_ %s
 
 // CHECK2: <_start>:
-// CHECK2-NEXT: movq {{.*}}(%rip), %rax  # 2022e0
-// CHECK2-NEXT: movq {{.*}}(%rip), %rbx  # 2022e0
-// CHECK2-NEXT: movq {{.*}}(%rip), %rcx  # 2022e8
+// CHECK2-NEXT: movq {{.*}}(%rip), %rax  # 0x2022e0
+// CHECK2-NEXT: movq {{.*}}(%rip), %rbx  # 0x2022e0
+// CHECK2-NEXT: movq {{.*}}(%rip), %rcx  # 0x2022e8
 
 .global _start
 _start:
   mov foo@gotpcrel(%rip), %rax
   mov __wrap_foo@gotpcrel(%rip), %rbx
   mov __real_foo@gotpcrel(%rip), %rcx

lld/test/ELF/x86-64-gotpc-offset.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-objdump -s -d %t | FileCheck %s
 
 # CHECK:      Contents of section .got:
 # CHECK-NEXT: {{^}} [[#%x,ADDR:]] {{.*}} 00000000
 
 # CHECK:      leal {{.*}}(%rip), %eax  # {{.*}} <foo>
-# CHECK-NEXT: movl {{.*}}(%rip), %eax  # [[#ADDR+4]]
-# CHECK-NEXT: movq {{.*}}(%rip), %rax  # [[#ADDR+1]]
+# CHECK-NEXT: movl {{.*}}(%rip), %eax  # 0x[[#ADDR+4]]
+# CHECK-NEXT: movq {{.*}}(%rip), %rax  # 0x[[#ADDR+1]]
 
 ## movl foo@GOTPCREL(%rip), %eax
   movl 0(%rip), %eax
   .reloc .-4, R_X86_64_GOTPCRELX, foo-4
 
 ## The instruction has an offset (addend!=-4). It is incorrect to relax movl to leal.
 ## movl foo@GOTPCREL+4(%rip), %eax
   movl 0(%rip), %eax

lld/test/ELF/x86-64-gotpc-relax-nopic.s

 # SYMRELOC:       Symbol {
 # SYMRELOC:        Name: bar
 # SYMRELOC-NEXT:   Value: 0x203248
 
 ## 2105751 = 0x202197 (bar)
 # DISASM:      Disassembly of section .text:
 # DISASM-EMPTY:
 # DISASM-NEXT: <_start>:
-# DISASM-NEXT:   2011c8:       adcl  {{.*}}(%rip), %eax  # 202240
-# DISASM-NEXT:                 addl  {{.*}}(%rip), %ebx  # 202240
-# DISASM-NEXT:                 andl  {{.*}}(%rip), %ecx  # 202240
-# DISASM-NEXT:                 cmpl  {{.*}}(%rip), %edx  # 202240
-# DISASM-NEXT:                 orl   {{.*}}(%rip), %edi  # 202240
-# DISASM-NEXT:                 sbbl  {{.*}}(%rip), %esi  # 202240
-# DISASM-NEXT:                 subl  {{.*}}(%rip), %ebp  # 202240
+# DISASM-NEXT:   2011c8:       adcl  {{.*}}(%rip), %eax  # 0x202240
+# DISASM-NEXT:                 addl  {{.*}}(%rip), %ebx  # 0x202240
+# DISASM-NEXT:                 andl  {{.*}}(%rip), %ecx  # 0x202240
+# DISASM-NEXT:                 cmpl  {{.*}}(%rip), %edx  # 0x202240
+# DISASM-NEXT:                 orl   {{.*}}(%rip), %edi  # 0x202240
+# DISASM-NEXT:                 sbbl  {{.*}}(%rip), %esi  # 0x202240
+# DISASM-NEXT:                 subl  {{.*}}(%rip), %ebp  # 0x202240
 # DISASM-NEXT:                 xorl  $0x203248, %r8d
 # DISASM-NEXT:                 testl $0x203248, %r15d
 # DISASM-NEXT:   201200:       adcq  $0x203248, %rax
 # DISASM-NEXT:                 addq  $0x203248, %rbx
 # DISASM-NEXT:                 andq  $0x203248, %rcx
 # DISASM-NEXT:                 cmpq  $0x203248, %rdx
 # DISASM-NEXT:                 orq   $0x203248, %rdi
 # DISASM-NEXT:                 sbbq  $0x203248, %rsi

 # SEC-PIC-NEXT:     0x2380 R_X86_64_RELATIVE - 0x3388
 # SEC-PIC-NEXT:   }
 # SEC-PIC-NEXT: ]
 
 ## Check that there was no relaxation performed. All values refer to got entry.
 # DISASM-PIC:      Disassembly of section .text:
 # DISASM-PIC-EMPTY:
 # DISASM-PIC-NEXT: <_start>:
-# DISASM-PIC-NEXT: 1268:       adcl  {{.*}}(%rip), %eax  # 2380
-# DISASM-PIC-NEXT:             addl  {{.*}}(%rip), %ebx  # 2380
-# DISASM-PIC-NEXT:             andl  {{.*}}(%rip), %ecx  # 2380
-# DISASM-PIC-NEXT:             cmpl  {{.*}}(%rip), %edx  # 2380
-# DISASM-PIC-NEXT:             orl   {{.*}}(%rip), %edi  # 2380
-# DISASM-PIC-NEXT:             sbbl  {{.*}}(%rip), %esi  # 2380
-# DISASM-PIC-NEXT:             subl  {{.*}}(%rip), %ebp  # 2380
-# DISASM-PIC-NEXT:             xorl  {{.*}}(%rip), %r8d  # 2380
-# DISASM-PIC-NEXT:             testl %r15d, {{.*}}(%rip) # 2380
-# DISASM-PIC-NEXT: 12a0:       adcq  {{.*}}(%rip), %rax  # 2380
-# DISASM-PIC-NEXT:             addq  {{.*}}(%rip), %rbx  # 2380
-# DISASM-PIC-NEXT:             andq  {{.*}}(%rip), %rcx  # 2380
-# DISASM-PIC-NEXT:             cmpq  {{.*}}(%rip), %rdx  # 2380
-# DISASM-PIC-NEXT:             orq   {{.*}}(%rip), %rdi  # 2380
-# DISASM-PIC-NEXT:             sbbq  {{.*}}(%rip), %rsi  # 2380
-# DISASM-PIC-NEXT:             subq  {{.*}}(%rip), %rbp  # 2380
-# DISASM-PIC-NEXT:             xorq  {{.*}}(%rip), %r8   # 2380
-# DISASM-PIC-NEXT:             testq %r15, {{.*}}(%rip)  # 2380
+# DISASM-PIC-NEXT: 1268:       adcl  {{.*}}(%rip), %eax  # 0x2380
+# DISASM-PIC-NEXT:             addl  {{.*}}(%rip), %ebx  # 0x2380
+# DISASM-PIC-NEXT:             andl  {{.*}}(%rip), %ecx  # 0x2380
+# DISASM-PIC-NEXT:             cmpl  {{.*}}(%rip), %edx  # 0x2380
+# DISASM-PIC-NEXT:             orl   {{.*}}(%rip), %edi  # 0x2380
+# DISASM-PIC-NEXT:             sbbl  {{.*}}(%rip), %esi  # 0x2380
+# DISASM-PIC-NEXT:             subl  {{.*}}(%rip), %ebp  # 0x2380
+# DISASM-PIC-NEXT:             xorl  {{.*}}(%rip), %r8d  # 0x2380
+# DISASM-PIC-NEXT:             testl %r15d, {{.*}}(%rip) # 0x2380
+# DISASM-PIC-NEXT: 12a0:       adcq  {{.*}}(%rip), %rax  # 0x2380
+# DISASM-PIC-NEXT:             addq  {{.*}}(%rip), %rbx  # 0x2380
+# DISASM-PIC-NEXT:             andq  {{.*}}(%rip), %rcx  # 0x2380
+# DISASM-PIC-NEXT:             cmpq  {{.*}}(%rip), %rdx  # 0x2380
+# DISASM-PIC-NEXT:             orq   {{.*}}(%rip), %rdi  # 0x2380
+# DISASM-PIC-NEXT:             sbbq  {{.*}}(%rip), %rsi  # 0x2380
+# DISASM-PIC-NEXT:             subq  {{.*}}(%rip), %rbp  # 0x2380
+# DISASM-PIC-NEXT:             xorq  {{.*}}(%rip), %r8   # 0x2380
+# DISASM-PIC-NEXT:             testq %r15, {{.*}}(%rip)  # 0x2380
 
 .data
 .type   bar, @object
 bar:
  .byte   1
  .size   bar, .-bar
 
 .text

lld/test/ELF/x86-64-plt.s

 # DISASM-NEXT:    callq {{.*}} <local>
 # DISASM-NEXT:    callq {{.*}} <bar@plt>
 # DISASM-NEXT:    jmp   {{.*}} <bar@plt>
 # DISASM-NEXT:    jmp   {{.*}} <weak@plt>
 
 # DISASM1:      Disassembly of section .plt:
 # DISASM1-EMPTY:
 # DISASM1-NEXT: <.plt>:
-# DISASM1-NEXT: 2012e0:     pushq 8450(%rip)  # 2033e8
-# DISASM1-NEXT:             jmpq *8452(%rip)  # 2033f0
+# DISASM1-NEXT: 2012e0:     pushq 8450(%rip)  # 0x2033e8
+# DISASM1-NEXT:             jmpq *8452(%rip)  # 0x2033f0
 # DISASM1-NEXT:             nopl (%rax)
 # DISASM1-EMPTY:
 # DISASM1-NEXT: <bar@plt>:
-# DISASM1-NEXT: 2012f0:     jmpq *8450(%rip)  # 2033f8
+# DISASM1-NEXT: 2012f0:     jmpq *8450(%rip)  # 0x2033f8
 # DISASM1-NEXT:             pushq $0
 # DISASM1-NEXT:             jmp 0x2012e0 <.plt>
 # DISASM1-EMPTY:
 # DISASM1-NEXT: <weak@plt>:
-# DISASM1-NEXT: 201300:     jmpq *8442(%rip)  # 203400
+# DISASM1-NEXT: 201300:     jmpq *8442(%rip)  # 0x203400
 # DISASM1-NEXT:             pushq $1
 # DISASM1-NEXT:             jmp 0x2012e0 <.plt>
 # DISASM1-NOT:  {{.}}
 
 # DISASM2:      Disassembly of section .plt:
 # DISASM2-EMPTY:
 # DISASM2-NEXT: <.plt>:
-# DISASM2-NEXT:   1310:     pushq 8434(%rip)  # 3408
-# DISASM2-NEXT:             jmpq *8436(%rip)  # 3410
+# DISASM2-NEXT:   1310:     pushq 8434(%rip)  # 0x3408
+# DISASM2-NEXT:             jmpq *8436(%rip)  # 0x3410
 # DISASM2-NEXT:             nopl (%rax)
 # DISASM2-EMPTY:
 # DISASM2-NEXT: <bar@plt>:
-# DISASM2-NEXT:   1320:     jmpq *8434(%rip)  # 3418
+# DISASM2-NEXT:   1320:     jmpq *8434(%rip)  # 0x3418
 # DISASM2-NEXT:             pushq $0
 # DISASM2-NEXT:             jmp 0x1310 <.plt>
 # DISASM2-EMPTY:
 # DISASM2-NEXT: <weak@plt>:
-# DISASM2-NEXT:   1330:     jmpq *8426(%rip)  # 3420
+# DISASM2-NEXT:   1330:     jmpq *8426(%rip)  # 0x3420
 # DISASM2-NEXT:             pushq $1
 # DISASM2-NEXT:             jmp 0x1310 <.plt>
 # DISASM2-NOT:  {{.}}
 
 .global _start
 .weak weak
 
 _start:
   call local
   call bar
   jmp bar@plt
   jmp weak
 
 ## foo is local and non-preemptale, no PLT is generated.
 local:
   ret

lld/test/ELF/x86-x32-plt.s

 # DISASM-NEXT:    callq {{.*}} <local>
 # DISASM-NEXT:    callq {{.*}} <bar@plt>
 # DISASM-NEXT:    jmp   {{.*}} <bar@plt>
 # DISASM-NEXT:    jmp   {{.*}} <weak@plt>
 
 # DISASM:      Disassembly of section .plt:
 # DISASM-EMPTY:
 # DISASM-NEXT: <.plt>:
-# DISASM-NEXT: 2011e0:     pushq 8346(%rip)  # 203280
-# DISASM-NEXT:             jmpq *8348(%rip)  # 203288
+# DISASM-NEXT: 2011e0:     pushq 8346(%rip)  # 0x203280
+# DISASM-NEXT:             jmpq *8348(%rip)  # 0x203288
 # DISASM-NEXT:             nopl (%rax)
 # DISASM-EMPTY:
 # DISASM-NEXT: <bar@plt>:
-# DISASM-NEXT: 2011f0:     jmpq *8346(%rip)  # 203290
+# DISASM-NEXT: 2011f0:     jmpq *8346(%rip)  # 0x203290
 # DISASM-NEXT:             pushq $0
 # DISASM-NEXT:             jmp 0x2011e0 <.plt>
 # DISASM-EMPTY:
 # DISASM-NEXT: <weak@plt>:
-# DISASM-NEXT: 201200:     jmpq *8338(%rip)  # 203298
+# DISASM-NEXT: 201200:     jmpq *8338(%rip)  # 0x203298
 # DISASM-NEXT:             pushq $1
 # DISASM-NEXT:             jmp 0x2011e0 <.plt>
 # DISASM-NOT:  {{.}}
 
 .global _start
 .weak weak
 
 _start:
   call local
   call bar
   jmp bar@plt
   jmp weak
 
 ## foo is local and non-preemptale, no PLT is generated.
 local:
   ret

lld/test/MachO/dso-handle.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
 
 # RUN: %lld -lSystem %t.o -o %t
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
-# CHECK:      leaq {{.*}} # 100000000
-# CHECK-NEXT: leaq {{.*}} # 100000000
+# CHECK:      leaq {{.*}} # 0x100000000
+# CHECK-NEXT: leaq {{.*}} # 0x100000000
 
 # RUN: %lld -dylib %t.o -o %t.dylib
 # RUN: llvm-objdump -d --no-show-raw-insn --rebase --section-headers %t.dylib | FileCheck %s --check-prefix=DYLIB-CHECK
-# DYLIB-CHECK:      leaq {{.*}} # 0
-# DYLIB-CHECK-NEXT: leaq {{.*}} # 0
+# DYLIB-CHECK:      leaq {{.*}} # 0x0
+# DYLIB-CHECK-NEXT: leaq {{.*}} # 0x0
 
 # DYLIB-LABEL: Sections:
 # DYLIB:       __data        00000008 [[#%x,DATA:]] DATA
 # DYLIB-LABEL: Rebase table:
 # DYLIB-NEXT:  segment  section  address            type
 # DYLIB-NEXT:  __DATA   __data   0x{{0*}}[[#DATA]]  pointer
 
 # RUN: llvm-objdump --syms %t.dylib | FileCheck %s --check-prefix=SYMS

lld/test/MachO/dylink-ordinal.s

 # REQUIRES: x86
 
 ## --no-leading-lines needed for .tbd files.
 # RUN: rm -rf %t; split-file --no-leading-lines %s %t
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/main.s -o %t/main.o
 # RUN: %lld -o %t/main -L%t -lFoo -lBar -lSystem %t/main.o
 # RUN: llvm-objdump --lazy-bind -d --no-show-raw-insn %t/main | FileCheck %s
 
 # CHECK: callq 0x[[#%x,FOO_OFF:]]
 # CHECK-NEXT: callq 0x[[#%x,BAR_OFF:]]
 
-# CHECK: [[#%x,BAR_OFF]]: jmpq {{.*}} # [[#%x,BAR_BIND:]]
-# CHECK: [[#%x,FOO_OFF]]: jmpq {{.*}} # [[#%x,FOO_BIND:]]
+# CHECK: [[#%x,BAR_OFF]]: jmpq {{.*}} # 0x[[#%x,BAR_BIND:]]
+# CHECK: [[#%x,FOO_OFF]]: jmpq {{.*}} # 0x[[#%x,FOO_BIND:]]
 
 # CHECK-LABEL: Lazy bind table:
 # CHECK-DAG: __DATA __la_symbol_ptr 0x[[#%x,FOO_BIND]] Foo _foo
 # CHECK-DAG: __DATA __la_symbol_ptr 0x[[#%x,BAR_BIND]] Foo _bar
 
 # RUN: llvm-nm -m %t/main | FileCheck --check-prefix=NM %s
 
 # NM-DAG: _bar (from Foo)

lld/test/MachO/static-link.s

 #
 # RUN: llvm-objdump --syms -d -r %t/test | FileCheck %s
 
 # CHECK: SYMBOL TABLE:
 # CHECK: {{0+}}[[ADDR:[0-9a-f]+]] g     O __TEXT,__cstring _goodbye_world
 
 # CHECK: Disassembly of section __TEXT,__text
 # CHECK-LABEL: <_main>:
-# CHECK: leaq {{.*}}(%rip), %rsi   # [[ADDR]] <_goodbye_world>
+# CHECK: leaq {{.*}}(%rip), %rsi   # 0x[[ADDR]] <_goodbye_world>
 
 .section __TEXT,__text
 .global _main
 
 _main:
   movl $0x2000004, %eax                 # write()
   mov $1, %rdi                          # stdout
   leaq _goodbye_world(%rip), %rsi
   mov $15, %rdx                         # length
   syscall
   mov $0, %rax
   ret

lld/test/MachO/tapi-link.s

 # REQUIRES: x86
 
 # RUN: split-file %s %t --no-leading-lines
 
 # RUN: llvm-mc -filetype obj -triple x86_64-apple-darwin %t/test.s -o %t/test.o
 
 # RUN: %lld -o %t/test -lSystem -lc++ -framework CoreFoundation %t/libNested.tbd %t/test.o
 # RUN: llvm-objdump --bind --no-show-raw-insn -d -r %t/test | FileCheck %s
 
 ## libReexportSystem.tbd tests that we can reference symbols from a dylib,
 ## re-exported by a top-level tapi document, which itself is re-exported by
 ## another top-level tapi document.
 # RUN: %lld -o %t/with-reexport %S/Inputs/libReexportSystem.tbd -lc++ -framework CoreFoundation %t/libNested.tbd %t/test.o
 # RUN: llvm-objdump --bind --no-show-raw-insn -d -r %t/with-reexport | FileCheck %s
 
 # CHECK: Disassembly of section __TEXT,__text:
-# CHECK: movq {{.*}} # [[ADDR:[0-9a-f]+]]
+# CHECK: movq {{.*}} # 0x[[ADDR:[0-9a-f]+]]
 
 # CHECK: Bind table:
 # CHECK-DAG: __DATA_CONST __got 0x[[ADDR]] pointer 0 libSystem ___nan
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 CoreFoundation _OBJC_CLASS_$_NSObject
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 CoreFoundation _OBJC_METACLASS_$_NSObject
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 CoreFoundation _OBJC_IVAR_$_NSConstantArray._count
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 CoreFoundation _OBJC_EHTYPE_$_NSException
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 libc++abi      ___gxx_personality_v0

lld/test/MachO/tlv-dylib.s

 # DYLIB:       Rebase table:
 # DYLIB-NEXT:  segment  section            address     type
 # DYLIB-EMPTY:
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/test.s -o %t/test.o
 # RUN: %lld -lSystem -L%t -ltlv %t/test.o -o %t/test
 # RUN: llvm-objdump --bind -d --no-show-raw-insn %t/test | FileCheck %s
 
-# CHECK:      movq [[#]](%rip), %rax # [[#%x, FOO:]]
-# CHECK-NEXT: movq [[#]](%rip), %rax # [[#%x, BAR:]]
-# CHECK-NEXT: movq [[#]](%rip), %rax # [[#%x, BAZ:]]
+# CHECK:      movq [[#]](%rip), %rax # 0x[[#%x, FOO:]]
+# CHECK-NEXT: movq [[#]](%rip), %rax # 0x[[#%x, BAR:]]
+# CHECK-NEXT: movq [[#]](%rip), %rax # 0x[[#%x, BAZ:]]
 
 # CHECK-LABEL: Bind table:
 # CHECK-DAG: __DATA       __thread_ptrs  0x{{0*}}[[#%x, FOO]] pointer 0   libtlv   _foo
 # CHECK-DAG: __DATA       __thread_ptrs  0x{{0*}}[[#%x, BAR]] pointer 0   libtlv   _bar
 # CHECK-DAG: __DATA_CONST __got          0x{{0*}}[[#%x, BAZ]] pointer 0   libtlv   _baz
 
 ## Check `type` on the various TLV sections, and check that
 ## nothing's after S_THREAD_LOCAL_ZEROFILL.

lld/test/MachO/weak-binding.s

 
 # CHECK:      Contents of section __DATA,__la_symbol_ptr:
 ## Check that this section contains a nonzero pointer. It should point to
 ## _weak_external_fn, but we don't have a good way of testing the exact value as
 ## the bytes here are in little-endian order.
 # CHECK-NEXT: {{[0-9a-f]+}} {{[0-9a-f ]*[1-9a-f]+[0-9a-f ]*}}
 
 # CHECK:      <_main>:
-# CHECK-NEXT: movq  [[#]](%rip), %rax  # [[#%X,WEAK_DY_GOT_ADDR:]]
-# CHECK-NEXT: movq  [[#]](%rip), %rax  # [[#%X,WEAK_EXT_GOT_ADDR:]]
-# CHECK-NEXT: leaq  [[#]](%rip), %rax  # [[#%X,WEAK_INT_GOT_ADDR:]]
-# CHECK-NEXT: movq  [[#]](%rip), %rax  # [[#%X,WEAK_TLV_ADDR:]]
-# CHECK-NEXT: movq  [[#]](%rip), %rax  # [[#%X,WEAK_DY_TLV_ADDR:]]
-# CHECK-NEXT: leaq  [[#]](%rip), %rax  # [[#%X,WEAK_INT_TLV_ADDR:]]
+# CHECK-NEXT: movq  [[#]](%rip), %rax  # 0x[[#%X,WEAK_DY_GOT_ADDR:]]
+# CHECK-NEXT: movq  [[#]](%rip), %rax  # 0x[[#%X,WEAK_EXT_GOT_ADDR:]]
+# CHECK-NEXT: leaq  [[#]](%rip), %rax  # 0x[[#%X,WEAK_INT_GOT_ADDR:]]
+# CHECK-NEXT: movq  [[#]](%rip), %rax  # 0x[[#%X,WEAK_TLV_ADDR:]]
+# CHECK-NEXT: movq  [[#]](%rip), %rax  # 0x[[#%X,WEAK_DY_TLV_ADDR:]]
+# CHECK-NEXT: leaq  [[#]](%rip), %rax  # 0x[[#%X,WEAK_INT_TLV_ADDR:]]
 # CHECK-NEXT: callq 0x{{[0-9a-f]*}}
 # CHECK-NEXT: callq 0x{{[0-9a-f]*}}
 # CHECK-NEXT: callq 0x{{[0-9a-f]*}}
 
 # CHECK-LABEL: Rebase table:
 # CHECK:       __DATA        __la_symbol_ptr 0x[[#%x,WEAK_EXT_FN:]]  pointer
 
 # CHECK-LABEL: Bind table:

lld/test/MachO/x86-64-reloc-signed.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
 # RUN: echo _t > %t.order
 # RUN: %lld -o %t -order_file %t.order %t.o
 # RUN: llvm-objdump --section-headers --syms -D %t | FileCheck %s
 
 # CHECK-LABEL: Sections:
 # CHECK:       __foo         {{[0-9a-f]+}}  [[#%x,FOO:]]  DATA
 
 # CHECK-LABEL: SYMBOL TABLE:
 # CHECK:       [[#%x,S:]]  g     O __DATA,__data _s
 
 # CHECK-LABEL: Disassembly of section
 # CHECK:      <_main>:
-# CHECK-NEXT:   movl {{.*}}  # [[#S]]
+# CHECK-NEXT:   movl {{.*}}  # 0x[[#S]]
 # CHECK-NEXT:   callq {{.*}}
-# CHECK-NEXT:   movl {{.*}}  # [[#S + 2]]
+# CHECK-NEXT:   movl {{.*}}  # 0x[[#S + 2]]
 # CHECK-NEXT:   callq {{.*}}
-# CHECK-NEXT:   movb {{.*}}  # [[#S]]
+# CHECK-NEXT:   movb {{.*}}  # 0x[[#S]]
 # CHECK-NEXT:   callq {{.*}}
 # CHECK:      <__not_text>:
-# CHECK-NEXT:   movl {{.*}}  # [[#FOO + 8]]
+# CHECK-NEXT:   movl {{.*}}  # 0x[[#FOO + 8]]
 # CHECK-NEXT:   callq {{.*}}
-# CHECK-NEXT:   movl {{.*}}  # [[#FOO + 8 + 2]]
+# CHECK-NEXT:   movl {{.*}}  # 0x[[#FOO + 8 + 2]]
 # CHECK-NEXT:   callq {{.*}}
-# CHECK-NEXT:   movb {{.*}}  # [[#FOO + 8]]
+# CHECK-NEXT:   movb {{.*}}  # 0x[[#FOO + 8]]
 # CHECK-NEXT:   callq {{.*}}
 
 .section __TEXT,__text
 .globl _main
 _main:
   ## Symbol relocations
   movl $0x434241, _s(%rip)  # X86_64_RELOC_SIGNED_4
   callq _f

llvm/test/MC/X86/tlsdesc-64.s

 # RUN: llvm-mc -triple x86_64-pc-linux-musl %s | FileCheck --check-prefix=PRINT %s
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-musl %s -o %t
 # RUN: llvm-readelf -s %t | FileCheck --check-prefix=SYM %s
 # RUN: llvm-objdump -d -r --no-show-raw-insn %t | FileCheck --match-full-lines %s
 
 # PRINT:      leaq a@tlsdesc(%rip), %rax
 # PRINT-NEXT: callq *a@tlscall(%rax)
 
 # SYM: TLS GLOBAL DEFAULT UND a
 
-# CHECK:      0: leaq (%rip), %rax  # 7 <{{.*}}>
+# CHECK:      0: leaq (%rip), %rax  # 0x7 <{{.*}}>
 # CHECK-NEXT:   0000000000000003: R_X86_64_GOTPC32_TLSDESC a-0x4
 # CHECK-NEXT: 7: callq *(%rax)
 # CHECK-NEXT:   0000000000000007: R_X86_64_TLSDESC_CALL a
 
 leaq a@tlsdesc(%rip), %rax
 call *a@tlscall(%rax)
 addq %fs:0, %rax

llvm/test/MC/X86/tlsdesc-x32.s

 # RUN: llvm-mc -triple x86_64-pc-linux-gnux32 %s | FileCheck --check-prefix=PRINT %s
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnux32 %s -o %t
 # RUN: llvm-readelf -s %t | FileCheck --check-prefix=SYM %s
 # RUN: llvm-objdump -d -r %t | FileCheck --match-full-lines %s
 
 # PRINT:      leal a@tlsdesc(%rip), %eax
 # PRINT-NEXT: callq *a@tlscall(%eax)
 
 # SYM: TLS GLOBAL DEFAULT UND a
 
-# CHECK:      0: 40 8d 05 00 00 00 00  leal (%rip), %eax  # 7 <{{.*}}>
+# CHECK:      0: 40 8d 05 00 00 00 00  leal (%rip), %eax  # 0x7 <{{.*}}>
 # CHECK-NEXT:   00000003: R_X86_64_GOTPC32_TLSDESC a-0x4
 # CHECK-NEXT: 7: 67 ff 10              callq *(%eax)
 # CHECK-NEXT:   00000007: R_X86_64_TLSDESC_CALL a
 # CHECK-NEXT: a: 8d 05 34 12 00 00     leal 4660(%rip), %eax # {{.*}}
 
 lea a@tlsdesc(%rip), %eax
 call *a@tlscall(%eax)
 lea 0x1234(%rip), %eax

llvm/test/tools/llvm-objdump/X86/disassemble-align.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t
 
 # Use '|' to show where the tabs line up.
 # RUN: llvm-objdump -d --print-imm-hex %t | tr '\t' '|' | \
 # RUN:   FileCheck --match-full-lines --strict-whitespace %s
 
 # RUN: llvm-objdump -d --print-imm-hex --no-show-raw-insn %t | tr '\t' '|' | \
 # RUN:   FileCheck -check-prefix=NORAW --match-full-lines -strict-whitespace %s
 
 # Instructions are expected to be aligned if the instruction in hex is not too long.
 
 #      CHECK:       0: c3                           |retq
-# CHECK-NEXT:       1: 48 8b 05 56 34 12 00         |movq|0x123456(%rip), %rax  # 12345e <.text+0x12345e>
+# CHECK-NEXT:       1: 48 8b 05 56 34 12 00         |movq|0x123456(%rip), %rax  # 0x12345e <.text+0x12345e>
 # CHECK-NEXT:       8: 48 b8 54 55 55 55 55 55 55 55|movabsq|$0x5555555555555554, %rax # imm = 0x5555555555555554
 # CHECK-NEXT:      12: 8f ea 00 12 4c 02 40 00 00 00 00     |lwpval|$0x0, 0x40(%rdx,%rax), %r15d
 # CHECK-NEXT:      1d: 8f ea 00 12 04 25 f0 1c f0 1c 00 00 00 00    |lwpins|$0x0, 0x1cf01cf0, %r15d
 # CHECK-NEXT:      2b: ff ff                        |<unknown>
 
 #      NORAW:       0:      |retq
-# NORAW-NEXT:       1:      |movq|0x123456(%rip), %rax  # 12345e <.text+0x12345e>
+# NORAW-NEXT:       1:      |movq|0x123456(%rip), %rax  # 0x12345e <.text+0x12345e>
 # NORAW-NEXT:       8:      |movabsq|$0x5555555555555554, %rax # imm = 0x5555555555555554
 # NORAW-NEXT:      12:      |lwpval|$0x0, 0x40(%rdx,%rax), %r15d
 # NORAW-NEXT:      1d:      |lwpins|$0x0, 0x1cf01cf0, %r15d
 # NORAW-NEXT:      2b:      |<unknown>
 
 .text
   retq
   movq 0x123456(%rip),%rax
   movabs $0x5555555555555554,%rax
   lwpval $0x0, 0x40(%rdx,%rax), %r15d
   lwpins $0x0, 0x1cf01cf0, %r15d
   .word 0xffff

llvm/test/tools/llvm-objdump/X86/disassemble-gdtls.s

 # RUN: llvm-mc %s -filetype=obj -triple=x86_64 | llvm-objdump -d - | FileCheck %s
 
 # CHECK:      <PR48901>:
 # TODO: Should display data16 prefixes.
-# CHECK-NEXT: 0: 66 48 8d 3d 00 00 00 00       leaq    (%rip), %rdi  # 8 <PR48901+0x8>
+# CHECK-NEXT: 0: 66 48 8d 3d 00 00 00 00       leaq    (%rip), %rdi  # 0x8 <PR48901+0x8>
 # CHECK-NEXT: 8: 66 66 48 e8 00 00 00 00       callq   0x10 <PR48901+0x10>
 # CHECK-EMPTY:
 
 PR48901:
  data16
  leaq   bar@TLSGD(%rip),%rdi
  data16
  data16
  rex64
  callq  __tls_get_addr@PLT
 
 .section .tdata,"awT",@progbits
 bar:
 .long 42

llvm/test/tools/llvm-objdump/X86/elf-disassemble-symbol-references.yaml

 ## Show that references in disassembly are labelled with the correct symbol.
 # RUN: yaml2obj %s --docnum=1 -o %t
 # RUN: llvm-objdump %t -d | FileCheck %s --check-prefix=EXEC
 
 # EXEC-LABEL: <first>:
 # EXEC-NEXT:   4000: e8 00 00 00 00                callq   0x4005 <third>
 # EXEC-LABEL: <third>:
 # EXEC-NEXT:   4005: e8 12 34 56 78                callq   0x7856741c <data1+0x7856241c>
 # EXEC-LABEL: <fourth>:
-# EXEC-NEXT:   400a: 8b 05 f0 0f 00 00             movl    4080(%rip), %eax  # 5000 <data1>
+# EXEC-NEXT:   400a: 8b 05 f0 0f 00 00             movl    4080(%rip), %eax  # 0x5000 <data1>
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:

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

for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
             if (!PrintTarget)
               if (Optional<uint64_t> MaybeTarget =
                       MIA->evaluateMemoryOperandAddress(
                           Inst, SectionAddr + Index, Size)) {
                 Target = *MaybeTarget;
                 PrintTarget = true;
                 // Do not print real address when symbolizing.
                 if (!SymbolizeOperands)
-                  FOS << "  # " << Twine::utohexstr(Target);
+                  FOS << "  # 0x" << Twine::utohexstr(Target);
               }
             if (PrintTarget) {
               // In a relocatable object, the target's section must reside in
               // the same section as the call instruction or it is accessed
               // through a relocation.
               //
               // In a non-relocatable object, the target may be in any section.
               // In that case, locate the section(s) containing the target