[AArch64InstPrinter] Change printAlignedLabel to print the target address in hexadecimal form

[MaskRay]

Summary

Similar to D76580 (x86) and D76591 (PPC).

// llvm-objdump -d output (before)
10000: 08 00 00 94                   bl      #32
10004: 08 00 00 94                   bl      #32

// llvm-objdump -d output (after)
10000: 08 00 00 94                   bl      0x10020
10004: 08 00 00 94                   bl      0x10024

// GNU objdump -d. The lack of 0x is not ideal due to ambiguity.
10000:       94000008        bl      10020 <bar+0x18>
10004:       94000008        bl      10024 <bar+0x1c>

The new output akes it easier to find the jump target.

[MaskRay]

Fix all tests

lld/test/COFF/arm64-delayimport.yaml

 # REQUIRES: aarch64
 
 # RUN: yaml2obj < %s > %t.obj
 # RUN: lld-link /entry:main /subsystem:console /out:%t.exe %t.obj %p/Inputs/library-arm64.lib /alternatename:__delayLoadHelper2=main /delayload:library.dll
 # RUN: llvm-objdump -d %t.exe | FileCheck %s --check-prefix DISASM
 # RUN: llvm-readobj --coff-imports %t.exe | FileCheck %s -check-prefix IMPORTS
 
 # DISASM:  140001014:      11 00 00 d0     adrp    x17, #8192
 # DISASM:  140001018:      31 22 00 91     add     x17, x17, #8
-# DISASM:  14000101c:      01 00 00 14     b       #4 <.text+0x20>
+# DISASM:  14000101c:      01 00 00 14     b       0x140001020 <.text+0x20>
 # DISASM:  140001020:      fd 7b b3 a9     stp     x29, x30, [sp, #-208]!
 # DISASM:  140001024:      fd 03 00 91     mov     x29, sp
 # DISASM:  140001028:      e0 07 01 a9     stp     x0, x1, [sp, #16]
 # DISASM:  14000102c:      e2 0f 02 a9     stp     x2, x3, [sp, #32]
 # DISASM:  140001030:      e4 17 03 a9     stp     x4, x5, [sp, #48]
 # DISASM:  140001034:      e6 1f 04 a9     stp     x6, x7, [sp, #64]
 # DISASM:  140001038:      e0 87 02 ad     stp     q0, q1, [sp, #80]
 # DISASM:  14000103c:      e2 8f 03 ad     stp     q2, q3, [sp, #112]
 # DISASM:  140001040:      e4 97 04 ad     stp     q4, q5, [sp, #144]
 # DISASM:  140001044:      e6 9f 05 ad     stp     q6, q7, [sp, #176]
 # DISASM:  140001048:      e1 03 11 aa     mov     x1, x17
 # DISASM:  14000104c:      00 00 00 b0     adrp    x0, #4096
 # DISASM:  140001050:      00 00 00 91     add     x0, x0, #0
-# DISASM:  140001054:      eb ff ff 97     bl      #-84 <.text>
+# DISASM:  140001054:      eb ff ff 97     bl      0x140001000 <.text>
 # DISASM:  140001058:      f0 03 00 aa     mov     x16, x0
 # DISASM:  14000105c:      e6 9f 45 ad     ldp     q6, q7, [sp, #176]
 # DISASM:  140001060:      e4 97 44 ad     ldp     q4, q5, [sp, #144]
 # DISASM:  140001064:      e2 8f 43 ad     ldp     q2, q3, [sp, #112]
 # DISASM:  140001068:      e0 87 42 ad     ldp     q0, q1, [sp, #80]
 # DISASM:  14000106c:      e6 1f 44 a9     ldp     x6, x7, [sp, #64]
 # DISASM:  140001070:      e4 17 43 a9     ldp     x4, x5, [sp, #48]
 # DISASM:  140001074:      e2 0f 42 a9     ldp     x2, x3, [sp, #32]

lld/test/COFF/arm64-import2.test

 # REQUIRES: aarch64
 
 # RUN: yaml2obj < %s > %t.obj
 # RUN: llvm-objdump -d %t.obj | FileCheck %s --check-prefix BEFORE
 # RUN: lld-link /entry:main /subsystem:console /out:%t.exe %t.obj %p/Inputs/library-arm64.lib %p/Inputs/library2-arm64.lib
 # RUN: llvm-objdump -d %t.exe | FileCheck %s --check-prefix AFTER
 # RUN: llvm-readobj --coff-imports %t.exe | FileCheck %s -check-prefix IMPORTS
 
 # BEFORE: Disassembly of section .text:
 # BEFORE-EMPTY:
-# BEFORE:        0:       00 00 00 94     bl      #0
-# BEFORE:        4:       00 00 00 94     bl      #0
+# BEFORE:        0:       00 00 00 94     bl      0x0
+# BEFORE:        4:       00 00 00 94     bl      0x4
 # BEFORE:        8:       c0 03 5f d6     ret
 
 # AFTER: Disassembly of section .text:
 # AFTER-EMPTY:
-# AFTER:  140001000:      03 00 00 94     bl      #12
-# AFTER:  140001004:      05 00 00 94     bl      #20
+# AFTER:  140001000:      03 00 00 94     bl      0x14000100c
+# AFTER:  140001004:      05 00 00 94     bl      0x140001018
 # AFTER:  140001008:      c0 03 5f d6     ret
 # AFTER:  14000100c:      10 00 00 b0     adrp    x16, #4096
 # AFTER:  140001010:      10 32 40 f9     ldr     x16, [x16, #96]
 # AFTER:  140001014:      00 02 1f d6     br      x16
 # AFTER:  140001018:      10 00 00 b0     adrp    x16, #4096
 # AFTER:  14000101c:      10 3a 40 f9     ldr     x16, [x16, #112]
 # AFTER:  140001020:      00 02 1f d6     br      x16
 

lld/test/COFF/arm64-relocs-imports.test

 # REQUIRES: aarch64
 
 # RUN: yaml2obj < %s > %t.obj
 # RUN: llvm-objdump -d %t.obj | FileCheck %s --check-prefix BEFORE
 # RUN: lld-link /entry:main /subsystem:console /out:%t.exe %t.obj %p/Inputs/library-arm64.lib
 # RUN: llvm-objdump -d %t.exe | FileCheck %s --check-prefix AFTER
 
 # BEFORE: Disassembly of section .text:
 # BEFORE-EMPTY:
 # BEFORE:        0:       fe 0f 1f f8     str     x30, [sp, #-16]!
 # BEFORE:        4:       00 00 00 90     adrp    x0, #0
 # BEFORE:        8:       00 08 00 91     add     x0, x0, #2
-# BEFORE:        c:       00 00 00 94     bl      #0
+# BEFORE:        c:       00 00 00 94     bl      0xc
 # BEFORE:       10:       00 01 40 39     ldrb    w0, [x8]
 # BEFORE:       14:       00 01 40 79     ldrh    w0, [x8]
 # BEFORE:       18:       00 01 40 b9     ldr     w0, [x8]
 # BEFORE:       1c:       00 01 40 f9     ldr     x0, [x8]
 # BEFORE:       20:       00 01 00 39     strb    w0, [x8]
 # BEFORE:       24:       00 01 00 79     strh    w0, [x8]
 # BEFORE:       28:       00 01 00 b9     str     w0, [x8]
 # BEFORE:       2c:       00 01 00 f9     str     x0, [x8]

 # BEFORE:       74:       00 00 00 00     udf #0
 # BEFORE:       78:       01 00 00 00     udf #1
 # BEFORE:       7c:       01 00 00 00     udf #1
 # BEFORE:       80:       00 00 00 91     add     x0, x0, #0
 # BEFORE:       84:       00 00 40 91     add     x0, x0, #0, lsl #12
 # BEFORE:       88:       00 00 40 f9     ldr     x0, [x0]
 # BEFORE:       8c:       01 00 00 00     udf #1
 # BEFORE:       90:       20 1a 09 30     adr x0, #74565
-# BEFORE:       94:       01 00 00 54     b.ne    #0
-# BEFORE:       98:       00 00 00 36     tbz     w0, #0, #0
+# BEFORE:       94:       01 00 00 54     b.ne    0x94
+# BEFORE:       98:       00 00 00 36     tbz     w0, #0, 0x98
 # BEFORE:       9c:       01 00 00 00     udf #1
 
 # AFTER: Disassembly of section .text:
 # AFTER-EMPTY:
 # AFTER:  140001000:      fe 0f 1f f8     str     x30, [sp, #-16]!
 # AFTER:  140001004:      00 00 00 b0     adrp    x0, #4096
 # AFTER:  140001008:      00 18 00 91     add     x0, x0, #6
-# AFTER:  14000100c:      25 00 00 94     bl      #148
+# AFTER:  14000100c:      25 00 00 94     bl      0x1400010a0
 # AFTER:  140001010:      00 21 40 39     ldrb    w0, [x8, #8]
 # AFTER:  140001014:      00 11 40 79     ldrh    w0, [x8, #8]
 # AFTER:  140001018:      00 09 40 b9     ldr     w0, [x8, #8]
 # AFTER:  14000101c:      00 05 40 f9     ldr     x0, [x8, #8]
 # AFTER:  140001020:      00 21 00 39     strb    w0, [x8, #8]
 # AFTER:  140001024:      00 11 00 79     strh    w0, [x8, #8]
 # AFTER:  140001028:      00 09 00 b9     str     w0, [x8, #8]
 # AFTER:  14000102c:      00 05 00 f9     str     x0, [x8, #8]

 # AFTER:  140001074:      01 00 00 00     udf #1
 # AFTER:  140001078:      09 20 00 00     udf #8201
 # AFTER:  14000107c:      09 00 00 00     udf #9
 # AFTER:  140001080:      00 20 0e 91     add     x0, x0, #904
 # AFTER:  140001084:      00 04 40 91     add     x0, x0, #1, lsl #12
 # AFTER:  140001088:      00 c4 41 f9     ldr     x0, [x0, #904]
 # AFTER:  14000108c:      03 00 00 00     udf #3
 # AFTER:  140001090:      e0 95 09 30     adr     x0, #78525
-# AFTER:  140001094:      61 00 00 54     b.ne    #12
-# AFTER:  140001098:      40 00 00 36     tbz     w0, #0, #8
+# AFTER:  140001094:      61 00 00 54     b.ne    0x1400010a0
+# AFTER:  140001098:      40 00 00 36     tbz     w0, #0, 0x1400010a0
 # AFTER:  14000109c:      61 ff ff ff     <unknown>
 # AFTER:  1400010a0:      10 00 00 b0     adrp    x16, #4096
 # AFTER:  1400010a4:      10 2a 40 f9     ldr     x16, [x16, #80]
 # AFTER:  1400010a8:      00 02 1f d6     br      x16
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_ARM64

lld/test/COFF/arm64-thunks.s

func1:
     .section .text$c, "xr"
     .space 0x8000
     .section .text$d, "xr"
     .align 2
 func2:
     ret
 
 // DISASM: 0000000140001000 <.text>:
-// DISASM: 140001000:      40 00 00 36     tbz     w0, #0, #8 <.text+0x8>
+// DISASM: 140001000:      40 00 00 36     tbz     w0, #0, 0x140001008 <.text+0x8>
 // DISASM: 140001004:      c0 03 5f d6     ret
 // DISASM: 140001008:      50 00 00 90     adrp    x16, #32768
 // DISASM: 14000100c:      10 52 00 91     add     x16, x16, #20
 // DISASM: 140001010:      00 02 1f d6     br      x16
 
-// DISASM: 140009014:      60 00 00 36     tbz     w0, #0, #12 <.text+0x8020>
+// DISASM: 140009014:      60 00 00 36     tbz     w0, #0, 0x140009020 <.text+0x8020>
 // DISASM: 140009018:      c0 03 5f d6     ret
 
 // DISASM: 140009020:      50 00 00 90     adrp    x16, #32768
 // DISASM: 140009024:      10 b2 00 91     add     x16, x16, #44
 // DISASM: 140009028:      00 02 1f d6     br      x16
 
 // DISASM: 14001102c:      c0 03 5f d6     ret

lld/test/ELF/aarch64-call26-thunk.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64 %S/Inputs/abs.s -o %tabs.o
 // RUN: llvm-mc -filetype=obj -triple=aarch64 %s -o %t.o
 // RUN: ld.lld %t.o %tabs.o -o %t
 // RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
 
 .text
 .globl _start
 _start:
     bl big
 
 // CHECK: Disassembly of section .text:
 // CHECK-EMPTY:
 // CHECK-NEXT: <_start>:
-// CHECK-NEXT:    210120:       bl      #4
+// CHECK-NEXT:    210120:       bl      0x210124
 // CHECK: <__AArch64AbsLongThunk_big>:
-// CHECK-NEXT:    210124:       ldr     x16, #8
+// CHECK-NEXT:    210124:       ldr     x16, 0x21012c
 // CHECK-NEXT:    210128:       br      x16
 // CHECK: <$d>:
 // CHECK-NEXT:    21012c:       00 00 00 00     .word   0x00000000
 // CHECK-NEXT:    210130:       10 00 00 00     .word   0x00000010
 

lld/test/ELF/aarch64-condb-reloc.s

 # CHECK:      <_bar>:
 # CHECK-NEXT:    210130: nop
 # CHECK-NEXT:    210134: nop
 # CHECK-NEXT:    210138: nop
 # CHECK:      <_dah>:
 # CHECK-NEXT:    21013c: nop
 # CHECK-NEXT:    210140: nop
 # CHECK:      <_start>:
-# CHECK-NEXT:    210144: b.eq #-36 <_foo>
-# CHECK-NEXT:    210148: b.eq #-24 <_bar>
-# CHECK-NEXT:    21014c: b.eq #-16 <_dah>
+# CHECK-NEXT:    210144: b.eq 0x210120 <_foo>
+# CHECK-NEXT:    210148: b.eq 0x210130 <_bar>
+# CHECK-NEXT:    21014c: b.eq 0x21013c <_dah>
 
 #DSOREL:      Section {
 #DSOREL:        Index:
 #DSOREL:        Name: .got.plt
 #DSOREL-NEXT:   Type: SHT_PROGBITS
 #DSOREL-NEXT:   Flags [
 #DSOREL-NEXT:     SHF_ALLOC
 #DSOREL-NEXT:     SHF_WRITE

 #DSO:      <_bar>:
 #DSO-NEXT:     10348: nop
 #DSO-NEXT:     1034c: nop
 #DSO-NEXT:     10350: nop
 #DSO:      <_dah>:
 #DSO-NEXT:     10354: nop
 #DSO-NEXT:     10358: nop
 #DSO:      <_start>:
-#DSO-NEXT:     1035c: b.eq #52 <_foo@plt>
-#DSO-NEXT:     10360: b.eq #64 <_bar@plt>
-#DSO-NEXT:     10364: b.eq #76 <_dah@plt>
+#DSO-NEXT:     1035c: b.eq 0x10390 <_foo@plt>
+#DSO-NEXT:     10360: b.eq 0x103a0 <_bar@plt>
+#DSO-NEXT:     10364: b.eq 0x103b0 <_dah@plt>
 #DSO-EMPTY:
 #DSO-NEXT: Disassembly of section .plt:
 #DSO-EMPTY:
 #DSO-NEXT: <.plt>:
 #DSO-NEXT:     10370: stp x16, x30, [sp, #-16]!
 #DSO-NEXT:     10374: adrp x16, #131072
 #DSO-NEXT:     10378: ldr x17, [x16, #1152]
 #DSO-NEXT:     1037c: add x16, x16, #1152

lld/test/ELF/aarch64-cortex-a53-843419-address.s

 // - We can handle redundant mapping symbols (two or more consecutive mapping
 //   symbols with the same type).
 // - We can ignore erratum sequences in multiple literal data ranges.
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at FF8 in unpatched output.
 // CHECK: <t3_ff8_ldr>:
 // CHECK-NEXT:      ff8:        20 00 00 d0     adrp    x0, #24576
 // CHECK-NEXT:      ffc:        21 00 40 f9     ldr             x1, [x1]
-// CHECK-NEXT:     1000:        f9 0f 00 14     b       #16356
+// CHECK-NEXT:     1000:        f9 0f 00 14     b       0x4fe4
 // CHECK-NEXT:     1004:        c0 03 5f d6     ret
         .section .text.01, "ax", %progbits
         .balign 4096
         .space 4096 - 8
         .globl t3_ff8_ldr
         .type t3_ff8_ldr, %function
 t3_ff8_ldr:
         adrp x0, dat
         ldr x1, [x1, #0]
         ldr x0, [x0, :got_lo12:dat]
         ret
 
         // create a redundant mapping symbol as we are already in a $x range
         // some object producers unconditionally generate a mapping symbol on
         // every symbol so we need to handle the case of $x $x.
         .local $x.999
 $x.999:
 // CHECK-PRINT-NEXT: detected cortex-a53-843419 erratum sequence starting at 1FFC in unpatched output.
 // CHECK: <t3_ffc_ldrsimd>:
 // CHECK-NEXT:     1ffc:        20 00 00 b0     adrp    x0, #20480
 // CHECK-NEXT:     2000:        21 00 40 bd     ldr             s1, [x1]
-// CHECK-NEXT:     2004:        fa 0b 00 14     b       #12264
+// CHECK-NEXT:     2004:        fa 0b 00 14     b       0x4fec
 // CHECK-NEXT:     2008:        c0 03 5f d6     ret
         .globl t3_ffc_ldrsimd
         .type t3_ffc_ldrsimd, %function
         .space 4096 - 12
 t3_ffc_ldrsimd:
         adrp x0, dat
         ldr s1, [x1, #0]
         ldr x2, [x0, :got_lo12:dat]
t3_ff8_ldralldata:
         .byte 0x40
         .byte 0xf9
         // Check that we can recognise the erratum sequence post literal data.
 
 // CHECK-PRINT-NEXT: detected cortex-a53-843419 erratum sequence starting at 3FF8 in unpatched output.
 // CHECK: <t3_ffc_ldr>:
 // CHECK-NEXT:     3ff8:        00 00 00 f0     adrp    x0, #12288
 // CHECK-NEXT:     3ffc:        21 00 40 f9     ldr             x1, [x1]
-// CHECK-NEXT:     4000:        fd 03 00 14     b       #4084
+// CHECK-NEXT:     4000:        fd 03 00 14     b       0x4ff4
 // CHECK-NEXT:     4004:        c0 03 5f d6     ret
         .space 4096 - 12
         .globl t3_ffc_ldr
         .type t3_ffc_ldr, %function
  t3_ffc_ldr:
         adrp x0, dat
         ldr x1, [x1, #0]
         ldr x0, [x0, :got_lo12:dat]
         ret
 
 // CHECK: <__CortexA53843419_1000>:
 // CHECK-NEXT:     4fe4:        00 0c 40 f9     ldr     x0, [x0, #24]
-// CHECK-NEXT:     4fe8:        07 f0 ff 17     b       #-16356
+// CHECK-NEXT:     4fe8:        07 f0 ff 17     b       0x1004
 // CHECK: <__CortexA53843419_2004>:
 // CHECK-NEXT:     4fec:        02 0c 40 f9     ldr     x2, [x0, #24]
-// CHECK-NEXT:     4ff0:        06 f4 ff 17     b       #-12264
+// CHECK-NEXT:     4ff0:        06 f4 ff 17     b       0x2008
 // CHECK: <__CortexA53843419_4000>:
 // CHECK-NEXT:     4ff4:        00 0c 40 f9     ldr     x0, [x0, #24]
-// CHECK-NEXT:     4ff8:        03 fc ff 17     b       #-4084
+// CHECK-NEXT:     4ff8:        03 fc ff 17     b       0x4004
 
         .section .text.02, "ax", %progbits
         .space 4096 - 36
 
         // Start a new InputSectionDescription (see Linker Script) so the
         // start address will be affected by any patches added to previous
         // InputSectionDescription.
 
 // CHECK-PRINT-NEXT: detected cortex-a53-843419 erratum sequence starting at 4FFC in unpatched output
 // CHECK: <t3_ffc_str>:
 // CHECK-NEXT:     4ffc:        00 00 00 d0     adrp    x0, #8192
 // CHECK-NEXT:     5000:        21 00 00 f9     str             x1, [x1]
-// CHECK-NEXT:     5004:        fb 03 00 14     b       #4076
+// CHECK-NEXT:     5004:        fb 03 00 14     b       0x5ff0
 // CHECK-NEXT:     5008:        c0 03 5f d6     ret
 
         .section .newisd, "ax", %progbits
         .globl t3_ffc_str
         .type t3_ffc_str, %function
 t3_ffc_str:
         adrp x0, dat
         str x1, [x1, #0]
         ldr x0, [x0, :got_lo12:dat]
         ret
         .space 4096 - 28
 
 // CHECK: <__CortexA53843419_5004>:
 // CHECK-NEXT:     5ff0:        00 0c 40 f9     ldr     x0, [x0, #24]
-// CHECK-NEXT:     5ff4:        05 fc ff 17     b       #-4076
+// CHECK-NEXT:     5ff4:        05 fc ff 17     b       0x5008
 
         // Start a new OutputSection (see Linker Script) so the
         // start address will be affected by any patches added to previous
         // InputSectionDescription.
 
 //CHECK-PRINT-NEXT: detected cortex-a53-843419 erratum sequence starting at 5FF8 in unpatched output
 // CHECK: <t3_ff8_str>:
 // CHECK-NEXT:     5ff8:        00 00 00 b0     adrp    x0, #4096
 // CHECK-NEXT:     5ffc:        21 00 00 f9     str             x1, [x1]
-// CHECK-NEXT:     6000:        03 00 00 14     b       #12
+// CHECK-NEXT:     6000:        03 00 00 14     b       0x600c
 // CHECK-NEXT:     6004:        c0 03 5f d6     ret
 
         .section .newos, "ax", %progbits
         .globl t3_ff8_str
         .type t3_ff8_str, %function
 t3_ff8_str:
         adrp x0, dat
         str x1, [x1, #0]
         ldr x0, [x0, :got_lo12:dat]
         ret
         .globl _start
         .type _start, %function
 _start:
         ret
 
 // CHECK: <__CortexA53843419_6000>:
 // CHECK-NEXT:     600c:        00 0c 40 f9     ldr     x0, [x0, #24]
-// CHECK-NEXT:     6010:        fd ff ff 17     b       #-12
+// CHECK-NEXT:     6010:        fd ff ff 17     b       0x6004
 
         .data
         .globl dat
 dat:    .word 0

lld/test/ELF/aarch64-cortex-a53-843419-large.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux %s -o %t.o
 // RUN: ld.lld --fix-cortex-a53-843419 -z separate-code %t.o -o %t2
 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 --start-address=2162688   --stop-address=2162700   | FileCheck --check-prefix=CHECK1 %s
 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 --start-address=2166784   --stop-address=2166788   | FileCheck --check-prefix=CHECK2 %s
 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 --start-address=2170872   --stop-address=2170888   | FileCheck --check-prefix=CHECK3 %s
 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 --start-address=69287928  --stop-address=69287944  | FileCheck --check-prefix=CHECK4 %s
 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 --start-address=102842376 --stop-address=102842392 | FileCheck --check-prefix=CHECK5 %s
 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 --start-address=136384524 --stop-address=136384528 | FileCheck --check-prefix=CHECK6 %s
 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 --start-address=136388604 --stop-address=136388628 | FileCheck --check-prefix=CHECK7 %s
 // Test case for Cortex-A53 Erratum 843419 in an OutputSection exceeding
 // the maximum branch range. Both range extension thunks and patches are
 // required.                
                   
 // CHECK1:  <__AArch64AbsLongThunk_need_thunk_after_patch>:
-// CHECK1-NEXT:    210000:       50 00 00 58     ldr     x16, #8
+// CHECK1-NEXT:    210000:       50 00 00 58     ldr     x16, 0x210008
 // CHECK1-NEXT:    210004:       00 02 1f d6     br      x16
 // CHECK1: <$d>:
 // CHECK1-NEXT:    210008:       0c 10 21 08     .word   0x0821100c
 
         .section .text.01, "ax", %progbits
         .balign 4096
         .globl _start
         .type _start, %function
 _start:
         // Expect thunk on pass 2
         bl need_thunk_after_patch
         .section .text.02, "ax", %progbits
         .space 4096 - 12
 
 // CHECK2: <_start>:
-// CHECK2-NEXT:    211000:       00 fc ff 97     bl      #-4096
+// CHECK2-NEXT:    211000:       00 fc ff 97     bl      0x210000
 
         // Expect patch on pass 1
         .section .text.03, "ax", %progbits
         .globl t3_ff8_ldr
         .type t3_ff8_ldr, %function
 t3_ff8_ldr:
         adrp x0, dat
         ldr x1, [x1, #0]
         ldr x0, [x0, :got_lo12:dat]
         ret
 
 // CHECK3: <t3_ff8_ldr>:
 // CHECK3-NEXT:    211ff8:       e0 00 04 f0     adrp    x0, #134344704
 // CHECK3-NEXT:    211ffc:       21 00 40 f9     ldr     x1, [x1]
-// CHECK3-NEXT:    212000:       02 08 80 15     b       #100671496
+// CHECK3-NEXT:    212000:       02 08 80 15     b       0x6214008
 // CHECK3-NEXT:    212004:       c0 03 5f d6     ret
 
         .section .text.04, "ax", %progbits
         .space 64 * 1024 * 1024
 
         // Expect patch on pass 1
         .section .text.05, "ax", %progbits
         .balign 4096
         .space 4096 - 8
         .globl t3_ff8_str
         .type t3_ff8_str, %function
 t3_ff8_str:
         adrp x0, dat
         ldr x1, [x1, #0]
         str x0, [x0, :got_lo12:dat]
         ret
 
 // CHECK4: <t3_ff8_str>:
 // CHECK4-NEXT:  4213ff8:       e0 00 02 b0     adrp    x0, #67227648
 // CHECK4-NEXT:  4213ffc:       21 00 40 f9     ldr     x1, [x1]
-// CHECK4-NEXT:  4214000:       04 00 80 14     b       #33554448
+// CHECK4-NEXT:  4214000:       04 00 80 14     b       0x6214010
 // CHECK4-NEXT:  4214004:       c0 03 5f d6     ret
 
         .section .text.06, "ax", %progbits
         .space 32 * 1024 * 1024
 
 // CHECK5: <__CortexA53843419_211000>:
 // CHECK5-NEXT:  6214008:       00 00 40 f9     ldr     x0, [x0]
-// CHECK5-NEXT:  621400c:       fe f7 7f 16     b       #-100671496
+// CHECK5-NEXT:  621400c:       fe f7 7f 16     b       0x212004
 // CHECK5: <__CortexA53843419_4213000>:
 // CHECK5-NEXT:  6214010:       00 00 00 f9     str     x0, [x0]
-// CHECK5-NEXT:  6214014:       fc ff 7f 17     b       #-33554448
+// CHECK5-NEXT:  6214014:       fc ff 7f 17     b       0x4214004
 
         .section .text.07, "ax", %progbits
         .space (32 * 1024 * 1024) - 12300
 
         .section .text.08, "ax", %progbits
         .globl need_thunk_after_patch
         .type need_thunk_after_patch, %function
 need_thunk_after_patch:
t3_ffc_ldr:
         adrp x0, dat
         ldr x1, [x1, #0]
         ldr x0, [x0, :got_lo12:dat]
         ret
 
 // CHECK7: <t3_ffc_ldr>:
 // CHECK7-NEXT:  8211ffc:       e0 00 00 f0     adrp    x0, #126976
 // CHECK7-NEXT:  8212000:       21 00 40 f9     ldr     x1, [x1]
-// CHECK7-NEXT:  8212004:       02 00 00 14     b       #8
+// CHECK7-NEXT:  8212004:       02 00 00 14     b       0x821200c
 // CHECK7-NEXT:  8212008:       c0 03 5f d6     ret
 // CHECK7: <__CortexA53843419_8212004>:
 // CHECK7-NEXT:  821200c:       00 00 40 f9     ldr     x0, [x0]
-// CHECK7-NEXT:  8212010:       fe ff ff 17     b       #-8
+// CHECK7-NEXT:  8212010:       fe ff ff 17     b       0x8212008
 
         .section .data
         .globl dat
 dat:    .quad 0

lld/test/ELF/aarch64-cortex-a53-843419-large2.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux %s -o %t.o
 // RUN: ld.lld --fix-cortex-a53-843419 -Ttext=0x8000000 %t.o -o %t2
 // RUN: llvm-objdump -d --start-address=0x8001000 --stop-address=0x8001004 %t2 | FileCheck %s
 
 .section .text.01, "ax", %progbits
 .balign 4096
 .space 4096 - 8
 adrp x0, thunk
 ldr x1, [x1, #0]
 // CHECK: <thunk>:
-// CHECK-NEXT: b #67108872 <__CortexA53843419_8001000>
+// CHECK-NEXT: b 0xc001008 <__CortexA53843419_8001000>
 thunk:
 ldr x0, [x0, :got_lo12:thunk]
 ret
 .space 64 * 1024 * 1024
 
 .section .text.02, "ax", %progbits
 .space 64 * 1024 * 1024

lld/test/ELF/aarch64-cortex-a53-843419-recognize.s

 // - Variations in instruction class for instruction 2.
 // - Optional instruction 3 present or not.
 // - Load or store for instruction 4.
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 211FF8 in unpatched output.
 // CHECK: <t3_ff8_ldr>:
 // CHECK-NEXT:    211ff8:        60 02 00 f0     adrp    x0, #323584
 // CHECK-NEXT:    211ffc:        21 00 40 f9     ldr             x1, [x1]
-// CHECK-FIX:     212000:        03 c8 00 14     b       #204812
+// CHECK-FIX:     212000:        03 c8 00 14     b       0x24400c
 // CHECK-NOFIX:   212000:        00 00 40 f9     ldr             x0, [x0]
 // CHECK-NEXT:    212004:        c0 03 5f d6     ret
 // CHECK-RELOCATABLE: <t3_ff8_ldr>:
 // CHECK-RELOCATABLE-NEXT:    ff8:        00 00 00 90     adrp    x0, #0
 // CHECK-RELOCATABLE-NEXT:    ffc:        21 00 40 f9     ldr             x1, [x1]
 // CHECK-RELOCATABLE-NEXT:   1000:        00 00 40 f9     ldr             x0, [x0]
 // CHECK-RELOCATABLE-NEXT:   1004:        c0 03 5f d6     ret
 
         .section .text.01, "ax", %progbits
         .balign 4096
         .globl t3_ff8_ldr
         .type t3_ff8_ldr, %function
         .space 4096 - 8
 t3_ff8_ldr:
         adrp x0, dat1
         ldr x1, [x1, #0]
         ldr x0, [x0, :got_lo12:dat1]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 213FF8 in unpatched output.
 // CHECK: <t3_ff8_ldrsimd>:
 // CHECK-NEXT:    213ff8:        60 02 00 b0     adrp    x0, #315392
 // CHECK-NEXT:    213ffc:        21 00 40 bd     ldr             s1, [x1]
-// CHECK-FIX:     214000:        05 c0 00 14     b       #196628
+// CHECK-FIX:     214000:        05 c0 00 14     b       0x244014
 // CHECK-NOFIX:   214000:        02 04 40 f9     ldr     x2, [x0, #8]
 // CHECK-NEXT:    214004:        c0 03 5f d6     ret
         .section .text.02, "ax", %progbits
         .balign 4096
         .globl t3_ff8_ldrsimd
         .type t3_ff8_ldrsimd, %function
         .space 4096 - 8
 t3_ff8_ldrsimd:
         adrp x0, dat2
         ldr s1, [x1, #0]
         ldr x2, [x0, :got_lo12:dat2]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 215FFC in unpatched output.
 // CHECK: <t3_ffc_ldrpost>:
 // CHECK-NEXT:    215ffc:        40 02 00 f0     adrp    x0, #307200
 // CHECK-NEXT:    216000:        21 84 40 bc     ldr     s1, [x1], #8
-// CHECK-FIX:     216004:        06 b8 00 14     b       #188440
+// CHECK-FIX:     216004:        06 b8 00 14     b       0x24401c
 // CHECK-NOFIX:   216004:        03 08 40 f9     ldr     x3, [x0, #16]
 // CHECK-NEXT:    216008:        c0 03 5f d6     ret
         .section .text.03, "ax", %progbits
         .balign 4096
         .globl t3_ffc_ldrpost
         .type t3_ffc_ldrpost, %function
         .space 4096 - 4
 t3_ffc_ldrpost:
         adrp x0, dat3
         ldr s1, [x1], #8
         ldr x3, [x0, :got_lo12:dat3]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 217FF8 in unpatched output.
 // CHECK: <t3_ff8_strpre>:
 // CHECK-NEXT:    217ff8:        40 02 00 b0     adrp    x0, #299008
 // CHECK-NEXT:    217ffc:        21 8c 00 bc     str     s1, [x1, #8]!
-// CHECK-FIX:     218000:        09 b0 00 14     b       #180260
+// CHECK-FIX:     218000:        09 b0 00 14     b       0x244024
 // CHECK-NOFIX:   218000:        02 0c 40 f9     ldr     x2, [x0, #24]
 // CHECK-NEXT:    218004:        c0 03 5f d6     ret
         .section .text.04, "ax", %progbits
         .balign 4096
         .globl t3_ff8_strpre
         .type t3_ff8_strpre, %function
         .space 4096 - 8
 t3_ff8_strpre:
         adrp x0, dat1
         str s1, [x1, #8]!
         ldr x2, [x0, :lo12:dat1]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 219FFC in unpatched output.
 // CHECK: <t3_ffc_str>:
 // CHECK-NEXT:    219ffc:        3c 02 00 f0     adrp    x28, #290816
 // CHECK-NEXT:    21a000:        42 00 00 f9     str             x2, [x2]
-// CHECK-FIX:     21a004:        0a a8 00 14     b       #172072
+// CHECK-FIX:     21a004:        0a a8 00 14     b       0x24402c
 // CHECK-NOFIX:   21a004:        9c 13 00 f9     str     x28, [x28, #32]
 // CHECK-NEXT:    21a008:        c0 03 5f d6     ret
         .section .text.05, "ax", %progbits
         .balign 4096
         .globl t3_ffc_str
         .type t3_ffc_str, %function
         .space 4096 - 4
 t3_ffc_str:
         adrp x28, dat2
         str x2, [x2, #0]
         str x28, [x28, :lo12:dat2]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 21BFFC in unpatched output.
 // CHECK: <t3_ffc_strsimd>:
 // CHECK-NEXT:    21bffc:        3c 02 00 b0     adrp    x28, #282624
 // CHECK-NEXT:    21c000:        44 00 00 b9     str             w4, [x2]
-// CHECK-FIX:     21c004:        0c a0 00 14     b       #163888
+// CHECK-FIX:     21c004:        0c a0 00 14     b       0x244034
 // CHECK-NOFIX:   21c004:        84 17 00 f9     str     x4, [x28, #40]
 // CHECK-NEXT:    21c008:        c0 03 5f d6     ret
         .section .text.06, "ax", %progbits
         .balign 4096
         .globl t3_ffc_strsimd
         .type t3_ffc_strsimd, %function
         .space 4096 - 4
 t3_ffc_strsimd:
         adrp x28, dat3
         str w4, [x2, #0]
         str x4, [x28, :lo12:dat3]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 21DFF8 in unpatched output.
 // CHECK: <t3_ff8_ldrunpriv>:
 // CHECK-NEXT:    21dff8:        1d 02 00 f0     adrp    x29, #274432
 // CHECK-NEXT:    21dffc:        41 08 40 38     ldtrb           w1, [x2]
-// CHECK-FIX:     21e000:        0f 98 00 14     b       #155708
+// CHECK-FIX:     21e000:        0f 98 00 14     b       0x24403c
 // CHECK-NOFIX:   21e000:        bd 03 40 f9     ldr             x29, [x29]
 // CHECK-NEXT:    21e004:        c0 03 5f d6     ret
         .section .text.07, "ax", %progbits
         .balign 4096
         .globl t3_ff8_ldrunpriv
         .type t3_ff8_ldrunpriv, %function
         .space 4096 - 8
 t3_ff8_ldrunpriv:
         adrp x29, dat1
         ldtrb w1, [x2, #0]
         ldr x29, [x29, :got_lo12:dat1]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 21FFFC in unpatched output.
 // CHECK: <t3_ffc_ldur>:
 // CHECK-NEXT:    21fffc:        1d 02 00 b0     adrp    x29, #266240
 // CHECK-NEXT:    220000:        42 40 40 b8     ldur    w2, [x2, #4]
-// CHECK-FIX:     220004:        10 90 00 14     b       #147520
+// CHECK-FIX:     220004:        10 90 00 14     b       0x244044
 // CHECK-NOFIX:   220004:        bd 07 40 f9     ldr     x29, [x29, #8]
 // CHECK-NEXT:    220008:        c0 03 5f d6     ret
         .balign 4096
         .globl t3_ffc_ldur
         .type t3_ffc_ldur, %function
         .space 4096 - 4
 t3_ffc_ldur:
         adrp x29, dat2
         ldur w2, [x2, #4]
         ldr x29, [x29, :got_lo12:dat2]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 221FFC in unpatched output.
 // CHECK: <t3_ffc_sturh>:
 // CHECK-NEXT:    221ffc:        f2 01 00 f0     adrp    x18, #258048
 // CHECK-NEXT:    222000:        43 40 00 78     sturh   w3, [x2, #4]
-// CHECK-FIX:     222004:        12 88 00 14     b       #139336
+// CHECK-FIX:     222004:        12 88 00 14     b       0x24404c
 // CHECK-NOFIX:   222004:        41 0a 40 f9     ldr     x1, [x18, #16]
 // CHECK-NEXT:    222008:        c0 03 5f d6     ret
         .section .text.09, "ax", %progbits
         .balign 4096
         .globl t3_ffc_sturh
         .type t3_ffc_sturh, %function
         .space 4096 - 4
 t3_ffc_sturh:
         adrp x18, dat3
         sturh w3, [x2, #4]
         ldr x1, [x18, :got_lo12:dat3]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 223FF8 in unpatched output.
 // CHECK: <t3_ff8_literal>:
 // CHECK-NEXT:    223ff8:        f2 01 00 b0     adrp    x18, #249856
-// CHECK-NEXT:    223ffc:        e3 ff ff 58     ldr     x3, #-4
-// CHECK-FIX:     224000:        15 80 00 14     b       #131156
+// CHECK-NEXT:    223ffc:        e3 ff ff 58     ldr     x3, 0x223ff8
+// CHECK-FIX:     224000:        15 80 00 14     b       0x244054
 // CHECK-NOFIX:   224000:        52 0e 40 f9     ldr     x18, [x18, #24]
 // CHECK-NEXT:    224004:        c0 03 5f d6     ret
         .section .text.10, "ax", %progbits
         .balign 4096
         .globl t3_ff8_literal
         .type t3_ff8_literal, %function
         .space 4096 - 8
 t3_ff8_literal:
         adrp x18, dat1
         ldr x3, t3_ff8_literal
         ldr x18, [x18, :lo12:dat1]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 225FFC in unpatched output.
 // CHECK: <t3_ffc_register>:
 // CHECK-NEXT:    225ffc:        cf 01 00 f0     adrp    x15, #241664
 // CHECK-NEXT:    226000:        43 68 61 f8     ldr             x3, [x2, x1]
-// CHECK-FIX:     226004:        16 78 00 14     b       #122968
+// CHECK-FIX:     226004:        16 78 00 14     b       0x24405c
 // CHECK-NOFIX:   226004:        ea 11 40 f9     ldr     x10, [x15, #32]
 // CHECK-NEXT:    226008:        c0 03 5f d6     ret
         .section .text.11, "ax", %progbits
         .balign 4096
         .globl t3_ffc_register
         .type t3_ffc_register, %function
         .space 4096 - 4
 t3_ffc_register:
         adrp x15, dat2
         ldr x3, [x2, x1]
         ldr x10, [x15, :lo12:dat2]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 227FF8 in unpatched output.
 // CHECK: <t3_ff8_stp>:
 // CHECK-NEXT:    227ff8:        d0 01 00 b0     adrp    x16, #233472
 // CHECK-NEXT:    227ffc:        61 08 00 a9     stp             x1, x2, [x3]
-// CHECK-FIX:     228000:        19 70 00 14     b       #114788
+// CHECK-FIX:     228000:        19 70 00 14     b       0x244064
 // CHECK-NOFIX:   228000:        0d 16 40 f9     ldr     x13, [x16, #40]
 // CHECK-NEXT:    228004:        c0 03 5f d6     ret
         .section .text.12, "ax", %progbits
         .balign 4096
         .globl t3_ff8_stp
         .type t3_ff8_stp, %function
         .space 4096 - 8
 t3_ff8_stp:
         adrp x16, dat3
         stp x1,x2, [x3, #0]
         ldr x13, [x16, :lo12:dat3]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 229FFC in unpatched output.
 // CHECK: <t3_ffc_stnp>:
 // CHECK-NEXT:    229ffc:        a7 01 00 f0     adrp    x7, #225280
 // CHECK-NEXT:    22a000:        61 08 00 a8     stnp            x1, x2, [x3]
-// CHECK-FIX:     22a004:        1a 68 00 14     b       #106600
+// CHECK-FIX:     22a004:        1a 68 00 14     b       0x24406c
 // CHECK-NOFIX:   22a004:        e9 0c 40 f9     ldr             x9, [x7, #24]
 // CHECK-NEXT:    22a008:        c0 03 5f d6     ret
         .section .text.13, "ax", %progbits
         .balign 4096
         .globl t3_ffc_stnp
         .type t3_ffc_stnp, %function
         .space 4096 - 4
 t3_ffc_stnp:
         adrp x7, dat1
         stnp x1,x2, [x3, #0]
         ldr x9, [x7, :lo12:dat1]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 22BFFC in unpatched output.
 // CHECK: <t3_ffc_st1singlepost>:
 // CHECK-NEXT:    22bffc:        b7 01 00 b0     adrp    x23, #217088
 // CHECK-NEXT:    22c000:        20 04 82 0d     st1 { v0.b }[1], [x1], x2
-// CHECK-FIX:     22c004:        1c 60 00 14     b       #98416
+// CHECK-FIX:     22c004:        1c 60 00 14     b       0x244074
 // CHECK-NOFIX:   22c004:        f6 12 40 f9     ldr     x22, [x23, #32]
 // CHECK-NEXT:    22c008:        c0 03 5f d6     ret
         .section .text.14, "ax", %progbits
         .balign 4096
         .globl t3_ffc_st1singlepost
         .type t3_ffc_st1singlepost, %function
         .space 4096 - 4
 t3_ffc_st1singlepost:
         adrp x23, dat2
         st1 { v0.b }[1], [x1], x2
         ldr x22, [x23, :lo12:dat2]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 22DFF8 in unpatched output.
 // CHECK: <t3_ff8_st1multiple>:
 // CHECK-NEXT:    22dff8:        97 01 00 f0     adrp    x23, #208896
 // CHECK-NEXT:    22dffc:        20 a0 00 4c     st1     { v0.16b, v1.16b }, [x1]
-// CHECK-FIX:     22e000:        1f 58 00 14     b       #90236
+// CHECK-FIX:     22e000:        1f 58 00 14     b       0x24407c
 // CHECK-NOFIX:   22e000:        f8 16 40 f9     ldr     x24, [x23, #40]
 // CHECK-NEXT:    22e004:        c0 03 5f d6     ret
         .section .text.15, "ax", %progbits
         .balign 4096
         .globl t3_ff8_st1multiple
         .type t3_ff8_st1muliple, %function
         .space 4096 - 8
 t3_ff8_st1multiple:
         adrp x23, dat3
         st1 { v0.16b, v1.16b }, [x1]
         ldr x24, [x23, :lo12:dat3]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 22FFF8 in unpatched output.
 // CHECK: <t4_ff8_ldr>:
 // CHECK-NEXT:    22fff8:        80 01 00 b0     adrp    x0, #200704
 // CHECK-NEXT:    22fffc:        21 00 40 f9     ldr             x1, [x1]
 // CHECK-NEXT:    230000:        42 00 00 8b     add             x2, x2, x0
-// CHECK-FIX:     230004:        20 50 00 14     b       #82048
+// CHECK-FIX:     230004:        20 50 00 14     b       0x244084
 // CHECK-NOFIX:   230004:        02 00 40 f9     ldr             x2, [x0]
 // CHECK-NEXT:    230008:        c0 03 5f d6     ret
         .section .text.16, "ax", %progbits
         .balign 4096
         .globl t4_ff8_ldr
         .type t4_ff8_ldr, %function
         .space 4096 - 8
 t4_ff8_ldr:
         adrp x0, dat1
         ldr x1, [x1, #0]
         add x2, x2, x0
         ldr x2, [x0, :got_lo12:dat1]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 231FFC in unpatched output.
 // CHECK: <t4_ffc_str>:
 // CHECK-NEXT:    231ffc:        7c 01 00 f0     adrp    x28, #192512
 // CHECK-NEXT:    232000:        42 00 00 f9     str             x2, [x2]
 // CHECK-NEXT:    232004:        20 00 02 cb     sub             x0, x1, x2
-// CHECK-FIX:     232008:        21 48 00 14     b       #73860
+// CHECK-FIX:     232008:        21 48 00 14     b       0x24408c
 // CHECK-NOFIX:   232008:        9b 07 00 f9     str     x27, [x28, #8]
 // CHECK-NEXT:    23200c:        c0 03 5f d6     ret
         .section .text.17, "ax", %progbits
         .balign 4096
         .globl t4_ffc_str
         .type t4_ffc_str, %function
         .space 4096 - 4
 t4_ffc_str:
         adrp x28, dat2
         str x2, [x2, #0]
         sub x0, x1, x2
         str x27, [x28, :got_lo12:dat2]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 233FF8 in unpatched output.
 // CHECK: <t4_ff8_stp>:
 // CHECK-NEXT:    233ff8:        70 01 00 b0     adrp    x16, #184320
 // CHECK-NEXT:    233ffc:        61 08 00 a9     stp             x1, x2, [x3]
 // CHECK-NEXT:    234000:        03 7e 10 9b     mul             x3, x16, x16
-// CHECK-FIX:     234004:        24 40 00 14     b       #65680
+// CHECK-FIX:     234004:        24 40 00 14     b       0x244094
 // CHECK-NOFIX:   234004:        0e 0a 40 f9     ldr     x14, [x16, #16]
 // CHECK-NEXT:    234008:        c0 03 5f d6     ret
         .section .text.18, "ax", %progbits
         .balign 4096
         .globl t4_ff8_stp
         .type t4_ff8_stp, %function
         .space 4096 - 8
 t4_ff8_stp:
         adrp x16, dat3
         stp x1,x2, [x3, #0]
         mul x3, x16, x16
         ldr x14, [x16, :got_lo12:dat3]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 235FF8 in unpatched output.
 // CHECK: <t4_ff8_stppre>:
 // CHECK-NEXT:    235ff8:        50 01 00 f0     adrp    x16, #176128
 // CHECK-NEXT:    235ffc:        61 08 81 a9     stp     x1, x2, [x3, #16]!
 // CHECK-NEXT:    236000:        03 7e 10 9b     mul             x3, x16, x16
-// CHECK-FIX:     236004:        26 38 00 14     b       #57496
+// CHECK-FIX:     236004:        26 38 00 14     b       0x24409c
 // CHECK-NOFIX:   236004:        0e 06 40 f9     ldr     x14, [x16, #8]
 // CHECK-NEXT:    236008:        c0 03 5f d6     ret
         .section .text.19, "ax", %progbits
         .balign 4096
         .globl t4_ff8_stppre
         .type t4_ff8_stppre, %function
         .space 4096 - 8
 t4_ff8_stppre:
         adrp x16, dat1
         stp x1,x2, [x3, #16]!
         mul x3, x16, x16
         ldr x14, [x16, #8]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 237FF8 in unpatched output.
 // CHECK: <t4_ff8_stppost>:
 // CHECK-NEXT:    237ff8:        50 01 00 b0     adrp    x16, #167936
 // CHECK-NEXT:    237ffc:        61 08 81 a8     stp     x1, x2, [x3], #16
 // CHECK-NEXT:    238000:        03 7e 10 9b     mul             x3, x16, x16
-// CHECK-FIX:     238004:        28 30 00 14     b       #49312
+// CHECK-FIX:     238004:        28 30 00 14     b       0x2440a4
 // CHECK-NOFIX:   238004:        0e 06 40 f9     ldr     x14, [x16, #8]
 // CHECK-NEXT:    238008:        c0 03 5f d6     ret
         .section .text.20, "ax", %progbits
         .balign 4096
         .globl t4_ff8_stppost
         .type t4_ff8_stppost, %function
         .space 4096 - 8
 t4_ff8_stppost:
         adrp x16, dat2
         stp x1,x2, [x3], #16
         mul x3, x16, x16
         ldr x14, [x16, #8]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 239FFC in unpatched output.
 // CHECK: <t4_ffc_stpsimd>:
 // CHECK-NEXT:    239ffc:        30 01 00 f0     adrp    x16, #159744
 // CHECK-NEXT:    23a000:        61 08 00 ad     stp             q1, q2, [x3]
 // CHECK-NEXT:    23a004:        03 7e 10 9b     mul             x3, x16, x16
-// CHECK-FIX:     23a008:        29 28 00 14     b       #41124
+// CHECK-FIX:     23a008:        29 28 00 14     b       0x2440ac
 // CHECK-NOFIX:   23a008:        0e 06 40 f9     ldr     x14, [x16, #8]
 // CHECK-NEXT:    23a00c:        c0 03 5f d6     ret
         .section .text.21, "ax", %progbits
         .balign 4096
         .globl t4_ffc_stpsimd
         .type t4_ffc_stpsimd, %function
         .space 4096 - 4
 t4_ffc_stpsimd:
         adrp x16, dat3
         stp q1,q2, [x3, #0]
         mul x3, x16, x16
         ldr x14, [x16, #8]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 23BFFC in unpatched output.
 // CHECK: <t4_ffc_stnp>:
 // CHECK-NEXT:    23bffc:        27 01 00 b0     adrp    x7, #151552
 // CHECK-NEXT:    23c000:        61 08 00 a8     stnp            x1, x2, [x3]
 // CHECK-NEXT:    23c004:        1f 20 03 d5     nop
-// CHECK-FIX:     23c008:        2b 20 00 14     b       #32940
+// CHECK-FIX:     23c008:        2b 20 00 14     b       0x2440b4
 // CHECK-NOFIX:   23c008:        ea 00 40 f9     ldr             x10, [x7]
 // CHECK-NEXT:    23c00c:        c0 03 5f d6     ret
         .section .text.22, "ax", %progbits
         .balign 4096
         .globl t4_ffc_stnp
         .type t4_ffc_stnp, %function
         .space 4096 - 4
 t4_ffc_stnp:
         adrp x7, dat1
         stnp x1,x2, [x3, #0]
         nop
         ldr x10, [x7, :got_lo12:dat1]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 23DFFC in unpatched output.
 // CHECK: <t4_ffc_st1>:
 // CHECK-NEXT:    23dffc:        18 01 00 f0     adrp    x24, #143360
 // CHECK-NEXT:    23e000:        20 80 00 4d     st1 { v0.s }[2], [x1]
 // CHECK-NEXT:    23e004:        f6 06 40 f9     ldr     x22, [x23, #8]
-// CHECK-FIX:     23e008:        2d 18 00 14     b       #24756
+// CHECK-FIX:     23e008:        2d 18 00 14     b       0x2440bc
 // CHECK-NOFIX:   23e008:        18 ff 3f f9     str     x24, [x24, #32760]
 // CHECK-NEXT:    23e00c:        c0 03 5f d6     ret
         .section .text.23, "ax", %progbits
         .balign 4096
         .globl t4_ffc_st1
         .type t4_ffc_st1, %function
         .space 4096 - 4
 t4_ffc_st1:
         adrp x24, dat2
         st1 { v0.s }[2], [x1]
         ldr x22, [x23, :got_lo12:dat2]
         str x24, [x24, #32760]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 23FFF8 in unpatched output.
 // CHECK: <t3_ff8_ldr_once>:
 // CHECK-NEXT:    23fff8:        00 01 00 b0     adrp    x0, #135168
 // CHECK-NEXT:    23fffc:        20 70 82 4c     st1     { v0.16b }, [x1], x2
-// CHECK-FIX:     240000:        31 10 00 14     b       #16580
+// CHECK-FIX:     240000:        31 10 00 14     b       0x2440c4
 // CHECK-NOFIX:   240000:        01 08 40 f9     ldr     x1, [x0, #16]
 // CHECK-NEXT:    240004:        02 08 40 f9     ldr     x2, [x0, #16]
 // CHECK-NEXT:    240008:        c0 03 5f d6     ret
         .section .text.24, "ax", %progbits
         .balign 4096
         .globl t3_ff8_ldr_once
         .type t3_ff8_ldr_once, %function
         .space 4096 - 8
 t3_ff8_ldr_once:
         adrp x0, dat3
         st1 { v0.16b }, [x1], x2
         ldr x1, [x0, #16]
         ldr x2, [x0, #16]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 241FF8 in unpatched output.
 // CHECK: <t3_ff8_ldxr>:
 // CHECK-NEXT:    241ff8:        e0 00 00 f0     adrp    x0, #126976
 // CHECK-NEXT:    241ffc:        03 7c 5f c8     ldxr    x3, [x0]
-// CHECK-FIX:     242000:        33 08 00 14     b       #8396
+// CHECK-FIX:     242000:        33 08 00 14     b       0x2440cc
 // CHECK-NOFIX:   242000:        01 08 40 f9     ldr     x1, [x0, #16]
 // CHECK:         242004:        02 08 40 f9     ldr     x2, [x0, #16]
 // CHECK-NEXT:    242008:        c0 03 5f d6     ret
         .section .text.25, "ax", %progbits
         .balign 4096
         .globl t3_ff8_ldxr
         .type t3_ff8_ldxr, %function
         .space 4096 - 8
 t3_ff8_ldxr:
         adrp x0, dat3
         ldxr x3, [x0]
         ldr x1, [x0, #16]
         ldr x2, [x0, #16]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 243FF8 in unpatched output.
 // CHECK: <t3_ff8_stxr>:
 // CHECK-NEXT:    243ff8:        e0 00 00 b0     adrp    x0, #118784
 // CHECK-NEXT:    243ffc:        03 7c 04 c8     stxr    w4, x3, [x0]
-// CHECK-FIX:     244000:        35 00 00 14     b       #212
+// CHECK-FIX:     244000:        35 00 00 14     b       0x2440d4
 // CHECK-NOFIX:   244000:        01 08 40 f9     ldr     x1, [x0, #16]
 // CHECK:         244004:        02 08 40 f9     ldr     x2, [x0, #16]
 // CHECK-NEXT:    244008:        c0 03 5f d6     ret
         .section .text.26, "ax", %progbits
         .balign 4096
         .globl t3_ff8_stxr
         .type t3_ff8_stxr, %function
         .space 4096 - 8
 t3_ff8_stxr:
         adrp x0, dat3
         stxr w4, x3, [x0]
         ldr x1, [x0, #16]
         ldr x2, [x0, #16]
         ret
 
         .text
         .globl _start
         .type _start, %function
 _start:
         ret
 
 // CHECK-FIX: <__CortexA53843419_212000>:
 // CHECK-FIX-NEXT:    24400c:    00 00 40 f9     ldr     x0, [x0]
-// CHECK-FIX-NEXT:    244010:    fd 37 ff 17     b       #-204812
+// CHECK-FIX-NEXT:    244010:    fd 37 ff 17     b       0x212004
 // CHECK-FIX: <__CortexA53843419_214000>:
 // CHECK-FIX-NEXT:    244014:    02 04 40 f9     ldr     x2, [x0, #8]
-// CHECK-FIX-NEXT:    244018:    fb 3f ff 17     b       #-196628
+// CHECK-FIX-NEXT:    244018:    fb 3f ff 17     b       0x214004
 // CHECK-FIX: <__CortexA53843419_216004>:
 // CHECK-FIX-NEXT:    24401c:    03 08 40 f9     ldr     x3, [x0, #16]
-// CHECK-FIX-NEXT:    244020:    fa 47 ff 17     b       #-188440
+// CHECK-FIX-NEXT:    244020:    fa 47 ff 17     b       0x216008
 // CHECK-FIX: <__CortexA53843419_218000>:
 // CHECK-FIX-NEXT:    244024:    02 0c 40 f9     ldr     x2, [x0, #24]
-// CHECK-FIX-NEXT:    244028:    f7 4f ff 17     b       #-180260
+// CHECK-FIX-NEXT:    244028:    f7 4f ff 17     b       0x218004
 // CHECK-FIX: <__CortexA53843419_21A004>:
 // CHECK-FIX-NEXT:    24402c:    9c 13 00 f9     str     x28, [x28, #32]
-// CHECK-FIX-NEXT:    244030:    f6 57 ff 17     b       #-172072
+// CHECK-FIX-NEXT:    244030:    f6 57 ff 17     b       0x21a008
 // CHECK-FIX: <__CortexA53843419_21C004>:
 // CHECK-FIX-NEXT:    244034:    84 17 00 f9     str     x4, [x28, #40]
-// CHECK-FIX-NEXT:    244038:    f4 5f ff 17     b       #-163888
+// CHECK-FIX-NEXT:    244038:    f4 5f ff 17     b       0x21c008
 // CHECK-FIX: <__CortexA53843419_21E000>:
 // CHECK-FIX-NEXT:    24403c:    bd 03 40 f9     ldr     x29, [x29]
-// CHECK-FIX-NEXT:    244040:    f1 67 ff 17     b       #-155708
+// CHECK-FIX-NEXT:    244040:    f1 67 ff 17     b       0x21e004
 // CHECK-FIX: <__CortexA53843419_220004>:
 // CHECK-FIX-NEXT:    244044:    bd 07 40 f9     ldr     x29, [x29, #8]
-// CHECK-FIX-NEXT:    244048:    f0 6f ff 17     b       #-147520
+// CHECK-FIX-NEXT:    244048:    f0 6f ff 17     b       0x220008
 // CHECK-FIX: <__CortexA53843419_222004>:
 // CHECK-FIX-NEXT:    24404c:    41 0a 40 f9     ldr     x1, [x18, #16]
-// CHECK-FIX-NEXT:    244050:    ee 77 ff 17     b       #-139336
+// CHECK-FIX-NEXT:    244050:    ee 77 ff 17     b       0x222008
 // CHECK-FIX: <__CortexA53843419_224000>:
 // CHECK-FIX-NEXT:    244054:    52 0e 40 f9     ldr     x18, [x18, #24]
-// CHECK-FIX-NEXT:    244058:    eb 7f ff 17     b       #-131156
+// CHECK-FIX-NEXT:    244058:    eb 7f ff 17     b       0x224004
 // CHECK-FIX: <__CortexA53843419_226004>:
 // CHECK-FIX-NEXT:    24405c:    ea 11 40 f9     ldr     x10, [x15, #32]
-// CHECK-FIX-NEXT:    244060:    ea 87 ff 17     b       #-122968
+// CHECK-FIX-NEXT:    244060:    ea 87 ff 17     b       0x226008
 // CHECK-FIX: <__CortexA53843419_228000>:
 // CHECK-FIX-NEXT:    244064:    0d 16 40 f9     ldr     x13, [x16, #40]
-// CHECK-FIX-NEXT:    244068:    e7 8f ff 17     b       #-114788
+// CHECK-FIX-NEXT:    244068:    e7 8f ff 17     b       0x228004
 // CHECK-FIX: <__CortexA53843419_22A004>:
 // CHECK-FIX-NEXT:    24406c:    e9 0c 40 f9     ldr     x9, [x7, #24]
-// CHECK-FIX-NEXT:    244070:    e6 97 ff 17     b       #-106600
+// CHECK-FIX-NEXT:    244070:    e6 97 ff 17     b       0x22a008
 // CHECK-FIX: <__CortexA53843419_22C004>:
 // CHECK-FIX-NEXT:    244074:    f6 12 40 f9     ldr     x22, [x23, #32]
-// CHECK-FIX-NEXT:    244078:    e4 9f ff 17     b       #-98416
+// CHECK-FIX-NEXT:    244078:    e4 9f ff 17     b       0x22c008
 // CHECK-FIX: <__CortexA53843419_22E000>:
 // CHECK-FIX-NEXT:    24407c:    f8 16 40 f9     ldr     x24, [x23, #40]
-// CHECK-FIX-NEXT:    244080:    e1 a7 ff 17     b       #-90236
+// CHECK-FIX-NEXT:    244080:    e1 a7 ff 17     b       0x22e004
 // CHECK-FIX: <__CortexA53843419_230004>:
 // CHECK-FIX-NEXT:    244084:    02 00 40 f9     ldr     x2, [x0]
-// CHECK-FIX-NEXT:    244088:    e0 af ff 17     b       #-82048
+// CHECK-FIX-NEXT:    244088:    e0 af ff 17     b       0x230008
 // CHECK-FIX: <__CortexA53843419_232008>:
 // CHECK-FIX-NEXT:    24408c:    9b 07 00 f9     str     x27, [x28, #8]
-// CHECK-FIX-NEXT:    244090:    df b7 ff 17     b       #-73860
+// CHECK-FIX-NEXT:    244090:    df b7 ff 17     b       0x23200c
 // CHECK-FIX: <__CortexA53843419_234004>:
 // CHECK-FIX-NEXT:    244094:    0e 0a 40 f9     ldr     x14, [x16, #16]
-// CHECK-FIX-NEXT:    244098:    dc bf ff 17     b       #-65680
+// CHECK-FIX-NEXT:    244098:    dc bf ff 17     b       0x234008
 // CHECK-FIX: <__CortexA53843419_236004>:
 // CHECK-FIX-NEXT:    24409c:    0e 06 40 f9     ldr     x14, [x16, #8]
-// CHECK-FIX-NEXT:    2440a0:    da c7 ff 17     b       #-57496
+// CHECK-FIX-NEXT:    2440a0:    da c7 ff 17     b       0x236008
 // CHECK-FIX: <__CortexA53843419_238004>:
 // CHECK-FIX-NEXT:    2440a4:    0e 06 40 f9     ldr     x14, [x16, #8]
-// CHECK-FIX-NEXT:    2440a8:    d8 cf ff 17     b       #-49312
+// CHECK-FIX-NEXT:    2440a8:    d8 cf ff 17     b       0x238008
 // CHECK-FIX: <__CortexA53843419_23A008>:
 // CHECK-FIX-NEXT:    2440ac:    0e 06 40 f9     ldr     x14, [x16, #8]
-// CHECK-FIX-NEXT:    2440b0:    d7 d7 ff 17     b       #-41124
+// CHECK-FIX-NEXT:    2440b0:    d7 d7 ff 17     b       0x23a00c
 // CHECK-FIX: <__CortexA53843419_23C008>:
 // CHECK-FIX-NEXT:    2440b4:    ea 00 40 f9     ldr     x10, [x7]
-// CHECK-FIX-NEXT:    2440b8:    d5 df ff 17     b       #-32940
+// CHECK-FIX-NEXT:    2440b8:    d5 df ff 17     b       0x23c00c
 // CHECK-FIX: <__CortexA53843419_23E008>:
 // CHECK-FIX-NEXT:    2440bc:    18 ff 3f f9     str     x24, [x24, #32760]
-// CHECK-FIX-NEXT:    2440c0:    d3 e7 ff 17     b       #-24756
+// CHECK-FIX-NEXT:    2440c0:    d3 e7 ff 17     b       0x23e00c
 // CHECK-FIX: <__CortexA53843419_240000>:
 // CHECK-FIX-NEXT:    2440c4:    01 08 40 f9     ldr     x1, [x0, #16]
-// CHECK-FIX-NEXT:    2440c8:    cf ef ff 17     b       #-16580
+// CHECK-FIX-NEXT:    2440c8:    cf ef ff 17     b       0x240004
 // CHECK-FIX: <__CortexA53843419_242000>:
 // CHECK-FIX-NEXT:    2440cc:    01 08 40 f9     ldr     x1, [x0, #16]
-// CHECK-FIX-NEXT:    2440d0:    cd f7 ff 17     b       #-8396
+// CHECK-FIX-NEXT:    2440d0:    cd f7 ff 17     b       0x242004
 // CHECK-FIX: <__CortexA53843419_244000>:
 // CHECK-FIX-NEXT:    2440d4:    01 08 40 f9     ldr     x1, [x0, #16]
-// CHECK-FIX-NEXT:    2440d8:    cb ff ff 17     b       #-212
+// CHECK-FIX-NEXT:    2440d8:    cb ff ff 17     b       0x244004
         .data
         .globl dat
         .globl dat2
         .globl dat3
 dat1:   .quad 1
 dat2:   .quad 2
 dat3:   .quad 3

lld/test/ELF/aarch64-cortex-a53-843419-thunk.s

t3_ff8_ldr:
         ldr x1, [x1, #0]
         ldr x0, [x0, :got_lo12:dat]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 10FF8 in unpatched output.
 // CHECK: 0000000000010ff8 <t3_ff8_ldr>:
 // CHECK-NEXT: adrp    x0, #134217728
 // CHECK-NEXT: ldr     x1, [x1]
-// CHECK-NEXT: b       #8
+// CHECK-NEXT: b       0x11008
 // CHECK-NEXT: ret
 // CHECK: 0000000000011008 <__CortexA53843419_11000>:
 // CHECK-NEXT: ldr     x0, [x0, #8]
-// CHECK-NEXT: b       #-8
+// CHECK-NEXT: b       0x11004
         .section .text.04, "ax", %progbits
         .globl far_away
         .type far_away, function
 far_away:
         ret
 
         .section .data
         .globl dat
 dat:    .quad 0

lld/test/ELF/aarch64-feature-bti.s

 # RUN: llvm-objdump -d --mattr=+bti --no-show-raw-insn %tno.so | FileCheck --check-prefix=NOBTI %s
 # RUN: llvm-readelf -x .got.plt %tno.so | FileCheck --check-prefix SOGOTPLT %s
 # RUN: llvm-readelf --dynamic-table %tno.so | FileCheck --check-prefix NOBTIDYN %s
 
 # NOBTIDYN-NOT:   0x0000000070000001 (AARCH64_BTI_PLT)
 # NOBTIDYN-NOT:   0x0000000070000003 (AARCH64_PAC_PLT)
 
 # NOBTI: 00000000000102b8 <func2>:
-# NOBTI-NEXT:    102b8: bl      #56 <func3@plt>
+# NOBTI-NEXT:    102b8: bl      0x102f0 <func3@plt>
 # NOBTI-NEXT:    102bc: ret
 # NOBTI: Disassembly of section .plt:
 # NOBTI: 00000000000102d0 <.plt>:
 # NOBTI-NEXT:    102d0: stp     x16, x30, [sp, #-16]!
 # NOBTI-NEXT:    102d4: adrp    x16, #131072
 # NOBTI-NEXT:    102d8: ldr     x17, [x16, #960]
 # NOBTI-NEXT:    102dc: add     x16, x16, #960
 # NOBTI-NEXT:    102e0: br      x17

 # RUN: llvm-readelf --dynamic-table %t.so | FileCheck --check-prefix BTIDYN %s
 
 # BTIPROP: Properties:    aarch64 feature: BTI
 
 # BTIDYN:      0x0000000070000001 (AARCH64_BTI_PLT)
 # BTIDYN-NOT:  0x0000000070000003 (AARCH64_PAC_PLT)
 
 # BTISO: 0000000000010348 <func2>:
-# BTISO-NEXT:    10348: bl      #56 <func3@plt>
+# BTISO-NEXT:    10348: bl      0x10380 <func3@plt>
 # BTISO-NEXT:           ret
 # BTISO: 0000000000010350 <func3>:
 # BTISO-NEXT:    10350: ret
 # BTISO: Disassembly of section .plt:
 # BTISO: 0000000000010360 <.plt>:
 # BTISO-NEXT:    10360: bti     c
 # BTISO-NEXT:           stp     x16, x30, [sp, #-16]!
 # BTISO-NEXT:           adrp    x16, #131072

 # RUN: ld.lld %t2.o --shared --soname=t2.so -o %t2.so
 
 # RUN: ld.lld %t.o %t.so %t2.so -o %t.exe
 # RUN: llvm-readelf --dynamic-table -n %t.exe | FileCheck --check-prefix=BTIPROP %s
 # RUN: llvm-objdump -d --mattr=+bti --no-show-raw-insn %t.exe | FileCheck --check-prefix=EXECBTI %s
 
 # EXECBTI: Disassembly of section .text:
 # EXECBTI: 0000000000210348 <func1>:
-# EXECBTI-NEXT:   210348: bl    #40 <func2@plt>
+# EXECBTI-NEXT:   210348: bl    0x210370 <func2@plt>
 # EXECBTI-NEXT:           ret
 # EXECBTI: Disassembly of section .plt:
 # EXECBTI: 0000000000210350 <.plt>:
 # EXECBTI-NEXT:   210350: bti   c
 # EXECBTI-NEXT:           stp   x16, x30, [sp, #-16]!
 # EXECBTI-NEXT:           adrp  x16, #131072
 # EXECBTI-NEXT:           ldr   x17, [x16, #1160]
 # EXECBTI-NEXT:           add   x16, x16, #1160

 ## We expect the same for PIE, as the address of an ifunc can escape
 # RUN: ld.lld --pie %t.o %t.so %t2.so -o %tpie.exe
 # RUN: llvm-readelf -n %tpie.exe | FileCheck --check-prefix=BTIPROP %s
 # RUN: llvm-readelf --dynamic-table -n %tpie.exe | FileCheck --check-prefix=BTIPROP %s
 # RUN: llvm-objdump -d --mattr=+bti --no-show-raw-insn %tpie.exe | FileCheck --check-prefix=PIE %s
 
 # PIE: Disassembly of section .text:
 # PIE: 0000000000010348 <func1>:
-# PIE-NEXT:    10348: bl     #40 <func2@plt>
+# PIE-NEXT:    10348: bl     0x10370 <func2@plt>
 # PIE-NEXT:           ret
 # PIE: Disassembly of section .plt:
 # PIE: 0000000000010350 <.plt>:
 # PIE-NEXT:    10350: bti    c
 # PIE-NEXT:           stp    x16, x30, [sp, #-16]!
 # PIE-NEXT:           adrp   x16, #131072
 # PIE-NEXT:           ldr    x17, [x16, #1160]
 # PIE-NEXT:           add    x16, x16, #1160

 ## .note.property, expect no bti c and no .note.gnu.property entry
 
 # RUN: ld.lld %t.o %t2.o %t.so -o %tnobti.exe
 # RUN: llvm-readelf --dynamic-table %tnobti.exe | FileCheck --check-prefix NOBTIDYN %s
 # RUN: llvm-objdump -d --mattr=+bti --no-show-raw-insn %tnobti.exe | FileCheck --check-prefix=NOEX %s
 
 # NOEX: Disassembly of section .text:
 # NOEX: 00000000002102e0 <func1>:
-# NOEX-NEXT:   2102e0: bl      #48 <func2@plt>
+# NOEX-NEXT:   2102e0: bl      0x210310 <func2@plt>
 # NOEX-NEXT:           ret
 # NOEX: 00000000002102e8 <func3>:
 # NOEX-NEXT:   2102e8: ret
 # NOEX: Disassembly of section .plt:
 # NOEX: 00000000002102f0 <.plt>:
 # NOEX-NEXT:   2102f0: stp     x16, x30, [sp, #-16]!
 # NOEX-NEXT:           adrp    x16, #131072
 # NOEX-NEXT:           ldr     x17, [x16, #1024]

 
 
 # RUN: llvm-readelf -n %tforcebti.exe | FileCheck --check-prefix=BTIPROP %s
 # RUN: llvm-readelf --dynamic-table %tforcebti.exe | FileCheck --check-prefix BTIDYN %s
 # RUN: llvm-objdump -d --mattr=+bti --no-show-raw-insn %tforcebti.exe | FileCheck --check-prefix=FORCE %s
 
 # FORCE: Disassembly of section .text:
 # FORCE: 0000000000210370 <func1>:
-# FORCE-NEXT:   210370: bl      #48 <func2@plt>
+# FORCE-NEXT:   210370: bl      0x2103a0 <func2@plt>
 # FORCE-NEXT:           ret
 # FORCE: 0000000000210378 <func3>:
 # FORCE-NEXT:   210378: ret
 # FORCE: Disassembly of section .plt:
 # FORCE: 0000000000210380 <.plt>:
 # FORCE-NEXT:   210380: bti     c
 # FORCE-NEXT:           stp     x16, x30, [sp, #-16]!
 # FORCE-NEXT:           adrp    x16, #131072

lld/test/ELF/aarch64-feature-btipac.s

 
 # RUN: ld.lld %t1.o %t3btipac.o --shared --soname=t.so -o %t.so
 # RUN: llvm-readelf -n %t.so | FileCheck --check-prefix BTIPACPROP %s
 # RUN: llvm-objdump -d --mattr=+v8.5a --no-show-raw-insn %t.so | FileCheck --check-prefix BTIPACSO %s
 # RUN: llvm-readelf --dynamic-table %t.so | FileCheck --check-prefix BTIPACDYN %s
 
 # BTIPACSO: Disassembly of section .text:
 # BTIPACSO: 0000000000010348 <func2>:
-# BTIPACSO-NEXT:    10348:              bl      #56 <func3@plt>
+# BTIPACSO-NEXT:    10348:              bl      0x10380 <func3@plt>
 # BTIPACSO-NEXT:                        ret
 # BTIPACSO: 0000000000010350 <func3>:
 # BTIPACSO-NEXT:    10350:              ret
 # BTIPACSO: Disassembly of section .plt:
 # BTIPACSO: 0000000000010360 <.plt>:
 # BTIPACSO-NEXT:    10360:              bti     c
 # BTIPACSO-NEXT:                        stp     x16, x30, [sp, #-16]!
 # BTIPACSO-NEXT:                        adrp    x16, #131072

 
 # RUN: ld.lld %t.o %t3btipac.o %t.so -o %t.exe
 # RUN: llvm-readelf -n %t.exe | FileCheck --check-prefix=BTIPACPROP %s
 # RUN: llvm-objdump -d --mattr=+v8.5a --no-show-raw-insn %t.exe | FileCheck --check-prefix BTIPACEX %s
 # RUN: llvm-readelf --dynamic-table %t.exe | FileCheck --check-prefix BTIPACDYNEX %s
 
 # BTIPACEX: Disassembly of section .text:
 # BTIPACEX: 0000000000210370 <func1>:
-# BTIPACEX-NEXT:   210370:              bl      #48 <func2@plt>
+# BTIPACEX-NEXT:   210370:              bl      0x2103a0 <func2@plt>
 # BTIPACEX-NEXT:                        ret
 # BTIPACEX-NEXT:                        ret
 # BTIPACEX: 000000000021037c <func3>:
 # BTIPACEX-NEXT:   21037c:              ret
 # BTIPACEX: Disassembly of section .plt:
 # BTIPACEX: 0000000000210380 <.plt>:
 # BTIPACEX-NEXT:   210380:              bti     c
 # BTIPACEX-NEXT:                        stp     x16, x30, [sp, #-16]!

 ## Check that combinations of BTI+PAC with 0 properties results in standard PLT
 
 # RUN: ld.lld %t.o %t3.o %t.so -o %t.exe
 # RUN: llvm-objdump -d --mattr=+v8.5a --no-show-raw-insn %t.exe | FileCheck --check-prefix EX %s
 # RUN: llvm-readelf --dynamic-table %t.exe | FileCheck --check-prefix=NODYN %s
 
 # EX: Disassembly of section .text:
 # EX: 00000000002102e0 <func1>:
-# EX-NEXT:   2102e0: bl      #48 <func2@plt>
+# EX-NEXT:   2102e0: bl      0x210310 <func2@plt>
 # EX-NEXT:           ret
 # EX-NEXT:           ret
 # EX: 00000000002102ec <func3>:
 # EX-NEXT:   2102ec: ret
 # EX: Disassembly of section .plt:
 # EX: 00000000002102f0 <.plt>:
 # EX-NEXT:   2102f0: stp     x16, x30, [sp, #-16]!
 # EX-NEXT:           adrp    x16, #131072
func1:
   bl func2
   ret
 .globl func3
 .type func3,%function
   ret
 
 # BTIPACEX2: Disassembly of section .text:
 # BTIPACEX2: 0000000000210370 <func1>:
-# BTIPACEX2-NEXT:   210370:              bl      #48 <func2@plt>
+# BTIPACEX2-NEXT:   210370:              bl      0x2103a0 <func2@plt>
 # BTIPACEX2-NEXT:                        ret
 # BTIPACEX2-NEXT:                        ret
 # BTIPACEX2: 000000000021037c <func3>:
 # BTIPACEX2-NEXT:   21037c:              ret
 # BTIPACEX2: Disassembly of section .plt:
 # BTIPACEX2: 0000000000210380 <.plt>:
 # BTIPACEX2-NEXT:   210380:              bti     c
 # BTIPACEX2-NEXT:                        stp     x16, x30, [sp, #-16]!
 # BTIPACEX2-NEXT:                        adrp    x16, #131072
 # BTIPACEX2-NEXT:                        ldr     x17, [x16, #1208]
 # BTIPACEX2-NEXT:                        add     x16, x16, #1208
 # BTIPACEX2-NEXT:                        br      x17
 # BTIPACEX2-NEXT:                        nop
 # BTIPACEX2-NEXT:                        nop
 # BTIPACEX2: 00000000002103a0 <func2@plt>:
 # BTIPACEX2-NEXT:   2103a0:              bti     c
 # BTIPACEX2-NEXT:                        adrp    x16, #131072
 # BTIPACEX2-NEXT:                        ldr     x17, [x16, #1216]
 # BTIPACEX2-NEXT:                        add     x16, x16, #1216
 # BTIPACEX2-NEXT:                        autia1716
 # BTIPACEX2-NEXT:                        br      x17
 
 # BTIPACDYN2:        0x0000000070000001 (AARCH64_BTI_PLT)
 # BTIPACDYN2-NEXT:   0x0000000070000003 (AARCH64_PAC_PLT)
 No newline at end of file

lld/test/ELF/aarch64-feature-pac.s

 # REQUIRES: aarch64
 # RUN: llvm-mc -filetype=obj -triple=aarch64-linux-gnu %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=aarch64-linux-gnu %p/Inputs/aarch64-pac1.s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=aarch64-linux-gnu %p/Inputs/aarch64-func3.s -o %t2.o
 # RUN: llvm-mc -filetype=obj -triple=aarch64-linux-gnu %p/Inputs/aarch64-func3-pac.s -o %t3.o
 # RUN: llvm-mc -filetype=obj -triple=aarch64-linux-gnu %p/Inputs/aarch64-func2.s -o %tno.o
 
 ## We do not add PAC support when the inputs don't have the .note.gnu.property
 ## field.
 
 # RUN: ld.lld %tno.o %t3.o --shared -o %tno.so
 # RUN: llvm-objdump -d --mattr=+v8.3a --no-show-raw-insn %tno.so | FileCheck --check-prefix=NOPAC %s
 # RUN: llvm-readelf -x .got.plt %tno.so | FileCheck --check-prefix SOGOTPLT %s
 # RUN: llvm-readelf --dynamic-table %tno.so | FileCheck --check-prefix NOPACDYN %s
 
 # NOPAC: 00000000000102b8 <func2>:
-# NOPAC-NEXT:    102b8: bl      #56 <func3@plt>
+# NOPAC-NEXT:    102b8: bl      0x102f0 <func3@plt>
 # NOPAC-NEXT:           ret
 # NOPAC: Disassembly of section .plt:
 # NOPAC: 00000000000102d0 <.plt>:
 # NOPAC-NEXT:    102d0: stp     x16, x30, [sp, #-16]!
 # NOPAC-NEXT:           adrp    x16, #131072
 # NOPAC-NEXT:           ldr     x17, [x16, #960]
 # NOPAC-NEXT:           add     x16, x16, #960
 # NOPAC-NEXT:           br      x17

 # RUN: ld.lld %t1.o %t3.o --shared --soname=t.so -o %t.so
 # RUN: llvm-readelf -n %t.so | FileCheck --check-prefix PACPROP %s
 # RUN: llvm-objdump -d --mattr=+v8.3a --no-show-raw-insn %t.so | FileCheck --check-prefix PACSO %s
 # RUN: llvm-readelf -x .got.plt %t.so | FileCheck --check-prefix SOGOTPLT2 %s
 # RUN: llvm-readelf --dynamic-table %t.so |  FileCheck --check-prefix PACDYN %s
 
 ## PAC has no effect on PLT[0], for PLT[N].
 # PACSO: 0000000000010348 <func2>:
-# PACSO-NEXT:    10348:         bl      #56 <func3@plt>
+# PACSO-NEXT:    10348:         bl      0x10380 <func3@plt>
 # PACSO-NEXT:                   ret
 # PACSO: 0000000000010350 <func3>:
 # PACSO-NEXT:    10350:         ret
 # PACSO: Disassembly of section .plt:
 # PACSO: 0000000000010360 <.plt>:
 # PACSO-NEXT:    10360:         stp     x16, x30, [sp, #-16]!
 # PACSO-NEXT:                   adrp    x16, #131072
 # PACSO-NEXT:                   ldr     x17, [x16, #1120]

 
 # RUN: ld.lld %t.o %t2.o -z pac-plt %t.so -o %tpacplt.exe
 # RUN: llvm-readelf -n %tpacplt.exe | FileCheck --check-prefix=PACPROP %s
 # RUN: llvm-readelf --dynamic-table %tpacplt.exe | FileCheck --check-prefix PACDYN2 %s
 # RUN: llvm-objdump -d --mattr=+v8.3a --no-show-raw-insn %tpacplt.exe | FileCheck --check-prefix PACPLT %s
 
 # PACPLT: Disassembly of section .text:
 # PACPLT: 0000000000210370 <func1>:
-# PACPLT-NEXT:   210370:        bl      #48 <func2@plt>
+# PACPLT-NEXT:   210370:        bl      0x2103a0 <func2@plt>
 # PACPLT-NEXT:                  ret
 # PACPLT: 0000000000210378 <func3>:
 # PACPLT-NEXT:   210378:        ret
 # PACPLT: Disassembly of section .plt:
 # PACPLT: 0000000000210380 <.plt>:
 # PACPLT-NEXT:   210380:        stp     x16, x30, [sp, #-16]!
 # PACPLT-NEXT:                  adrp    x16, #131072
 # PACPLT-NEXT:                  ldr     x17, [x16, #1192]

lld/test/ELF/aarch64-gnu-ifunc-plt.s

 // Check that a PLT header is written and the ifunc entries appear last
 // DISASM: Disassembly of section .text:
 // DISASM-EMPTY:
 // DISASM-NEXT: <foo>:
 // DISASM-NEXT:    2102d8: ret
 // DISASM:      <bar>:
 // DISASM-NEXT:    2102dc: ret
 // DISASM:      <_start>:
-// DISASM-NEXT:    2102e0: bl      #80 <zed2+0x210330>
-// DISASM-NEXT:    2102e4: bl      #92 <zed2+0x210340>
-// DISASM-NEXT:    2102e8: bl      #40 <bar2@plt>
-// DISASM-NEXT:    2102ec: bl      #52 <zed2@plt>
+// DISASM-NEXT:    2102e0: bl      0x210330 <zed2+0x210330>
+// DISASM-NEXT:    2102e4: bl      0x210340 <zed2+0x210340>
+// DISASM-NEXT:    2102e8: bl      0x210310 <bar2@plt>
+// DISASM-NEXT:    2102ec: bl      0x210320 <zed2@plt>
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-EMPTY:
 // DISASM-NEXT: <.plt>:
 // DISASM-NEXT:    2102f0: stp     x16, x30, [sp, #-16]!
 // DISASM-NEXT:    2102f4: adrp    x16, #131072
 // DISASM-NEXT:    2102f8: ldr     x17, [x16, #1104]
 // DISASM-NEXT:    2102fc: add     x16, x16, #1104

lld/test/ELF/aarch64-gnu-ifunc.s

 
 // DISASM: Disassembly of section .text:
 // DISASM-EMPTY:
 // DISASM-NEXT: <foo>:
 // DISASM-NEXT:  210188: ret
 // DISASM: <bar>:
 // DISASM-NEXT:  21018c: ret
 // DISASM:      <_start>:
-// DISASM-NEXT:  210190: bl  #16
-// DISASM-NEXT:  210194: bl  #28
+// DISASM-NEXT:  210190: bl  0x2101a0
+// DISASM-NEXT:  210194: bl  0x2101b0
 // DISASM-NEXT:  210198: add x2, x2, #344
 // DISASM-NEXT:  21019c: add x2, x2, #392
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .iplt:
 // DISASM-EMPTY:
 // DISASM-NEXT: <.iplt>:
 // DISASM-NEXT:  2101a0: adrp x16, #65536
 // DISASM-NEXT:  2101a4: ldr x17, [x16, #448]

lld/test/ELF/aarch64-jump26-thunk.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64 %S/Inputs/abs.s -o %tabs.o
 // RUN: llvm-mc -filetype=obj -triple=aarch64 %s -o %t.o
 // RUN: ld.lld %t.o %tabs.o -o %t
 // RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
 
 .text
 .globl _start
 _start:
     b big
 
 // CHECK: Disassembly of section .text:
 // CHECK-EMPTY:
 // CHECK-NEXT: <_start>:
-// CHECK-NEXT:    210120:       b       #4
+// CHECK-NEXT:    210120:       b       0x210124
 // CHECK: <__AArch64AbsLongThunk_big>:
-// CHECK-NEXT:    210124:       ldr     x16, #8
+// CHECK-NEXT:    210124:       ldr     x16, 0x21012c
 // CHECK-NEXT:    210128:       br      x16
 // CHECK: <$d>:
 // CHECK-NEXT:    21012c:       00 00 00 00     .word   0x00000000
 // CHECK-NEXT:    210130:       10 00 00 00     .word   0x00000010

lld/test/ELF/aarch64-plt.s

 // DUMPDSO: Contents of section .got.plt:
 // .got.plt[0..2] = 0 (reserved)
 // .got.plt[3..5] = .plt = 0x10010
 // DUMPDSO-NEXT: 30450 00000000 00000000 00000000 00000000
 // DUMPDSO-NEXT: 30460 00000000 00000000 40030100 00000000
 // DUMPDSO-NEXT: 30470 40030100 00000000 40030100 00000000
 
 // DISASMDSO: <_start>:
-// DISASMDSO-NEXT:     10330: b       #0x30 <foo@plt>
-// DISASMDSO-NEXT:     10334: b       #0x3c <bar@plt>
-// DISASMDSO-NEXT:     10338: b       #0x48 <weak@plt>
+// DISASMDSO-NEXT:     10330: b       0x10360 <foo@plt>
+// DISASMDSO-NEXT:     10334: b       0x10370 <bar@plt>
+// DISASMDSO-NEXT:     10338: b       0x10380 <weak@plt>
 
 // DISASMDSO: <foo>:
 // DISASMDSO-NEXT:     1033c: nop
 
 // DISASMDSO: Disassembly of section .plt:
 // DISASMDSO-EMPTY:
 // DISASMDSO-NEXT: <.plt>:
 // DISASMDSO-NEXT:     10340: stp     x16, x30, [sp, #-0x10]!

 // DUMPEXE: Contents of section .got.plt:
 // .got.plt[0..2] = 0 (reserved)
 // .got.plt[3..4] = .plt = 0x40010
 // DUMPEXE-NEXT:  2303f0 00000000 00000000 00000000 00000000
 // DUMPEXE-NEXT:  230400 00000000 00000000 e0022100 00000000
 // DUMPEXE-NEXT:  230410 e0022100 00000000
 
 // DISASMEXE: <_start>:
-// DISASMEXE-NEXT:    2102c8: b #0xc <foo>
-// DISASMEXE-NEXT:    2102cc: b #0x34 <bar@plt>
-// DISASMEXE-NEXT:    2102d0: b #0x40 <weak@plt>
+// DISASMEXE-NEXT:    2102c8: b 0x2102d4 <foo>
+// DISASMEXE-NEXT:    2102cc: b 0x210300 <bar@plt>
+// DISASMEXE-NEXT:    2102d0: b 0x210310 <weak@plt>
 
 // DISASMEXE: <foo>:
 // DISASMEXE-NEXT:    2102d4: nop
 
 // DISASMEXE: Disassembly of section .plt:
 // DISASMEXE-EMPTY:
 // DISASMEXE-NEXT: <.plt>:
 // DISASMEXE-NEXT:    2102e0: stp     x16, x30, [sp, #-0x10]!

lld/test/ELF/aarch64-relocs.s

 
 # S = 0x21014c, A = 0x4, P = 0x210154
 # R = S + A - P = -0x4 = 0xfffffffc
 # (R & 0x0ffffffc) >> 2 = 0x03ffffff
 # 0x94000000 | 0x03ffffff = 0x97ffffff
 # CHECK: Disassembly of section .R_AARCH64_CALL26:
 # CHECK-EMPTY:
 # CHECK-NEXT: <call26>:
-# CHECK-NEXT:   210154:       ff ff ff 97     bl     #-4
+# CHECK-NEXT:   210154:       ff ff ff 97     bl     0x210150
 
 .section .R_AARCH64_JUMP26,"ax",@progbits
 jump26:
         b sub
 
 # S = 0x21014c, A = 0x4, P = 0x210158
 # R = S + A - P = -0x8 = 0xfffffff8
 # (R & 0x0ffffffc) >> 2 = 0x03fffffe
 # 0x14000000 | 0x03fffffe = 0x17fffffe
 # CHECK: Disassembly of section .R_AARCH64_JUMP26:
 # CHECK-EMPTY:
 # CHECK-NEXT: <jump26>:
-# CHECK-NEXT:   210158:       fe ff ff 17     b      #-8
+# CHECK-NEXT:   210158:       fe ff ff 17     b      0x210150
 
 .section .R_AARCH64_LDST32_ABS_LO12_NC,"ax",@progbits
 ldst32:
   ldr s4, [x5, :lo12:foo32]
 foo32:
   .asciz "foo"
   .size mystr, 3
 

lld/test/ELF/aarch64-thunk-pi.s

  .section .text_low, "ax", %progbits
  .globl low_target
  .type low_target, %function
 low_target:
  // Need thunk to high_target@plt
  bl high_target
  ret
 // CHECK: <low_target>:
-// CHECK-NEXT:       d8:       bl      #0x14 <__AArch64ADRPThunk_high_target>
+// CHECK-NEXT:       d8:       bl      0xec <__AArch64ADRPThunk_high_target>
 // CHECK-NEXT:                 ret
 
  .hidden low_target2
  .globl low_target2
  .type low_target2, %function
 low_target2:
  // Need thunk to high_target2
  bl high_target2
  // .text_high+8 = high_target2
  bl .text_high+8
  ret
 // CHECK: <low_target2>:
-// CHECK-NEXT:       e0:       bl      #0x18 <__AArch64ADRPThunk_high_target2>
-// CHECK-NEXT:       e4:       bl      #0x20 <__AArch64ADRPThunk_>
+// CHECK-NEXT:       e0:       bl      0xf8 <__AArch64ADRPThunk_high_target2>
+// CHECK-NEXT:       e4:       bl      0x104 <__AArch64ADRPThunk_>
 // CHECK-NEXT:                 ret
 
 // Expect range extension thunks for .text_low
 // adrp calculation is (PC + signed immediate) & (!0xfff)
 // CHECK: <__AArch64ADRPThunk_high_target>:
 // CHECK-NEXT:       ec:       adrp    x16, #0x10000000
 // CHECK-NEXT:                 add     x16, x16, #0x40
 // CHECK-NEXT:                 br      x16

  .section .text_high, "ax", %progbits
  .globl high_target
  .type high_target, %function
 high_target:
  // No thunk needed as we can reach low_target@plt
  bl low_target
  ret
 // CHECK: <high_target>:
-// CHECK-NEXT: 10000000:       bl #0x50 <low_target@plt>
+// CHECK-NEXT: 10000000:       bl 0x10000050 <low_target@plt>
 // CHECK-NEXT:                 ret
 
  .hidden high_target2
  .globl high_target2
  .type high_target2, %function
 high_target2:
  // Need thunk to low_target
  bl low_target2
  ret
 // CHECK: <high_target2>:
-// CHECK-NEXT: 10000008:       bl      #0x8 <__AArch64ADRPThunk_low_target2>
+// CHECK-NEXT: 10000008:       bl      0x10000010 <__AArch64ADRPThunk_low_target2>
 // CHECK-NEXT:                 ret
 
 // Expect Thunk for .text.high
 
 // CHECK: <__AArch64ADRPThunk_low_target2>:
 // CHECK-NEXT: 10000010:       adrp    x16, #-0x10000000
 // CHECK-NEXT:                 add     x16, x16, #0xe0
 // CHECK-NEXT:                 br      x16

lld/test/ELF/aarch64-thunk-script.s

 high_target:
  // No Thunk needed as we are within signed immediate range
  bl _start
  ret
 
 // CHECK: Disassembly of section .text_low:
 // CHECK-EMPTY:
 // CHECK-NEXT: <_start>:
-// CHECK-NEXT:     2000:       bl      #0xc <__AArch64AbsLongThunk_high_target>
-// CHECK-NEXT:     2004:       bl      #0x18 <__AArch64AbsLongThunk_>
+// CHECK-NEXT:     2000:       bl      0x200c <__AArch64AbsLongThunk_high_target>
+// CHECK-NEXT:     2004:       bl      0x201c <__AArch64AbsLongThunk_>
 // CHECK-NEXT:                 ret
 // CHECK: <__AArch64AbsLongThunk_high_target>:
-// CHECK-NEXT:     200c:       ldr     x16, #0x8
+// CHECK-NEXT:     200c:       ldr     x16, 0x2014
 // CHECK-NEXT:                 br      x16
 // CHECK: <$d>:
 // CHECK-NEXT:     2014:       00 20 00 08     .word   0x08002000
 // CHECK-NEXT:     2018:       00 00 00 00     .word   0x00000000
 // CHECK:      <__AArch64AbsLongThunk_>:
-// CHECK-NEXT:     201c:       ldr x16, #0x8
+// CHECK-NEXT:     201c:       ldr x16, 0x2024
 // CHECK-NEXT:     2020:       br x16
 // CHECK:      <$d>:
 // CHECK-NEXT:     2024:       04 20 00 08     .word   0x08002004
 // CHECK-NEXT:     2028:       00 00 00 00     .word   0x00000000
 // CHECK: Disassembly of section .text_high:
 // CHECK-EMPTY:
 // CHECK-NEXT: <high_target>:
-// CHECK-NEXT:  8002000:       bl      #-0x8000000 <_start>
+// CHECK-NEXT:  8002000:       bl      0x2000 <_start>
 // CHECK-NEXT:                 ret
 
 /// Local symbols copied from %t.o
 // NM:      t $x.0
 // NM-NEXT: t $x.1
 /// Local thunk symbols.
 // NM-NEXT: t __AArch64AbsLongThunk_high_target
 // NM-NEXT: t $x
 // NM-NEXT: t $d
 // NM-NEXT: t __AArch64AbsLongThunk_{{$}}
 // NM-NEXT: t $x
 // NM-NEXT: t $d
 /// Global symbols.
 // NM-NEXT: T _start
 // NM-NEXT: T high_target

lld/test/ELF/aarch64-thunk-section-location.s

  .balign 0x1000
 
  .globl high_target
  .type high_target, %function
 high_target:
  ret
 
 // CHECK: <__AArch64AbsLongThunk_high_target>:
-// CHECK-NEXT:  81d1008:       ldr     x16, #8
+// CHECK-NEXT:  81d1008:       ldr     x16, 0x81d1010
 // CHECK-NEXT:  81d100c:       br      x16
 // CHECK: <$d>:
 // CHECK-NEXT:  81d1010:       00 20 21 08     .word   0x08212000

lld/test/ELF/aarch64-tstbr14-reloc.s

 # CHECK-NEXT:  210124: nop
 # CHECK-NEXT:  210128: nop
 # CHECK-NEXT:  21012c: nop
 # CHECK:      <_bar>:
 # CHECK-NEXT:  210130: nop
 # CHECK-NEXT:  210134: nop
 # CHECK-NEXT:  210138: nop
 # CHECK:      <_start>:
-# CHECK-NEXT:  21013c: tbnz w3, #15, #-28 <_foo>
-# CHECK-NEXT:  210140: tbnz w3, #15, #-16 <_bar>
-# CHECK-NEXT:  210144: tbz x6, #45, #-36 <_foo>
-# CHECK-NEXT:  210148: tbz x6, #45, #-24 <_bar>
+# CHECK-NEXT:  21013c: tbnz w3, #15, 0x210120 <_foo>
+# CHECK-NEXT:  210140: tbnz w3, #15, 0x210130 <_bar>
+# CHECK-NEXT:  210144: tbz x6, #45, 0x210120 <_foo>
+# CHECK-NEXT:  210148: tbz x6, #45, 0x210130 <_bar>
 
 #DSOREL:      Section {
 #DSOREL:        Index:
 #DSOREL:        Name: .got.plt
 #DSOREL-NEXT:   Type: SHT_PROGBITS
 #DSOREL-NEXT:   Flags [
 #DSOREL-NEXT:     SHF_ALLOC
 #DSOREL-NEXT:     SHF_WRITE

 #DSO-NEXT:  102fc: nop
 #DSO-NEXT:  10300: nop
 #DSO-NEXT:  10304: nop
 #DSO:      <_bar>:
 #DSO-NEXT:  10308: nop
 #DSO-NEXT:  1030c: nop
 #DSO-NEXT:  10310: nop
 #DSO:      <_start>:
-#DSO-NEXT:  10314: tbnz w3, #15, #60 <_foo@plt>
-#DSO-NEXT:  10318: tbnz w3, #15, #72 <_bar@plt>
-#DSO-NEXT:  1031c: tbz x6, #45, #52 <_foo@plt>
-#DSO-NEXT:  10320: tbz x6, #45, #64 <_bar@plt>
+#DSO-NEXT:  10314: tbnz w3, #15, 0x10350 <_foo@plt>
+#DSO-NEXT:  10318: tbnz w3, #15, 0x10360 <_bar@plt>
+#DSO-NEXT:  1031c: tbz x6, #45, 0x10350 <_foo@plt>
+#DSO-NEXT:  10320: tbz x6, #45, 0x10360 <_bar@plt>
 #DSO-EMPTY:
 #DSO-NEXT: Disassembly of section .plt:
 #DSO-EMPTY:
 #DSO-NEXT: <.plt>:
 #DSO-NEXT:  10330: stp x16, x30, [sp, #-16]!
 #DSO-NEXT:  10334: adrp x16, #131072
 #DSO-NEXT:  10338: ldr x17, [x16, #1072]
 #DSO-NEXT:  1033c: add x16, x16, #1072

lld/test/ELF/aarch64-undefined-weak.s

 // R_AARCH64_PREL64
  .xword target - .
 // R_AARCH64_PREL16
  .hword target - .
 
 // CHECK: Disassembly of section .text:
 // CHECK-EMPTY:
 // CHECK-NEXT: 0000000010010120 <_start>:
-// CHECK-NEXT: 10010120: b       #4
-// CHECK-NEXT: 10010124: bl      #4
-// CHECK-NEXT: 10010128: b.eq    #4
-// CHECK-NEXT: 1001012c: cbz     x1, #4
+// CHECK-NEXT: 10010120: b       0x10010124
+// CHECK-NEXT: 10010124: bl      0x10010128
+// CHECK-NEXT: 10010128: b.eq    0x1001012c
+// CHECK-NEXT: 1001012c: cbz     x1, 0x10010130
 // CHECK-NEXT: 10010130: adr     x0, #0
 // CHECK-NEXT: 10010134: adrp    x0, #0
-// CHECK-NEXT: 10010138: ldr     x8, #0
+// CHECK-NEXT: 10010138: ldr     x8, 0x10010138
 // CHECK:      1001013c: 00 00 00 00     .word   0x00000000
 // CHECK-NEXT: 10010140: 00 00 00 00     .word   0x00000000
 // CHECK-NEXT: 10010144: 00 00 00 00     .word   0x00000000
 // CHECK-NEXT: 10010148: 00 00           .short  0x0000

lld/test/ELF/pr34660.s

 # IMM = hex(65540) = 0x10004
 # PC = 0x10000
 # As the relocation is PC-relative, IMM + PC = 0x20004 which is the VA of the
 # correct symbol.
 
 # DISASM: Disassembly of section .text:
 # DISASM-EMPTY:
 # DISASM-NEXT: <$x.0>:
-# DISASM-NEXT:   1022c:       ldr     x8, #131176
+# DISASM-NEXT:   1022c:       ldr     x8, 0x30294
 
 # SYM: Symbol table '.symtab'
 # SYM:  0000000000030294     0 NOTYPE  LOCAL  DEFAULT    6 patatino
 
   ldr x8, patatino
   .data
   .zero 4
 patatino:

lld/test/ELF/relocation-b-aarch64.test

 # REQUIRES: aarch64
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: ld.lld %t.o -o %t.out
 # RUN: llvm-objdump -d --no-show-raw-insn %t.out | FileCheck %s
 
 # Check that the R_AARCH64_JUMP26 writes the branch opcode as well as the
 # immediate. We use this property to overwrite instructions with a branch.
 
 # CHECK: Disassembly of section .text:
 # CHECK-EMPTY:
 # CHECK-NEXT: <foo>:
-# CHECK-NEXT:    210120:       b       #4
+# CHECK-NEXT:    210120:       b       0x210124
 # CHECK: <bar>:
-# CHECK-NEXT:    210124:       b       #-4
+# CHECK-NEXT:    210124:       b       0x210120
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_AARCH64
 Sections:

llvm/lib/Target/AArch64/MCTargetDesc/AArch64InstPrinter.cpp

void AArch64InstPrinter::printAlignedLabel(const MCInst *MI, uint64_t Address,
                                            unsigned OpNum,
                                            const MCSubtargetInfo &STI,
                                            raw_ostream &O) {
   const MCOperand &Op = MI->getOperand(OpNum);
 
   // If the label has already been resolved to an immediate offset (say, when
   // we're running the disassembler), just print the immediate.
   if (Op.isImm()) {
-    O << "#" << formatImm(Op.getImm() * 4);
+    int64_t Offset = Op.getImm() * 4;
+    if (PrintBranchImmAsAddress)
+      O << formatHex(Address + Offset);
+    else
+      O << "#" << formatImm(Offset);
     return;
   }
 
   // If the branch target is simply an address then print it in hex.
   const MCConstantExpr *BranchTarget =
       dyn_cast<MCConstantExpr>(MI->getOperand(OpNum).getExpr());
   int64_t TargetAddress;
   if (BranchTarget && BranchTarget->evaluateAsAbsolute(TargetAddress)) {

llvm/test/CodeGen/AArch64/callbr-asm-obj-file.ll

 ; RUN: llc < %s -mtriple=aarch64-unknown-linux-gnu -filetype=obj -o - \
 ; RUN:  | llvm-objdump --triple=aarch64-unknown-linux-gnu -d - \
 ; RUN:  | FileCheck %s
 
 %struct.c = type { i1 (...)* }
 
 @l = common hidden local_unnamed_addr global i32 0, align 4
 
 ; CHECK-LABEL: <test1>:
 ; CHECK-LABEL: <$d.1>:
 ; CHECK-LABEL: <$x.2>:
-; CHECK-NEXT:    b #16 <$x.4+0x4>
+; CHECK-NEXT:    b 0x30 <$x.4+0x4>
 ; CHECK-LABEL: <$x.4>:
-; CHECK-NEXT:    b #4 <$x.4+0x4>
+; CHECK-NEXT:    b 0x30 <$x.4+0x4>
 ; CHECK-NEXT:    mov w0, wzr
 ; CHECK-NEXT:    ldr x30, [sp], #16
 ; CHECK-NEXT:    ret
 define hidden i32 @test1() {
   %1 = tail call i32 bitcast (i32 (...)* @g to i32 ()*)()
   %2 = icmp eq i32 %1, 0
   br i1 %2, label %3, label %5
 
7:                                                ; preds = %3, %4, %5
   ret i32 %8
 }
 
 declare dso_local i32 @g(...) local_unnamed_addr
 
 declare dso_local i32 @i(...) local_unnamed_addr
 
 ; CHECK-LABEL: <test2>:
-; CHECK:         bl #0 <test2+0x18>
+; CHECK:         bl {{.*}} <test2+0x18>
 ; CHECK-LABEL: <$d.5>:
 ; CHECK-LABEL: <$x.6>:
-; CHECK-NEXT:    b #-20 <test2+0x18>
+; CHECK-NEXT:    b {{.*}} <test2+0x18>
 define hidden i32 @test2() local_unnamed_addr {
   %1 = load i32, i32* @l, align 4
   %2 = icmp eq i32 %1, 0
   br i1 %2, label %10, label %3
 
 3:                                                ; preds = %0
   %4 = tail call i32 bitcast (i32 (...)* @g to i32 ()*)()
   %5 = icmp eq i32 %4, 0

 
 10:                                               ; preds = %7, %0, %6, %9
   ret i32 undef
 }
 
 ; CHECK-LABEL: <test3>:
 ; CHECK-LABEL: <$d.9>:
 ; CHECK-LABEL: <$x.10>:
-; CHECK-NEXT:    b #-20 <test3+0x18>
+; CHECK-NEXT:    b {{.*}} <test3+0x18>
 ; CHECK-LABEL: <$x.12>:
-; CHECK-NEXT:    b #4 <$x.12+0x4>
+; CHECK-NEXT:    b {{.*}} <$x.12+0x4>
 ; CHECK-NEXT:    mov w0, wzr
 ; CHECK-NEXT:    ldr x30, [sp], #16
 ; CHECK-NEXT:    ret
 define internal i1 @test3() {
   %1 = tail call i32 bitcast (i32 (...)* @g to i32 ()*)()
   %2 = icmp eq i32 %1, 0
   br i1 %2, label %3, label %5
 

llvm/test/CodeGen/AArch64/inlineasm-ldr-pseudo.ll

 ; We actually need to use -filetype=obj in this test because if we output
 ; assembly, the current code path will bypass the parser and just write the
 ; raw text out to the Streamer. We need to actually parse the inlineasm to
 ; demonstrate the bug. Going the asm->obj route does not show the issue.
 ; RUN: llc -mtriple=aarch64   < %s -filetype=obj | llvm-objdump --arch=aarch64 -d - | FileCheck %s
 
 ; CHECK-LABEL: <foo>:
 ; CHECK:       a0 79 95 d2   mov x0, #43981
 ; CHECK:       c0 03 5f d6   ret
 define i32 @foo() nounwind {
 entry:
   %0 = tail call i32 asm sideeffect "ldr $0,=0xabcd", "=r"() nounwind
   ret i32 %0
 }
 ; CHECK-LABEL: <bar>:
-; CHECK:        40 00 00 58                                      ldr    x0, #8
+; CHECK:        40 00 00 58                                      ldr    x0, 0x10
 ; CHECK:        c0 03 5f d6                                      ret
 ; Make sure the constant pool entry comes after the return
 ; CHECK-LABEL:        <$d.1>:
 define i32 @bar() nounwind {
 entry:
   %0 = tail call i32 asm sideeffect "ldr $0,=0x10001", "=r"() nounwind
   ret i32 %0
 }

llvm/test/tools/llvm-objdump/MachO/AArch64/pc-rel-targets.test

 // RUN: llvm-objdump -d %p/Inputs/kextbundle.macho-aarch64 | FileCheck %s
 
-CHECK:  4008:       03 00 00 94     bl      #12 <_bar.stub>
+CHECK:  4008:       03 00 00 94     bl      0x4014 <_bar.stub>