Add execute-only compatible thunks

Author: Il-Capitano

lld/ELF/Thunks.cpp

@@ -91,6 +91,19 @@ class AArch64ABSLongThunk final : public AArch64Thunk {
   ThunkSection *tsec = nullptr;
 };
 
+// AArch64 long range Thunks compatible with execute-only code.
+class AArch64ABSXOLongThunk final : public AArch64Thunk {
+public:
+  AArch64ABSXOLongThunk(Ctx &ctx, Symbol &dest, int64_t addend,
+                        bool mayNeedLandingPad)
+      : AArch64Thunk(ctx, dest, addend, mayNeedLandingPad) {}
+  uint32_t size() override { return getMayUseShortThunk() ? 4 : 20; }
+  void addSymbols(ThunkSection &sec) override;
+
+private:
+  void writeLong(uint8_t *buf) override;
+};
+
 class AArch64ADRPThunk final : public AArch64Thunk {
 public:
   AArch64ADRPThunk(Ctx &ctx, Symbol &dest, int64_t addend,
@@ -663,6 +676,33 @@ void AArch64ABSLongThunk::addLongMapSyms() {
   addSymbol("$d", STT_NOTYPE, 8, *tsec);
 }
 
+void AArch64ABSXOLongThunk::writeLong(uint8_t *buf) {
+  const uint8_t data[] = {
+      0x10, 0x00, 0x80, 0xd2, // movz x16, :abs_g0_nc:S, lsl #0
+      0x10, 0x00, 0xa0, 0xf2, // movk x16, :abs_g1_nc:S, lsl #16
+      0x10, 0x00, 0xc0, 0xf2, // movk x16, :abs_g2_nc:S, lsl #32
+      0x10, 0x00, 0xe0, 0xf2, // movk x16, :abs_g3:S,    lsl #48
+      0x00, 0x02, 0x1f, 0xd6, // br   x16
+  };
+  // If mayNeedLandingPad is true then destination is an
+  // AArch64BTILandingPadThunk that defines landingPad.
+  assert(!mayNeedLandingPad || landingPad != nullptr);
+  uint64_t s = mayNeedLandingPad
+                   ? landingPad->getVA(ctx, 0)
+                   : getAArch64ThunkDestVA(ctx, destination, addend);
+  memcpy(buf, data, sizeof(data));
+  ctx.target->relocateNoSym(buf + 0, R_AARCH64_MOVW_UABS_G0_NC, s);
+  ctx.target->relocateNoSym(buf + 4, R_AARCH64_MOVW_UABS_G1_NC, s);
+  ctx.target->relocateNoSym(buf + 8, R_AARCH64_MOVW_UABS_G2_NC, s);
+  ctx.target->relocateNoSym(buf + 12, R_AARCH64_MOVW_UABS_G3, s);
+}
+
+void AArch64ABSXOLongThunk::addSymbols(ThunkSection &sec) {
+  addSymbol(ctx.saver.save("__AArch64AbsXOLongThunk_" + destination.getName()),
+            STT_FUNC, 0, sec);
+  addSymbol("$x", STT_NOTYPE, 0, sec);
+}
+
 // This Thunk has a maximum range of 4Gb, this is sufficient for all programs
 // using the small code model, including pc-relative ones. At time of writing
 // clang and gcc do not support the large code model for position independent
@@ -1482,15 +1522,20 @@ Thunk::Thunk(Ctx &ctx, Symbol &d, int64_t a)
 
 Thunk::~Thunk() = default;
 
-static std::unique_ptr<Thunk> addThunkAArch64(Ctx &ctx, RelType type, Symbol &s,
+static std::unique_ptr<Thunk> addThunkAArch64(Ctx &ctx, const InputSection &sec,
+                                              RelType type, Symbol &s,
                                               int64_t a) {
   assert(is_contained({R_AARCH64_CALL26, R_AARCH64_JUMP26, R_AARCH64_PLT32},
                       type));
   bool mayNeedLandingPad =
       (ctx.arg.andFeatures & GNU_PROPERTY_AARCH64_FEATURE_1_BTI) &&
       !isAArch64BTILandingPad(ctx, s, a);
+  bool isPureCode = sec.getParent()->flags & SHF_AARCH64_PURECODE;
   if (ctx.arg.picThunk)
     return std::make_unique<AArch64ADRPThunk>(ctx, s, a, mayNeedLandingPad);
+  if (isPureCode)
+    return std::make_unique<AArch64ABSXOLongThunk>(ctx, s, a,
+                                                   mayNeedLandingPad);
   return std::make_unique<AArch64ABSLongThunk>(ctx, s, a, mayNeedLandingPad);
 }
 
@@ -1702,7 +1747,7 @@ std::unique_ptr<Thunk> elf::addThunk(Ctx &ctx, const InputSection &isec,
 
   switch (ctx.arg.emachine) {
   case EM_AARCH64:
-    return addThunkAArch64(ctx, rel.type, s, a);
+    return addThunkAArch64(ctx, isec, rel.type, s, a);
   case EM_ARM:
     return addThunkArm(ctx, isec, rel.type, s, a);
   case EM_AVR:

lld/test/ELF/Inputs/big-execute-only.s

@@ -0,0 +1,3 @@
+.section .text,"axy",@progbits,unique,0
+.global big
+big = 0x1111222233334444

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

@@ -0,0 +1,22 @@
+// REQUIRES: aarch64
+// RUN: llvm-mc -filetype=obj -triple=aarch64 %S/Inputs/big-execute-only.s -o %tbig.o
+// RUN: llvm-mc -filetype=obj -triple=aarch64 %s -o %t.o
+// RUN: ld.lld %t.o %tbig.o -o %t
+// RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
+
+.section .text,"axy",@progbits,unique,0
+.globl _start
+_start:
+    bl big
+
+// CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
+// CHECK-NEXT: <_start>:
+// CHECK-NEXT:    210120:       bl      0x210124
+// CHECK:      <__AArch64AbsXOLongThunk_big>:
+// CHECK-NEXT:    210124:       mov  x16, #0x4444
+// CHECK-NEXT:    210128:       movk x16, #0x3333, lsl #16
+// CHECK-NEXT:    21012c:       movk x16, #0x2222, lsl #32
+// CHECK-NEXT:    210130:       movk x16, #0x1111, lsl #48
+// CHECK-NEXT:    210134:       br   x16
+

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

@@ -0,0 +1,22 @@
+// REQUIRES: aarch64
+// RUN: llvm-mc -filetype=obj -triple=aarch64 %S/Inputs/big-execute-only.s -o %tbig.o
+// RUN: llvm-mc -filetype=obj -triple=aarch64 %s -o %t.o
+// RUN: ld.lld %t.o %tbig.o -o %t
+// RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
+
+.section .text,"axy",@progbits,unique,0
+.globl _start
+_start:
+    b big
+
+// CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
+// CHECK-NEXT: <_start>:
+// CHECK-NEXT:    210120:       b       0x210124
+// CHECK:      <__AArch64AbsXOLongThunk_big>:
+// CHECK-NEXT:    210124:       mov     x16, #0x4444
+// CHECK-NEXT:    210128:       movk    x16, #0x3333, lsl #16
+// CHECK-NEXT:    21012c:       movk    x16, #0x2222, lsl #32
+// CHECK-NEXT:    210130:       movk    x16, #0x1111, lsl #48
+// CHECK-NEXT:    210134:       br      x16
+