[ELF] Rename .plt to .iplt and decrease EM_PPC{,64} alignment of .glink to 4

[MaskRay]

Summary

GNU ld creates the synthetic section .iplt, and has a built-in linker
script that assigns .iplt to the output section .plt . There is no
output section named .iplt .

Making .iplt an output section actually has a benefit that makes the
tricky toolchain feature stand out. Symbolizers don't have to deal with
mixed PLT entries (e.g. llvm-objdump -d incorrectly annotates such jump
targets).

On EM_PPC{,64}, .glink contains a PLT resolver and a series of jump
instructions. The 4-byte entry size makes it unnecessary to have an
alignment of 16.

Mark ppc32-gnu-ifunc.s as XFAIL: *. It tests IPLT on EM_PPC, which
never works.

[MaskRay]

Update tests

[MaskRay]

Add reviewers

[ruiu]

lld/ELF/SyntheticSections.cpp

2453

Could you add a comment explaining why PPC is special?

[MaskRay]

lld/ELF/SyntheticSections.cpp

2453

I think the user will likely also read PPC64.cpp:writePlt to understand why its alignment is different. The comment may be redundant. (.glink is a series of bl instructions. Over-aligning to 16 does not improve anything.)

It is not that PPC is special. I think x86/ARM/AArch64 just happen to find 32 is the optimal alignment. Though, I believe on AArch64, at least with -z pac-plt or -z bti, 16 as the alignment is no longer optimal or necessary.

[peter.smith]

Looks good to me too.

lld/ELF/SyntheticSections.cpp

2453

I think the alignment of 16 comes from the cache line size, this obviously doesn't help when the PLT entry size is > 16. I've not got any data to know if it is worth increasing alignment for larger sequences.

[MaskRay]

Address comments

[MaskRay]

Rebase (update tests) after D71519

lld/ELF/SyntheticSections.cpp

 
 // On PowerPC64 the lazy symbol resolvers go into the `global linkage table`
 // in the .glink section, rather then the typical .plt section.
 PltSection::PltSection()
     : SyntheticSection(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS, 16, ".plt"),
       headerSize(target->pltHeaderSize) {
   if (config->emachine == EM_PPC || config->emachine == EM_PPC64) {
     name = ".glink";
+    alignment = 4;
   }
 
   // The PLT needs to be writable on SPARC as the dynamic linker will
   // modify the instructions in the PLT entries.
   if (config->emachine == EM_SPARCV9)
     this->flags |= SHF_WRITE;
 }
 
void PltSection::addSymbols() {
   size_t off = headerSize;
   for (size_t i = 0; i < entries.size(); ++i) {
     target->addPltSymbols(*this, off);
     off += target->pltEntrySize;
   }
 }
 
 IpltSection::IpltSection()
-    : SyntheticSection(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS, 16, ".plt") {
+    : SyntheticSection(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS, 16, ".iplt") {
   if (config->emachine == EM_PPC || config->emachine == EM_PPC64) {
     name = ".glink";
+    alignment = 4;
   }
 }
 
 void IpltSection::writeTo(uint8_t *buf) {
   uint32_t off = 0;
   for (const Symbol *sym : entries) {
     target->writeIplt(buf + off, sym->getGotPltVA(), getVA() + off,
                       sym->pltIndex);

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

 ## The address of myfunc is the address of the PLT entry for myfunc.
 # PDE:      myfunc_resolver:
 # PDE-NEXT:   210170:   ret
 # PDE:      main:
 # PDE-NEXT:   210174:   adrp    x8, #0
 # PDE-NEXT:   210178:   add     x8, x8, #384
 # PDE-NEXT:   21017c:   ret
 # PDE-EMPTY:
-# PDE-NEXT: Disassembly of section .plt:
+# PDE-NEXT: Disassembly of section .iplt:
 # PDE-EMPTY:
 # PDE-NEXT: myfunc:
 ## page(.got.plt) - page(0x210010) = 65536
 # PDE-NEXT:   210180: adrp    x16, #65536
 # PDE-NEXT:   210184: ldr     x17, [x16, #400]
 # PDE-NEXT:   210188: add     x16, x16, #400
 # PDE-NEXT:   21018c: br      x17
 
 ## The adrp to myfunc should generate a PLT entry and a GOT entry with an
 ## irelative relocation.
 # PDE-RELOC:      .rela.dyn {
 # PDE-RELOC-NEXT:   0x220190 R_AARCH64_IRELATIVE - 0x210170
 # PDE-RELOC-NEXT: }
 
 # PIE:      myfunc_resolver:
 # PIE-NEXT:    10260: ret
 # PIE:      main:
 # PIE-NEXT:    10264: adrp    x8, #0
 # PIE-NEXT:    10268: add     x8, x8, #624
 # PIE-NEXT:    1026c: ret
 # PIE-EMPTY:
-# PIE-NEXT: Disassembly of section .plt:
+# PIE-NEXT: Disassembly of section .iplt:
 # PIE-EMPTY:
 # PIE-NEXT: myfunc:
 # PIE-NEXT:    10270: adrp    x16, #131072
 # PIE-NEXT:    10274: ldr     x17, [x16, #880]
 # PIE-NEXT:    10278: add     x16, x16, #880
 # PIE-NEXT:    1027c: br      x17
 
 # PIE-RELOC:      .rela.dyn {
 # PIE-RELOC-NEXT:   0x30370 R_AARCH64_IRELATIVE - 0x10260
 # PIE-RELOC-NEXT: }

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

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

 // DISASM-NEXT:    210318: add     x16, x16, #1112
 // DISASM-NEXT:    21031c: br      x17
 // DISASM-EMPTY:
 // DISASM-NEXT:   zed2@plt:
 // DISASM-NEXT:    210320: adrp    x16, #131072
 // DISASM-NEXT:    210324: ldr     x17, [x16, #1120]
 // DISASM-NEXT:    210328: add     x16, x16, #1120
 // DISASM-NEXT:    21032c: br      x17
+// DISASM-EMPTY:
+// DISASM-NEXT: Disassembly of section .iplt:
+// DISASM-EMPTY:
+// DISASM-NEXT: .iplt:
 // DISASM-NEXT:    210330: adrp    x16, #131072
 // DISASM-NEXT:    210334: ldr     x17, [x16, #1128]
 // DISASM-NEXT:    210338: add     x16, x16, #1128
 // DISASM-NEXT:    21033c: br      x17
 // DISASM-NEXT:    210340: adrp    x16, #131072
 // DISASM-NEXT:    210344: ldr     x17, [x16, #1136]
 // DISASM-NEXT:    210348: add     x16, x16, #1136
 // DISASM-NEXT:    21034c: br      x17

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

 // DISASM: bar:
 // DISASM-NEXT:  21018c: ret
 // DISASM:      _start:
 // DISASM-NEXT:  210190: bl  #16
 // DISASM-NEXT:  210194: bl  #28
 // DISASM-NEXT:  210198: add x2, x2, #344
 // DISASM-NEXT:  21019c: add x2, x2, #392
 // DISASM-EMPTY:
-// DISASM-NEXT: Disassembly of section .plt:
+// DISASM-NEXT: Disassembly of section .iplt:
 // DISASM-EMPTY:
-// DISASM-NEXT: .plt:
+// DISASM-NEXT: .iplt:
 // DISASM-NEXT:  2101a0: adrp x16, #65536
 // DISASM-NEXT:  2101a4: ldr x17, [x16, #448]
 // DISASM-NEXT:  2101a8: add x16, x16, #448
 // DISASM-NEXT:  2101ac: br x17
 // DISASM-NEXT:  2101b0: adrp x16, #65536
 // DISASM-NEXT:  2101b4: ldr x17, [x16, #456]
 // DISASM-NEXT:  2101b8: add x16, x16, #456
 // DISASM-NEXT:  2101bc: br x17

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

 # CHECK-NEXT:   210170:
 
 # CHECK:      main:
 # .got.plt - page(0x210174) = 0x220190 - 0x210000 = 0x10190
 # CHECK-NEXT:   210174: adrp    x8, #0x10000
 # CHECK-NEXT:   210178: ldr     x8, [x8, #0x190]
 # CHECK-NEXT:   21017c: ret
 
-# CHECK:      Disassembly of section .plt:
+# CHECK:      Disassembly of section .iplt:
 # CHECK-EMPTY:
-# CHECK-NEXT: .plt:
+# CHECK-NEXT: .iplt:
 # .got.plt - page(0x210180) = 0x220190 - 0x210000 = 0x10190
 # CHECK-NEXT:   210180: adrp    x16, #0x10000
 # CHECK-NEXT:   210184: ldr     x17, [x16, #0x190]
 # CHECK-NEXT:   210188: add     x16, x16, #0x190
 # CHECK-NEXT:   21018c: br      x17
 
 # SEC: .got.plt PROGBITS 0000000000220190 000190 000008 00 WA 0 0 8
 

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

 # CHECK-NEXT:                   nop
 # CHECK: 00000000000103a0 func1@plt:
 # CHECK-NEXT:    103a0:         bti     c
 # CHECK-NEXT:                   adrp    x16, #131072
 # CHECK-NEXT:                   ldr     x17, [x16, #1280]
 # CHECK-NEXT:                   add     x16, x16, #1280
 # CHECK-NEXT:                   br      x17
 # CHECK-NEXT:                   nop
-# CHECK-NEXT:           ...
-# CHECK: 00000000000103c0 myfunc:
+# CHECK-EMPTY:
+# CHECK: Disassembly of section .iplt:
+# CHECK-EMPTY:
+# CHECK-NEXT: 00000000000103c0 myfunc:
 # CHECK-NEXT:    103c0:         bti     c
 # CHECK-NEXT:                   adrp    x16, #131072
 # CHECK-NEXT:                   ldr     x17, [x16, #1288]
 # CHECK-NEXT:                   add     x16, x16, #1288
 # CHECK-NEXT:                   br      x17
 # CHECK-NEXT:                   nop
 
 .section ".note.gnu.property", "a"

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

 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       SHF_ALLOC
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: 0x100F4
 // CHECK-NEXT:     Offset: 0xF4
 // CHECK-NEXT:     Size: 16
 // CHECK-NEXT:     Link:
 // CHECK-NEXT:     Info: 4
-// CHECK:          Name: .plt
+// CHECK:          Name: .iplt
 // CHECK-NEXT:     Type: SHT_PROGBITS
 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       SHF_ALLOC
 // CHECK-NEXT:       SHF_EXECINSTR
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: 0x11130
 // CHECK-NEXT:     Offset: 0x130
 // CHECK-NEXT:     Size: 32

 // DISASM-NEXT:    11110:      bl      #40
 // 1 * 65536 + 244 = 0x100f4 __rel_iplt_start
 // DISASM-NEXT:    11114:      movw    r0, #244
 // DISASM-NEXT:    11118:      movt    r0, #1
 // 1 * 65536 + 260 = 0x10104 __rel_iplt_end
 // DISASM-NEXT:    1111c:      movw    r0, #260
 // DISASM-NEXT:    11120:      movt    r0, #1
 // DISASM-EMPTY:
-// DISASM-NEXT: Disassembly of section .plt:
+// DISASM-NEXT: Disassembly of section .iplt:
 // DISASM-EMPTY:
 // DISASM-NEXT: $a:
 // DISASM-NEXT:    11130:       add     r12, pc, #0, #12
 // DISASM-NEXT:    11134:       add     r12, r12, #4096
 // DISASM-NEXT:    11138:       ldr     pc, [r12, #24]!
 // DISASM: $d:
 // DISASM-NEXT:    1113c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DISASM: $a:
 // DISASM-NEXT:    11140:       add     r12, pc, #0, #12
 // DISASM-NEXT:    11144:       add     r12, r12, #4096
 // DISASM-NEXT:    11148:       ldr     pc, [r12, #12]!
 // DISASM: $d:
 // DISASM-NEXT:    1114c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 

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

 // IREL1-REL3: .rela.dyn
 // IREL1-REL3-NEXT: R_X86_64_RELATIVE
 // IREL1-REL3-NEXT: R_X86_64_RELATIVE
 // IREL1-REL3-NEXT: R_X86_64_RELATIVE
 // IREL1-REL3-NEXT: R_X86_64_IRELATIVE
 // IREL1-REL3-NOT: R_X86_64_
 
 // Make sure the static relocations look right, both with and without headers.
-// DUMP: Contents of section .plt:
+// DUMP: Contents of section .iplt:
 // DUMP-NEXT: 2011f0
 // DUMP: Contents of section .got:
 // DUMP-NEXT: 202200 f0112000 00000000
 // DUMP: Contents of section .data:
 // DUMP-NEXT: 203208 f0112000 00000000 f1112000 00000000
 
 // DUMP2: Contents of section .plt:
 // DUMP2-NEXT: 2011f0

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

 // CHECK-NEXT: }
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name: bar
 // CHECK-NEXT:   Value: 0x401110
 // CHECK-NEXT:   Size: 0
 // CHECK-NEXT:   Binding: Global
 // CHECK-NEXT:   Type: Function
 // CHECK-NEXT:   Other: 0
-// CHECK-NEXT:   Section: .plt
+// CHECK-NEXT:   Section: .iplt
 // CHECK-NEXT: }
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name: bar_resolver
 // CHECK-NEXT:   Value: 0x4010E5
 // CHECK-NEXT:   Size: 0
 // CHECK-NEXT:   Binding: Global
 // CHECK-NEXT:   Type: Function
 // CHECK-NEXT:   Other: 0
 // CHECK-NEXT:   Section: .text
 // CHECK-NEXT: }
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name: foo
 // CHECK-NEXT:   Value: 0x401100
 // CHECK-NEXT:   Size: 0
 // CHECK-NEXT:   Binding: Global
 // CHECK-NEXT:   Type: Function
 // CHECK-NEXT:   Other: 0
-// CHECK-NEXT:   Section: .plt
+// CHECK-NEXT:   Section: .iplt
 // CHECK-NEXT: }
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name: foo_resolver
 // CHECK-NEXT:   Value: 0x4010E4
 // CHECK-NEXT:   Size: 0
 // CHECK-NEXT:   Binding: Global
 // CHECK-NEXT:   Type: Function
 // CHECK-NEXT:   Other: 0
 // CHECK-NEXT:   Section: .text
 // CHECK-NEXT: }
 // CHECK-NEXT:]
 
 // 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:                 movl $4194516, %edx
 // DISASM-NEXT:                 movl $4194532, %edx
 // DISASM-EMPTY:
-// DISASM-NEXT: Disassembly of section .plt:
+// DISASM-NEXT: Disassembly of section .iplt:
 // DISASM-EMPTY:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:   401100:       jmpl *4202784
 // DISASM-NEXT:                 pushl $0
 // DISASM-NEXT:                 jmp -32 <_start+0xa>
 // DISASM:      bar:
 // DISASM-NEXT:   401110:       jmpl *4202788
 // DISASM-NEXT:                 pushl $8

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@plt+0x10>
-// DISASM-NEXT:                  calll   80 <zed2@plt+0x20>
+// 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-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-EMPTY:
 // DISASM-NEXT:   zed2@plt:
 // DISASM-NEXT:    4011f0:       jmpl    *4207272
 // DISASM-NEXT:                  pushl   $8
 // DISASM-NEXT:                  jmp     -48 <.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     -32 <zed2@plt>
 // DISASM-NEXT:                  jmpl    *4207280
 // DISASM-NEXT:                  pushl   $8
 // DISASM-NEXT:                  jmp     -48 <zed2@plt>
 
 .text

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

 // DISASM-NEXT:   201300:       jmpq    *8514(%rip)
 // DISASM-NEXT:   201306:       pushq   $0
 // DISASM-NEXT:   20130b:       jmp     -32 <.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-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     -32 <zed2@plt>
 // DISASM-NEXT:   201330:       jmpq    *8490(%rip)
 // DISASM-NEXT:   201336:       pushq   $1
 // DISASM-NEXT:   20133b:       jmp     -48 <zed2@plt>
 
 .text

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

 // DISASM-NEXT:     1330:       jmpq    *8482(%rip)
 // DISASM-NEXT:     1336:       pushq   $0
 // DISASM-NEXT:     133b:       jmp     -32 <.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:      Disassembly of section .iplt:
+// DISASM-EMPTY:
+// DISASM:      .iplt:
 // DISASM-NEXT:     1350:       jmpq    *8466(%rip)
 // DISASM-NEXT:     1356:       pushq   $0
 // DISASM-NEXT:     135b:       jmp     -32 <f2@plt>
 
 // CHECK: Relocations [
 // CHECK-NEXT:   Section (5) .rela.dyn {
 // CHECK-NEXT:     0x3468 R_X86_64_IRELATIVE - 0x1308
 // CHECK-NEXT:   }

lld/test/ELF/gnu-ifunc.s

 // DISASM-NEXT:  201189: {{.*}} retq
 // DISASM:      _start:
 // DISASM-NEXT:  20118a: {{.*}} callq 33
 // DISASM-NEXT:  20118f: {{.*}} callq 44
 // 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 .plt:
+// DISASM-NEXT: Disassembly of section .iplt:
 // DISASM-EMPTY:
-// DISASM-NEXT: .plt:
+// DISASM-NEXT: .iplt:
 // DISASM-NEXT:  2011b0: {{.*}} jmpq *4122(%rip)
 // DISASM-NEXT:  2011b6: {{.*}} pushq $0
 // DISASM-NEXT:  2011bb: {{.*}} jmp -32 <_start+0x16>
 // DISASM-NEXT:  2011c0: {{.*}} jmpq *4114(%rip)
 // DISASM-NEXT:  2011c6: {{.*}} pushq $1
 // DISASM-NEXT:  2011cb: {{.*}} jmp -48 <_start+0x16>
 
 .text

lld/test/ELF/linkerscript/orphan-report.s

 # REPORT-NEXT: <internal>:(.rela.dyn) is being placed in '.rela.dyn'
 # REPORT-NEXT: <internal>:(.eh_frame) is being placed in '.eh_frame'
 # REPORT-NEXT: <internal>:(.got) is being placed in '.got'
 # REPORT-NEXT: <internal>:(.got.plt) is being placed in '.got.plt'
 # REPORT-NEXT: <internal>:(.got.plt) is being placed in '.got.plt'
 # REPORT-NEXT: <internal>:(.rela.plt) is being placed in '.rela.plt'
 # REPORT-NEXT: <internal>:(.rela.dyn) is being placed in '.rela.dyn'
 # REPORT-NEXT: <internal>:(.plt) is being placed in '.plt'
-# REPORT-NEXT: <internal>:(.plt) is being placed in '.plt'
+# REPORT-NEXT: <internal>:(.iplt) is being placed in '.iplt'
 # REPORT-NEXT: <internal>:(.symtab) is being placed in '.symtab'
 # REPORT-NEXT: <internal>:(.symtab_shndx) is being placed in '.symtab_shndx'
 # REPORT-NEXT: <internal>:(.shstrtab) is being placed in '.shstrtab'
 # REPORT-NEXT: <internal>:(.strtab) is being placed in '.strtab'
 
 ## Check --orphan-handling=warn reports warnings about orphans.
 # RUN: ld.lld -shared --orphan-handling=warn -o %t.out --script %t.script \
 # RUN:   %t.o 2>&1 -verbose | FileCheck %s --check-prefix=REPORT

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

 # RELOC-NEXT:   R_PPC_ADDR32 h 0x0
 # RELOC-NEXT: }
 # RELOC-NEXT: .rela.plt {
 # RELOC-NEXT:   R_PPC_JMP_SLOT f 0x0
 # RELOC-NEXT:   R_PPC_JMP_SLOT g 0x0
 # RELOC-NEXT:   R_PPC_JMP_SLOT h 0x0
 # RELOC-NEXT: }
 
-# SEC: .got PROGBITS 00020374
-# DYN: PPC_GOT 0x20374
+# SEC: .got PROGBITS 00020368
+# 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, -32400
+# PIE-NEXT:           addi 30, 30, -32412
 # SHARED-NEXT: 10230: mflr 30
 # SHARED-NEXT:        addis 30, 30, 3
-# SHARED-NEXT:        addi 30, 30, -32408
+# SHARED-NEXT:        addi 30, 30, -32420
 
 ## Two bl 00008000.got2.plt_pic32.f
 # CHECK-NEXT:    bl .+40
 # CHECK-NEXT:    bl .+36
 ## Two bl 00008000.got2.plt_pic32.g
 # CHECK-NEXT:    bl .+48
 # CHECK-NEXT:    bl .+44
 ## Two bl 00008000.got2.plt_pic32.h

 # CHECK-EMPTY:
 
 ## Another -fPIC call stub of f from another object file %t2.o
 ## .got2 may have different addresses in different object files,
 ## so the call stub cannot be shared.
 # CHECK-NEXT:  00008000.got2.plt_pic32.f:
 
 ## In Secure PLT ABI, .plt stores function pointers to first instructions of .glink
-# HEX: 0x00040378 000102a0 000102a4 000102a8
+# HEX: 0x0004036c 00010294 00010298 0001029c
 
 ## These instructions are referenced by .plt entries.
-# PIE:    000102a0 .glink:
-# SHARED: 000102c0 .glink:
+# PIE:    00010294 .glink:
+# SHARED: 000102b4 .glink:
 # CHECK-NEXT: b .+12
 # CHECK-NEXT: b .+8
 # CHECK-NEXT: b .+4
 
 ## PLTresolve
 ## Operand of addi: 0x100a8-.glink = 24
 # CHECK-NEXT:         addis 11, 11, 0
 # CHECK-NEXT:         mflr 0
 # CHECK-NEXT:         bcl 20, 31, .+4
-# PIE-NEXT:    102b8: addi 11, 11, 24
-# SHARED-NEXT: 102d8: addi 11, 11, 24
+# PIE-NEXT:    102ac: addi 11, 11, 24
+# SHARED-NEXT: 102cc: addi 11, 11, 24
 
 # CHECK-NEXT: mflr 12
 # CHECK-NEXT: mtlr 0
 # CHECK-NEXT: subf 11, 12, 11
 
 ## Operand of lwz in -pie mode: &.got[1] - 0x100a8 = 0x20088+4 - 0x100a8 = 65536*1-28
 # CHECK-NEXT:  addis 12, 12, 1
 # PIE-NEXT:    lwz 0, 192(12)

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

 # REQUIRES: ppc
+# XFAIL: *
 # RUN: llvm-mc -filetype=obj -triple=powerpc %s -o %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-readobj -r %t | FileCheck --check-prefix=RELOC %s
 # RUN: llvm-readelf -S -s %t | FileCheck --check-prefixes=SEC,SYM %s
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
 
 # RELOC:      .rela.dyn {
 # RELOC-NEXT:   0x10020114 R_PPC_IRELATIVE - 0x100100E0

lld/test/ELF/ppc32-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
 
 ## DT_PPC_GOT represents the address of _GLOBAL_OFFSET_TABLE_.
-# GD-DYN: PPC_GOT 0x2035C
+# GD-DYN: PPC_GOT 0x20358
 
 # GD-REL:      .rela.dyn {
-# GD-REL-NEXT:   0x2035C R_PPC_DTPMOD32 a 0x0
-# GD-REL-NEXT:   0x20360 R_PPC_DTPREL32 a 0x0
-# GD-REL-NEXT:   0x20364 R_PPC_DTPMOD32 b 0x0
-# GD-REL-NEXT:   0x20368 R_PPC_DTPREL32 b 0x0
-# GD-REL-NEXT:   0x2036C R_PPC_DTPMOD32 c 0x0
-# GD-REL-NEXT:   0x20370 R_PPC_DTPREL32 c 0x0
+# GD-REL-NEXT:   0x20358 R_PPC_DTPMOD32 a 0x0
+# GD-REL-NEXT:   0x2035C R_PPC_DTPREL32 a 0x0
+# 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: lwz 3, 0(3)
 
 ## &DTPMOD(b) - _GLOBAL_OFFSET_TABLE_ = 0x20080 - 0x20078 = 8

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

 # REQUIRES: ppc
 # RUN: llvm-mc -filetype=obj -triple=powerpc %s -o %t.o
 # RUN: echo '.globl __tls_get_addr; __tls_get_addr:' | llvm-mc -filetype=obj -triple=powerpc - -o %tga.o
 
 # RUN: ld.lld -shared %t.o -o %t.so
 # RUN: llvm-readobj -r %t.so | FileCheck --check-prefix=LD-REL %s
 # RUN: llvm-objdump -d --no-show-raw-insn %t.so | FileCheck --check-prefix=LD %s
 
 # RUN: ld.lld %t.o %tga.o -o %t
 # RUN: llvm-readelf -r %t | FileCheck --check-prefix=NOREL %s
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck --check-prefix=LE %s
 
 # LD-REL:      .rela.dyn {
-# LD-REL-NEXT:   0x202CC R_PPC_DTPMOD32 - 0x0
+# 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
 ## 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

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: 4209d8 d8894200 00000000 00000000 00000000
-// HEX-LE-NEXT: 4209e8 00000000 00000000
+// HEX-LE-NEXT: 4209d0 d0894200 00000000 00000000 00000000
+// HEX-LE-NEXT: 4209e0 00000000 00000000
 
 // HEX-BE:      section '.got':
-// HEX-BE-NEXT: 4209d8 00000000 004289d8 00000000 00000000
-// HEX-BE-NEXT: 4209e8 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-toc-relax-ifunc.s

 # REQUIRES: ppc
 
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le %s -o %t.o
 # RUN: echo '.globl ifunc; .type ifunc, %gnu_indirect_function; ifunc:' | \
 # RUN:   llvm-mc -filetype=obj -triple=powerpc64le - -o %t1.o
 # RUN: ld.lld %t.o %t1.o -o %t
 # RUN: llvm-readelf -S -s %t | FileCheck --check-prefix=SEC %s
 # RUN: llvm-readelf -x .toc %t | FileCheck --check-prefix=HEX %s
 # RUN: llvm-objdump -d %t | FileCheck --check-prefix=DIS %s
 
 ## ifunc is a non-preemptable STT_GNU_IFUNC. The R_PPC64_ADDR64 in .toc
 ## creates a canonical PLT for it and changes its type to STT_FUNC. We can thus
 ## still perform toc-indirect to toc-relative relaxation because the distance
 ## to the address of the canonical PLT is fixed.
 
 # SEC: .text PROGBITS 00000000100101e0
-# SEC: .plt  NOBITS   0000000010030200
-# SEC: 00000000100101f0 0 FUNC GLOBAL DEFAULT 3 ifunc
+# SEC: .plt  NOBITS   00000000100301f8
+# SEC: 00000000100101e8 0 FUNC GLOBAL DEFAULT 3 ifunc
 
 ## .toc[0] stores the address of the canonical PLT.
 # HEX:      section '.toc':
-# HEX-NEXT: 0x100201f8 f0010110 00000000
+# HEX-NEXT: 0x100201f0 e8010110 00000000
 
 # REL:      .rela.dyn {
-# REL-NEXT:   0x10030200 R_PPC64_IRELATIVE - 0x100101e8
+# REL-NEXT:   0x100301f8 R_PPC64_IRELATIVE - 0x100101e8
 # REL-NEXT: }
 
 # DIS: addi 3, 3,
 
 addis 3, 2, .toc@toc@ha
 ld 3, .toc@toc@l(3)
 
 .section .toc,"aw",@progbits
   .quad ifunc