[X86InstPrinter] Change printPCRelImm to print the target address in hexadecimal form

[MaskRay]

Summary

// llvm-objdump -d output (before)
400000: e8 0b 00 00 00   callq 11
400005: e8 0b 00 00 00   callq 11

// llvm-objdump -d output (after)
400000: e8 0b 00 00 00  callq 0x400010
400005: e8 0b 00 00 00  callq 0x400015

// GNU objdump -d. The lack of 0x is not ideal because it cannot be re-assembled
400000: e8 0b 00 00 00  callq 400010
400005: e8 0b 00 00 00  callq 400015

In llvm-objdump, we pass the address of the next MCInst. Ideally we
should just thread the address of the current address, unfortunately we
cannot call X86MCCodeEmitter::encodeInstruction (X86MCCodeEmitter
requires MCInstrInfo and MCContext) to get the length of the MCInst.

MCInstPrinter::printInst has other callers (e.g llvm-mc -filetype=asm, llvm-mca) which set Address to 0. They leave MCInstPrinter::PrintBranchImmAsAddress as false and this change is a no-op for them.

[MaskRay]

tools/llvm-objdump/llvm-objdump.cpp currently passes the address of the current instruction to MCInstPrinter::printInst:

IP.printInst(MI, Address.Address, "", STI, OS);

x86 requires PC-offset bias. This patch does not take the length of MCInst into account, so the result is wrong.

Without X86MCCodeEmitter::encodeInstruction (which requires MCInstrInfo and MCContext), it seems difficult to get the length of MCInst.

We could teach tools/llvm-objdump/llvm-objdump.cpp to pass the address of the next MCInst, i.e.

IP.printInst(MI, Address.Address + Bytes.size(), "", STI, OS);

but this seems ugly.

[MaskRay]

Take PC offset bias into account

[jhenderson]

llvm/lib/Target/X86/MCTargetDesc/X86InstPrinterCommon.cpp

293

Whilst you're reflowing this, please fix "for example" -> "For example".

295

I don't know if it matters, but should the reference to Address be \p Address?

301–302

This might be a dumb question, since I'm not familiar with the disassembly stuff, but why is this here?

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

739–740

This is the PC bias bit, right? I thought PC bias was a thing on other platforms too?

This is probably at least deserving of a comment.

[MaskRay]

Improve tests

llvm/lib/Target/X86/MCTargetDesc/X86InstPrinterCommon.cpp

301–302

x86-32's address space is 32-bit. call .-4 at address 0 shall be displayed as 0xfffffffc, instead of 0xfffffffffffffffc. There are several tests relying on the behavior.

[MaskRay]

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

739–740

I think AArch64/PPC/RISC-V do not have PC bias. Their PC relative immediate is relative to the current instruction.

[andreadb]

llvm/test/tools/llvm-mca/X86/show-encoding.s

58 ↗

(On Diff #252344)

I find the jl 0xffffffffffffffa6 less readable than the old jl -90 to be honest.

For cases like this where the address of the next instruction is unknown (and therefore set to zero), I suggest that we fall back to the old behavior.
This case in is particularly annoying here because the Imm value is negative.

Note that this is quite a common pattern for code snippets processed by mca.
The branch at the end of a mca code snippet is often a backedge.

I don't know the motivations for this change. However, can we at least avoid to change the value if the PC value is unknown? Just an idea.

[MaskRay]

llvm/test/tools/llvm-mca/X86/show-encoding.s

58 ↗

(On Diff #252344)

jl -90 is not an ideal output. The unambiguous form is jl .-90

I'll add a member variable TargetAddressAsDotRelative in D72172.

I don't know the motivations for this change.

call/jump instructions not displaying the target address has always been a great pain for many users. I personally prefer GNU objdump -d just because this issue.

[MaskRay]

llvm/test/tools/llvm-mca/X86/show-encoding.s

58 ↗

(On Diff #252344)

s/D72172/D76574/

[MaskRay]

Rebase after MCInstPrinter::PrintBranchImmAsAddress is added to the parent patch.

llvm-mc -filetype=asm and llvm-mca are unaffected now.

[andreadb]

In D76580#1939897, @MaskRay wrote:

Rebase after MCInstPrinter::PrintBranchImmAsAddress is added to the parent patch.

llvm-mc -filetype=asm and llvm-mca are unaffected now.

Thanks!

[jhenderson]

I think this looks okay to me. LGTM. Caveat: I don't know much about the disassembler, so I leave it up to you whether you think somebody else should review.

lld/test/COFF/delayimports32.test

 BASEREL-NEXT:   }
 BASEREL-NEXT:   Entry {
 BASEREL-NEXT:     Type: HIGHLOW
 BASEREL-NEXT:     Address: 0x3024
 BASEREL-NEXT:   }
 BASEREL-NEXT: ]
 
 DISASM:      1029:      b8 20 30 40 00  movl    $4206624, %eax
-DISASM-NEXT: 102e:      e9 0a 00 00 00  jmp     10 <.text+0x3d>
+DISASM-NEXT: 102e:      e9 0a 00 00 00  jmp     0x40103d <.text+0x3d>
 DISASM-NEXT: 1033:      b8 24 30 40 00  movl    $4206628, %eax
-DISASM-NEXT: 1038:      e9 00 00 00 00  jmp     0 <.text+0x3d>
+DISASM-NEXT: 1038:      e9 00 00 00 00  jmp     0x40103d <.text+0x3d>
 DISASM-NEXT: 103d:      51      pushl   %ecx
 DISASM-NEXT: 103e:      52      pushl   %edx
 DISASM-NEXT: 103f:      50      pushl   %eax
 DISASM-NEXT: 1040:      68 00 20 40 00  pushl   $4202496
-DISASM-NEXT: 1045:      e8 b6 ff ff ff  calll   -74 <.text>
+DISASM-NEXT: 1045:      e8 b6 ff ff ff  calll   0x401000 <.text>
 DISASM-NEXT: 104a:      5a      popl    %edx
 DISASM-NEXT: 104b:      59      popl    %ecx
 DISASM-NEXT: 104c:      ff e0   jmpl    *%eax

lld/test/COFF/imports.test

 TEXT: Disassembly of section .text:
 TEXT-EMPTY:
 TEXT-NEXT: <.text>:
 TEXT-NEXT: subq    $40, %rsp
 TEXT-NEXT: movq    $0, %rcx
 TEXT-NEXT: leaq    8180(%rip), %rdx
 TEXT-NEXT: leaq    8167(%rip), %r8
 TEXT-NEXT: movl    $0, %r9d
-TEXT-NEXT: callq   60
+TEXT-NEXT: callq   0x140001060
 TEXT-NEXT: movl    $0, %ecx
-TEXT-NEXT: callq   18
-TEXT-NEXT: callq   29
+TEXT-NEXT: callq   0x140001040
+TEXT-NEXT: callq   0x140001050
 TEXT:      jmpq    *4098(%rip)
 TEXT:      jmpq    *4090(%rip)
 TEXT:      jmpq    *4082(%rip)
 
 IMPORT:      Import {
 IMPORT-NEXT:   Name: std64.dll
 IMPORT-NEXT:   ImportLookupTableRVA: 0x2028
 IMPORT-NEXT:   ImportAddressTableRVA: 0x2048

lld/test/COFF/lto-comdat.ll

 ; TEXT-11-NEXT: xorl  %eax, %eax
 ; TEXT-11-NEXT: retq
 
 ; HEADERS-01: AddressOfEntryPoint: 0x1000
 ; TEXT-01: Disassembly of section .text:
 ; TEXT-01-EMPTY:
 ; TEXT-01-NEXT: <.text>:
 ; TEXT-01-NEXT: subq  $40, %rsp
-; TEXT-01-NEXT: callq 23
-; TEXT-01-NEXT: callq 18
-; TEXT-01-NEXT: callq 13
+; TEXT-01-NEXT: callq 0x140001020
+; TEXT-01-NEXT: callq 0x140001020
+; TEXT-01-NEXT: callq 0x140001020
 ; TEXT-01-NEXT: xorl  %eax, %eax
 ; TEXT-01-NEXT: addq  $40, %rsp
 ; TEXT-01: retq
 ; TEXT-01-NOT: callq
 ; TEXT-01: retq
 ; TEXT-01: int3
 ; TEXT-01: int3
 ; TEXT-01: int3
 ; TEXT-01-NOT: {{.}}
 
 ; HEADERS-10: AddressOfEntryPoint: 0x1020
 ; TEXT-10: Disassembly of section .text:
 ; TEXT-10-EMPTY:
 ; TEXT-10-NEXT: <.text>:
 ; TEXT-10-NEXT: subq  $40, %rsp
-; TEXT-10-NEXT: callq 55
+; TEXT-10-NEXT: callq 0x140001040
 ; TEXT-10-NEXT: nop
 ; TEXT-10-NEXT: addq  $40, %rsp
 ; TEXT-10-NEXT: retq
 ; TEXT-10-NEXT: int3
 ; TEXT-10-NEXT: subq  $40, %rsp
-; TEXT-10-NEXT: callq 39
+; TEXT-10-NEXT: callq 0x140001040
 ; TEXT-10-NEXT: nop
 ; TEXT-10-NEXT: addq  $40, %rsp
 ; TEXT-10-NEXT: retq
 ; TEXT-10-NEXT: int3
 ; TEXT-10-NEXT: subq  $40, %rsp
-; TEXT-10-NEXT: callq -41
-; TEXT-10-NEXT: callq -30
+; TEXT-10-NEXT: callq 0x140001000
+; TEXT-10-NEXT: callq 0x140001010
 ; TEXT-10-NEXT: xorl  %eax, %eax
 ; TEXT-10-NEXT: addq  $40, %rsp
 ; TEXT-10-NEXT: retq
 ; TEXT-10-NOT: callq
 ; TEXT-10: retq
 ; TEXT-10-NOT: {{.}}
 
 target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"

lld/test/COFF/lto.ll

 ; TEXT-11-NEXT: movl  $2, %eax
 ; TEXT-11-NEXT: retq
 
 ; HEADERS-01: AddressOfEntryPoint: 0x1000
 ; TEXT-01: Disassembly of section .text:
 ; TEXT-01-EMPTY:
 ; TEXT-01-NEXT: <.text>:
 ; TEXT-01-NEXT: subq  $40, %rsp
-; TEXT-01-NEXT: callq 23
+; TEXT-01-NEXT: callq 0x140001020
 ; TEXT-01-NEXT: xorl  %eax, %eax
 ; TEXT-01-NEXT: addq  $40, %rsp
 ; TEXT-01-NEXT: retq
 ; TEXT-01-NEXT: retq
 ; TEXT-01-NEXT: int3
 ; TEXT-01-NEXT: int3
 ; TEXT-01-NEXT: int3
 ; TEXT-01-NEXT: int3

 ; TEXT-10-NEXT: int3
 ; TEXT-10-NEXT: int3
 ; TEXT-10-NEXT: int3
 ; TEXT-10-NEXT: int3
 ; TEXT-10-NEXT: int3
 ; TEXT-10-NEXT: int3
 ; TEXT-10-NEXT: int3
 ; TEXT-10-NEXT: subq  $40, %rsp
-; TEXT-10-NEXT: callq -41
+; TEXT-10-NEXT: callq 0x140001000
 ; TEXT-10-NEXT: xorl  %eax, %eax
 ; TEXT-10-NEXT: addq  $40, %rsp
 ; TEXT-10-NEXT: retq
 
 target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 define i32 @main() {

lld/test/ELF/comdat.s

// CHECK-NOT: nop
 
         .section bar, "ax"
         call foo
 
 // CHECK: Disassembly of section bar:
 // CHECK-EMPTY:
 // CHECK-NEXT: <bar>:
 // 0x1234 - 0x1235 - 5 = -6
-// CHECK-NEXT:   1235:  {{.*}}  callq  -6
+// CHECK-NEXT:   1235:  {{.*}}  callq  0x1234
 
         .section .text3,"axG",@progbits,zed,comdat,unique,0
 
 
 // READ:      Name: .text2
 // READ-NEXT: Type: SHT_PROGBITS
 // READ-NEXT: Flags [
 // READ-NEXT:   SHF_ALLOC

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

 
 // DISASM: Disassembly of section .text:
 // DISASM-EMPTY:
 // DISASM-NEXT: <foo_resolver>:
 // DISASM-NEXT:   4010e4:       retl
 // DISASM: <bar_resolver>:
 // DISASM-NEXT:   4010e5:       retl
 // DISASM:      <_start>:
-// DISASM-NEXT:   4010e6:       calll 21 <foo>
-// DISASM-NEXT:                 calll 32 <bar>
+// DISASM-NEXT:   4010e6:       calll 0x401100 <foo>
+// DISASM-NEXT:                 calll 0x401110 <bar>
 // DISASM-NEXT:                 movl $4194516, %edx
 // DISASM-NEXT:                 movl $4194532, %edx
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .iplt:
 // DISASM-EMPTY:
 // DISASM-NEXT: <foo>:
 // DISASM-NEXT:   401100:       jmpl *4202784
 // DISASM-NEXT:                 pushl $0
-// DISASM-NEXT:                 jmp -4198672
+// DISASM-NEXT:                 jmp 0x0
 // DISASM:      <bar>:
 // DISASM-NEXT:   401110:       jmpl *4202788
 // DISASM-NEXT:                 pushl $8
-// DISASM-NEXT:                 jmp -4198688
+// DISASM-NEXT:                 jmp 0x0
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
 .type foo_resolver STT_FUNC
 .globl foo_resolver
 foo_resolver:

lld/test/ELF/gnu-ifunc-noplt-i386.s

 // DISASM-EMPTY:
 // DISASM-NEXT: 004011ec <foo>:
 // DISASM-NEXT:   retl
 // DISASM-EMPTY:
 // DISASM-NEXT: 004011ed <bar>:
 // DISASM-NEXT:   retl
 // DISASM-EMPTY:
 // DISASM-NEXT: 004011ee <_start>:
-// DISASM-NEXT:   calll -0x4 <_start+0x1>
-// DISASM-NEXT:   calll -0x4 <_start+0x6>
-// DISASM-NEXT:   calll 0x23 <bar2@plt>
-// DISASM-NEXT:   calll 0x2e <zed2@plt>
+// DISASM-NEXT:   calll 0x4011ef <_start+0x1>
+// DISASM-NEXT:   calll 0x4011f4 <_start+0x6>
+// DISASM-NEXT:   calll 0x401220 <bar2@plt>
+// DISASM-NEXT:   calll 0x401230 <zed2@plt>
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-EMPTY:
 // DISASM-NEXT: 00401210 <.plt>:
 // DISASM-NEXT:   pushl 0x4032cc
 // DISASM-NEXT:   jmpl *0x4032d0
 // DISASM-NEXT:   nop
 // DISASM-NEXT:   nop
 // DISASM-NEXT:   nop
 // DISASM-NEXT:   nop
 // DISASM-EMPTY:
 // DISASM-NEXT: 00401220 <bar2@plt>:
 // DISASM-NEXT:   jmpl  *0x4032d4
 // DISASM-NEXT:   pushl $0x0
-// DISASM-NEXT:   jmp -0x20 <.plt>
+// DISASM-NEXT:   jmp 0x401210 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT: 00401230 <zed2@plt>:
 // DISASM-NEXT:   jmpl  *0x4032d8
 // DISASM-NEXT:   pushl $0x8
-// DISASM-NEXT:   jmp -0x30 <.plt>
+// DISASM-NEXT:   jmp 0x401210 <.plt>
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret
 
 .type bar STT_GNU_IFUNC

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

 // DISASM-EMPTY:
 // DISASM-NEXT: 0000000000201320 <foo>:
 // DISASM-NEXT:   201320:       retq
 // DISASM-EMPTY:
 // DISASM-NEXT: 0000000000201321 <bar>:
 // DISASM-NEXT:   201321:       retq
 // DISASM-EMPTY:
 // DISASM-NEXT: 0000000000201322 <_start>:
-// DISASM-NEXT:   201322:       callq 0 <_start+0x5>
-// DISASM-NEXT:   201327:       callq 0 <_start+0xa>
-// DISASM-NEXT:   20132c:       callq 31 <bar2@plt>
-// DISASM-NEXT:   201331:       callq 42 <zed2@plt>
+// DISASM-NEXT:   201322:       callq 0x201327 <_start+0x5>
+// DISASM-NEXT:   201327:       callq 0x20132c <_start+0xa>
+// DISASM-NEXT:   20132c:       callq 0x201350 <bar2@plt>
+// DISASM-NEXT:   201331:       callq 0x201360 <zed2@plt>
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-EMPTY:
 // DISASM-NEXT: 0000000000201340 <.plt>:
 // DISASM-NEXT:   201340:       pushq 8514(%rip)
 // DISASM-NEXT:   201346:       jmpq  *8516(%rip)
 // DISASM-NEXT:   20134c:       nopl  (%rax)
 // DISASM-EMPTY:
 // DISASM-NEXT: 0000000000201350 <bar2@plt>:
 // DISASM-NEXT:   201350:       jmpq  *8514(%rip)
 // DISASM-NEXT:   201356:       pushq $0
-// DISASM-NEXT:   20135b:       jmp -32 <.plt>
+// DISASM-NEXT:   20135b:       jmp 0x201340 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT: 0000000000201360 <zed2@plt>:
 // DISASM-NEXT:   201360:       jmpq  *8506(%rip)
 // DISASM-NEXT:   201366:       pushq $1
-// DISASM-NEXT:   20136b:       jmp -48 <.plt>
+// DISASM-NEXT:   20136b:       jmp 0x201340 <.plt>
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret
 
 .type bar STT_GNU_IFUNC

lld/test/ELF/gnu-ifunc-plt-i386.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:    4011b4:       retl
 // DISASM:      <bar>:
 // DISASM-NEXT:    4011b5:       retl
 // DISASM:      <_start>:
-// DISASM-NEXT:    4011b6:       calll   69 <zed2+0x401200>
-// DISASM-NEXT:                  calll   80 <zed2+0x401210>
-// DISASM-NEXT:                  calll   27 <bar2@plt>
-// DISASM-NEXT:                  calll   38 <zed2@plt>
+// DISASM-NEXT:    4011b6:       calll   0x401200 <zed2+0x401200>
+// DISASM-NEXT:                  calll   0x401210 <zed2+0x401210>
+// DISASM-NEXT:                  calll   0x4011e0 <bar2@plt>
+// DISASM-NEXT:                  calll   0x4011f0 <zed2@plt>
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-EMPTY:
 // DISASM-NEXT: <.plt>:
 // DISASM-NEXT:    4011d0:       pushl   4207260
 // DISASM-NEXT:                  jmpl    *4207264
 // DISASM-NEXT:                  nop
 // DISASM-NEXT:                  nop
 // DISASM-NEXT:                  nop
 // DISASM-NEXT:                  nop
 // DISASM-EMPTY:
 // DISASM-NEXT:   <bar2@plt>:
 // DISASM-NEXT:    4011e0:       jmpl    *4207268
 // DISASM-NEXT:                  pushl   $0
-// DISASM-NEXT:                  jmp     -32 <.plt>
+// DISASM-NEXT:                  jmp     0x4011d0 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT:   <zed2@plt>:
 // DISASM-NEXT:    4011f0:       jmpl    *4207272
 // DISASM-NEXT:                  pushl   $8
-// DISASM-NEXT:                  jmp     -48 <.plt>
+// DISASM-NEXT:                  jmp     0x4011d0 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .iplt:
 // DISASM-EMPTY:
 // DISASM-NEXT: <.iplt>:
 // DISASM-NEXT:                  jmpl    *4207276
 // DISASM-NEXT:                  pushl   $0
-// DISASM-NEXT:                  jmp     -64 <.plt>
+// DISASM-NEXT:                  jmp     0x4011d0 <.plt>
 // DISASM-NEXT:                  jmpl    *4207280
 // DISASM-NEXT:                  pushl   $8
-// DISASM-NEXT:                  jmp     -80 <.plt>
+// DISASM-NEXT:                  jmp     0x4011d0 <.plt>
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret
 
 .type bar STT_GNU_IFUNC

lld/test/ELF/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:   2012d8:       retq
 // DISASM:      <bar>:
 // DISASM-NEXT:   2012d9:       retq
 // DISASM:      <_start>:
-// DISASM-NEXT:   2012da:       callq   65
-// DISASM-NEXT:   2012df:       callq   76
+// DISASM-NEXT:   2012da:       callq   0x201320
+// DISASM-NEXT:   2012df:       callq   0x201330
 // DISASM-NEXT:                 callq   {{.*}} <bar2@plt>
 // DISASM-NEXT:                 callq   {{.*}} <zed2@plt>
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-EMPTY:
 // DISASM-NEXT: <.plt>:
 // DISASM-NEXT:   2012f0:       pushq   8514(%rip)
 // DISASM-NEXT:   2012f6:       jmpq    *8516(%rip)
 // DISASM-NEXT:   2012fc:       nopl    (%rax)
 // DISASM-EMPTY:
 // DISASM-NEXT:   <bar2@plt>:
 // DISASM-NEXT:   201300:       jmpq    *8514(%rip)
 // DISASM-NEXT:   201306:       pushq   $0
-// DISASM-NEXT:   20130b:       jmp     -32 <.plt>
+// DISASM-NEXT:   20130b:       jmp     0x2012f0 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT:   <zed2@plt>:
 // DISASM-NEXT:   201310:       jmpq    *8506(%rip)
 // DISASM-NEXT:   201316:       pushq   $1
-// DISASM-NEXT:   20131b:       jmp     -48 <.plt>
+// DISASM-NEXT:   20131b:       jmp     0x2012f0 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .iplt:
 // DISASM-EMPTY:
 // DISASM-NEXT: <.iplt>:
 // DISASM-NEXT:   201320:       jmpq    *8498(%rip)
 // DISASM-NEXT:   201326:       pushq   $0
-// DISASM-NEXT:   20132b:       jmp     -64 <.plt>
+// DISASM-NEXT:   20132b:       jmp     0x2012f0 <.plt>
 // DISASM-NEXT:   201330:       jmpq    *8490(%rip)
 // DISASM-NEXT:   201336:       pushq   $1
-// DISASM-NEXT:   20133b:       jmp     -80 <.plt>
+// DISASM-NEXT:   20133b:       jmp     0x2012f0 <.plt>
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret
 
 .type bar STT_GNU_IFUNC

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

 // handler and a JUMP_SLOT is used for a preemptible ifunc
 // DISASM: Disassembly of section .text:
 // DISASM-EMPTY:
 // DISASM-NEXT: <fct>:
 // DISASM-NEXT:     1308:       retq
 // DISASM:     <fct2>:
 // DISASM-NEXT:     1309:       retq
 // DISASM:     <f1>:
-// DISASM-NEXT:     130a:       callq   65
-// DISASM-NEXT:     130f:       callq   28
-// DISASM-NEXT:     1314:       callq   39
+// DISASM-NEXT:     130a:       callq   0x1350
+// DISASM-NEXT:     130f:       callq   0x1330
+// DISASM-NEXT:     1314:       callq   0x1340
 // DISASM-NEXT:     1319:       retq
 // DISASM:     <f2>:
 // DISASM-NEXT:     131a:       retq
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-EMPTY:
 // DISASM-NEXT: <.plt>:
 // DISASM-NEXT:     1320:       pushq   8482(%rip)
 // DISASM-NEXT:     1326:       jmpq    *8484(%rip)
 // DISASM-NEXT:     132c:       nopl    (%rax)
 // DISASM-EMPTY:
 // DISASM-NEXT:   <fct2@plt>:
 // DISASM-NEXT:     1330:       jmpq    *8482(%rip)
 // DISASM-NEXT:     1336:       pushq   $0
-// DISASM-NEXT:     133b:       jmp     -32 <.plt>
+// DISASM-NEXT:     133b:       jmp     0x1320 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT:   <f2@plt>:
 // DISASM-NEXT:     1340:       jmpq    *8474(%rip)
 // DISASM-NEXT:     1346:       pushq   $1
-// DISASM-NEXT:     134b:       jmp     -48 <.plt>
+// DISASM-NEXT:     134b:       jmp     0x1320 <.plt>
 // DISASM:      Disassembly of section .iplt:
 // DISASM-EMPTY:
 // DISASM:      <.iplt>:
 // DISASM-NEXT:     1350:       jmpq    *8466(%rip)
 // DISASM-NEXT:     1356:       pushq   $0
-// DISASM-NEXT:     135b:       jmp     -64 <.plt>
+// DISASM-NEXT:     135b:       jmp     0x1320 <.plt>
 
 // CHECK: Relocations [
 // CHECK-NEXT:   Section (5) .rela.dyn {
 // CHECK-NEXT:     0x3468 R_X86_64_IRELATIVE - 0x1308
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section (6) .rela.plt {
 // CHECK-NEXT:     0x3458 R_X86_64_JUMP_SLOT fct2 0x0
 // CHECK-NEXT:     0x3460 R_X86_64_JUMP_SLOT f2 0x0

lld/test/ELF/gnu-ifunc.s

 
 // DISASM: Disassembly of section .text:
 // DISASM-EMPTY:
 // DISASM-NEXT: <foo>:
 // DISASM-NEXT:  201188: {{.*}} retq
 // DISASM:      <bar>:
 // DISASM-NEXT:  201189: {{.*}} retq
 // DISASM:      <_start>:
-// DISASM-NEXT:  20118a: {{.*}} callq 33
-// DISASM-NEXT:  20118f: {{.*}} callq 44
+// DISASM-NEXT:  20118a: {{.*}} callq 0x2011b0
+// DISASM-NEXT:  20118f: {{.*}} callq 0x2011c0
 // DISASM-NEXT:  201194: {{.*}} movl $2097496, %edx
 // DISASM-NEXT:  201199: {{.*}} movl $2097544, %edx
 // DISASM-NEXT:  20119e: {{.*}} movl $2097545, %edx
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .iplt:
 // DISASM-EMPTY:
 // DISASM-NEXT: <.iplt>:
 // DISASM-NEXT:  2011b0: {{.*}} jmpq *4122(%rip)
 // DISASM-NEXT:  2011b6: {{.*}} pushq $0
-// DISASM-NEXT:  2011bb: {{.*}} jmp -2101696
+// DISASM-NEXT:  2011bb: {{.*}} jmp 0x0
 // DISASM-NEXT:  2011c0: {{.*}} jmpq *4114(%rip)
 // DISASM-NEXT:  2011c6: {{.*}} pushq $1
-// DISASM-NEXT:  2011cb: {{.*}} jmp -2101712
+// DISASM-NEXT:  2011cb: {{.*}} jmp 0x0
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret
 
 .type bar STT_GNU_IFUNC

lld/test/ELF/i386-feature-cet.s

 # RUN: llvm-objdump -d --no-show-raw-insn --print-imm-hex %t | FileCheck --check-prefix=DISASM %s
 
 # GOTPLT:      Hex dump of section '.got.plt':
 # GOTPLT-NEXT: 0x004032d0 50224000 00000000 00000000 20124000
 # GOTPLT-NEXT: 0x004032e0 0b124000
 
 # DISASM:      Disassembly of section .text:
 # DISASM:      00401200 <func1>:
-# DISASM-NEXT: 401200:       calll   0x2b <func2+0x401230>
-# DISASM-NEXT: 401205:       calll   0x36 <ifunc>
+# DISASM-NEXT: 401200:       calll   0x401230 <func2+0x401230>
+# DISASM-NEXT: 401205:       calll   0x401240 <ifunc>
 # DISASM-NEXT:               retl
 
 # DISASM:      Disassembly of section .plt:
 # DISASM:      00401210 <.plt>:
 # DISASM-NEXT: 401210:       pushl   0x4032d4
 # DISASM-NEXT:               jmpl    *0x4032d8
 # DISASM-NEXT:               nop
 # DISASM-NEXT:               nop
 # DISASM-NEXT:               nop
 # DISASM-NEXT:               nop
 # DISASM-NEXT:               endbr32
 # DISASM-NEXT:               pushl   $0x0
-# DISASM-NEXT:               jmp     -0x1e <.plt>
+# DISASM-NEXT:               jmp     0x401210 <.plt>
 # DISASM-NEXT:               nop
 
 # DISASM:      Disassembly of section .plt.sec:
 # DISASM:      00401230 <.plt.sec>:
 # DISASM-NEXT: 401230:       endbr32
 # DISASM-NEXT:               jmpl    *0x4032dc
 # DISASM-NEXT:               nopw    (%eax,%eax)
 

lld/test/ELF/i386-plt.s

 // CHECK-NEXT:     0x403288 R_386_JUMP_SLOT zed 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // DISASM:       <local>:
 // DISASM-NEXT:  4011bc:
 // DISASM-NEXT:  4011be:
 // DISASM:       <_start>:
-// DISASM-NEXT: 4011c0:       jmp 0x2b <bar@plt>
-// DISASM-NEXT: 4011c5:       jmp 0x26 <bar@plt>
-// DISASM-NEXT: 4011ca:       jmp 0x31 <zed@plt>
-// DISASM-NEXT: 4011cf:       jmp -0x18 <local>
+// DISASM-NEXT: 4011c0:       jmp 0x4011f0 <bar@plt>
+// DISASM-NEXT: 4011c5:       jmp 0x4011f0 <bar@plt>
+// DISASM-NEXT: 4011ca:       jmp 0x401200 <zed@plt>
+// DISASM-NEXT: 4011cf:       jmp 0x4011bc <local>
 
 // DISASM:      Disassembly of section .plt:
 // DISASM-EMPTY:
 // DISASM-NEXT: <.plt>:
 /// Push .got.plt[1], then jump to .got.plt[2]
 // DISASM-NEXT: 4011e0:       pushl 0x40327c
 // DISASM-NEXT:               jmpl *0x403280
 // DISASM-NEXT:               nop
 // DISASM-NEXT:               nop
 // DISASM-NEXT:               nop
 // DISASM-NEXT:               nop
 // DISASM-EMPTY:
 // DISASM-NEXT: <bar@plt>:
 /// .got.plt[3] = 0x403278 + 12 = 0x403284
 // DISASM-NEXT: 4011f0:       jmpl *0x403284
 // DISASM-NEXT:               pushl $0x0
-// DISASM-NEXT:               jmp -0x20 <.plt>
+// DISASM-NEXT:               jmp 0x4011e0 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT: <zed@plt>:
 /// .got.plt[4] = 0x403278 + 16 = 0x403288
 // DISASM-NEXT: 401200:       jmpl *0x403288
 // DISASM-NEXT:               pushl $0x8
-// DISASM-NEXT:               jmp -0x30 <.plt>
+// DISASM-NEXT:               jmp 0x4011e0 <.plt>
 
 // CHECKSHARED:        Name: .plt
 // CHECKSHARED-NEXT:   Type: SHT_PROGBITS
 // CHECKSHARED-NEXT:   Flags [
 // CHECKSHARED-NEXT:     SHF_ALLOC
 // CHECKSHARED-NEXT:     SHF_EXECINSTR
 // CHECKSHARED-NEXT:   ]
 // CHECKSHARED-NEXT:   Address: 0x1200

 // CHECKSHARED-NEXT:       0x32A0 R_386_JUMP_SLOT zed 0x0
 // CHECKSHARED-NEXT:     }
 // CHECKSHARED-NEXT:   ]
 
 // DISASMSHARED:      <local>:
 // DISASMSHARED-NEXT: 11e0:
 // DISASMSHARED-NEXT: 11e2:
 // DISASMSHARED:      <_start>:
-// DISASMSHARED-NEXT: 11e4:       jmp 39 <bar@plt>
-// DISASMSHARED-NEXT:             jmp 34 <bar@plt>
-// DISASMSHARED-NEXT:             jmp 45 <zed@plt>
-// DISASMSHARED-NEXT:             jmp -24 <local>
+// DISASMSHARED-NEXT: 11e4:       jmp 0x1210 <bar@plt>
+// DISASMSHARED-NEXT:             jmp 0x1210 <bar@plt>
+// DISASMSHARED-NEXT:             jmp 0x1220 <zed@plt>
+// DISASMSHARED-NEXT:             jmp 0x11e0 <local>
 // DISASMSHARED-EMPTY:
 // DISASMSHARED-NEXT: Disassembly of section .plt:
 // DISASMSHARED-EMPTY:
 // DISASMSHARED-NEXT: <.plt>:
 // DISASMSHARED-NEXT: 1200:       pushl 4(%ebx)
 // DISASMSHARED-NEXT:             jmpl *8(%ebx)
 // DISASMSHARED-NEXT:             nop
 // DISASMSHARED-NEXT:             nop
 // DISASMSHARED-NEXT:             nop
 // DISASMSHARED-NEXT:             nop
 // DISASMSHARED:      <bar@plt>:
 // DISASMSHARED-NEXT: 1210:       jmpl *12(%ebx)
 // DISASMSHARED-NEXT:             pushl $0
-// DISASMSHARED-NEXT:             jmp -32 <.plt>
+// DISASMSHARED-NEXT:             jmp 0x1200 <.plt>
 // DISASMSHARED:      <zed@plt>:
 // DISASMSHARED-NEXT: 1220:       jmpl *16(%ebx)
 // DISASMSHARED-NEXT:             pushl $8
-// DISASMSHARED-NEXT:             jmp -48 <.plt>
+// DISASMSHARED-NEXT:             jmp 0x1200 <.plt>
 
 // DISASMPIE:      Disassembly of section .plt:
 // DISASMPIE-EMPTY:
 // DISASMPIE-NEXT: <.plt>:
 // DISASMPIE-NEXT: 11e0:       pushl 4(%ebx)
 // DISASMPIE-NEXT:             jmpl *8(%ebx)
 // DISASMPIE-NEXT:             nop
 // DISASMPIE-NEXT:             nop
 // DISASMPIE-NEXT:             nop
 // DISASMPIE-NEXT:             nop
 // DISASMPIE-EMPTY:
 // DISASMPIE-NEXT: <bar@plt>:
 // DISASMPIE-NEXT: 11f0:       jmpl *12(%ebx)
 // DISASMPIE-NEXT:             pushl $0
-// DISASMPIE-NEXT:             jmp -32 <.plt>
+// DISASMPIE-NEXT:             jmp 0x11e0 <.plt>
 // DISASMPIE-EMPTY:
 // DISASMPIE-NEXT: <zed@plt>:
 // DISASMPIE-NEXT: 1200:       jmpl *16(%ebx)
 // DISASMPIE-NEXT:             pushl $8
-// DISASMPIE-NEXT:             jmp -48 <.plt>
+// DISASMPIE-NEXT:             jmp 0x11e0 <.plt>
 
 local:
 .long 0
 
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT
   jmp local@plt

lld/test/ELF/i386-reloc-large-addend.s

 // REQUIRES: x86
 // RUN: llvm-mc %s -o %t.o -triple i386-pc-linux-code16 -filetype=obj
 
 // RUN: echo ".global foo; foo = 0x1" > %t1.s
 // RUN: llvm-mc %t1.s -o %t1.o -triple i386-pc-linux -filetype=obj
 
 // RUN: ld.lld -Ttext 0x7000 %t.o %t1.o -o %t
 // RUN: llvm-objdump -d --triple=i386-pc-linux-code16 %t | FileCheck %s
 
 // CHECK:        Disassembly of section .text:
 // CHECK-EMPTY:
 // CHECK-NEXT: <_start>:
-// CHECK-NEXT:     7000:       e9 fe 1f        jmp     8190
+// CHECK-NEXT:     7000:       e9 fe 1f        jmp     0x9001
 //                            0x1 + 0x9000 - 0x7003 == 8190
         .global _start
 _start:
 jmp foo + 0x9000

lld/test/ELF/i386-reloc-range.s

 // REQUIRES: x86
 // RUN: llvm-mc %s -o %t.o -triple i386-pc-linux-code16 -filetype=obj
 
 // RUN: echo ".global foo; foo = 0x10202" > %t1.s
 // RUN: llvm-mc %t1.s -o %t1.o -triple i386-pc-linux -filetype=obj
 // RUN: echo ".global foo; foo = 0x10203" > %t2.s
 // RUN: llvm-mc %t2.s -o %t2.o -triple i386-pc-linux -filetype=obj
 
 // RUN: ld.lld -Ttext 0x200 %t.o %t1.o -o %t1
 // RUN: llvm-objdump -d --no-show-raw-insn --triple=i386-pc-linux-code16 %t1 | FileCheck %s
 
 // CHECK:        Disassembly of section .text:
 // CHECK-EMPTY:
 // CHECK-NEXT: <_start>:
-// CHECK-NEXT:      200:       jmp -1
+// CHECK-NEXT:      200:       jmp 0x202
 //              0x10202 - 0x203 == 0xffff
 
 // RUN: not ld.lld -Ttext 0x200 %t.o %t2.o -o /dev/null 2>&1 | FileCheck --check-prefix=ERR %s
 
 // ERR: {{.*}}:(.text+0x1): relocation R_386_PC16 out of range: 65536 is not in [-65536, 65535]; references foo
 
         .global _start
 _start:
         jmp foo

lld/test/ELF/i386-retpoline-nopic-linkerscript.s

 // RUN: llvm-objdump -d -s --no-show-raw-insn %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-EMPTY:
 // CHECK-NEXT: <.plt>:
 // CHECK-NEXT: 10:       pushl   236
 // CHECK-NEXT: 16:       pushl   %eax
 // CHECK-NEXT: 17:       movl    240, %eax
-// CHECK-NEXT: 1c:       calll   15 <.plt+0x20>
+// CHECK-NEXT: 1c:       calll   0x30 <.plt+0x20>
 // CHECK-NEXT: 21:       pause
 // CHECK-NEXT: 23:       lfence
-// CHECK-NEXT: 26:       jmp     -7 <.plt+0x11>
+// CHECK-NEXT: 26:       jmp     0x21 <.plt+0x11>
 // CHECK-NEXT: 28:       int3
 // CHECK-NEXT: 29:       int3
 // CHECK-NEXT: 2a:       int3
 // CHECK-NEXT: 2b:       int3
 // CHECK-NEXT: 2c:       int3
 // CHECK-NEXT: 2d:       int3
 // CHECK-NEXT: 2e:       int3
 // CHECK-NEXT: 2f:       int3
 // CHECK-NEXT: 30:       movl    %ecx, (%esp)
 // CHECK-NEXT: 33:       movl    4(%esp), %ecx
 // CHECK-NEXT: 37:       movl    %eax, 4(%esp)
 // CHECK-NEXT: 3b:       movl    %ecx, %eax
 // CHECK-NEXT: 3d:       popl    %ecx
 // CHECK-NEXT: 3e:       retl
 // CHECK-NEXT: 3f:       int3
 // CHECK-NEXT: 40:       pushl   %eax
 // CHECK-NEXT: 41:       movl    244, %eax
-// CHECK-NEXT: 46:       calll   -27 <.plt+0x20>
-// CHECK-NEXT: 4b:       jmp     -47 <.plt+0x11>
+// CHECK-NEXT: 46:       calll   0x30 <.plt+0x20>
+// CHECK-NEXT: 4b:       jmp     0x21 <.plt+0x11>
 // CHECK-NEXT: 50:       pushl   $0
-// CHECK-NEXT: 55:       jmp     -74 <.plt>
+// CHECK-NEXT: 55:       jmp     0x10 <.plt>
 // CHECK-NEXT: 5a:       int3
 // CHECK-NEXT: 5b:       int3
 // CHECK-NEXT: 5c:       int3
 // CHECK-NEXT: 5d:       int3
 // CHECK-NEXT: 5e:       int3
 // CHECK-NEXT: 5f:       int3
 // CHECK-NEXT: 60:       pushl   %eax
 // CHECK-NEXT: 61:       movl    248, %eax
-// CHECK-NEXT: 66:       calll   -59 <.plt+0x20>
-// CHECK-NEXT: 6b:       jmp     -79 <.plt+0x11>
+// CHECK-NEXT: 66:       calll   0x30 <.plt+0x20>
+// CHECK-NEXT: 6b:       jmp     0x21 <.plt+0x11>
 // CHECK-NEXT: 70:       pushl   $8
-// CHECK-NEXT: 75:       jmp     -106 <.plt>
+// CHECK-NEXT: 75:       jmp     0x10 <.plt>
 // CHECK-NEXT: 7a:       int3
 // CHECK-NEXT: 7b:       int3
 // CHECK-NEXT: 7c:       int3
 // CHECK-NEXT: 7d:       int3
 // CHECK-NEXT: 7e:       int3
 // CHECK-NEXT: 7f:       int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/test/ELF/i386-retpoline-nopic.s

 // CHECK-NEXT: 30124000
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-EMPTY:
 // CHECK-NEXT: <.plt>:
 // CHECK-NEXT: 4011d0:       pushl   4207276
 // CHECK-NEXT: 4011d6:       pushl   %eax
 // CHECK-NEXT: 4011d7:       movl    4207280, %eax
-// CHECK-NEXT: 4011dc:       calll   15 <.plt+0x20>
+// CHECK-NEXT: 4011dc:       calll   0x4011f0 <.plt+0x20>
 // CHECK-NEXT: 4011e1:       pause
 // CHECK-NEXT: 4011e3:       lfence
-// CHECK-NEXT: 4011e6:       jmp     -7 <.plt+0x11>
+// CHECK-NEXT: 4011e6:       jmp     0x4011e1 <.plt+0x11>
 // CHECK-NEXT: 4011e8:       int3
 // CHECK-NEXT: 4011e9:       int3
 // CHECK-NEXT: 4011ea:       int3
 // CHECK-NEXT: 4011eb:       int3
 // CHECK-NEXT: 4011ec:       int3
 // CHECK-NEXT: 4011ed:       int3
 // CHECK-NEXT: 4011ee:       int3
 // CHECK-NEXT: 4011ef:       int3
 // CHECK-NEXT: 4011f0:       movl    %ecx, (%esp)
 // CHECK-NEXT: 4011f3:       movl    4(%esp), %ecx
 // CHECK-NEXT: 4011f7:       movl    %eax, 4(%esp)
 // CHECK-NEXT: 4011fb:       movl    %ecx, %eax
 // CHECK-NEXT: 4011fd:       popl    %ecx
 // CHECK-NEXT: 4011fe:       retl
 // CHECK-NEXT: 4011ff:       int3
 // CHECK-NEXT: 401200:       pushl   %eax
 // CHECK-NEXT: 401201:       movl    4207284, %eax
-// CHECK-NEXT: 401206:       calll   -27 <.plt+0x20>
-// CHECK-NEXT: 40120b:       jmp     -47 <.plt+0x11>
+// CHECK-NEXT: 401206:       calll   0x4011f0 <.plt+0x20>
+// CHECK-NEXT: 40120b:       jmp     0x4011e1 <.plt+0x11>
 // CHECK-NEXT: 401210:       pushl   $0
-// CHECK-NEXT: 401215:       jmp     -74 <.plt>
+// CHECK-NEXT: 401215:       jmp     0x4011d0 <.plt>
 // CHECK-NEXT: 40121a:       int3
 // CHECK-NEXT: 40121b:       int3
 // CHECK-NEXT: 40121c:       int3
 // CHECK-NEXT: 40121d:       int3
 // CHECK-NEXT: 40121e:       int3
 // CHECK-NEXT: 40121f:       int3
 // CHECK-NEXT: 401220:       pushl   %eax
 // CHECK-NEXT: 401221:       movl    4207288, %eax
-// CHECK-NEXT: 401226:       calll   -59 <.plt+0x20>
-// CHECK-NEXT: 40122b:       jmp     -79 <.plt+0x11>
+// CHECK-NEXT: 401226:       calll   0x4011f0 <.plt+0x20>
+// CHECK-NEXT: 40122b:       jmp     0x4011e1 <.plt+0x11>
 // CHECK-NEXT: 401230:       pushl   $8
-// CHECK-NEXT: 401235:       jmp     -106 <.plt>
+// CHECK-NEXT: 401235:       jmp     0x4011d0 <.plt>
 // CHECK-NEXT: 40123a:       int3
 // CHECK-NEXT: 40123b:       int3
 // CHECK-NEXT: 40123c:       int3
 // CHECK-NEXT: 40123d:       int3
 // CHECK-NEXT: 40123e:       int3
 // CHECK-NEXT: 40123f:       int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/test/ELF/i386-retpoline-pic-linkerscript.s

 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-EMPTY:
 // CHECK-NEXT: <.plt>:
 // CHECK-NEXT: 10:       ff b3 04 00 00 00       pushl   4(%ebx)
 // CHECK-NEXT: 16:       50      pushl   %eax
 // CHECK-NEXT: 17:       8b 83 08 00 00 00 movl    8(%ebx), %eax
-// CHECK-NEXT: 1d:       e8 0e 00 00 00  calll   14 <.plt+0x20>
+// CHECK-NEXT: 1d:       e8 0e 00 00 00  calll   0x30 <.plt+0x20>
 // CHECK-NEXT: 22:       f3 90   pause
 // CHECK-NEXT: 24:       0f ae e8        lfence
-// CHECK-NEXT: 27:       eb f9   jmp     -7 <.plt+0x12>
+// CHECK-NEXT: 27:       eb f9   jmp     0x22 <.plt+0x12>
 // CHECK-NEXT: 29:       cc      int3
 // CHECK-NEXT: 2a:       cc      int3
 // CHECK-NEXT: 2b:       cc      int3
 // CHECK-NEXT: 2c:       cc      int3
 // CHECK-NEXT: 2d:       cc      int3
 // CHECK-NEXT: 2e:       cc      int3
 // CHECK-NEXT: 2f:       cc      int3
 // CHECK-NEXT: 30:       89 0c 24        movl    %ecx, (%esp)
 // CHECK-NEXT: 33:       8b 4c 24 04     movl    4(%esp), %ecx
 // CHECK-NEXT: 37:       89 44 24 04     movl    %eax, 4(%esp)
 // CHECK-NEXT: 3b:       89 c8   movl    %ecx, %eax
 // CHECK-NEXT: 3d:       59      popl    %ecx
 // CHECK-NEXT: 3e:       c3      retl
 // CHECK-NEXT: 3f:       cc      int3
 // CHECK-NEXT: 40:       50      pushl   %eax
 // CHECK-NEXT: 41:       8b 83 0c 00 00 00       movl    12(%ebx), %eax
-// CHECK-NEXT: 47:       e8 e4 ff ff ff  calll   -28 <.plt+0x20>
-// CHECK-NEXT: 4c:       e9 d1 ff ff ff  jmp     -47 <.plt+0x12>
+// CHECK-NEXT: 47:       e8 e4 ff ff ff  calll   0x30 <.plt+0x20>
+// CHECK-NEXT: 4c:       e9 d1 ff ff ff  jmp     0x22 <.plt+0x12>
 // CHECK-NEXT: 51:       68 00 00 00 00  pushl   $0
-// CHECK-NEXT: 56:       e9 b5 ff ff ff  jmp     -75 <.plt>
+// CHECK-NEXT: 56:       e9 b5 ff ff ff  jmp     0x10 <.plt>
 // CHECK-NEXT: 5b:       cc      int3
 // CHECK-NEXT: 5c:       cc      int3
 // CHECK-NEXT: 5d:       cc      int3
 // CHECK-NEXT: 5e:       cc      int3
 // CHECK-NEXT: 5f:       cc      int3
 // CHECK-NEXT: 60:       50      pushl   %eax
 // CHECK-NEXT: 61:       8b 83 10 00 00 00       movl    16(%ebx), %eax
-// CHECK-NEXT: 67:       e8 c4 ff ff ff  calll   -60 <.plt+0x20>
-// CHECK-NEXT: 6c:       e9 b1 ff ff ff  jmp     -79 <.plt+0x12>
+// CHECK-NEXT: 67:       e8 c4 ff ff ff  calll   0x30 <.plt+0x20>
+// CHECK-NEXT: 6c:       e9 b1 ff ff ff  jmp     0x22 <.plt+0x12>
 // CHECK-NEXT: 71:       68 08 00 00 00  pushl   $8
-// CHECK-NEXT: 76:       e9 95 ff ff ff  jmp     -107 <.plt>
+// CHECK-NEXT: 76:       e9 95 ff ff ff  jmp     0x10 <.plt>
 // CHECK-NEXT: 7b:       cc      int3
 // CHECK-NEXT: 7c:       cc      int3
 // CHECK-NEXT: 7d:       cc      int3
 // CHECK-NEXT: 7e:       cc      int3
 // CHECK-NEXT: 7f:       cc      int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/test/ELF/i386-retpoline-pic.s

 // CHECK-NEXT: 32b8 31120000
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-EMPTY:
 // CHECK-NEXT: <.plt>:
 // CHECK-NEXT: 11d0:       pushl   4(%ebx)
 // CHECK-NEXT: 11d6:       pushl   %eax
 // CHECK-NEXT: 11d7:       movl    8(%ebx), %eax
-// CHECK-NEXT: 11dd:       calll   14 <.plt+0x20>
+// CHECK-NEXT: 11dd:       calll   0x11f0 <.plt+0x20>
 // CHECK-NEXT: 11e2:       pause
 // CHECK-NEXT: 11e4:       lfence
-// CHECK-NEXT: 11e7:       jmp     -7 <.plt+0x12>
+// CHECK-NEXT: 11e7:       jmp     0x11e2 <.plt+0x12>
 // CHECK-NEXT: 11e9:       int3
 // CHECK-NEXT: 11ea:       int3
 // CHECK-NEXT: 11eb:       int3
 // CHECK-NEXT: 11ec:       int3
 // CHECK-NEXT: 11ed:       int3
 // CHECK-NEXT: 11ee:       int3
 // CHECK-NEXT: 11ef:       int3
 // CHECK-NEXT: 11f0:       movl    %ecx, (%esp)
 // CHECK-NEXT: 11f3:       movl    4(%esp), %ecx
 // CHECK-NEXT: 11f7:       movl    %eax, 4(%esp)
 // CHECK-NEXT: 11fb:       movl    %ecx, %eax
 // CHECK-NEXT: 11fd:       popl    %ecx
 // CHECK-NEXT: 11fe:       retl
 // CHECK-NEXT: 11ff:       int3
 // CHECK-NEXT: 1200:       pushl   %eax
 // CHECK-NEXT: 1201:       movl    12(%ebx), %eax
-// CHECK-NEXT: 1207:       calll   -28 <.plt+0x20>
-// CHECK-NEXT: 120c:       jmp     -47 <.plt+0x12>
+// CHECK-NEXT: 1207:       calll   0x11f0 <.plt+0x20>
+// CHECK-NEXT: 120c:       jmp     0x11e2 <.plt+0x12>
 // CHECK-NEXT: 1211:       pushl   $0
-// CHECK-NEXT: 1216:       jmp     -75 <.plt>
+// CHECK-NEXT: 1216:       jmp     0x11d0 <.plt>
 // CHECK-NEXT: 121b:       int3
 // CHECK-NEXT: 121c:       int3
 // CHECK-NEXT: 121d:       int3
 // CHECK-NEXT: 121e:       int3
 // CHECK-NEXT: 121f:       int3
 // CHECK-NEXT: 1220:       pushl   %eax
 // CHECK-NEXT: 1221:       movl    16(%ebx), %eax
-// CHECK-NEXT: 1227:       calll   -60 <.plt+0x20>
-// CHECK-NEXT: 122c:       jmp     -79 <.plt+0x12>
+// CHECK-NEXT: 1227:       calll   0x11f0 <.plt+0x20>
+// CHECK-NEXT: 122c:       jmp     0x11e2 <.plt+0x12>
 // CHECK-NEXT: 1231:       pushl   $8
-// CHECK-NEXT: 1236:       jmp     -107 <.plt>
+// CHECK-NEXT: 1236:       jmp     0x11d0 <.plt>
 // CHECK-NEXT: 123b:       int3
 // CHECK-NEXT: 123c:       int3
 // CHECK-NEXT: 123d:       int3
 // CHECK-NEXT: 123e:       int3
 // CHECK-NEXT: 123f:       int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/test/ELF/i386-tls-dynamic.s

 
 # DIS:      Disassembly of section .text:
 # DIS-EMPTY:
 # DIS-NEXT: <_start>:
 ## General dynamic model:
 ## -4128 and -4120 are first and second GOT entries offsets.
 ## Each one is a pair of records.
 # DIS-NEXT: 1260:       leal -4128(,%ebx), %eax
-# DIS-NEXT: 1267:       calll 100
+# DIS-NEXT: 1267:       calll 0x12d0
 # DIS-NEXT: 126c:       leal -4120(,%ebx), %eax
-# DIS-NEXT: 1273:       calll 88
+# DIS-NEXT: 1273:       calll 0x12d0
 ## Local dynamic model:
 ## -16 is a local module tls index offset.
 # DIS-NEXT: 1278:       leal -4112(%ebx), %eax
-# DIS-NEXT: 127e:       calll 77
+# DIS-NEXT: 127e:       calll 0x12d0
 # DIS-NEXT: 1283:       leal 8(%eax), %edx
 # DIS-NEXT: 1289:       leal -4112(%ebx), %eax
-# DIS-NEXT: 128f:       calll 60
+# DIS-NEXT: 128f:       calll 0x12d0
 # DIS-NEXT: 1294:       leal 12(%eax), %edx
 ## Initial exec model:
 # DIS-NEXT: 129a:       movl %gs:0, %eax
 # DIS-NEXT: 12a0:       addl -4104(%ebx), %eax
 # DIS-NEXT: 12a6:       movl %gs:0, %eax
 # DIS-NEXT: 12ac:       addl -4100(%ebx), %eax

lld/test/ELF/local-got-pie.s

  .global foo
 foo:
  nop
 
 // 0x22C8 - 0x1210 - 5 = 4275
 // DISASM:      Disassembly of section .text:
 // DISASM-EMPTY:
 // DISASM-NEXT: <_start>:
-// DISASM-NEXT:   1210: {{.*}} callq 4275
+// DISASM-NEXT:   1210: {{.*}} callq 0x22c8
 // DISASM:      <foo>:
 // DISASM-NEXT:   1215: {{.*}} nop
 
 // CHECK:      Name: .got
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE

lld/test/ELF/local-got-shared.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: ld.lld %t.o -o %t -shared
 // RUN: llvm-readobj -S -d -r %t | FileCheck %s
 // RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck --check-prefix=DISASM %s
 
 bar:
   call foo@gotpcrel
 
         .hidden foo
         .global foo
 foo:
         nop
 
 // 0x22E0 - 0x1228 - 5 = 4275
 // DISASM:      <bar>:
-// DISASM-NEXT:   1228:       callq 4275
+// DISASM-NEXT:   1228:       callq 0x22e0
 
 // DISASM:      <foo>:
 // DISASM-NEXT:   122d:       nop
 
 // CHECK:      Name: .got
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC

lld/test/ELF/local-got.s

call foo@gotpcrel
 
         .global foo
 foo:
         nop
 
 // 0x202320 - 0x201250 - 5 =  4299
 // 0x202328 - 0x201255 - 5 =  4302
 // DISASM:      <_start>:
-// DISASM-NEXT:   201250:       callq 4299
-// DISASM-NEXT:   201255:       callq 4302
+// DISASM-NEXT:   201250:       callq 0x202320
+// DISASM-NEXT:   201255:       callq 0x202328
 
 // DISASM:      <foo>:
 // DISASM-NEXT:   20125a:       nop
 
 // CHECK:      Name: .got
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC

lld/test/ELF/lto/linker-script-symbols-ipo.ll

 
 ;; Check that LTO does not do IPO for symbols assigned by script.
 ; RUN: ld.lld %t1.o %t2.o -o %t4 --script %t.script -save-temps
 ; RUN: llvm-objdump -d %t4 | FileCheck %s --check-prefix=NOIPO
 ; NOIPO:      Disassembly of section .text:
 ; NOIPO:      <foo>:
 ; NOIPO-NEXT:   movl $2, %eax
 ; NOIPO:      <_start>:
-; NOIPO-NEXT:   jmp -21 <foo>
+; NOIPO-NEXT:   jmp 0x201160 <foo>
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define i32 @bar() {
   ret i32 1
 }
 
 define i32 @foo() {
   ret i32 2
 }

lld/test/ELF/no-inhibit-exec.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: not ld.lld %t -o /dev/null
 # RUN: ld.lld %t --noinhibit-exec -o %t2
 # RUN: llvm-objdump -d %t2 | FileCheck %s
 # RUN: llvm-readobj -r %t2 | FileCheck %s --check-prefix=RELOC
 
 # CHECK: Disassembly of section .text:
 # CHECK-EMPTY:
 # CHECK-NEXT: _start
-# CHECK-NEXT: 201120: {{.*}} callq -2101541
+# CHECK-NEXT: 201120: {{.*}} callq 0x0
 
 # RELOC:      Relocations [
 # RELOC-NEXT: ]
 
 # next code will not link without noinhibit-exec flag
 # because of undefined symbol _bar
 .globl _start
 _start:
   call _bar

lld/test/ELF/pre_init_fini_array_missing.s

 // With no .init_array section the symbols resolve to .text.
 // 0x201120 - (0x201120 + 5) = -5
 // 0x201120 - (0x201125 + 5) = -10
 // ...
 
 // CHECK: Disassembly of section .text:
 // CHECK-EMPTY:
 // CHECK-NEXT:  <_start>:
-// CHECK-NEXT:   201120:       callq    -5
-// CHECK-NEXT:                 callq    -10
-// CHECK-NEXT:                 callq    -15
-// CHECK-NEXT:                 callq    -20
-// CHECK-NEXT:                 callq    -25
-// CHECK-NEXT:                 callq    -30
+// CHECK-NEXT:   201120:       callq    0x201120
+// CHECK-NEXT:                 callq    0x201120
+// CHECK-NEXT:                 callq    0x201120
+// CHECK-NEXT:                 callq    0x201120
+// CHECK-NEXT:                 callq    0x201120
+// CHECK-NEXT:                 callq    0x201120
 
 // In position-independent binaries, they resolve to .text too.
 
 // PIE:      Disassembly of section .text:
 // PIE-EMPTY:
 // PIE-NEXT: <_start>:
-// PIE-NEXT:     1210:       callq   -5
-// PIE-NEXT:                 callq   -10
-// PIE-NEXT:                 callq   -15
-// PIE-NEXT:                 callq   -20
-// PIE-NEXT:                 callq   -25
-// PIE-NEXT:                 callq   -30
+// PIE-NEXT:     1210:       callq   0x1210
+// PIE-NEXT:                 callq   0x1210
+// PIE-NEXT:                 callq   0x1210
+// PIE-NEXT:                 callq   0x1210
+// PIE-NEXT:                 callq   0x1210
+// PIE-NEXT:                 callq   0x1210

lld/test/ELF/relocation-i686.s

 // CHECK: Disassembly of section .R_386_32:
 // CHECK-EMPTY:
 // CHECK-NEXT: <R_386_32>:
 // CHECK-NEXT:   movl $4198829, %edx
 
 // CHECK: Disassembly of section .R_386_PC32:
 // CHECK-EMPTY:
 // CHECK-NEXT: <R_386_PC32>:
-// CHECK-NEXT:   calll 4
+// CHECK-NEXT:   calll 0x4011ba
 
 // CHECK:      <R_386_PC32_2>:
 // CHECK-NEXT:   nop
 
 // Create a .got
 movl bar@GOT, %eax
 
 // ADDR:      Name: .plt

 // CHECK-NEXT:   4011c0:       movl  $8384, %eax
 
 .section .dynamic_reloc, "ax",@progbits
  call bar
 // .plt + 16 - (0x4011c5 + 5) = 0x4011e0 + 16 - 0x4011ca = 38
 // CHECK:      Disassembly of section .dynamic_reloc:
 // CHECK-EMPTY:
 // CHECK-NEXT: <.dynamic_reloc>:
-// CHECK-NEXT:   4011c5:       calll 38 <bar@plt>
+// CHECK-NEXT:   4011c5:       calll 0x4011f0 <bar@plt>
 
 .section .R_386_GOT32,"ax",@progbits
 .global R_386_GOT32
 R_386_GOT32:
  movl bar@GOT, %eax
  movl zed@GOT, %eax
  movl bar+8@GOT, %eax
  movl zed+4@GOT, %eax

lld/test/ELF/relocation.s

 .zero 4
 .global lulz
 lulz:
   nop
 
 // CHECK: Disassembly of section .text:
 // CHECK-EMPTY:
 // CHECK-NEXT: <_start>:
-// CHECK-NEXT:   201310:  e8 04 00 00 00   callq 4
+// CHECK-NEXT:   201310:  e8 04 00 00 00   callq 0x201319
 // CHECK-NEXT:   201315:
 
 // CHECK:      <lulz>:
 // CHECK-NEXT:   201319:  90  nop
 
 
 .section       .text2,"ax",@progbits
 .global R_X86_64_32

 R_X86_64_PC32:
  call bar
  movl $bar, %eax
 //16 is a size of PLT[0]
 // 0x201340 + 16 - (0x201327 + 5) = 36
 // CHECK:      Disassembly of section .R_X86_64_PC32:
 // CHECK-EMPTY:
 // CHECK-NEXT: <R_X86_64_PC32>:
-// CHECK-NEXT:  201327:   {{.*}}  callq  36
+// CHECK-NEXT:  201327:   {{.*}}  callq  0x201350
 // CHECK-NEXT:  20132c:   {{.*}}  movl $2102096, %eax
 
 .section .R_X86_64_32S_2,"ax",@progbits
 .global R_X86_64_32S_2
 R_X86_64_32S_2:
   mov bar2, %eax
 // plt is  at 0x201340. The second plt entry is at 0x201360 == 2102112
 // CHECK:      Disassembly of section .R_X86_64_32S_2:
 // CHECK-EMPTY:
 // CHECK-NEXT: <R_X86_64_32S_2>:
 // CHECK-NEXT: 201331: {{.*}}  movl    2102112, %eax

lld/test/ELF/startstop.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 // RUN: ld.lld %t -o %t.so -shared
 // RUN: llvm-objdump -d --no-show-raw-insn %t.so | FileCheck --check-prefix=DISASM %s
 // RUN: llvm-readobj --symbols -r %t.so | FileCheck -check-prefix=SYMBOL %s
 
 // DISASM: <_start>:
-// DISASM:    1330:       callq   10 <__start_foo>
-// DISASM:    1335:       callq   8 <__start_bar>
-// DISASM:    133a:       callq   3 <__start_bar>
+// DISASM:    1330:       callq   0x133f <__start_foo>
+// DISASM:    1335:       callq   0x1342 <__start_bar>
+// DISASM:    133a:       callq   0x1342 <__start_bar>
 // DISASM: Disassembly of section foo:
 // DISASM-EMPTY:
 // DISASM: <__start_foo>:
 // DISASM:    133f:       nop
 // DISASM:                nop
 // DISASM:                nop
 // DISASM: Disassembly of section bar:
 // DISASM-EMPTY:

lld/test/ELF/x86-64-feature-cet.s

 
 # GOTPLT:      Hex dump of section '.got.plt':
 # GOTPLT-NEXT: 203480 80232000 00000000 00000000 00000000
 # GOTPLT-NEXT: 203490 00000000 00000000 50132000 00000000
 # GOTPLT-NEXT: 2034a0 00000000 00000000
 
 # DISASM:      Disassembly of section .text:
 # DISASM:      0000000000201330 <func1>:
-# DISASM-NEXT: 201330:       callq   0x2b <func2+0x201360>
-# DISASM-NEXT: 201335:       callq   0x36 <func2+0x201370>
+# DISASM-NEXT: 201330:       callq   0x201360 <func2+0x201360>
+# DISASM-NEXT: 201335:       callq   0x201370 <func2+0x201370>
 # DISASM-NEXT:               retq
 
 # DISASM:      Disassembly of section .plt:
 # DISASM:      0000000000201340 <.plt>:
 # DISASM-NEXT: 201340:       pushq   0x2142(%rip)
 # DISASM-NEXT:               jmpq    *0x2144(%rip)
 # DISASM-NEXT:               nopl    (%rax)
 # DISASM-NEXT:               endbr64
 # DISASM-NEXT:               pushq   $0x0
-# DISASM-NEXT:               jmp     -0x1e <.plt>
+# DISASM-NEXT:               jmp     0x201340 <.plt>
 # DISASM-NEXT:               nop
 
 # DISASM:      Disassembly of section .plt.sec:
 # DISASM:      0000000000201360 <.plt.sec>:
 # DISASM-NEXT: 201360:       endbr64
 # DISASM-NEXT:               jmpq    *0x212e(%rip)
 # DISASM-NEXT:               nopw    (%rax,%rax)
 

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

 # DISASM-NEXT: movq 4234(%rip), %rax
 # DISASM-NEXT: movq 4227(%rip), %rax
 # DISASM-NEXT: leaq -52(%rip), %rax
 # DISASM-NEXT: leaq -59(%rip), %rax
 # DISASM-NEXT: leaq -65(%rip), %rax
 # DISASM-NEXT: leaq -72(%rip), %rax
 # DISASM-NEXT: movq 4192(%rip), %rax
 # DISASM-NEXT: movq 4185(%rip), %rax
-# DISASM-NEXT: callq -93 <foo>
-# DISASM-NEXT: callq -99 <foo>
-# DISASM-NEXT: callq -104 <hid>
-# DISASM-NEXT: callq -110 <hid>
+# DISASM-NEXT: callq 0x201170 <foo>
+# DISASM-NEXT: callq 0x201170 <foo>
+# DISASM-NEXT: callq 0x201171 <hid>
+# DISASM-NEXT: callq 0x201171 <hid>
 # DISASM-NEXT: callq *4155(%rip)
 # DISASM-NEXT: callq *4149(%rip)
-# DISASM-NEXT: jmp   -128 <foo>
+# DISASM-NEXT: jmp   0x201170 <foo>
 # DISASM-NEXT: nop
-# DISASM-NEXT: jmp   -134 <foo>
+# DISASM-NEXT: jmp   0x201170 <foo>
 # DISASM-NEXT: nop
-# DISASM-NEXT: jmp   -139 <hid>
+# DISASM-NEXT: jmp   0x201171 <hid>
 # DISASM-NEXT: nop
-# DISASM-NEXT: jmp   -145 <hid>
+# DISASM-NEXT: jmp   0x201171 <hid>
 # DISASM-NEXT: nop
 # DISASM-NEXT: jmpq  *4119(%rip)
 # DISASM-NEXT: jmpq  *4113(%rip)
 
 .text
 .globl foo
 .type foo, @function
 foo:

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

 // DISASM-NEXT: <.plt>:
 // DISASM-NEXT:   1320:       pushq 8450(%rip)
 // DISASM-NEXT:               jmpq *8452(%rip)
 // DISASM-NEXT:               nopl (%rax)
 // DISASM-EMPTY:
 // DISASM-NEXT:   <bar@plt>:
 // DISASM-NEXT:   1330:       jmpq *8450(%rip)
 // DISASM-NEXT:               pushq $0
-// DISASM-NEXT:               jmp -32 <.plt>
+// DISASM-NEXT:               jmp 0x1320 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT:   <zed@plt>:
 // DISASM-NEXT:   1340:       jmpq *8442(%rip)
 // DISASM-NEXT:               pushq $1
-// DISASM-NEXT:               jmp -48 <.plt>
+// DISASM-NEXT:               jmp 0x1320 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT:   <_start@plt>:
 // DISASM-NEXT:   1350:       jmpq *8434(%rip)
 // DISASM-NEXT:               pushq $2
-// DISASM-NEXT:               jmp -64 <.plt>
+// DISASM-NEXT:               jmp 0x1320 <.plt>
 
 // 0x201030 - (0x201000 + 1) - 4 = 43
 // 0x201030 - (0x201005 + 1) - 4 = 38
 // 0x201040 - (0x20100a + 1) - 4 = 49
 // 0x201000 - (0x20100f + 1) - 4 = -20
 
 // DISASM2:      <_start>:
-// DISASM2-NEXT:   jmp  43 <bar@plt>
-// DISASM2-NEXT:   jmp  38 <bar@plt>
-// DISASM2-NEXT:   jmp  49 <zed@plt>
-// DISASM2-NEXT:   jmp  -20 <_start>
+// DISASM2-NEXT:   jmp  0x2012f0 <bar@plt>
+// DISASM2-NEXT:   jmp  0x2012f0 <bar@plt>
+// DISASM2-NEXT:   jmp  0x201300 <zed@plt>
+// DISASM2-NEXT:   jmp  0x2012c0 <_start>
 
 // 0x202018 - 0x201036  = 4066
 // 0x202020 - 0x201046  = 4058
 
 // DISASM2:      Disassembly of section .plt:
 // DISASM2-EMPTY:
 // DISASM2-NEXT: <.plt>:
 // DISASM2-NEXT:  2012e0:       pushq 8450(%rip)
 // DISASM2-NEXT:                jmpq *8452(%rip)
 // DISASM2-NEXT:                nopl  (%rax)
 // DISASM2-EMPTY:
 // DISASM2-NEXT: <bar@plt>:
 // DISASM2-NEXT:  2012f0:       jmpq *8450(%rip)
 // DISASM2-NEXT:                pushq $0
-// DISASM2-NEXT:                jmp -32 <.plt>
+// DISASM2-NEXT:                jmp 0x2012e0 <.plt>
 // DISASM2-EMPTY:
 // DISASM2-NEXT: <zed@plt>:
 // DISASM2-NEXT:  201300:       jmpq *8442(%rip)
 // DISASM2-NEXT:                pushq $1
-// DISASM2-NEXT:                jmp -48 <.plt>
+// DISASM2-NEXT:                jmp 0x2012e0 <.plt>
 // DISASM2-NOT:   {{.}}
 
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT
   jmp _start@plt

lld/test/ELF/x86-64-retpoline-linkerscript.s

 // RUN: ld.lld -shared %t1.o %t2.so -o %t.exe -z retpolineplt --script %t.script
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-EMPTY:
 // CHECK-NEXT: <.plt>:
 // CHECK-NEXT: 10:       ff 35 32 01 00 00       pushq   306(%rip)
 // CHECK-NEXT: 16:       4c 8b 1d 33 01 00 00    movq    307(%rip), %r11
-// CHECK-NEXT: 1d:       e8 0e 00 00 00  callq   14 <.plt+0x20>
+// CHECK-NEXT: 1d:       e8 0e 00 00 00  callq   0x30 <.plt+0x20>
 // CHECK-NEXT: 22:       f3 90   pause
 // CHECK-NEXT: 24:       0f ae e8        lfence
-// CHECK-NEXT: 27:       eb f9   jmp     -7 <.plt+0x12>
+// CHECK-NEXT: 27:       eb f9   jmp     0x22 <.plt+0x12>
 // CHECK-NEXT: 29:       cc      int3
 // CHECK-NEXT: 2a:       cc      int3
 // CHECK-NEXT: 2b:       cc      int3
 // CHECK-NEXT: 2c:       cc      int3
 // CHECK-NEXT: 2d:       cc      int3
 // CHECK-NEXT: 2e:       cc      int3
 // CHECK-NEXT: 2f:       cc      int3
 // CHECK-NEXT: 30:       4c 89 1c 24     movq    %r11, (%rsp)
 // CHECK-NEXT: 34:       c3      retq
 // CHECK-NEXT: 35:       cc      int3
 // CHECK-NEXT: 36:       cc      int3
 // CHECK-NEXT: 37:       cc      int3
 // CHECK-NEXT: 38:       cc      int3
 // CHECK-NEXT: 39:       cc      int3
 // CHECK-NEXT: 3a:       cc      int3
 // CHECK-NEXT: 3b:       cc      int3
 // CHECK-NEXT: 3c:       cc      int3
 // CHECK-NEXT: 3d:       cc      int3
 // CHECK-NEXT: 3e:       cc      int3
 // CHECK-NEXT: 3f:       cc      int3
 // CHECK-NEXT: 40:       4c 8b 1d 11 01 00 00    movq    273(%rip), %r11
-// CHECK-NEXT: 47:       e8 e4 ff ff ff  callq   -28 <.plt+0x20>
-// CHECK-NEXT: 4c:       e9 d1 ff ff ff  jmp     -47 <.plt+0x12>
+// CHECK-NEXT: 47:       e8 e4 ff ff ff  callq   0x30 <.plt+0x20>
+// CHECK-NEXT: 4c:       e9 d1 ff ff ff  jmp     0x22 <.plt+0x12>
 // CHECK-NEXT: 51:       68 00 00 00 00  pushq   $0
-// CHECK-NEXT: 56:       e9 b5 ff ff ff  jmp     -75 <.plt>
+// CHECK-NEXT: 56:       e9 b5 ff ff ff  jmp     0x10 <.plt>
 // CHECK-NEXT: 5b:       cc      int3
 // CHECK-NEXT: 5c:       cc      int3
 // CHECK-NEXT: 5d:       cc      int3
 // CHECK-NEXT: 5e:       cc      int3
 // CHECK-NEXT: 5f:       cc      int3
 // CHECK-NEXT: 60:       4c 8b 1d f9 00 00 00    movq    249(%rip), %r11
-// CHECK-NEXT: 67:       e8 c4 ff ff ff  callq   -60 <.plt+0x20>
-// CHECK-NEXT: 6c:       e9 b1 ff ff ff  jmp     -79 <.plt+0x12>
+// CHECK-NEXT: 67:       e8 c4 ff ff ff  callq   0x30 <.plt+0x20>
+// CHECK-NEXT: 6c:       e9 b1 ff ff ff  jmp     0x22 <.plt+0x12>
 // CHECK-NEXT: 71:       68 01 00 00 00  pushq   $1
-// CHECK-NEXT: 76:       e9 95 ff ff ff  jmp     -107 <.plt>
+// CHECK-NEXT: 76:       e9 95 ff ff ff  jmp     0x10 <.plt>
 // CHECK-NEXT: 7b:       cc      int3
 // CHECK-NEXT: 7c:       cc      int3
 // CHECK-NEXT: 7d:       cc      int3
 // CHECK-NEXT: 7e:       cc      int3
 // CHECK-NEXT: 7f:       cc      int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/test/ELF/x86-64-retpoline-znow-linkerscript.s

 // RUN:   .dynstr : { *(.dynstr) } \
 // RUN: }" > %t.script
 // RUN: ld.lld -shared %t1.o %t2.so -o %t.exe -z retpolineplt -z now --script %t.script
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-EMPTY:
 // CHECK-NEXT: <.plt>:
-// CHECK-NEXT: 10:  e8 0b 00 00 00  callq 11 <.plt+0x10>
+// CHECK-NEXT: 10:  e8 0b 00 00 00  callq 0x20 <.plt+0x10>
 // CHECK-NEXT: 15:  f3 90   pause
 // CHECK-NEXT: 17:  0f ae e8  lfence
-// CHECK-NEXT: 1a:  eb f9   jmp -7 <.plt+0x5>
+// CHECK-NEXT: 1a:  eb f9   jmp 0x15 <.plt+0x5>
 // CHECK-NEXT: 1c:  cc  int3
 // CHECK-NEXT: 1d:  cc  int3
 // CHECK-NEXT: 1e:  cc  int3
 // CHECK-NEXT: 1f:  cc  int3
 // CHECK-NEXT: 20:  4c 89 1c 24   movq  %r11, (%rsp)
 // CHECK-NEXT: 24:  c3  retq
 // CHECK-NEXT: 25:  cc  int3
 // CHECK-NEXT: 26:  cc  int3
 // CHECK-NEXT: 27:  cc  int3
 // CHECK-NEXT: 28:  cc  int3
 // CHECK-NEXT: 29:  cc  int3
 // CHECK-NEXT: 2a:  cc  int3
 // CHECK-NEXT: 2b:  cc  int3
 // CHECK-NEXT: 2c:  cc  int3
 // CHECK-NEXT: 2d:  cc  int3
 // CHECK-NEXT: 2e:  cc  int3
 // CHECK-NEXT: 2f:  cc  int3
 // CHECK-NEXT: 30:  4c 8b 1d 31 00 00 00  movq  49(%rip), %r11
-// CHECK-NEXT: 37:  e9 d4 ff ff ff  jmp -44 <.plt>
+// CHECK-NEXT: 37:  e9 d4 ff ff ff  jmp 0x10 <.plt>
 // CHECK-NEXT: 3c:  cc  int3
 // CHECK-NEXT: 3d:  cc  int3
 // CHECK-NEXT: 3e:  cc  int3
 // CHECK-NEXT: 3f:  cc  int3
 // CHECK-NEXT: 40:      4c 8b 1d 29 00 00 00  movq  41(%rip), %r11
-// CHECK-NEXT: 47:  e9 c4 ff ff ff  jmp -60 <.plt>
+// CHECK-NEXT: 47:  e9 c4 ff ff ff  jmp 0x10 <.plt>
 // CHECK-NEXT: 4c:  cc  int3
 // CHECK-NEXT: 4d:  cc  int3
 // CHECK-NEXT: 4e:  cc  int3
 // CHECK-NEXT: 4f:  cc  int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/test/ELF/x86-64-retpoline-znow-static-iplt.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld -z retpolineplt -z now %t.o -o %t
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
 
 #0x2011a9+5 + 34 = 0x2011d0 (foo@plt)
 # CHECK:      <_start>:
-# CHECK-NEXT:  2011a9:       callq   34
+# CHECK-NEXT:  2011a9:       callq   0x2011d0
 
 #Static IPLT header due to -z retpolineplt
 # CHECK:       00000000002011b0 <.plt>:
-# CHECK-NEXT:  2011b0:       callq   11 <.plt+0x10>
+# CHECK-NEXT:  2011b0:       callq   0x2011c0 <.plt+0x10>
 # CHECK-NEXT:  2011b5:       pause
 # CHECK-NEXT:  2011b7:       lfence
 #foo@plt
 # CHECK:       2011d0:       movq    4105(%rip), %r11
-# CHECK-NEXT:  2011d7:       jmp     -44 <.plt>
+# CHECK-NEXT:  2011d7:       jmp     0x2011b0 <.plt>
 
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
   ret
 
 .globl _start
 _start:
   call foo

lld/test/ELF/x86-64-retpoline-znow.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -soname=so -o %t2.so
 
 // RUN: ld.lld -shared %t1.o %t2.so -o %t.exe -z retpolineplt -z now
 // RUN: llvm-objdump -d -s --no-show-raw-insn %t.exe | FileCheck %s
 
 // CHECK:      Contents of section .got.plt:
 // CHECK-NEXT: 23f0 10230000 00000000 00000000 00000000
 // CHECK-NEXT: 2400 00000000 00000000 00000000 00000000
 // CHECK-NEXT: 2410 00000000 00000000
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-EMPTY:
 // CHECK-NEXT: <.plt>:
-// CHECK-NEXT: 12d0:       callq   11 <.plt+0x10>
+// CHECK-NEXT: 12d0:       callq   0x12e0 <.plt+0x10>
 // CHECK-NEXT:             pause
 // CHECK-NEXT:             lfence
-// CHECK-NEXT:             jmp     -7 <.plt+0x5>
+// CHECK-NEXT:             jmp     0x12d5 <.plt+0x5>
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT: 12e0:       movq    %r11, (%rsp)
 // CHECK-NEXT:             retq
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT: 12f0:       movq    4369(%rip), %r11
-// CHECK-NEXT:             jmp     -44 <.plt>
+// CHECK-NEXT:             jmp     0x12d0 <.plt>
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT: 1300:       movq    4361(%rip), %r11
-// CHECK-NEXT:             jmp     -60 <.plt>
+// CHECK-NEXT:             jmp     0x12d0 <.plt>
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

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

 // CHECK-NEXT: 3440 00000000 00000000 41130000 00000000
 // CHECK-NEXT: 3450 61130000 00000000
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-EMPTY:
 // CHECK-NEXT: <.plt>:
 // CHECK-NEXT: 1300:       pushq   8498(%rip)
 // CHECK-NEXT:             movq    8499(%rip), %r11
-// CHECK-NEXT:             callq   14 <.plt+0x20>
+// CHECK-NEXT:             callq   0x1320 <.plt+0x20>
 // CHECK-NEXT:             pause
 // CHECK-NEXT:             lfence
-// CHECK-NEXT:             jmp     -7 <.plt+0x12>
+// CHECK-NEXT:             jmp     0x1312 <.plt+0x12>
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT: 1320:       movq    %r11, (%rsp)
 // CHECK-NEXT:             retq
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT: 1330:       movq    8465(%rip), %r11
-// CHECK-NEXT:             callq   -28 <.plt+0x20>
-// CHECK-NEXT:             jmp     -47 <.plt+0x12>
+// CHECK-NEXT:             callq   0x1320 <.plt+0x20>
+// CHECK-NEXT:             jmp     0x1312 <.plt+0x12>
 // CHECK-NEXT:             pushq   $0
-// CHECK-NEXT:             jmp     -75 <.plt>
+// CHECK-NEXT:             jmp     0x1300 <.plt>
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT: 1350:       movq    8441(%rip), %r11
-// CHECK-NEXT:             callq   -60 <.plt+0x20>
-// CHECK-NEXT:             jmp     -79 <.plt+0x12>
+// CHECK-NEXT:             callq   0x1320 <.plt+0x20>
+// CHECK-NEXT:             jmp     0x1312 <.plt+0x12>
 // CHECK-NEXT:             pushq   $1
-// CHECK-NEXT:             jmp     -107 <.plt>
+// CHECK-NEXT:             jmp     0x1300 <.plt>
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

llvm/include/llvm/MC/MCInstPrinter.h

public:
   /// Customize the printer according to a command line option.
   /// @return true if the option is recognized and applied.
   virtual bool applyTargetSpecificCLOption(StringRef Opt) { return false; }
 
   /// Specify a stream to emit comments to.
   void setCommentStream(raw_ostream &OS) { CommentStream = &OS; }
 
   /// Print the specified MCInst to the specified raw_ostream.
+  ///
+  /// \p Address the address of current instruction on most targets, used to
+  /// print a PC relative immediate as the target address. On targets where a PC
+  /// relative immediate is relative to the next instruction and the length of a
+  /// MCInst is difficult to measure (e.g. x86), this is the address of the next
+  /// instruction. If Address is 0, the immediate will be printed.
   virtual void printInst(const MCInst *MI, uint64_t Address, StringRef Annot,
                          const MCSubtargetInfo &STI, raw_ostream &OS) = 0;
 
   /// Return the name of the specified opcode enum (e.g. "MOV32ri") or
   /// empty if we can't resolve it.
   StringRef getOpcodeName(unsigned Opcode) const;
 
   /// Print the assembler register name.

llvm/lib/Target/X86/MCTargetDesc/X86InstPrinterCommon.cpp

 //===--- X86InstPrinterCommon.cpp - X86 assembly instruction printing -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file includes common code for rendering MCInst instances as Intel-style
 // and Intel-style assembly.
 //
 //===----------------------------------------------------------------------===//
 
 #include "X86InstPrinterCommon.h"
 #include "X86BaseInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/Casting.h"
 #include <cstdint>
 #include <cassert>
case X86::TO_POS_INF:
     O << "{ru-sae}";
     break;
   case X86::TO_ZERO:
     O << "{rz-sae}";
     break;
   }
 }
 
-/// printPCRelImm - This is used to print an immediate value that ends up
-/// being encoded as a pc-relative value (e.g. for jumps and calls).  In
-/// Intel-style these print slightly differently than normal immediates.
-/// for example, a $ is not emitted.
+/// value (e.g. for jumps and calls). In Intel-style these print slightly
+/// differently than normal immediates. For example, a $ is not emitted.
+///
+/// \p Address The address of the next instruction.
+/// \see MCInstPrinter::printInst
 void X86InstPrinterCommon::printPCRelImm(const MCInst *MI, uint64_t Address,
                                          unsigned OpNo, raw_ostream &O) {
   const MCOperand &Op = MI->getOperand(OpNo);
-  if (Op.isImm())
+  if (Op.isImm()) {
+    if (PrintBranchImmAsAddress) {
+      uint64_t Target = Address + Op.getImm();
+      if (MAI.getCodePointerSize() == 4)
+        Target &= 0xffffffff;
+      O << formatHex(Target);
+    } else
       O << formatImm(Op.getImm());
-  else {
+  } else {
     assert(Op.isExpr() && "unknown pcrel immediate operand");
     // If a symbolic branch target was added as a constant expression then print
     // that address in hex.
     const MCConstantExpr *BranchTarget = dyn_cast<MCConstantExpr>(Op.getExpr());
     int64_t Address;
     if (BranchTarget && BranchTarget->evaluateAsAbsolute(Address)) {
       O << formatHex((uint64_t)Address);
     } else {

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

 ; RUN: llc < %s -mtriple=x86_64-linux-gnu -filetype=obj -o - \
 ; RUN:  | llvm-objdump --triple=x86_64-linux-gnu -d - \
 ; RUN:  | FileCheck %s
 
 ; CHECK: 0000000000000000 <test1>:
-; CHECK-NEXT:   0: 74 00 je 0 <test1+0x2>
+; CHECK-NEXT:   0: 74 00 je 0x2 <test1+0x2>
 ; CHECK-NEXT:   2: c3    retq
 
 define void @test1() {
 entry:
   callbr void asm sideeffect "je ${0:l}", "X,~{dirflag},~{fpsr},~{flags}"(i8* blockaddress(@test1, %a.b.normal.jump))
           to label %asm.fallthrough [label %a.b.normal.jump]
 
 asm.fallthrough:
   ret void
 
 a.b.normal.jump:
   ret void
 }

llvm/test/LTO/Resolution/X86/not-prevailing.ll

 ; RUN: opt -module-summary %s -o %t1.o
 ; RUN: opt -module-summary -o %t2.o %S/Inputs/not-prevailing.ll
 ; RUN: llvm-lto2 run -o %t3.o %t1.o %t2.o -r %t1.o,foo,x -r %t1.o,zed,px -r %t1.o,bar,x \
 ; RUN:   -r %t2.o,bar,x -save-temps
 
 ; Check that 'foo' and 'bar' were not inlined.
 ; CHECK:      <zed>:
 ; CHECK-NEXT:  {{.*}}  pushq   %rbx
-; CHECK-NEXT:  {{.*}}  callq   0 <zed+0x6>
+; CHECK-NEXT:  {{.*}}  callq   0x6 <zed+0x6>
 ; CHECK-NEXT:  {{.*}}  movl    %eax, %ebx
-; CHECK-NEXT:  {{.*}}  callq   0 <zed+0xd>
+; CHECK-NEXT:  {{.*}}  callq   0xd <zed+0xd>
 ; CHECK-NEXT:  {{.*}}  movl    %ebx, %eax
 ; CHECK-NEXT:  {{.*}}  popq    %rbx
 ; CHECK-NEXT:  {{.*}}  retq
 
 ; RUN: llvm-objdump -d %t3.o.1 | FileCheck %s
 ; RUN: llvm-readelf --symbols %t3.o.1 | FileCheck %s --check-prefix=SYMBOLS
 
 ; Check that 'foo' and 'bar' produced as undefined.

llvm/test/MC/COFF/cv-inline-linetable-unlikely.s

 # calls to __asan_report*, for which it is very important to have an accurate
 # stack trace.
 
 # ASM:      0000000000000000 <g>:
 # ASM-NEXT:        0: 48 83 ec 28                   subq    $40, %rsp
 # ASM-NEXT:        4: c7 05 fc ff ff ff 00 00 00 00 movl    $0, -4(%rip)
 #  Begin inline loc (matches cv_loc below)
 # ASM-NEXT:        e: 83 3d ff ff ff ff 00          cmpl    $0, -1(%rip)
-# ASM-NEXT:       15: 75 0f                         jne     15 <g+0x26>
+# ASM-NEXT:       15: 75 0f                         jne     0x26 <g+0x26>
 #  End inline loc
 # ASM-NEXT:       17: c7 05 fc ff ff ff 00 00 00 00 movl    $0, -4(%rip)
 # ASM-NEXT:       21: 48 83 c4 28                   addq    $40, %rsp
 # ASM-NEXT:       25: c3                            retq
 #  Begin inline loc (matches cv_loc below)
-# ASM-NEXT:       26: e8 00 00 00 00                callq   0 <g+0x2b>
+# ASM-NEXT:       26: e8 00 00 00 00                callq   0x2b <g+0x2b>
 # ASM-NEXT:       2b: 0f 0b                         ud2
 #  End inline loc
 
 # CODEVIEW:      S_INLINESITE [size = 24]
 # CODEVIEW-NEXT: inlinee = 0x1002 (f), parent = 0, end = 0
 # CODEVIEW-NEXT:   0B2E      code 0xE (+0xE) line 1 (+1)
 # CODEVIEW-NEXT:   0409      code end 0x17 (+0x9)
 # CODEVIEW-NEXT:   0B2F      code 0x26 (+0xF) line 2 (+1)

llvm/test/MC/COFF/cv-loc-unreachable-2.s

 # RUN: llvm-mc %s -triple=i686-pc-win32 -filetype=obj -o %t.obj
 # RUN: llvm-objdump -d %t.obj | FileCheck %s --check-prefix=ASM
 # RUN: llvm-pdbutil dump -il -symbols %t.obj | FileCheck %s --check-prefix=CODEVIEW
 
 # Based on the other cv-loc-unreachable-2.s, but with other code in the same
 # section afterwards. We had negative label difference assertions when .cv_loc
 # bound tightly to the next instruction.
 
 # ASM:      00000000 <_callit>:
 #   begin inline {
-# ASM-NEXT:        0: e8 00 00 00 00                calll   0 <_callit+0x5>
+# ASM-NEXT:        0: e8 00 00 00 00                calll   0x5 <_callit+0x5>
 # ASM-NEXT:        5: 85 c0                         testl   %eax, %eax
-# ASM-NEXT:        7: 75 01                         jne     1 <_callit+0xa>
+# ASM-NEXT:        7: 75 01                         jne     0xa <_callit+0xa>
 #   } end inline
 # ASM-NEXT:        9: c3                            retl
 #   begin inline {
 # ASM-NEXT:        a: 6a 20                         pushl   $32
 # ASM-NEXT:        c: ff 15 00 00 00 00             calll   *0
 #   } end inline
 
 # CODEVIEW: Inlinee |  Line | Source File

llvm/test/MC/COFF/cv-loc-unreachable.s

 # }
 # void callit() {
 #   do_exit();
 # }
 
 
 # ASM:      00000000 <_callit>:
 #   begin inline {
-# ASM-NEXT:        0: e8 00 00 00 00                calll   0 <_callit+0x5>
+# ASM-NEXT:        0: e8 00 00 00 00                calll   0x5 <_callit+0x5>
 # ASM-NEXT:        5: 85 c0                         testl   %eax, %eax
-# ASM-NEXT:        7: 75 01                         jne     1 <_callit+0xa>
+# ASM-NEXT:        7: 75 01                         jne     0xa <_callit+0xa>
 #   } end inline
 # ASM-NEXT:        9: c3                            retl
 #   begin inline {
 # ASM-NEXT:        a: 6a 20                         pushl   $32
 # ASM-NEXT:        c: ff 15 00 00 00 00             calll   *0
 #   } end inline
 
 # CODEVIEW: Inlinee |  Line | Source File

llvm/test/MC/X86/AlignedBundling/misaligned-bundle-group.s

foo:
         push    %ebp # 1 byte
         .align  16
         .bundle_lock align_to_end
 # CHECK:            1:  nopw %cs:(%eax,%eax)
 # CHECK:            10: nopw %cs:(%eax,%eax)
 # CHECK-RELAX:      1a: nop
 # CHECK-RELAX:      20: nopw %cs:(%eax,%eax)
 # CHECK-RELAX:      2a: nopw %cs:(%eax,%eax)
-# CHECK-OPT:        1b: calll -4
-# CHECK-RELAX:      3b: calll -4
+# CHECK-OPT:        1b: calll 0x1c
+# CHECK-RELAX:      3b: calll 0x3c
         calll   bar # 5 bytes
         .bundle_unlock
         ret         # 1 byte

llvm/test/MC/X86/AlignedBundling/single-inst-bundling.s

# CHECK-NEXT:     10: imull
 
   movl    %ebx, %edi
   callq   bar
   cmpl    %r14d, %ebp
 # CHECK-RELAX:   nopl
   jle     .L_ELSE
 # Due to the padding that's inserted before the addl, the jump target
 # becomes farther by one byte.
-# CHECK-OPT:     jle 5
-# CHECK-RELAX:   jle 7
+# CHECK-OPT:     jle 0x24
+# CHECK-RELAX:   jle 0x2d
 
   addl    %ebp, %eax
 # CHECK-OPT:     nop
 # CHECK-OPT-NEXT:20: addl
 # CHECK-RELAX:   26: addl
 
   jmp     .L_RET
 .L_ELSE:

llvm/test/MC/X86/align-via-padding.s

# relaxation padding.
   int3
 foo:
   ret
 
   # Canonical toy loop to show benefit - we can align the loop header with
   # fewer nops by relaxing the branch, even though we don't need to
   # CHECK: <loop_preheader>:
   # CHECK: 45: 48 85 c0                       testq %rax, %rax
-  # CHECK: 48: 2e 2e 2e 2e 0f 8e 1e 00 00 00  jle 30 <loop_exit>
+  # CHECK: 48: 2e 2e 2e 2e 0f 8e 1e 00 00 00  jle 0x70 <loop_exit>
   # CHECK: 52: 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00      nopw  %cs:(%rax,%rax)
   # CHECK: <loop_header>:
   # CHECK: 60: 48 83 e8 01                    subq $1, %rax
   # CHECK: 64: 48 85 c0                       testq %rax, %rax
-  # CHECK: 67: 7e 07                          jle 7 <loop_exit>
+  # CHECK: 67: 7e 07                          jle 0x70 <loop_exit>
   # CHECK: 69: 2e 2e e9 f0 ff ff ff           jmp
   # CHECK: <loop_exit>:
   # CHECK: 70: c3                             retq
   .p2align 5
   .skip 5
 loop_preheader:
   testq %rax, %rax
   jle loop_exit
   .p2align 5
 loop_header:
   subq $1, %rax
   testq %rax, %rax
   jle loop_exit
   jmp loop_header
   .p2align 4
 loop_exit:
   ret
 
   # Correctness cornercase - can't prefix pad jmp without having relaxed it
   # first as doing so would make the relative offset too large
   # CHECK: fd: cc                             int3
-  # CHECK: fe: eb 80                          jmp -128 <loop_exit+0x10>
+  # CHECK: fe: eb 80                          jmp 0x80 <loop_exit+0x10>
   # CHECK: 100: cc                            int3
 .p2align 5
 .L1:
 .rept 126
   int3
 .endr
   jmp .L1
 .rept 30
   int3
 .endr
 .p2align 5

llvm/test/MC/X86/align-via-relaxation.s

 # RUN: llvm-mc -mcpu=skylake -filetype=obj -triple x86_64-pc-linux-gnu -x86-pad-max-prefix-size=0 %s | llvm-objdump -d --section=.text - | FileCheck %s
 
 # This test exercises only the padding via relaxation logic.  The  interaction
 # etween prefix padding and relaxation logic can be seen in align-via-padding.s
 
   .file "test.c"
   .text
   .section  .text
   # Demonstrate that we can relax instructions to provide padding, not
   # just insert nops.  jmps are being used for ease of demonstration.
   # CHECK: .text
-  # CHECK: 0: eb 1f                         jmp 31 <foo>
-  # CHECK: 2: e9 1a 00 00 00                jmp 26 <foo>
-  # CHECK: 7: e9 15 00 00 00                jmp 21 <foo>
-  # CHECK: c: e9 10 00 00 00                jmp 16 <foo>
-  # CHECK: 11: e9 0b 00 00 00               jmp 11 <foo>
-  # CHECK: 16: e9 06 00 00 00               jmp 6 <foo>
-  # CHECK: 1b: e9 01 00 00 00               jmp 1 <foo>
+  # CHECK: 0: eb 1f                         jmp 0x21 <foo>
+  # CHECK: 2: e9 1a 00 00 00                jmp 0x21 <foo>
+  # CHECK: 7: e9 15 00 00 00                jmp 0x21 <foo>
+  # CHECK: c: e9 10 00 00 00                jmp 0x21 <foo>
+  # CHECK: 11: e9 0b 00 00 00               jmp 0x21 <foo>
+  # CHECK: 16: e9 06 00 00 00               jmp 0x21 <foo>
+  # CHECK: 1b: e9 01 00 00 00               jmp 0x21 <foo>
   # CHECK: 20: cc                           int3
   .p2align 4
   jmp foo
   jmp foo
   jmp foo
   jmp foo
   jmp foo
   jmp foo
   jmp foo
   .p2align 5
   int3
 foo:
   ret
 
   # Check that we're not shifting aroudn the offsets of labels - doing
   # that would require a further round of relaxation
   # CHECK: <bar>:
-  # CHECK: 22: eb fe                          jmp -2 <bar>
+  # CHECK: 22: eb fe                          jmp 0x22 <bar>
   # CHECK: 24: 66 66 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:(%rax,%rax)
   # CHECK: 30: 0f 0b                          ud2
 
 bar:  
   jmp bar
 nobypass:
   .p2align 4
   ud2
 
 
   # Canonical toy loop to show benefit - we can align the loop header with
   # fewer nops by relaxing the branch, even though we don't need to
   # CHECK: <loop_preheader>:
   # CHECK: 45: 48 85 c0                       testq %rax, %rax
-  # CHECK: 48: 0f 8e 22 00 00 00              jle 34 <loop_exit>
+  # CHECK: 48: 0f 8e 22 00 00 00              jle 0x70 <loop_exit>
   # CHECK: 4e: 66 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:(%rax,%rax)
   # CHECK: 5d: 0f 1f 00                       nopl (%rax)
   # CHECK: <loop_header>:
   # CHECK: 60: 48 83 e8 01                    subq $1, %rax
   # CHECK: 64: 48 85 c0                       testq %rax, %rax
-  # CHECK: 67: 7e 07                          jle 7 <loop_exit>
-  # CHECK: 69: e9 f2 ff ff ff                 jmp -14 <loop_header>
+  # CHECK: 67: 7e 07                          jle 0x70 <loop_exit>
+  # CHECK: 69: e9 f2 ff ff ff                 jmp 0x60 <loop_header>
   # CHECK: 6e: 66 90                          nop
   # CHECK: <loop_exit>:
   # CHECK: 70: c3                             retq
   .p2align 5
   .skip 5
 loop_preheader:
   testq %rax, %rax
   jle loop_exit

llvm/test/MC/X86/x86-branch-relaxation.s

bar16:
   .globl  baz32
 baz32:
   jmp foo
   
 
 
   
 // CHECK16-LABEL: bar16
-// CHECK16-NEXT: e9 fe ff   jmp -2 <bar16+0x1>
+// CHECK16-NEXT: e9 fe ff   jmp 0x1 <bar16+0x1>
 // CHECK32-LABEL: baz32
-// CHECK32-NEXT: e9 fc ff ff ff   jmp -4 <baz32+0x1>
+// CHECK32-NEXT: e9 fc ff ff ff   jmp 0x1 <baz32+0x1>
 
   

llvm/test/Object/X86/objdump-disassembly-inline-relocations.test

 
 # MACHO-i386: file format mach-o 32-bit i386
 # MACHO-i386: Disassembly of section __TEXT,__text:
 # MACHO-i386: <_main>:
 # MACHO-i386:        0:       83 ec 0c                                        subl    $12, %esp
 # MACHO-i386:        3:       c7 44 24 08 00 00 00 00                         movl    $0, 8(%esp)
 # MACHO-i386:        b:       c7 04 24 24 00 00 00                            movl    $36, (%esp)
 # MACHO-i386:                                e: GENERIC_RELOC_VANILLA __cstring
-# MACHO-i386:       12:       e8 1f 00 00 00                                  calll   31
+# MACHO-i386:       12:       e8 1f 00 00 00                                  calll   0x36
 # MACHO-i386:                               13: GENERIC_RELOC_VANILLA __jump_table
-# MACHO-i386:       17:       e8 15 00 00 00                                  calll   21
+# MACHO-i386:       17:       e8 15 00 00 00                                  calll   0x31
 # MACHO-i386:                               18: GENERIC_RELOC_VANILLA __jump_table
 # MACHO-i386:       1c:       8b 44 24 08                                     movl    8(%esp), %eax
 # MACHO-i386:       20:       83 c4 0c                                        addl    $12, %esp
 # MACHO-i386:       23:       c3                                              ret
 
 # RUN: llvm-objdump -d -r %p/../Inputs/trivial-object-test.macho-x86-64 \
 # RUN:              | FileCheck %s -check-prefix MACHO-x86-64
 

 
 # ELF-i386: file format elf32-i386
 # ELF-i386: Disassembly of section .text:
 # ELF-i386: <main>:
 # ELF-i386:        0:     83 ec 0c                                        subl    $12, %esp
 # ELF-i386:        3:     c7 44 24 08 00 00 00 00                         movl    $0, 8(%esp)
 # ELF-i386:        b:     c7 04 24 00 00 00 00                            movl    $0, (%esp)
 # ELF-i386:                              e: R_386_32      .rodata.str1.1
-# ELF-i386:       12:     e8 fc ff ff ff                                  calll   -4
+# ELF-i386:       12:     e8 fc ff ff ff                                  calll   0x13
 # ELF-i386:                             13: R_386_PC32    puts
-# ELF-i386:       17:     e8 fc ff ff ff                                  calll   -4
+# ELF-i386:       17:     e8 fc ff ff ff                                  calll   0x18
 # ELF-i386:                             18: R_386_PC32    SomeOtherFunction
 # ELF-i386:       1c:     8b 44 24 08                                     movl    8(%esp), %eax
 # ELF-i386:       20:     83 c4 0c                                        addl    $12, %esp
 # ELF-i386:       23:     c3                                              ret
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32

llvm/test/Object/X86/objdump-trivial-object.test

 # RUN: yaml2obj --docnum=1 %s -o %t.elf-i386
 # RUN: llvm-objdump -d %t.elf-i386 | FileCheck %s --check-prefix=ELF-i386
 
 # ELF-i386: file format elf32-i386
 # ELF-i386: Disassembly of section .text:
 # ELF-i386:        0: 83 ec 0c                        subl    $12, %esp
 # ELF-i386:        3: c7 44 24 08 00 00 00 00         movl    $0, 8(%esp)
 # ELF-i386:        b: c7 04 24 00 00 00 00            movl    $0, (%esp)
-# ELF-i386:       12: e8 fc ff ff ff                  calll   -4
-# ELF-i386:       17: e8 fc ff ff ff                  calll   -4
+# ELF-i386:       12: e8 fc ff ff ff                  calll   0x13
+# ELF-i386:       17: e8 fc ff ff ff                  calll   0x18
 # ELF-i386:       1c: 8b 44 24 08                     movl    8(%esp), %eax
 # ELF-i386:       20: 83 c4 0c                        addl    $12, %esp
 # ELF-i386:       23: c3                              ret
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB

llvm/test/tools/llvm-objdump/ELF/call-absolute-symbol.test

 // REQUIRES: x86_64-linux
 // RUN: llvm-objdump -d %p/Inputs/call-absolute-symbol.elf-x86_64 | FileCheck %s
-CHECK: 201000:  e8 fb f0 df ff  callq -2100997 <foo>
+CHECK: 201000:  e8 fb f0 df ff  callq 0x100 <foo>

llvm/test/tools/llvm-objdump/MachO/hex-displacement.test

 # Check that target displacement has '0x' prefix
 # to accent hex format of the number.
 
 # RUN: llvm-objdump -d %p/Inputs/hello.exe.macho-i386 | FileCheck %s
 
-# CHECK: 1f47:   e8 00 00 00 00  calll   0 <_main+0xc>
+# CHECK: 1f47:   e8 00 00 00 00  calll   0x1f4c <_main+0xc>

llvm/test/tools/llvm-objdump/X86/coff-disassemble-export.test

 // RUN: llvm-objdump -d %p/Inputs/disassemble.dll.coff-i386 | \
 // RUN:   FileCheck %s
 
 // CHECK-LABEL: <g>:
-// CHECK: calll 8 <f>
+// CHECK: calll 0x10001010 <f>
 
 // CHECK-LABEL: f:
-// CHECK: calll -24 <g>
+// CHECK: calll 0x10001000 <g>

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

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

llvm/test/tools/llvm-objdump/X86/elf-disassemble-no-symtab.test

 ## Show that llvm-objdump can handle a missing symbol table when printing
 ## references and labels.
 
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy -R .symtab %t
 # RUN: llvm-objdump %t -d | FileCheck %s
 
 # CHECK:       Disassembly of section .text:
 # CHECK-EMPTY:
 # CHECK-NEXT:  0000000000004000 <.text>:
-# CHECK-NEXT:    4000: e8 42 00 00 00                callq   66 <.text+0x47>
+# CHECK-NEXT:    4000: e8 42 00 00 00                callq   0x4047 <.text+0x47>
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:    .text
     Type:    SHT_PROGBITS
     Address: 0x4000
     Flags:   [SHF_ALLOC, SHF_EXECINSTR]
     Content: 'e842000000'

llvm/test/tools/llvm-objdump/X86/elf-disassemble-relocs.test

 ## Show that --disassemble + --reloc prints relocations inline and does not dump
 ## the relocation sections.
 
 # RUN: yaml2obj %s --docnum=1 -o %t1.o
 # RUN: llvm-objdump %t1.o -d -r | FileCheck %s --implicit-check-not="RELOCATION RECORDS"
 
-# CHECK:      0: e8 00 00 00 00                callq   0 <.text+0x5>
+# CHECK:      0: e8 00 00 00 00                callq   0x5 <.text+0x5>
 # CHECK-NEXT:          0000000000000001:  R_X86_64_PC32        foo-0x4
 # CHECK-NEXT:          0000000000000002:  R_X86_64_NONE        bar+0x8
-# CHECK-NEXT: 5: e8 00 00 00 00                callq   0 <.text+0xa>
+# CHECK-NEXT: 5: e8 00 00 00 00                callq   0xa <.text+0xa>
 # CHECK-NEXT:          0000000000000006:  R_X86_64_PLT32       foo+0x1
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64

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: Disassembly of section .text1:
-# EXEC:     4000: e8 00 00 00 00                callq   0 <third>
+# EXEC:     4000: e8 00 00 00 00                callq   0x4005 <third>
 # EXEC: Disassembly of section .text2:
-# EXEC:     4005: e8 12 34 56 78                callq   2018915346 <fourth+0x78563412>
+# EXEC:     4005: e8 12 34 56 78                callq   0x7856741c <fourth+0x78563412>
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
- Name:    fourth
     Value:   0x400A
 
 # RUN: yaml2obj %s --docnum=2 -o %t.o
 # RUN: llvm-objdump %t.o -d | FileCheck %s --check-prefix=REL
 
 # REL:      Disassembly of section .text1:
 # REL-EMPTY:
 # REL-NEXT: 0000000000000000 <.text1>:
-# REL-NEXT:        0: e8 00 00 00 00                callq   0 <.text1+0x5>
+# REL-NEXT:        0: e8 00 00 00 00                callq   0x5 <.text1+0x5>
 # REL-EMPTY:
 # REL-NEXT: Disassembly of section .text2:
 # REL-EMPTY:
 # REL-NEXT: 0000000000000000 <.text2>:
-# REL-NEXT:        0: e8 00 00 00 00                callq   0 <sym2>
+# REL-NEXT:        0: e8 00 00 00 00                callq   0x5 <sym2>
 # REL-EMPTY:
 # REL-NEXT: Disassembly of section .text3:
 # REL-EMPTY:
 # REL-NEXT: 0000000000000000 <.text3>:
-# REL-NEXT:        0: e8 00 00 00 00                callq   0 <.text3+0x5>
+# REL-NEXT:        0: e8 00 00 00 00                callq   0x5 <.text3+0x5>
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:

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

 ## Test that --section works correctly for -d with -r.
 # RUN: yaml2obj %s -o %t.o
 
 ## Show that only the specified sections are disassembled.
 ## Also show that no relocation sections are dumped because none are
 ## specified.
 # RUN: llvm-objdump -d -r %t.o --section=.text --section=.rodata \
 # RUN:   | FileCheck %s --check-prefixes=DISASM,RELOC --implicit-check-not=.text2
 
 # DISASM:       Disassembly of section .text:
 # DISASM-EMPTY:
 # DISASM-NEXT:  0000000000000400 <.text>:
-# DISASM-NEXT:  400: e8 00 00 00 00                callq   0 <.text+0x5>
+# DISASM-NEXT:  400: e8 00 00 00 00                callq   0x405 <.text+0x5>
 # RELOC-NEXT:                      00000401:  R_X86_64_PC32        foo+0x1
 # RELOC-NEXT:                      00000401:  R_X86_64_GOT32       foo
 # DISASM:       Disassembly of section .rodata:
 # DISASM-EMPTY:
 # DISASM-NEXT:  0000000000000000 <.rodata>:
 # DISASM-NEXT:  0: 00 00                           addb    %al, (%rax)
 # RELOC-NEXT:              0000000000000000:  R_X86_64_NONE        foo
 # DISASM-NEXT:  2: 00 00                           addb    %al, (%rax)

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

virtual void printInst(MCInstPrinter &IP, const MCInst *MI,
     }
 
     // The output of printInst starts with a tab. Print some spaces so that
     // the tab has 1 column and advances to the target tab stop.
     unsigned TabStop = NoShowRawInsn ? 16 : 40;
     unsigned Column = OS.tell() - Start;
     OS.indent(Column < TabStop - 1 ? TabStop - 1 - Column : 7 - Column % 8);
 
-    if (MI)
-      IP.printInst(MI, Address.Address, "", STI, OS);
-    else
+    if (MI) {
+      // See MCInstPrinter::printInst. On targets where a PC relative immediate
+      // is relative to the next instruction and the length of a MCInst is
+      // difficult to measure (x86), this is the address of the next
+      // instruction.
+      uint64_t Addr =
+          Address.Address + (STI.getTargetTriple().isX86() ? Bytes.size() : 0);
+      IP.printInst(MI, Addr, "", STI, OS);
+    } else
       OS << "\t<unknown>";
   }
 };
 PrettyPrinter PrettyPrinterInst;
 
 class HexagonPrettyPrinter : public PrettyPrinter {
 public:
   void printLead(ArrayRef<uint8_t> Bytes, uint64_t Address,