[PPCInstPrinter] Change printBranchOperand(calltarget) to print the target address in hexadecimal form

[MaskRay]

Summary

// llvm-objdump -d output (before)
0: bl .-4
4: bl .+0
8: bl .+4

// llvm-objdump -d output (after) ; GNU objdump -d
0: bl 0xfffffffc / bl 0xfffffffffffffffc
4: bl 0x4
8: bl 0xc

Many Operand's are not annotated as OPERAND_PCREL. They are not affected (e.g. b .+67108860). I plan to fix them in future patches.

Modified test/tools/llvm-objdump/ELF/PowerPC/branch-offset.s to test
address space wraparound for powerpc32 and powerpc64.

[jhenderson]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCInstPrinter.cpp

421

Not being a PPC expert, what is the << 2 all about?

llvm/lib/Target/PowerPC/MCTargetDesc/PPCInstPrinter.h

68

Don't miss this clang-format request!

[nemanjai]

This seems perfectly fine with me - and more consistent with GNU binutils.
However, I think the AIX guys should also have a look as I am not sure what the system assembler's capabilities are on AIX. I'll add a couple of AIX reviewers.

llvm/lib/Target/PowerPC/MCTargetDesc/PPCInstPrinter.cpp

421

The branches on PPC must branch to word-aligned (4-byte word) addresses. So the branch address is the encoded value shifted two bits to the left (plus PC for the PC-relative ones).

[jasonliu]

@nemanjai
AIX system assembler does not seem to like this new form.

Assembler:
test.s: line 46: 1252-086 The target of the branch instruction
        must be a relocatable or external expression.

[MaskRay]

In D76591#1939318, @jasonliu wrote:

@nemanjai
AIX system assembler does not seem to like this new form.

Assembler:
test.s: line 46: 1252-086 The target of the branch instruction
        must be a relocatable or external expression.

llvm-objdump -d output may not be assembled back. That said, I think most users like the PC relative immediate to be displayed as the target address. If AIX users don't agree, I can special case it.

[hubert.reinterpretcast]

To maintain/correct the AIX output for the tools there seems to be a prerequisite fix to llvm::object::ObjectFile::makeTriple.

[MaskRay]

Force relative form bl .+ on AIX.

[sfertile]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCInstPrinter.cpp

438

Do we have a way to print the hex value without a leading '0x'? If we are making the effort to match binutils objump, why wouldn't we match exactly for this case?

[MaskRay]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCInstPrinter.cpp

438

Don't use formatHex then we are done. However, I actually think an explicit 0x is better.

A GNU objdump -d result (x86_64) cannot be re-assembled back. The omission of 0x is one of the reasons.

[sfertile]

In D76591#1939442, @MaskRay wrote:

In D76591#1939318, @jasonliu wrote:

@nemanjai
AIX system assembler does not seem to like this new form.

Assembler:
test.s: line 46: 1252-086 The target of the branch instruction
        must be a relocatable or external expression.

llvm-objdump -d output may not be assembled back. That said, I think most users like the PC relative immediate to be displayed as the target address. If AIX users don't agree, I can special case it.

Sorry for the churn but I think your initial approach is correct. objdump on AIX also prints the target address as hex and like you say, the output isn't meant to be assembled back. Any cases where we the output is asm are unaltered right?

llvm/lib/Target/PowerPC/MCTargetDesc/PPCInstPrinter.cpp

438

I don't feel too strongly either way but I though the tools that are replicating binutils tools are meant to be exact drop-in replacements outside of replicating bugs. If this is one of many things that precludes objdumps output from being disassembled then we should prioritize compatibility, otherwise I have no reservations about keeping the leading `0x'.

[MaskRay]

The new form actually matches GNU objdump -d output.

In GNU objdump, on x86-64, 0x is omitted. On powerpc, 0x is kept...

[MaskRay]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCInstPrinter.cpp

438

Sorry, I was mistaken. GNU objdump -d on powerpc actually keeps the leading 0x. So we are actually consistent with GNU objdump.

[sfertile]

LGTM.

[jhenderson]

LGTM too.

llvm/lib/Target/PowerPC/MCTargetDesc/PPCInstPrinter.cpp

421

Thanks!

lld/test/ELF/ppc32-call-stub-nopic.s

 
 # RELOC:      .rela.plt {
 # RELOC-NEXT:   0x100302C4 R_PPC_JMP_SLOT f 0x0
 # RELOC-NEXT:   0x100302C8 R_PPC_JMP_SLOT g 0x0
 # RELOC-NEXT: }
 
 ## .got2+0x8000-0x10004 = 0x30000+0x8000-0x10004 = 65536*2+32764
 # CHECK-LABEL: <_start>:
-# CHECK-NEXT:    bl .+16
-# CHECK-NEXT:    bl .+12
-# CHECK-NEXT:    bl .+24
-# CHECK-NEXT:    bl .+20
+# CHECK-NEXT:    bl 0x100101d0
+# CHECK-NEXT:    bl 0x100101d0
+# CHECK-NEXT:    bl 0x100101e0
+# CHECK-NEXT:    bl 0x100101e0
 # CHECK-EMPTY:
 
 ## -fno-PIC call stubs of f and g.
 ## .plt[0] = 0x100302c4 = 65536*4099+708
 ## .plt[1] = 0x100302c8 = 65536*4099+712
 # CHECK-NEXT:  <00000000.plt_call32.f>:
 # CHECK-NEXT:    lis 11, 4099
 # CHECK-NEXT:    lwz 11, 708(11)

lld/test/ELF/ppc32-call-stub-pic.s

 # DYN: PPC_GOT 0x20368
 
 ## .got2+0x8000-0x10004 = 0x30000+0x8000-0x10004 = 65536*2+32764
 # CHECK-LABEL: <_start>:
 # CHECK-NEXT:         bcl 20, 31, .+4
 # PIE-NEXT:    10210: mflr 30
 # PIE-NEXT:           addis 30, 30, 3
 # PIE-NEXT:           addi 30, 30, -32412
-# SHARED-NEXT: 10230: mflr 30
-# SHARED-NEXT:        addis 30, 30, 3
-# SHARED-NEXT:        addi 30, 30, -32420
-
 ## Two bl 00008000.got2.plt_pic32.f
-# CHECK-NEXT:    bl .+40
-# CHECK-NEXT:    bl .+36
+# PIE-NEXT:           bl 0x10244
+# PIE-NEXT:           bl 0x10244
 ## Two bl 00008000.got2.plt_pic32.g
-# CHECK-NEXT:    bl .+48
-# CHECK-NEXT:    bl .+44
+# PIE-NEXT:           bl 0x10254
+# PIE-NEXT:           bl 0x10254
 ## Two bl 00008000.got2.plt_pic32.h
-# CHECK-NEXT:    bl .+56
-# CHECK-NEXT:    bl .+52
-# CHECK-NEXT:    addis 30, 30, {{.*}}
-# CHECK-NEXT:    addi 30, 30, {{.*}}
+# PIE-NEXT:           bl 0x10264
+# PIE-NEXT:           bl 0x10264
+# PIE-NEXT:           addis 30, 30, {{.*}}
+# PIE-NEXT:           addi 30, 30, {{.*}}
 ## bl 00008000.plt_pic32.f
-# CHECK-NEXT:    bl .+56
+# PIE-NEXT:           bl 0x10274
 ## bl 00008000.plt_pic32.f
-# CHECK-NEXT:    bl .+68
+# PIE-NEXT:           bl 0x10284
+# SHARED-NEXT: 10230: mflr 30
+# SHARED-NEXT:        addis 30, 30, 3
+# SHARED-NEXT:        addi 30, 30, -32420
+# SHARED-NEXT:        bl 0x10264
+# SHARED-NEXT:        bl 0x10264
+# SHARED-NEXT:        bl 0x10274
+# SHARED-NEXT:        bl 0x10274
+# SHARED-NEXT:        bl 0x10284
+# SHARED-NEXT:        bl 0x10284
+# SHARED-NEXT:        addis 30, 30, {{.*}}
+# SHARED-NEXT:        addi 30, 30, {{.*}}
+# SHARED-NEXT:        bl 0x10294
+# SHARED-NEXT:        bl 0x102a4
 # CHECK-EMPTY:
 
 ## -fPIC call stubs of f and g.
 # CHECK-NEXT:  <00008000.got2.plt_pic32.f>:
 # CHECK-NEXT:    lwz 11, 32760(30)
 # CHECK-NEXT:    mtctr 11
 # CHECK-NEXT:    bctr
 # CHECK-NEXT:    nop

lld/test/ELF/ppc32-ifunc-nonpreemptible-nopic.s

 
 # SYM: 10010100 0 FUNC GLOBAL DEFAULT {{.*}} func
 # HEX: 0x10020110 10010100
 
 # CHECK:      Disassembly of section .text:
 # CHECK:      <.text>:
 # CHECK-NEXT: 100100e0: blr
 # CHECK:      <_start>:
-# CHECK-NEXT:   bl .+12
+# CHECK-NEXT:   bl 0x100100f0
 # CHECK-NEXT:   lis 9, 4097
 # CHECK-NEXT:   addi 9, 9, 256
 # CHECK-EMPTY:
 # CHECK-NEXT: <00000000.plt_call32.func>:
 ## 0x10020110 = 65536*4098+272
 # CHECK-NEXT:   lis 11, 4098
 # CHECK-NEXT:   lwz 11, 272(11)
 

lld/test/ELF/ppc32-ifunc-nonpreemptible-pic.s

 
 .section .got2,"aw"
 .long func
 
 # CHECK:      Disassembly of section .text:
 # CHECK:      <.text>:
 # CHECK-NEXT: 10188: blr
 # CHECK:      <_start>:
-# CHECK-NEXT:   bl .+12
+# CHECK-NEXT:   bl 0x10198
 # CHECK-NEXT:   lis 9, 1
 # CHECK-NEXT:   addi 9, 9, 424
 # CHECK-EMPTY:
 # CHECK-NEXT: <00008000.got2.plt_pic32.func>:
 ## 0x10020114 = 65536*4098+276
 # CHECK-NEXT:   lwz 11, -32764(30)
 # CHECK-NEXT:   mtctr 11
 # CHECK-NEXT:   bctr

lld/test/ELF/ppc32-long-thunk.s

 
 # RUN: ld.lld -T %t.script -pie %t.o -o %t
 # RUN: llvm-readelf -r %t | FileCheck --check-prefix=SEC %s
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck --check-prefixes=CHECK,PI %s
 
 # SEC: There are no relocations in this file.
 
 # CHECK:      <_start>:
-# CHECK-NEXT:     2000: bl .+24
-# CHECK-NEXT:           bl .+20
-# CHECK-NEXT:           bl .+16
-# CHECK-NEXT:           bl .+33554428
-# PD-NEXT:              bl .+24
-# PI-NEXT:              bl .+40
+# CHECK-NEXT:     2000: bl 0x2018
+# CHECK-NEXT:           bl 0x2018
+# CHECK-NEXT:           bl 0x2018
+# CHECK-NEXT:           bl 0x2002008
+# PD-NEXT:              bl 0x2028
+# PI-NEXT:              bl 0x2038
 
 ## high = 0x02002008 = 65536*512+8200
 # PD:         <__LongThunk_high>:
 # PD-NEXT:        2018: lis 12, 512
 # PD-NEXT:              addi 12, 12, 8200
 # PD-NEXT:              mtctr 12
 # PD-NEXT:              bctr
 

 bl high@local     # Need a thunk
 bl high@local     # Need a thunk
 bl high+32768@plt # Need a thunk
 bl high
 bl .text_high+16  # Need a thunk
 blr
 
 # PD:         02002008 <high>:
-# PD-NEXT:              bl .-33554432
-# PD-NEXT:              bl .+4
+# PD-NEXT:              bl 0x2008
+# PD-NEXT:              bl 0x2002010
 # PD:         <__LongThunk_>:
 # PD-NEXT:     2002010: lis 12, 0
 # PD-NEXT:              addi 12, 12, 8200
 # PD-NEXT:              mtctr 12
 # PD-NEXT:              bctr
 
 .section .text_high, "ax", %progbits
 nop
 nop
 .globl high
 high:
 bl .text_low+8
 bl .text_low+8    # Need a thunk

lld/test/ELF/ppc32-tls-gd.s

 # GD-REL-NEXT:   0x20360 R_PPC_DTPMOD32 b 0x0
 # GD-REL-NEXT:   0x20364 R_PPC_DTPREL32 b 0x0
 # GD-REL-NEXT:   0x20368 R_PPC_DTPMOD32 c 0x0
 # GD-REL-NEXT:   0x2036C R_PPC_DTPREL32 c 0x0
 # GD-REL-NEXT: }
 
 ## &DTPMOD(a) - _GLOBAL_OFFSET_TABLE_ = 0x20078 - 0x20078 = 0
 # GD:      addi 3, 31, 0
-# GD-NEXT: bl .+32
+# GD-NEXT: bl 0x1028c
 # GD-NEXT: lwz 3, 0(3)
 
 ## &DTPMOD(b) - _GLOBAL_OFFSET_TABLE_ = 0x20080 - 0x20078 = 8
 # GD-NEXT: addi 3, 31, 8
-# GD-NEXT: bl .+20
+# GD-NEXT: bl 0x1028c
 # GD-NEXT: lwz 3, 0(3)
 
 ## &DTPMOD(c) - _GLOBAL_OFFSET_TABLE_ = 0x20088 - 0x20078 = 16
 # GD-NEXT: addi 3, 9, 16
-# GD-NEXT: bl .+8
+# GD-NEXT: bl 0x1028c
 # GD-NEXT: lwz 3, 0(3)
 
 # NOREL: no relocations
 
 ## a@tprel = 8-0x7000 = -28664
 # LE:      addis 3, 2, 0
 # LE-NEXT: addi 3, 3, -28664
 # LE-NEXT: lwz 3, 0(3)

lld/test/ELF/ppc32-tls-ld.s

 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck --check-prefix=LE %s
 
 # LD-REL:      .rela.dyn {
 # LD-REL-NEXT:   0x202C4 R_PPC_DTPMOD32 - 0x0
 # LD-REL-NEXT: }
 
 ## .got - _GLOBAL_OFFSET_TABLE_ = 0
 # LD:      addi 3, 30, 0
-# LD-NEXT: bl .+40
+# LD-NEXT: bl 0x101f8
 ## a@dtprel = st_value(a)-0x8000 = 65540-0x8000 = 65536*1-32764
 ## b@dtprel = st_value(a)-0x8000 = 131080-0x8000 = 65536*2-32760
 # LD-NEXT: addis 9, 3, 1
 # LD-NEXT: addis 10, 3, 2
 # LD-NEXT: addi 9, 9, -32764
 # LD-NEXT: addi 10, 10, -32760
 ## small@dtprel = st_value(small)-0x8000 = 4-0x8000 = -32764
 # LD-NEXT: addi 9, 3, -32764
 
 ## Check that b@got@tlsld does not allocate another GOT entry.
 ## It shares In.Got->TlsIndexOff allocated when processing a@got@tlsld.
 ## .got - _GLOBAL_OFFSET_TABLE_ = 0
 # LD-NEXT: addi 3, 9, 0
-# LD-NEXT: bl .+12
+# LD-NEXT: bl 0x101f8
 ## b@dtprel = st_value(a)-0x8000 = 131080-0x8000 = 65536*2-32760
 # LD-NEXT: addis 29, 3, 2
 # LD-NEXT: addi 29, 29, -32760
 
 ## When producing an executable, the LD code sequence can be relaxed to LE.
 ## It is the same as GD->LE.
 ## tpoff(_TLS_MODULE_BASE_) = 0, tpoff(a) = -8, tpoff(b) = -4
 

lld/test/ELF/ppc32-weak-undef-call.s

 # REQUIRES: ppc
 # RUN: llvm-mc -filetype=obj -triple=powerpc %s -o %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck --check-prefix=PDE %s
 # RUN: ld.lld -pie %t.o -o %t
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck --check-prefix=PIC %s
 # RUN: ld.lld -shared %t.o -o %t
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck --check-prefix=PIC %s
 
 ## It does not really matter how we fixup it, but we cannot overflow and
 ## should not generate a call stub (this would waste space).
-# PDE: bl .+0
+# PDE: bl 0x100100b4
 
 ## With -pie or -shared, create a call stub. ld.bfd produces bl .+0
-# PIC: bl .+4
-# PIC: <00000000.plt_pic32.foo>:
+# PIC:       bl 0x[[PLT:[0-9a-f]+]]
+# PIC-EMPTY:
+# PIC-NEXT:  000[[PLT]] <00000000.plt_pic32.foo>:
 
 .weak foo
 bl foo

lld/test/ELF/ppc64-bsymbolic-toc-restore.s

 # REQUIRES: ppc
 
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %p/Inputs/ppc64-bsymbolic-local-def.s  -o %t2.o
 # RUN: ld.lld -Bsymbolic -shared %t1.o %t2.o -o %t
-# RUN: llvm-objdump -d -r %t | FileCheck %s
+# RUN: llvm-objdump -d -r --no-show-raw-insn %t | FileCheck %s
 # RUN: not ld.lld -shared %t1.o %t2.o -o /dev/null 2>&1 | FileCheck --check-prefix=FAIL %s
 
 # RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %p/Inputs/ppc64-bsymbolic-local-def.s  -o %t2.o
 # RUN: ld.lld -Bsymbolic -shared %t1.o %t2.o -o %t
-# RUN: llvm-objdump -d -r %t | FileCheck %s
+# RUN: llvm-objdump -d -r --no-show-raw-insn %t | FileCheck %s
 # RUN: not ld.lld -shared %t1.o %t2.o -o /dev/null 2>&1 | FileCheck --check-prefix=FAIL %s
 
 # FAIL: call to def lacks nop, can't restore toc
 
 # Test to document the toc-restore behavior with -Bsymbolic option. Since
 # -Bsymbolic causes the call to bind to the internal definition we know the
 # caller and callee share the same TOC base. This means branching to the
 # local entry point of the callee, and no need for a nop to follow the call
.Lcaller_lep:
     blr
 
 # Note that the bl .+44 is a call to def's local entry, jumping past the first 2
 # instructions. Branching to the global entry would corrupt the TOC pointer
 # since the global entry requires that %r12 hold the address of the function
 # being called.
 
 # CHECK-LABEL: caller
-# CHECK:         bl .+44
+# CHECK:         bl 0x[[DEF:[0-9a-f]+]]
 # CHECK-NEXT:    mr 31, 3
-# CHECK-NEXT:    bl .+44
+# CHECK-NEXT:    bl 0x[[NOT_DEFINED:[0-9a-f]+]]
 # CHECK-NEXT:    ld 2, 24(1)
 # CHECK-NEXT:    add 3, 3, 31
 # CHECK-NEXT:    addi 1, 1, 32
 # CHECK-NEXT:    ld 0, -16(1)
 # CHECK-NEXT:    mtlr 0
 # CHECK-NEXT:    blr
 # CHECK-EMPTY:
 # CHECK-NEXT:  <def>:
 # CHECK-NEXT:    addis 2, 12, 2
 # CHECK-NEXT:    addi 2, 2, -32456
-# CHECK-NEXT:    li 3, 55
+# CHECK-NEXT:    [[DEF]]: li 3, 55
 # CHECK-NEXT:    blr
+# CHECK-EMPTY:
+# CHECK-NEXT:  00000000000[[NOT_DEFINED]] <__plt_not_defined>:

lld/test/ELF/ppc64-call-reach.s

.Llep:
         addi 1, 1, 32
         ld 0, 16(1)
         mtlr 0
         b tail_callee
 
 # Check that we are branching to the definitions, and not range-extending
 # thunks.
 # CHECK-LABEL: test
-# CHECK:  10010014:       bl .+33554428
+# CHECK:  10010014:       bl 0x12010010
 # CHECK:  10010024:       b  .+33554428
 
 # NEGOFFSET-LABEL: test
-# NEGOFFSET:  10010014:       bl .-33554432
+# NEGOFFSET:  10010014:       bl 0xe010014
 # NEGOFFSET:  10010024:       b  .+33554432
 
 # THUNK-LABEL: <test>:
-# THUNK: 10010014:       bl .+20
+# THUNK: 10010014:       bl 0x10010028
 # THUNK: 10010024:       b .+20
 
 # .branch_lt[0]
 # THUNK-LABEL: <__long_branch_callee>:
 # THUNK-NEXT: 10010028:       addis 12, 2, 1
 # THUNK-NEXT:                 ld 12, -32760(12)
 # THUNK-NEXT:                 mtctr 12
 # THUNK-NEXT:                 bctr

lld/test/ELF/ppc64-func-entry-points.s

glob:
   .long 10                      # 0xa
   .size glob, 4
 
 # Check that foo_external_diff has a global entry point and we branch to
 # foo_external_diff+8. Also check that foo_external_same has no global entry
 # point and we branch to start of foo_external_same.
 
 // CHECK-LABEL: <_start>:
-// CHECK:         100101f0: bl .+144
-// CHECK:         10010204: bl .+84
+// CHECK:         100101f0: bl 0x10010280
+// CHECK:         10010204: bl 0x10010258
 // CHECK-LABEL: <foo_external_diff>:
 // CHECK-NEXT:    10010250: addis 2, 12, 2
 // CHECK-NEXT:    10010254: addi 2, 2, -32696
 // CHECK-NEXT:    10010258: addis 5, 2, 1
 // CHECK-LABEL: <foo_external_same>:
 // CHECK-NEXT:    10010280: add 3, 4, 3

lld/test/ELF/ppc64-ifunc.s

 
 # SECTIONS: .plt NOBITS 00000000100302a0 0002a0 000018 00 WA 0 0 8
 
 # __plt_ifunc - . = 0x10010218 - 0x10010208 = 16
 # __plt_ifunc2 - . = 0x1001022c - 0x10010210 = 28
 # CHECK: <_start>:
 # CHECK-NEXT:                 addis 2, 12, 2
 # CHECK-NEXT:                 addi 2, 2, -32636
-# CHECK-NEXT: 1001021c:       bl .+32
+# CHECK-NEXT: 1001021c:       bl 0x1001023c
 # CHECK-NEXT:                 ld 2, 24(1)
-# CHECK-NEXT: 10010224:       bl .+44
+# CHECK-NEXT: 10010224:       bl 0x10010250
 # CHECK-NEXT:                 ld 2, 24(1)
 # CHECK-NEXT:                 addis 3, 2, -2
 # CHECK-NEXT:                 addi 3, 3, 32748
 # CHECK-NEXT:                 addis 3, 2, -2
 # CHECK-NEXT:                 addi 3, 3, 32732
 
 # .plt[0] - .TOC. = 0x100302a0 - 0x10028298 = (1<<16) - 32760
 # CHECK: <__plt_ifunc2>:

lld/test/ELF/ppc64-local-dynamic.s

 // When calculating offset relative to the dynamic thread pointer we have to
 // adjust by 0x8000 since each DTV pointer points 0x8000 bytes past the start of
 // its TLS block.
 // #ha(i@dtprel) --> (0x0 -0x8000 + 0x8000) >> 16 = 0
 // #lo(i@dtprel) --> (0x0 -0x8000) = -0x8000 = -32768
 // Dis:     <test>:
 // Dis:        addis 3, 2, 0
 // Dis-NEXT:   addi 3, 3, -32760
-// Dis-NEXT:   bl .+60
+// Dis-NEXT:   bl 0x10058
 // Dis-NEXT:   ld 2, 24(1)
 // Dis-NEXT:   addis 3, 3, 0
 // Dis-NEXT:   lwa 3, -32768(3)
 
 
 // #hi(j@got@tlsld) --> (0x20108 - 0x28100 ) > 16 = -1
 // Dis: <test_hi>:
 // Dis:   lis 3, -1
 
 // k@got@tlsld --> (0x20108 - 0x28100) = -7ff8 = -32760
 // Dis: <test_16>:
 // Dis:   li 3, -32760

lld/test/ELF/ppc64-long-branch-pi.s

 # RELOC-NEXT:   0x20020E8 R_PPC64_RELATIVE - 0x8000
 # RELOC-NEXT:   0x20020F0 R_PPC64_RELATIVE - 0x2002000
 # RELOC-NEXT:   0x20020F8 R_PPC64_RELATIVE - 0x2002008
 # RELOC-NEXT:   0x2002100 R_PPC64_RELATIVE - 0x200200C
 # RELOC-NEXT:   0x2002108 R_PPC64_RELATIVE - 0x2000
 # RELOC-NEXT: }
 
 # CHECK:      <_start>:
-# CHECK-NEXT:     2000:       bl .+16
-# CHECK-NEXT:                 bl .+33554428
-# CHECK-NEXT:                 bl .+24
-# CHECK-NEXT:                 bl .+36
+# CHECK-NEXT:     2000:       bl 0x2010
+# CHECK-NEXT:                 bl 0x2002000
+# CHECK-NEXT:                 bl 0x2020
+# CHECK-NEXT:                 bl 0x2030
 
 ## &.branch_lt[0] - .TOC. = .branch_lt - (.got+0x8000) = -32752
 # CHECK:      <__long_branch_>:
 # CHECK-NEXT:     2010:       addis 12, 2, 0
 # CHECK-NEXT:                 ld 12, -32752(12)
 # CHECK-NEXT:                 mtctr 12
 # CHECK-NEXT:                 bctr
 

 .globl _start
 _start:
 bl .text_high     # Need a thunk
 bl .text_high
 bl .text_high+8   # Need a thunk
 bl .text_high+0xc # Need a thunk
 
 # CHECK:      <high_target>:
-# CHECK-NEXT:  2002000:   bl .-33554428
-# CHECK-NEXT:             bl .-33554432
-# CHECK-NEXT:             bl .+8
+# CHECK-NEXT:  2002000:   bl 0x2004
+# CHECK-NEXT:             bl 0x2004
+# CHECK-NEXT:             bl 0x2002010
 
 ## &.branch_lt[3] - .TOC. = .branch_lt - (.got+0x8000) = -32728
 # CHECK:      <__long_branch_>:
 # CHECK-NEXT:  2002010:       addis 12, 2, 0
 # CHECK-NEXT:                 ld 12, -32728(12)
 # CHECK-NEXT:                 mtctr 12
 # CHECK-NEXT:                 bctr
 

lld/test/ELF/ppc64-long-branch.s

 
 ## high@localentry (high+8), .text_high+16 and .text_low+8
 # BRANCH-LE:      0x02002030 08200002 00000000 10200002 00000000
 # BRANCH-LE-NEXT: 0x02002040 08200000 00000000
 # BRANCH-BE:      0x02002030 00000000 02002008 00000000 02002010
 # BRANCH-BE-NEXT: 0x02002040 00000000 00002008
 
 # CHECK:      <_start>:
-# CHECK-NEXT:     2000:       bl .+24
-# CHECK-NEXT:                 bl .+20
-# CHECK-NEXT:                 bl .+16
-# CHECK-NEXT:                 bl .+33554428
+# CHECK-NEXT:     2000:       bl 0x2018
+# CHECK-NEXT:                 bl 0x2018
+# CHECK-NEXT:                 bl 0x2018
+# CHECK-NEXT:                 bl 0x2002008
 
 ## &.branch_lt[0] - .TOC. = .branch_lt - (.got+0x8000) = -32760
 # CHECK:      <__long_branch_high>:
 # CHECK-NEXT:     2018:       addis 12, 2, 0
 # CHECK-NEXT:                 ld 12, -32760(12)
 # CHECK-NEXT:                 mtctr 12
 # CHECK-NEXT:                 bctr
 

 bl .text_high+16 # Need a thunk
 blr
 
 # CHECK:      Disassembly of section .text_high:
 # CHECK-EMPTY:
 # CHECK-NEXT: <high>:
 # CHECK-NEXT:  2002000:       addis 2, 12, 1
 # CHECK-NEXT:                 addi 2, 2, -32728
-# CHECK-NEXT:                 bl .-33554432
-# CHECK-NEXT:                 bl .+8
+# CHECK-NEXT:                 bl 0x2008
+# CHECK-NEXT:                 bl 0x2002014
 # CHECK:      <__long_branch_>:
 # CHECK-NEXT:  2002014:       addis 12, 2, 0
 # CHECK-NEXT:                 ld 12, -32744(12)
 # CHECK-NEXT:                 mtctr 12
 # CHECK-NEXT:                 bctr
 
 .section .text_high, "ax", %progbits
 .globl high
 high:
 addis 2, 12, .TOC.-high@ha
 addi 2, 2, .TOC.-high@l
 .localentry high, 8
 bl .text_low+8
 bl .text_low+8 # Need a thunk
 blr

lld/test/ELF/ppc64-plt-stub.s

 # SEC: 0x0000000000000003 (PLTGOT) 0x100303e8
 
 ## .plt[0] holds the address of _dl_runtime_resolve.
 ## .plt[1] holds the link map.
 ## The JMP_SLOT relocation is stored at .plt[2]
 # RELOC: 0x10030010 R_PPC64_JMP_SLOT foo 0x0
 
 # CHECK:      <_start>:
-# CHECK:      10010298: bl .+16
+# CHECK:      10010298: bl 0x100102a8
 
 # CHECK-LABEL: 00000000100102a8 <__plt_foo>:
 # CHECK-NEXT:      std 2, 24(1)
 # CHECK-NEXT:      addis 12, 2, 1
 # CHECK-NEXT:      ld 12, -32744(12)
 # CHECK-NEXT:      mtctr 12
 # CHECK-NEXT:      bctr
 

lld/test/ELF/ppc64-rel-calls.s

 .global bar
 bar:
   bl _start
   nop
   bl .Lfoo
   nop
   blr
 
-# CHECK:      10010164: bl .-12
+# CHECK:      10010164: bl 0x10010158
 # CHECK-NEXT:           nop
-# CHECK-NEXT: 1001016c: bl .-20
+# CHECK-NEXT: 1001016c: bl 0x10010158
 # CHECK-NEXT:           nop
 # CHECK-NEXT:           blr

lld/test/ELF/ppc64-tls-gd.s

 # GD-REL-NEXT:   0x20550 R_PPC64_DTPREL64 b 0x0
 # GD-REL-NEXT:   0x20558 R_PPC64_DTPMOD64 c 0x0
 # GD-REL-NEXT:   0x20560 R_PPC64_DTPREL64 c 0x0
 # GD-REL-NEXT: }
 
 ## &DTPMOD(a) - .TOC. = &.got[0] - (.got+0x8000) = -32768
 # GD:      addis 3, 2, 0
 # GD-NEXT: addi 3, 3, -32768
-# GD-NEXT: bl .+36
+# GD-NEXT: bl 0x103f4
 # GD-NEXT: ld 2, 24(1)
 
 ## &DTPMOD(b) - .TOC. = &.got[2] - (.got+0x8000) = -32752
 # GD-NEXT: addis 3, 2, 0
 # GD-NEXT: addi 3, 3, -32752
-# GD-NEXT: bl .+20
+# GD-NEXT: bl 0x103f4
 # GD-NEXT: ld 2, 24(1)
 
 ## &DTPMOD(b) - .TOC. = &.got[4] - (.got+0x8000) = -32736
 # GD-NEXT: li 3, -32736
-# GD-NEXT: bl .+8
+# GD-NEXT: bl 0x103f4
 # GD-NEXT: ld 2, 24(1)
 
 # NOREL: no relocations
 
 ## a@tprel = st_value(a)-0x7000 = -28664
 # LE:      nop
 # LE-NEXT: addis 3, 13, 0
 # LE-NEXT: nop

lld/test/ELF/ppc64-toc-restore-recursive-call.s

 # required to follow the call.
 
 # The decision to use a plt-stub for the recursive call is not one I feel
 # strongly about either way. It was done because it matches what bfd and gold do
 # for recursive calls as well as keeps the logic for recursive calls consistent
 # with non-recursive calls.
 
 # CHECK-LABEL: 0000000000010290 <recursive_func>:
-# CHECK:       102b8:       bl .+32
+# CHECK:       102b8:       bl 0x102d8
 # CHECK-NEXT:               ld 2, 24(1)
 
 # CHECK-LABEL: 00000000000102d8 <__plt_recursive_func>:
 
         .abiversion 2
         .section ".text"
         .p2align 2
         .global recursive_func

lld/test/ELF/ppc64-toc-restore.s

 # Calling external function foo in a shared object needs a nop.
 # Calling local function bar_local doe not need a nop.
 .global _start
 _start:
   bl foo
   nop
   bl bar_local
 // CHECK-LABEL: <_start>:
-// CHECK-NEXT:  100102c8:       bl .+60
+// CHECK-NEXT:  100102c8:       bl 0x10010304
 // CHECK-NEXT:  100102cc:       ld 2, 24(1)
-// CHECK-NEXT:  100102d0:       bl .-16
+// CHECK-NEXT:  100102d0:       bl 0x100102c0
 // CHECK-EMPTY:
 
 # Calling a function in another object file which will have same
 # TOC base does not need a nop. If nop present, do not rewrite to
 # a toc restore
 .global diff_object
 _diff_object:
   bl foo_not_shared
   bl foo_not_shared
   nop
 // CHECK-LABEL: <_diff_object>:
-// CHECK-NEXT:  100102d4:       bl .+28
-// CHECK-NEXT:  100102d8:       bl .+24
+// CHECK-NEXT:  100102d4:       bl 0x100102f0
+// CHECK-NEXT:  100102d8:       bl 0x100102f0
 // CHECK-NEXT:  100102dc:       nop
 
 # Branching to a local function does not need a nop
 .global noretbranch
 noretbranch:
   b bar_local
 // CHECK-LABEL: <noretbranch>:
 // CHECK:       100102e0:        b .+67108832
 // CHECK-EMPTY:
 
 // This should come last to check the end-of-buffer condition.
 .global last
 last:
   bl foo
   nop
 // CHECK-LABEL: <last>:
-// CHECK-NEXT:  100102e4:       bl .+32
+// CHECK-NEXT:  100102e4:       bl 0x10010304
 // CHECK-NEXT:  100102e8:       ld 2, 24(1)

lld/test/ELF/ppc64-weak-undef-call.s

_start:
   blr
 
 .weak weakfunc
 
 # It does not really matter how we fixup the bl, if at all, because it needs to
 # be unreachable. But, we should link successfully. We should not, however,
 # generate a .plt entry (this would be wasted space). For now, we do nothing
 # (leaving the zero relative offset present in the input).
-# CHECK: 10010158:       bl .+0
+# CHECK: 10010158:       bl 0x10010158
 # CHECK: 1001015c:       nop
 # CHECK: 10010160:       blr

llvm/lib/Target/PowerPC/MCTargetDesc/PPCInstPrinter.h

public:
   void printU7ImmOperand(const MCInst *MI, unsigned OpNo, raw_ostream &O);
   void printU8ImmOperand(const MCInst *MI, unsigned OpNo, raw_ostream &O);
   void printU10ImmOperand(const MCInst *MI, unsigned OpNo, raw_ostream &O);
   void printU12ImmOperand(const MCInst *MI, unsigned OpNo, raw_ostream &O);
   void printS16ImmOperand(const MCInst *MI, unsigned OpNo, raw_ostream &O);
   void printS34ImmOperand(const MCInst *MI, unsigned OpNo, raw_ostream &O);
   void printU16ImmOperand(const MCInst *MI, unsigned OpNo, raw_ostream &O);
   void printImmZeroOperand(const MCInst *MI, unsigned OpNo, raw_ostream &O);
-  void printBranchOperand(const MCInst *MI, unsigned OpNo, raw_ostream &O);
-  void printBranchOperand(const MCInst *MI, uint64_t /*Address*/, unsigned OpNo,
-                          raw_ostream &O) {
-    printBranchOperand(MI, OpNo, O);
+  void printBranchOperand(const MCInst *MI, uint64_t Address, unsigned OpNo,
+    raw_ostream &O, bool RelativeForm = false);
+  void printBranchOperand(const MCInst *MI, unsigned OpNo, raw_ostream &O) {
+    printBranchOperand(MI, 0, OpNo, O, true);
   }
   void printAbsBranchOperand(const MCInst *MI, unsigned OpNo, raw_ostream &O);
   void printTLSCall(const MCInst *MI, unsigned OpNo, raw_ostream &O);
 
   void printcrbitm(const MCInst *MI, unsigned OpNo, raw_ostream &O);
 
   void printMemRegImm(const MCInst *MI, unsigned OpNo, raw_ostream &O);
   void printMemRegImm34PCRel(const MCInst *MI, unsigned OpNo, raw_ostream &O);
   void printMemRegImm34(const MCInst *MI, unsigned OpNo, raw_ostream &O);
   void printMemRegReg(const MCInst *MI, unsigned OpNo, raw_ostream &O);
 };
 } // end namespace llvm
 
 #endif

llvm/lib/Target/PowerPC/MCTargetDesc/PPCInstPrinter.cpp

 void PPCInstPrinter::printU16ImmOperand(const MCInst *MI, unsigned OpNo,
                                         raw_ostream &O) {
   if (MI->getOperand(OpNo).isImm())
     O << (unsigned short)MI->getOperand(OpNo).getImm();
   else
     printOperand(MI, OpNo, O);
 }
 
-void PPCInstPrinter::printBranchOperand(const MCInst *MI, unsigned OpNo,
-                                        raw_ostream &O) {
+void PPCInstPrinter::printBranchOperand(const MCInst *MI, uint64_t Address,
+                                        unsigned OpNo, raw_ostream &O,
+                                        bool RelativeForm) {
   if (!MI->getOperand(OpNo).isImm())
     return printOperand(MI, OpNo, O);
-
+  int32_t Imm = SignExtend32<32>((unsigned)MI->getOperand(OpNo).getImm() << 2);
+  if (RelativeForm) {
     // Branches can take an immediate operand. This is used by the branch
-  // selection pass to print, for example `.+8` (for ELF) or `$+8` (for AIX) to
-  // express an eight byte displacement from the program counter.
+    // selection pass to print, for example `.+8` (for ELF) or `$+8` (for AIX)
+    // to express an eight byte displacement from the program counter.
     if (!TT.isOSAIX())
       O << ".";
     else
       O << "$";
 
-  int32_t Imm = SignExtend32<32>((unsigned)MI->getOperand(OpNo).getImm() << 2);
     if (Imm >= 0)
       O << "+";
     O << Imm;
+  } else {
+    uint64_t Target = Address + Imm;
+    if (!TT.isPPC64())
+      Target &= 0xffffffff;
+    O << formatHex(Target);
+  }
 }
 
 void PPCInstPrinter::printAbsBranchOperand(const MCInst *MI, unsigned OpNo,
                                            raw_ostream &O) {
   if (!MI->getOperand(OpNo).isImm())
     return printOperand(MI, OpNo, O);
 
   O << SignExtend32<32>((unsigned)MI->getOperand(OpNo).getImm() << 2);

llvm/test/CodeGen/PowerPC/aix-user-defined-memcpy.ll

 ; 32-DIS-NEXT:        0: 38 60 00 03                   li 3, 3
 ; 32-DIS-NEXT:        4: 4e 80 00 20                   blr
 ; 32-DIS-NEXT:        8: 60 00 00 00                   nop
 ; 32-DIS-NEXT:        c: 60 00 00 00                   nop
 ; 32-DIS:      00000010 <.call_memcpy>:
 ; 32-DIS-NEXT:       10: 7c 08 02 a6                   mflr 0
 ; 32-DIS-NEXT:       14: 90 01 00 08                   stw 0, 8(1)
 ; 32-DIS-NEXT:       18: 94 21 ff c0                   stwu 1, -64(1)
-; 32-DIS-NEXT:       1c: 4b ff ff e5                   bl .-28
+; 32-DIS-NEXT:       1c: 4b ff ff e5                   bl 0x0
 ; 32-DIS-NEXT:       20: 60 00 00 00                   nop
 ; 32-DIS-NEXT:       24: 38 21 00 40                   addi 1, 1, 64
 ; 32-DIS-NEXT:       28: 80 01 00 08                   lwz 0, 8(1)
 ; 32-DIS-NEXT:       2c: 7c 08 03 a6                   mtlr 0
 ; 32-DIS-NEXT:       30: 4e 80 00 20                   blr
 
 ; 64-CHECK: LLVM ERROR: 64-bit XCOFF object files are not supported yet.

llvm/test/CodeGen/PowerPC/aix-xcoff-reloc.ll

 
 ; DIS:      {{.*}}aix-xcoff-reloc.ll.tmp.o:   file format aixcoff-rs6000
 ; DIS:      Disassembly of section .text:
 ; DIS:      00000000 <.text>:
 ; DIS-NEXT:        0: 7c 08 02 a6                   mflr 0
 ; DIS-NEXT:        4: 90 01 00 08                   stw 0, 8(1)
 ; DIS-NEXT:        8: 94 21 ff c0                   stwu 1, -64(1)
 ; DIS-NEXT:        c: 38 60 00 01                   li 3, 1
-; DIS-NEXT:       10: 4b ff ff f1                   bl .-16
+; DIS-NEXT:       10: 4b ff ff f1                   bl 0x0
 ; DIS-NEXT:       14: 60 00 00 00                   nop
 ; DIS-NEXT:       18: 80 82 00 00                   lwz 4, 0(2)
 ; DIS-NEXT:       1c: 80 a2 00 04                   lwz 5, 4(2)
 ; DIS-NEXT:       20: 80 84 00 00                   lwz 4, 0(4)
 ; DIS-NEXT:       24: 80 a5 00 00                   lwz 5, 0(5)
 ; DIS-NEXT:       28: 7c 63 22 14                   add 3, 3, 4
 ; DIS-NEXT:       2c: 7c 63 2a 14                   add 3, 3, 5
 ; DIS-NEXT:       30: 38 21 00 40                   addi 1, 1, 64

llvm/test/tools/llvm-objdump/ELF/PowerPC/branch-offset.s

 # RUN: llvm-mc -triple=powerpc -filetype=obj %s -o %t.32.o
 # RUN: llvm-objdump -d --no-show-raw-insn %t.32.o | FileCheck --check-prefixes=ELF32,CHECK %s
 
 # RUN: llvm-mc -triple=powerpc64le -filetype=obj %s -o %t.64.o
 # RUN: llvm-objdump -d --no-show-raw-insn %t.64.o | FileCheck --check-prefixes=ELF64,CHECK %s
 
 # RUN: llvm-mc -triple=powerpc64 -filetype=obj %s -o %t.64.o
 # RUN: llvm-objdump -d --no-show-raw-insn %t.64.o | FileCheck --check-prefixes=ELF64,CHECK %s
 
 # CHECK-LABEL: <bl>:
-# ELF32-NEXT:   bl .-4
-# ELF64-NEXT:   bl .-4
-# CHECK-NEXT:   bl .+0
-# CHECK-NEXT:   bl .+4
+# ELF32-NEXT:   bl 0xfffffffc
+# ELF64-NEXT:   bl 0xfffffffffffffffc
+# CHECK-NEXT:   bl 0x4
+# CHECK-NEXT:   bl 0xc
 
 bl:
   bl .-4
   bl .
   bl .+4
 
 # CHECK-LABEL: <b>:
 # CHECK-NEXT:   b .+67108860