[PowerPC] Fix thunk alignment issue when using pc-rel instruction

[NeHuang]

Summary

Thunk alignment is needed when using pc-rel instructions to avoid crossing the 64 byte boundary.

Patched by @nemanjai

[NeHuang]

• Updated the LIT cases accordingly.
• Create a test case for thunk alignment fix.

[MaskRay]

lld/test/ELF/ppc64-thunk-alignment.s

1 ↗

(On Diff #285706)

I don't think the additional test is necessary. The address differences should be reflected by other tests.

Having too many tests for a feature is also something we should try to avoid.

[MaskRay]

lld/test/ELF/ppc64-toc-call-to-pcrel.s

35

Doesn't it have <__toc_save_callee>?

[NeHuang]

Thanks MaskRay. The additional test removed.

[NeHuang]

lld/test/ELF/ppc64-thunk-alignment.s

1 ↗

(On Diff #285706)

Will do.

lld/test/ELF/ppc64-toc-call-to-pcrel.s

35

Sorry I did not quite get your point. 0x10020040 is the start address of __toc_save_callee stub.

[MaskRay]

lld/test/ELF/ppc64-toc-call-to-pcrel.s

35

For b and bl , objdump -d symbolizes the target address. If it symbolizes bfl and the result is meaningful, please add <__toc_save_callee>

[NeHuang]

lld/test/ELF/ppc64-toc-call-to-pcrel.s

35

Thanks for the clarification. Run object dump with llvm-objdump -d --no-show-raw-insn --mcpu=future ppc64-toc-call-to-pcrel.s.tmp and got results as below, I do not think the dis-assembler gives us the stub name for bfl and we can not add <__toc_save_callee> here.

...
1002002c: lwz 3, 32724(30)
10020030: bfl 0, 0x10020040
10020034: ld 2, 24(1)
...

[sfertile]

LGTM.

lld/ELF/SyntheticSections.cpp

return llvm::find_if(exidxSections, [](InputSection *isec) {
          }) != exidxSections.end();
 }
 
 bool ARMExidxSyntheticSection::classof(const SectionBase *d) {
   return d->kind() == InputSectionBase::Synthetic && d->type == SHT_ARM_EXIDX;
 }
 
 ThunkSection::ThunkSection(OutputSection *os, uint64_t off)
-    : SyntheticSection(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS, 4,
-                       ".text.thunk") {
+    : SyntheticSection(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS,
+                       config->emachine == EM_PPC64 ? 16 : 4, ".text.thunk") {
   this->parent = os;
   this->outSecOff = off;
 }
 
 size_t ThunkSection::getSize() const {
   if (roundUpSizeForErrata)
     return alignTo(size, 4096);
   return size;

lld/ELF/Thunks.cpp

 };
 
 // PPC64 R12 Setup Stub
 // When a caller that does not maintain a toc-pointer performs a local call to
 // a callee which requires a toc-pointer then we need this stub to place the
 // callee's global entry point into r12 without a save of R2.
 class PPC64R12SetupStub final : public Thunk {
 public:
-  PPC64R12SetupStub(Symbol &dest) : Thunk(dest, 0) {}
+  PPC64R12SetupStub(Symbol &dest) : Thunk(dest, 0) { alignment = 16; }
   uint32_t size() override { return 16; }
   void writeTo(uint8_t *buf) override;
   void addSymbols(ThunkSection &isec) override;
 };
 
 // PPC64 PC-relative PLT Stub
 // When a caller that does not maintain a toc-pointer performs an extern call
 // then this stub is needed for:
 // 1) Loading the target functions address from the procedure linkage table into
 //    r12 for use by the target functions global entry point, and into the count
 //    register with pc-relative instructions.
 // 2) Transferring control to the target function through an indirect branch.
 class PPC64PCRelPLTStub final : public Thunk {
 public:
-  PPC64PCRelPLTStub(Symbol &dest) : Thunk(dest, 0) {}
+  PPC64PCRelPLTStub(Symbol &dest) : Thunk(dest, 0) { alignment = 16; }
   uint32_t size() override { return 16; }
   void writeTo(uint8_t *buf) override;
   void addSymbols(ThunkSection &isec) override;
   bool isCompatibleWith(const InputSection &isec,
                         const Relocation &rel) const override;
 };
 
 // A bl instruction uses a signed 24 bit offset, with an implicit 4 byte

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

 # 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:    addi 2, 2, -32448
 # CHECK-NEXT:    [[DEF]]: li 3, 55
 # CHECK-NEXT:    blr
+# CHECK-NEXT:    trap
+# CHECK-NEXT:    trap
 # CHECK-EMPTY:
 # CHECK-NEXT:  00000000000[[NOT_DEFINED]] <__plt_not_defined>:

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

 # CHECK:  10010014:       bl 0x12010010
 # CHECK:  10010024:       b  0x12010020
 
 # NEGOFFSET-LABEL: test
 # NEGOFFSET:  10010014:       bl 0xe010014
 # NEGOFFSET:  10010024:       b  0xe010024
 
 # THUNK-LABEL: <test>:
-# THUNK: 10010014:       bl 0x10010028
-# THUNK: 10010024:       b 0x10010038
+# THUNK: 10010014:       bl 0x10010030
+# THUNK: 10010024:       b 0x10010040
 
 # .branch_lt[0]
 # THUNK-LABEL: <__long_branch_callee>:
-# THUNK-NEXT: 10010028:       addis 12, 2, 1
+# THUNK-NEXT: 10010030:       addis 12, 2, 1
 # THUNK-NEXT:                 ld 12, -32760(12)
 # THUNK-NEXT:                 mtctr 12
 # THUNK-NEXT:                 bctr
 
 # .branch_lt[1]
 # THUNK-LABEL: <__long_branch_tail_callee>:
-# THUNK-NEXT: 10010038:       addis 12, 2, 1
+# THUNK-NEXT: 10010040:       addis 12, 2, 1
 # THUNK-NEXT:                 ld 12, -32752(12)
 # THUNK-NEXT:                 mtctr 12
 # THUNK-NEXT:                 bctr
 
 # The offset from the TOC to the .branch_lt section  is (-1 << 16) - 32768.
 #                Name             Type            Address          Off    Size
 # BRANCHLT:     .got              PROGBITS        0000000010020000 020000 000008
 # BRANCHLT:     .branch_lt        PROGBITS        0000000010030008 020008 000010
 # BRANCHLT-NOT: .plt

lld/test/ELF/ppc64-dtprel.s

 // OutputRelocs:      Relocation section '.rela.dyn' at offset 0x{{[0-9a-f]+}} contains 1 entries:
 // OutputRelocs-NEXT: Offset Info Type Symbol's Value Symbol's Name + Addend
 // OutputRelocs-NEXT: R_PPC64_DTPMOD64
 
 
 // The got entry for i is at .got+8*1 = 0x4209e0
 // i@dtprel = 1024 - 0x8000 = -31744 = 0xffffffffffff8400
 // HEX-LE:      section '.got':
-// HEX-LE-NEXT: 4209c8 c8894200 00000000 00000000 00000000
-// HEX-LE-NEXT: 4209d8 00000000 00000000
+// HEX-LE-NEXT: 4209d0 d0894200 00000000 00000000 00000000
+// HEX-LE-NEXT: 4209e0 00000000 00000000
 
 // HEX-BE:      section '.got':
-// HEX-BE-NEXT: 4209c8 00000000 004289c8 00000000 00000000
-// HEX-BE-NEXT: 4209d8 00000000 00000000
+// HEX-BE-NEXT: 4209d0 00000000 004289d0 00000000 00000000
+// HEX-BE-NEXT: 4209e0 00000000 00000000
 
 // Dis:     <test>:
 // Dis:      addi 4, 3, -31744
 // Dis-NEXT: lwa 4, -31744(3)
 
 // #k@dtprel(1024 + 4 + 1024 * 1024 * 4) = 0x400404
 
 // #highesta(k@dtprel) --> ((0x400404 - 0x8000 + 0x8000) >> 48) & 0xffff = 0

lld/test/ELF/ppc64-ifunc.s

 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-readelf -s %t | FileCheck --check-prefix=SYM %s
 # RUN: llvm-readelf -S %t | FileCheck --check-prefix=SECTIONS %s
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
 # RUN: llvm-readobj -r %t | FileCheck --check-prefix=REL %s
 
 # SYM: Value            Size Type   Bind   Vis     Ndx
 # SYM: 0000000010028298    0 NOTYPE LOCAL  HIDDEN    4 .TOC.
-# SYM: 0000000010010284    0 FUNC   GLOBAL DEFAULT   3 ifunc1
+# SYM: 0000000010010288    0 FUNC   GLOBAL DEFAULT   3 ifunc1
 # SYM: 0000000010010210    0 IFUNC  GLOBAL DEFAULT   2 ifunc2
-# SYM: 0000000010010274    0 FUNC   GLOBAL DEFAULT   3 ifunc3
+# SYM: 0000000010010278    0 FUNC   GLOBAL DEFAULT   3 ifunc3
 
 # 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 0x1001023c
+# CHECK-NEXT: 1001021c:       bl 0x10010240
 # CHECK-NEXT:                 ld 2, 24(1)
-# CHECK-NEXT: 10010224:       bl 0x10010250
+# CHECK-NEXT: 10010224:       bl 0x10010254
 # CHECK-NEXT:                 ld 2, 24(1)
 # CHECK-NEXT:                 addis 3, 2, -2
-# CHECK-NEXT:                 addi 3, 3, 32748
+# CHECK-NEXT:                 addi 3, 3, 32752
 # CHECK-NEXT:                 addis 3, 2, -2
-# CHECK-NEXT:                 addi 3, 3, 32732
+# CHECK-NEXT:                 addi 3, 3, 32736
 
 # .plt[0] - .TOC. = 0x100302a0 - 0x10028298 = (1<<16) - 32760
 # CHECK: <__plt_ifunc2>:
 # CHECK-NEXT:     std 2, 24(1)
 # CHECK-NEXT:     addis 12, 2, 1
 # CHECK-NEXT:     ld 12, -32760(12)
 # CHECK-NEXT:     mtctr 12
 # CHECK-NEXT:     bctr
 
 # .plt[1] - .TOC. = 0x100302a0+8 - 0x10028298 = (1<<16) - 32752
 # CHECK: <__plt_ifunc3>:
 # CHECK-NEXT:     std 2, 24(1)
 # CHECK-NEXT:     addis 12, 2, 1
 # CHECK-NEXT:     ld 12, -32752(12)
 # CHECK-NEXT:     mtctr 12
 # CHECK-NEXT:     bctr
 # CHECK-EMPTY:
 
 ## .glink has 3 IPLT entries for ifunc1, ifunc2 and ifunc3.
 ## ifunc2 and ifunc3 have the same code sequence as their PLT call stubs.
 # CHECK:      Disassembly of section .glink:
 # CHECK-EMPTY:
-# CHECK-NEXT: 0000000010010264 <.glink>:
+# CHECK-NEXT: 0000000010010268 <.glink>:
 # CHECK-NEXT:     addis 12, 2, 1
 # CHECK-NEXT:     ld 12, -32760(12)
 # CHECK-NEXT:     mtctr 12
 # CHECK-NEXT:     bctr
 # CHECK-EMPTY:
-# CHECK-NEXT: 0000000010010274 <ifunc3>:
+# CHECK-NEXT: 0000000010010278 <ifunc3>:
 # CHECK-NEXT:     addis 12, 2, 1
 # CHECK-NEXT:     ld 12, -32752(12)
 # CHECK-NEXT:     mtctr 12
 # CHECK-NEXT:     bctr
 # CHECK-EMPTY:
-# CHECK-NEXT: 0000000010010284 <ifunc1>:
+# CHECK-NEXT: 0000000010010288 <ifunc1>:
 # CHECK-NEXT:     addis 12, 2, 1
 # CHECK-NEXT:     ld 12, -32744(12)
 # CHECK-NEXT:     mtctr 12
 # CHECK-NEXT:     bctr
 
 ## Check that we emit 3 R_PPC64_IRELATIVE in .rela.dyn.
 # REL:      .rela.dyn {
 # REL-NEXT:   0x100302A0 R_PPC64_IRELATIVE - 0x10010210

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 0x10058
+// Dis-NEXT:   bl 0x10060
 // 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-init.s

 # REQUIRES: ppc
 
 # RUN: llvm-mc -filetype=obj -triple=powerpc64-pc-freebsd13.0 %s -o %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
 
 ## .init consists of sections from several object files. Sections other than the
 ## last one do not have a terminator. Check we do not create a long branch stub
 ## in the middle.
 ## We currently use thunk section spacing to ensure the stub is in the end. This
 ## is not foolproof but good enough to not break in practice.
 
 # CHECK: Disassembly of section .init:
 # CHECK-EMPTY:
 # CHECK-LABEL: <_init>:
 # CHECK:         blr
+# CHECK-NEXT:    trap
+# CHECK-NEXT:    trap
 # CHECK-EMPTY:
 # CHECK-LABEL: <__long_branch_foo>:
 
 .globl foo
 foo:
   .space 0x2000000
   blr
 

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

 # RUN: llvm-mc -filetype=obj -triple=powerpc64le %s -o %t.o
 # RUN: ld.lld -pie -T %t.lds %t.o -o %t
 # RUN: llvm-readelf -r %t | FileCheck --check-prefix=SEC %s
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
 
 # SEC: There are no relocations in this file.
 
 # CHECK-LABEL: <_start>:
-# CHECK-NEXT:  2000: bt 2, 0x2014
-# CHECK-NEXT:        bt+ 2, 0x2014
+# CHECK-NEXT:  2000: bt 2, 0x2020
+# CHECK-NEXT:        bt+ 2, 0x2020
 # CHECK-NEXT:        bf 2, 0xa004
-# CHECK-NEXT:        bt 2, 0x2024
+# CHECK-NEXT:        bt 2, 0x2030
 # CHECK-NEXT:        blr
+# CHECK-NEXT:        trap
+# CHECK-NEXT:        trap
+# CHECK-NEXT:        trap
 # CHECK-EMPTY:
 # CHECK-NEXT: <__long_branch_high>:
-# CHECK-NEXT:  2014: addis 12, 2, 0
+# CHECK-NEXT:  2020: addis 12, 2, 0
 # CHECK-NEXT:        ld 12, {{.*}}(12)
 # CHECK-NEXT:        mtctr 12
 # CHECK-NEXT:        bctr
 # CHECK-EMPTY:
 
 # CHECK-NEXT: <__long_branch_>:
-# CHECK-NEXT:  2024: addis 12, 2, 0
+# CHECK-NEXT:  2030: addis 12, 2, 0
 # CHECK-NEXT:        ld 12, {{.*}}(12)
 # CHECK-NEXT:        mtctr 12
 # CHECK-NEXT:        bctr
 
 .section .text_low, "ax", @progbits
 .globl _start
 _start:
 beq high           # Need a thunk

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

 # RUN: llvm-mc -filetype=obj -triple=ppc64 %s -o %t.o
 # RUN: ld.lld -T %t.script %t.o -o %t
 # RUN: llvm-readelf -S -r %t | FileCheck --check-prefix=SEC %s
 # RUN: llvm-readelf -x .branch_lt %t | FileCheck --check-prefix=BRANCH-BE %s
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
 # RUN: llvm-nm --no-sort %t | FileCheck --check-prefix=NM %s
 
 # SEC: Name       Type     Address          Off     Size   ES Flg Lk Inf Al
-# SEC: .got       PROGBITS 0000000002002028 2002028 000008 00  WA  0   0  8
-# SEC: .branch_lt PROGBITS 0000000002002030 2002030 000018 00  WA  0   0  8
+# SEC: .got       PROGBITS 0000000002002030 2002030 000008 00  WA  0   0  8
+# SEC: .branch_lt PROGBITS 0000000002002038 2002038 000018 00  WA  0   0  8
 
 # SEC: There are no relocations in this file.
 
 ## 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
+# BRANCH-LE:      0x02002038 08200002 00000000 10200002 00000000
+# BRANCH-LE-NEXT: 0x02002048 08200000 00000000
+# BRANCH-BE:      0x02002038 00000000 02002008 00000000 02002010
+# BRANCH-BE-NEXT: 0x02002048 00000000 00002008
 
 # CHECK:      <_start>:
-# CHECK-NEXT:     2000:       bl 0x2018
-# CHECK-NEXT:                 bl 0x2018
-# CHECK-NEXT:                 bl 0x2018
+# CHECK-NEXT:     2000:       bl 0x2020
+# CHECK-NEXT:                 bl 0x2020
+# CHECK-NEXT:                 bl 0x2020
 # 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:     2020:       addis 12, 2, 0
 # CHECK-NEXT:                 ld 12, -32760(12)
 # CHECK-NEXT:                 mtctr 12
 # CHECK-NEXT:                 bctr
 
 ## &.branch_lt[1] - .TOC. = .branch_lt - (.got+0x8000) = -32752
 # CHECK:      <__long_branch_>:
-# CHECK-NEXT:     2028:       addis 12, 2, 0
+# CHECK-NEXT:     2030:       addis 12, 2, 0
 # CHECK-NEXT:                 ld 12, -32752(12)
 # CHECK-NEXT:                 mtctr 12
 # CHECK-NEXT:                 bctr
 
 .section .text_low, "ax", %progbits
 .globl _start
 _start:
 bl high          # Need a thunk
 bl high          # Need a thunk
 bl high          # Need a thunk
 bl high
 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:                 addi 2, 2, -32720
 # CHECK-NEXT:                 bl 0x2008
-# CHECK-NEXT:                 bl 0x2002014
+# CHECK-NEXT:                 bl 0x2002020
 # CHECK:      <__long_branch_>:
-# CHECK-NEXT:  2002014:       addis 12, 2, 0
+# CHECK-NEXT:  2002020:       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

lld/test/ELF/ppc64-pcrel-call-to-extern.s

 # SYMBOL:      1: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT [<other: 0x60>] UND callee_global_TOC
 # SYMBOL-NEXT: 2: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT                UND callee_global_stother0
 # SYMBOL-NEXT: 3: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT [<other: 0x20>] UND callee_global_stother1
 
 # SYMBOL: Symbol table '.symtab' contains 12 entries:
 # SYMBOL:      2: 0000000010010000     0 NOTYPE  LOCAL  DEFAULT [<other: 0x20>]   6 caller1
 # SYMBOL-NEXT: 3: 0000000010020000     0 NOTYPE  LOCAL  DEFAULT [<other: 0x20>]   7 caller2
 # SYMBOL-NEXT: 4: 0000000010030000     0 NOTYPE  LOCAL  DEFAULT [<other: 0x20>]   8 caller3
-# SYMBOL:      6: 0000000010010008    16 FUNC    LOCAL  DEFAULT                  6 __plt_pcrel_callee_global_stother0
-# SYMBOL-NEXT: 7: 0000000010020008    16 FUNC    LOCAL  DEFAULT                  7 __plt_pcrel_callee_global_stother1
-# SYMBOL-NEXT: 8: 0000000010030008    16 FUNC    LOCAL  DEFAULT                  8 __plt_pcrel_callee_global_TOC
+# SYMBOL:      6: 0000000010010010    16 FUNC    LOCAL  DEFAULT                  6 __plt_pcrel_callee_global_stother0
+# SYMBOL-NEXT: 7: 0000000010020010    16 FUNC    LOCAL  DEFAULT                  7 __plt_pcrel_callee_global_stother1
+# SYMBOL-NEXT: 8: 0000000010030010    16 FUNC    LOCAL  DEFAULT                  8 __plt_pcrel_callee_global_TOC
 # SYMBOL-NEXT: 9: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT [<other: 0x60>] UND callee_global_TOC
 # SYMBOL-NEXT: 10: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT                UND callee_global_stother0
 # SYMBOL-NEXT: 11: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT [<other: 0x20>] UND callee_global_stother1
 
 ## DT_PLTGOT points to .plt
-# SEC: .plt              NOBITS          0000000010030140 040140 000028 00  WA  0   0  8
-# SEC: 0x0000000000000003 (PLTGOT)      0x10030140
+# SEC: .plt              NOBITS          0000000010030148 040148 000028 00  WA  0   0  8
+# SEC: 0x0000000000000003 (PLTGOT)      0x10030148
 
 ## The first 2 entries in the .plt are reserved for the dynamic linkers
 ## usage. The JMP_SLOT relocations are stored at .plt[2], .plt[3], .plt[4].
 ## Check that we emit 3 R_PPC64_JMP_SLOT in .rela.plt.
 # REL:      .rela.plt {
-# REL-NEXT:   0x10030150 R_PPC64_JMP_SLOT callee_global_stother0 0x0
-# REL-NEXT:   0x10030158 R_PPC64_JMP_SLOT callee_global_stother1 0x0
-# REL-NEXT:   0x10030160 R_PPC64_JMP_SLOT callee_global_TOC 0x0
+# REL-NEXT:   0x10030158 R_PPC64_JMP_SLOT callee_global_stother0 0x0
+# REL-NEXT:   0x10030160 R_PPC64_JMP_SLOT callee_global_stother1 0x0
+# REL-NEXT:   0x10030168 R_PPC64_JMP_SLOT callee_global_TOC 0x0
 # REL-NEXT: }
 
 # CHECK-LABEL: <caller1>:
-# CHECK:       10010000: bl 0x10010008
+# CHECK:       10010000: bl 0x10010010
 # CHECK-NEXT:  10010004: blr
 
-## .plt[2] - 0x10010008 = 0x10030150 - 0x10010008 = 0x20148 = 131400
+## .plt[2] - 0x10010010 = 0x10030158 - 0x10010010 = 0x20148 = 131400
 # CHECK-LABEL: <__plt_pcrel_callee_global_stother0>:
-# CHECK:       10010008: pld 12, 131400(0), 1
-# CHECK-NEXT:  10010010: mtctr 12
-# CHECK-NEXT:  10010014: bctr
+# CHECK:       10010010: pld 12, 131400(0), 1
+# CHECK-NEXT:  10010018: mtctr 12
+# CHECK-NEXT:  1001001c: bctr
 
 # CHECK-LABEL: <caller2>:
-# CHECK:       10020000: bl 0x10020008
+# CHECK:       10020000: bl 0x10020010
 # CHECK-NEXT:  10020004: blr
 
-## .plt[3] - 0x10020008 = 0x10030158 - 0x10020008 = 0x10150 = 65872
+## .plt[3] - 0x10020010 = 0x10030160 - 0x10020010 = 0x10150 = 65872
 # CHECK-LABEL: <__plt_pcrel_callee_global_stother1>:
-# CHECK:       10020008: pld 12, 65872(0), 1
-# CHECK-NEXT:  10020010: mtctr 12
-# CHECK-NEXT:  10020014: bctr
+# CHECK:       10020010: pld 12, 65872(0), 1
+# CHECK-NEXT:  10020018: mtctr 12
+# CHECK-NEXT:  1002001c: bctr
 
 # CHECK-LABEL: <caller3>:
-# CHECK:       10030000: bl 0x10030008
+# CHECK:       10030000: bl 0x10030010
 # CHECK-NEXT:  10030004: blr
 
-## .plt[4] - 0x10030008 = 0x10030160 - 0x10030008 = 0x158 = 344
+## .plt[4] - 0x10030010 = 0x10030168 - 0x10030010 = 0x150 = 344
 # CHECK-LABEL: <__plt_pcrel_callee_global_TOC>:
-# CHECK:       10030008: pld 12, 344(0), 1
-# CHECK-NEXT:  10030010: mtctr 12
-# CHECK-NEXT:  10030014: bctr
+# CHECK:       10030010: pld 12, 344(0), 1
+# CHECK-NEXT:  10030018: mtctr 12
+# CHECK-NEXT:  1003001c: bctr
 
 .ifdef AUX
 .section .text_caller1, "ax", %progbits
 caller1:
   .localentry caller1, 1
   bl callee_global_stother0@notoc
   blr
 .section .text_caller2, "ax", %progbits

lld/test/ELF/ppc64-pcrel-call-to-toc.s

 # RUN: llvm-objdump -d --no-show-raw-insn --mcpu=pwr10 %t | FileCheck %s
 
 ## When a function without TOC accesses a function using TOC, an r12 setup stub
 ## is inserted
 
 # SYMBOL:      1: 0000000010020000 0 NOTYPE LOCAL DEFAULT [<other: 0x60>] 2 callee
 # SYMBOL-NEXT: 2: 0000000010030000 0 NOTYPE LOCAL DEFAULT [<other: 0x20>] 3 caller
 # SYMBOL-NEXT: 3: 0000000010010000 0 NOTYPE LOCAL DEFAULT 1 func
-# SYMBOL:      6: 000000001003000c 16 FUNC LOCAL DEFAULT 3 __gep_setup_callee
+# SYMBOL:      6: 0000000010030010 16 FUNC LOCAL DEFAULT 3 __gep_setup_callee
 
 # CHECK-LABEL: <func>:
 # CHECK-NEXT:  blr
 
 # CHECK-LABEL: <callee>:
 # CHECK:       bl 0x10010000
 # CHECK-NEXT:  addis 4, 2, -1
 # CHECK-NEXT:  lwz 4, 32744(4)
 # CHECK-NEXT:  blr
 
 # CHECK-LABEL: <caller>:
-# CHECK-NEXT:  bl 0x1003000c
+# CHECK-NEXT:  bl 0x10030010
 # CHECK-NEXT:  blr
 
 # CHECK-LABEL: <__gep_setup_callee>:
-# CHECK-NEXT:  paddi 12, 0, -65548, 1
+# CHECK-NEXT:  paddi 12, 0, -65552, 1
 # CHECK-NEXT:  mtctr 12
 # CHECK-NEXT:  bctr
 
 .section .text_func, "ax", %progbits
 func:
   blr
 
 .section .text_callee, "ax", %progbits

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

 .ifdef T1
 .globl callee
 callee:
   blr
 .endif
 
 # T2-LABEL: <p9codegen>:
 # T2-NEXT:    10010300: addis 2, 12, 1
-# T2-NEXT:    10010304: addi 2, 2, -32392
+# T2-NEXT:    10010304: addi 2, 2, -32384
 # T2-NEXT:    10010308: addis 4, 2, -1
-# T2-NEXT:    1001030c: lwa 3, 32436(4)
+# T2-NEXT:    1001030c: lwa 3, 32428(4)
 # T2-NEXT:    10010310: bl 0x10010330
 # T2-NEXT:    10010314: ld 2, 24(1)
 # T2-NEXT:    10010318: blr
 
 # T2-LABEL: <p10codegen>:
 # T2-NEXT:    1001031c: plwa 3, 16(0), 1
-# T2-NEXT:    10010324: bl 0x10010344
+# T2-NEXT:    10010324: bl 0x10010350
 # T2-NEXT:    10010328: blr
 
 # T2-LABEL: <__plt_callee>:
 # T2-NEXT:    10010330: std 2, 24(1)
 # T2-NEXT:    10010334: addis 12, 2, 0
 # T2-NEXT:    10010338: ld 12, -32744(12)
 # T2-NEXT:    1001033c: mtctr 12
 # T2-NEXT:    10010340: bctr
 
 # T2-LABEL: <__plt_pcrel_callee>:
-# T2-NEXT:    10010344: pld 12, 332(0), 1
-# T2-NEXT:    1001034c: mtctr 12
-# T2-NEXT:    10010350: bctr
+# T2-NEXT:    10010350: pld 12, 328(0), 1
+# T2-NEXT:    10010358: mtctr 12
+# T2-NEXT:    1001035c: bctr
 .ifdef T2
 .section .text_start, "ax", %progbits
 p9codegen:
 .Lfunc_gep0:
   addis 2, 12, .TOC.-.Lfunc_gep0@ha
   addi 2, 2, .TOC.-.Lfunc_gep0@l
 .Lfunc_lep0:
   .localentry p9codegen, .Lfunc_lep0-.Lfunc_gep0

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

 # RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %p/Inputs/shared-ppc64.s -o %t2.o
 # RUN: ld.lld -shared %t2.o -soname=t2.so -o %t2.so
 # RUN: ld.lld %t.o %t2.so -o %t
 # RUN: llvm-readelf -S -d %t | FileCheck --check-prefix=SEC %s
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
 
 ## DT_PLTGOT points to .plt
-# SEC: .plt NOBITS 00000000100303e8 0003e8 000018
-# SEC: 0x0000000000000003 (PLTGOT) 0x100303e8
+# SEC: .plt NOBITS 00000000100303f0 0003f0 000018
+# SEC: 0x0000000000000003 (PLTGOT) 0x100303f0
 
 ## .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 0x100102a8
+# CHECK:      10010298: bl 0x100102b0
 
-# CHECK-LABEL: 00000000100102a8 <__plt_foo>:
+# CHECK-LABEL: 00000000100102b0 <__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
 
 
         .text

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

 # RUN: llvm-readelf -r %t | FileCheck --check-prefix=NOREL %s
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck --check-prefix=LE %s
 
 # RUN: ld.lld %t.o %t1.so -o %t
 # RUN: llvm-readobj -r %t | FileCheck --check-prefix=IE-REL %s
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck --check-prefix=IE %s
 
 # GD-REL:      .rela.dyn {
-# GD-REL-NEXT:   0x20538 R_PPC64_DTPMOD64 a 0x0
-# GD-REL-NEXT:   0x20540 R_PPC64_DTPREL64 a 0x0
-# GD-REL-NEXT:   0x20548 R_PPC64_DTPMOD64 b 0x0
-# 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:   0x20548 R_PPC64_DTPMOD64 a 0x0
+# GD-REL-NEXT:   0x20550 R_PPC64_DTPREL64 a 0x0
+# GD-REL-NEXT:   0x20558 R_PPC64_DTPMOD64 b 0x0
+# GD-REL-NEXT:   0x20560 R_PPC64_DTPREL64 b 0x0
+# GD-REL-NEXT:   0x20568 R_PPC64_DTPMOD64 c 0x0
+# GD-REL-NEXT:   0x20570 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 0x103f4
+# GD-NEXT: bl 0x10400
 # 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 0x103f4
+# GD-NEXT: bl 0x10400
 # GD-NEXT: ld 2, 24(1)
 
 ## &DTPMOD(b) - .TOC. = &.got[4] - (.got+0x8000) = -32736
 # GD-NEXT: li 3, -32736
-# GD-NEXT: bl 0x103f4
+# GD-NEXT: bl 0x10400
 # 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-call-to-pcrel.s

 
 # The point of this test is to make sure that when a function with TOC access
 # a local function with st_other=1, a TOC save stub is inserted.
 
 # SYMBOL: Symbol table '.symtab' contains 7 entries
 # SYMBOL: 10010000     0 NOTYPE  LOCAL  DEFAULT [<other: 0x20>]   1 callee
 # SYMBOL: 10020000     0 NOTYPE  LOCAL  DEFAULT [<other: 0x60>]   2 caller
 # SYMBOL: 10020020     0 NOTYPE  LOCAL  DEFAULT [<other: 0x60>]   2 caller_14
-# SYMBOL: 1002003c     8 FUNC    LOCAL  DEFAULT                   2 __toc_save_callee
+# SYMBOL: 10020040     8 FUNC    LOCAL  DEFAULT                   2 __toc_save_callee
 
 # CHECK-LABEL: callee
 # CHECK:       blr
 
 # CHECK-LABEL: caller
-# CHECK:       bl 0x1002003c
+# CHECK:       bl 0x10020040
 # CHECK-NEXT:  ld 2, 24(1)
 # CHECK-NEXT:  blr
 
 # CHECK-LABEL: caller_14
-# CHECK:       bfl 0, 0x1002003c
+# CHECK:       bfl 0, 0x10020040
 # CHECK-NEXT:  ld 2, 24(1)
 # CHECK-NEXT:  blr
 
 # CHECK-LABEL: __toc_save_callee
 # CHECK-NEXT:  std 2, 24(1)
 # CHECK-NEXT:  b 0x10010000
 
 

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 0x102d8
+# CHECK:       102b8:       bl 0x102e0
 # CHECK-NEXT:               ld 2, 24(1)
 
-# CHECK-LABEL: 00000000000102d8 <__plt_recursive_func>:
+# CHECK-LABEL: 00000000000102e0 <__plt_recursive_func>:
 
         .abiversion 2
         .section ".text"
         .p2align 2
         .global recursive_func
         .type recursive_func, @function
 recursive_func:
 .Lrf_gep:

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 0x10010304
+// CHECK-NEXT:  100102c8:       bl 0x10010310
 // CHECK-NEXT:  100102cc:       ld 2, 24(1)
 // 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

 // 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 0x10010304
+// CHECK-NEXT:  100102e4:       bl 0x10010310
 // CHECK-NEXT:  100102e8:       ld 2, 24(1)