[ELF] Decrease alignment of ThunkSection on 64-bit targets from 8 to 4

[MaskRay]

Summary

ThunkSection contains 4-byte instructions on all targets that use
thunks. Thunks should not be used in any performance sensitive places,
and locality/cache line/instruction fetching arguments should not apply.

We use 16 bytes as preferred function alignments for modern PowerPC cores.
In any case, 8 is not optimal.

[merge_guards_bot]

Unit tests: fail. 61901 tests passed, 7 failed and 782 were skipped.

failed: lld.ELF/aarch64-cortex-a53-843419-thunk.s
failed: lld.ELF/aarch64-thunk-pi.s
failed: lld.ELF/aarch64-thunk-script.s
failed: lld.ELF/ppc64-dtprel.s
failed: lld.ELF/ppc64-ifunc.s
failed: lld.ELF/ppc64-tls-gd.s
failed: lld.ELF/ppc64-toc-restore.s

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[peter.smith]

I'm happy to go ahead with this. The maximum alignment for instructions on Arm and AArch64 is 4, which is what the compiler uses for code sections.

[MaskRay]

Fix tests

[merge_guards_bot]

Unit tests: fail. 61922 tests passed, 1 failed and 783 were skipped.

failed: lld.ELF/conflict.s

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[hans]

I've cherry-picked this to 10.x in db51c41a646c79e60cc763f0ecd58494112a32d1 to simplify cherry-picking 01ad4c838466bd5db180608050ed8ccb3b62d136 as requested in https://bugs.llvm.org/show_bug.cgi?id=44764

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,
-                       config->wordsize, ".text.thunk") {
+    : SyntheticSection(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS, 4,
+                       ".text.thunk") {
   this->parent = os;
   this->outSecOff = off;
 }
 
 // When the errata patching is on, we round the size up to a 4 KiB
 // boundary. This limits the effect that adding Thunks has on the addresses
 // of the program modulo 4 KiB. As the errata patching is sensitive to address
 // modulo 4 KiB this can prevent further patches from being needed due to

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

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

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

_start:
         .globl t3_ff8_ldr
         .type t3_ff8_ldr, %function
 t3_ff8_ldr:
         adrp x0, dat
         ldr x1, [x1, #0]
         ldr x0, [x0, :got_lo12:dat]
         ret
 
-// CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 11FFC in unpatched output.
-// CHECK: 0000000000011ffc t3_ff8_ldr:
+// CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 11FF8 in unpatched output.
+// CHECK: 0000000000011ff8 t3_ff8_ldr:
 // CHECK-NEXT: adrp    x0, #134213632
 // CHECK-NEXT: ldr     x1, [x1]
 // CHECK-NEXT: b       #8
 // CHECK-NEXT: ret
-// CHECK: 000000000001200c __CortexA53843419_12004:
+// CHECK: 0000000000012008 __CortexA53843419_12000:
 // CHECK-NEXT: ldr     x0, [x0, #8]
 // CHECK-NEXT: b       #-8
         .section .text.04, "ax", %progbits
         .globl far_away
         .type far_away, function
 far_away:
         ret
 
         .section .data
         .globl dat
 dat:    .quad 0

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

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

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

  .section .text_low, "ax", %progbits
  .globl low_target
  .type low_target, %function
 low_target:
  // Need thunk to high_target@plt
  bl high_target
  ret
 // CHECK: low_target:
-// CHECK-NEXT:       d8:       bl      #0x18 <__AArch64ADRPThunk_high_target>
+// CHECK-NEXT:       d8:       bl      #0x14 <__AArch64ADRPThunk_high_target>
 // CHECK-NEXT:                 ret
 
  .hidden low_target2
  .globl low_target2
  .type low_target2, %function
 low_target2:
  // Need thunk to high_target2
  bl high_target2
  // .text_high+8 = high_target2
  bl .text_high+8
  ret
 // CHECK: low_target2:
-// CHECK-NEXT:       e0:       bl      #0x1c <__AArch64ADRPThunk_high_target2>
-// CHECK-NEXT:       e4:       bl      #0x24 <__AArch64ADRPThunk_>
+// CHECK-NEXT:       e0:       bl      #0x18 <__AArch64ADRPThunk_high_target2>
+// CHECK-NEXT:       e4:       bl      #0x20 <__AArch64ADRPThunk_>
 // CHECK-NEXT:                 ret
 
 // Expect range extension thunks for .text_low
 // adrp calculation is (PC + signed immediate) & (!0xfff)
 // CHECK: __AArch64ADRPThunk_high_target:
-// CHECK-NEXT:       f0:       adrp    x16, #0x10000000
+// CHECK-NEXT:       ec:       adrp    x16, #0x10000000
 // CHECK-NEXT:                 add     x16, x16, #0x40
 // CHECK-NEXT:                 br      x16
 // CHECK: __AArch64ADRPThunk_high_target2:
-// CHECK-NEXT:       fc:       adrp    x16, #0x10000000
+// CHECK-NEXT:       f8:       adrp    x16, #0x10000000
 // CHECK-NEXT:                 add     x16, x16, #0x8
 // CHECK-NEXT:                 br      x16
 /// Identical to the previous one, but for the target .text_high+8.
 // CHECK: __AArch64ADRPThunk_:
-// CHECK-NEXT:      108:       adrp    x16, #0x10000000
+// CHECK-NEXT:      104:       adrp    x16, #0x10000000
 // CHECK-NEXT:                 add     x16, x16, #0x8
 // CHECK-NEXT:                 br      x16
 
 
  .section .text_high, "ax", %progbits
  .globl high_target
  .type high_target, %function
 high_target:

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

 high_target:
  // No Thunk needed as we are within signed immediate range
  bl _start
  ret
 
 // CHECK: Disassembly of section .text_low:
 // CHECK-EMPTY:
 // CHECK-NEXT: _start:
-// CHECK-NEXT:     2000:       bl      #0x10 <__AArch64AbsLongThunk_high_target>
-// CHECK-NEXT:     2004:       bl      #0x1c <__AArch64AbsLongThunk_>
+// CHECK-NEXT:     2000:       bl      #0xc <__AArch64AbsLongThunk_high_target>
+// CHECK-NEXT:     2004:       bl      #0x18 <__AArch64AbsLongThunk_>
 // CHECK-NEXT:                 ret
 // CHECK: __AArch64AbsLongThunk_high_target:
-// CHECK-NEXT:     2010:       ldr     x16, #0x8
+// CHECK-NEXT:     200c:       ldr     x16, #0x8
 // CHECK-NEXT:                 br      x16
 // CHECK: $d:
-// CHECK-NEXT:     2018:       00 20 00 08     .word   0x08002000
-// CHECK-NEXT:     201c:       00 00 00 00     .word   0x00000000
+// CHECK-NEXT:     2014:       00 20 00 08     .word   0x08002000
+// CHECK-NEXT:     2018:       00 00 00 00     .word   0x00000000
 // CHECK:      __AArch64AbsLongThunk_:
-// CHECK-NEXT:     2020:       ldr x16, #0x8
-// CHECK-NEXT:     2024:       br x16
+// CHECK-NEXT:     201c:       ldr x16, #0x8
+// CHECK-NEXT:     2020:       br x16
 // CHECK:      $d:
-// CHECK-NEXT:     2028:       04 20 00 08     .word   0x08002004
-// CHECK-NEXT:     202c:       00 00 00 00     .word   0x00000000
+// CHECK-NEXT:     2024:       04 20 00 08     .word   0x08002004
+// CHECK-NEXT:     2028:       00 00 00 00     .word   0x00000000
 // CHECK: Disassembly of section .text_high:
 // CHECK-EMPTY:
 // CHECK-NEXT: high_target:
 // CHECK-NEXT:  8002000:       bl      #-0x8000000 <_start>
 // CHECK-NEXT:                 ret

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: 4209d0 d0894200 00000000 00000000 00000000
-// HEX-LE-NEXT: 4209e0 00000000 00000000
+// HEX-LE-NEXT: 4209c8 c8894200 00000000 00000000 00000000
+// HEX-LE-NEXT: 4209d8 00000000 00000000
 
 // HEX-BE:      section '.got':
-// HEX-BE-NEXT: 4209d0 00000000 004289d0 00000000 00000000
-// HEX-BE-NEXT: 4209e0 00000000 00000000
+// HEX-BE-NEXT: 4209c8 00000000 004289c8 00000000 00000000
+// HEX-BE-NEXT: 4209d8 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: 0000000010010288    0 FUNC   GLOBAL DEFAULT   3 ifunc1
+# SYM: 0000000010010284    0 FUNC   GLOBAL DEFAULT   3 ifunc1
 # SYM: 0000000010010210    0 IFUNC  GLOBAL DEFAULT   2 ifunc2
-# SYM: 0000000010010278    0 FUNC   GLOBAL DEFAULT   3 ifunc3
+# SYM: 0000000010010274    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 .+36
+# CHECK-NEXT: 1001021c:       bl .+32
 # CHECK-NEXT:                 ld 2, 24(1)
-# CHECK-NEXT: 10010224:       bl .+48
+# CHECK-NEXT: 10010224:       bl .+44
 # CHECK-NEXT:                 ld 2, 24(1)
 # CHECK-NEXT:                 addis 3, 2, -2
-# CHECK-NEXT:                 addi 3, 3, 32752
+# CHECK-NEXT:                 addi 3, 3, 32748
 # CHECK-NEXT:                 addis 3, 2, -2
-# CHECK-NEXT:                 addi 3, 3, 32736
+# CHECK-NEXT:                 addi 3, 3, 32732
 
-# .plt[0] - .TOC. = 0x100302b0 - 0x100282a8 = (1<<16) - 32760
+# .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. = 0x100302b0+8 - 0x100282a8 = (1<<16) - 32752
+# .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: 0000000010010268 .glink:
+# CHECK-NEXT: 0000000010010264 .glink:
 # CHECK-NEXT:     addis 12, 2, 1
 # CHECK-NEXT:     ld 12, -32760(12)
 # CHECK-NEXT:     mtctr 12
 # CHECK-NEXT:     bctr
 # CHECK-EMPTY:
-# CHECK-NEXT: 0000000010010278 ifunc3:
+# CHECK-NEXT: 0000000010010274 ifunc3:
 # CHECK-NEXT:     addis 12, 2, 1
 # CHECK-NEXT:     ld 12, -32752(12)
 # CHECK-NEXT:     mtctr 12
 # CHECK-NEXT:     bctr
 # CHECK-EMPTY:
-# CHECK-NEXT: 0000000010010288 ifunc1:
+# CHECK-NEXT: 0000000010010284 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-long-branch.s

 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 .+12
+# CHECK-NEXT:                 bl .+8
 # CHECK:      __long_branch_:
-# CHECK-NEXT:  2002018:       addis 12, 2, 0
+# 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-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:   0x20540 R_PPC64_DTPMOD64 a 0x0
-# GD-REL-NEXT:   0x20548 R_PPC64_DTPREL64 a 0x0
-# GD-REL-NEXT:   0x20550 R_PPC64_DTPMOD64 b 0x0
-# GD-REL-NEXT:   0x20558 R_PPC64_DTPREL64 b 0x0
-# GD-REL-NEXT:   0x20560 R_PPC64_DTPMOD64 c 0x0
-# GD-REL-NEXT:   0x20568 R_PPC64_DTPREL64 c 0x0
+# 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: }
 
 ## &DTPMOD(a) - .TOC. = &.got[0] - (.got+0x8000) = -32768
 # GD:      addis 3, 2, 0
 # GD-NEXT: addi 3, 3, -32768
-# GD-NEXT: bl .+40
+# GD-NEXT: bl .+36
 # 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 .+24
+# GD-NEXT: bl .+20
 # GD-NEXT: ld 2, 24(1)
 
 ## &DTPMOD(b) - .TOC. = &.got[4] - (.got+0x8000) = -32736
 # GD-NEXT: li 3, -32736
-# GD-NEXT: bl .+12
+# GD-NEXT: bl .+8
 # 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.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 .+64
+// CHECK-NEXT:  100102c8:       bl .+60
 // CHECK-NEXT:  100102cc:       ld 2, 24(1)
 // CHECK-NEXT:  100102d0:       bl .-16
 // 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 .+36
+// CHECK-NEXT:  100102e4:       bl .+32
 // CHECK-NEXT:  100102e8:       ld 2, 24(1)