[LLD][ARM] Allow relative exceptions relocations in shared libraries

[peter.smith]

Summary

The R_ARM_NONE and R_ARM_PREL31 relocations are currently faulted when used in a shared object with:
can't create dynamic relocation R_ARM_NONE against symbol aeabi_unwind_cpp_pr0
can't create dynamic relocation R_ARM_PREL31 against symbol gxx_personality_v0

In the case of R_ARM_NONE this is because the R_ARM_NONE relocation is R_ABS when it should be relative, and it should be skipped in the same way that a R_HINT is handled as it should not affect any PLT-generation. Unfortunately R_ARM_NONE can't map to R_HINT as R_HINT has side-effects for TLS generation. I've introduced a R_NONE RelExpr to handle R_ARM_NONE in shared objects.

In the case of R_ARM_PREL31 this should map to R_PLT_PC as the personality routine can be imported so in a shared object the R_ARM_PREL31 has to resolve to the address of the PLT entry for the personality routine.

[ruiu]

I wonder why we are mapping R_AARCH64_TLSDESC_CALL to R_HINT. The other relocation that is mapped to R_HINT is R_MIPS_JALR, but that relocation is purely a hint -- the linker is allowed to do a peephole optimization by rewriting the instructions pointed by the relocation, but it's allowed to not do. On the other hand, we need to do something for TLS generation for R_AARCH64_TLSDESC_CALL. It seems that two semantically different relocations are mapped to one relocation type.

Maybe you could create a new relocation type for R_AARCH64_TLSDESC_CALL and then map R_ARM_NONE to R_HINT?

[peter.smith]

Thank you for the review. I've implemented the suggestion to add a R_TLSDESC_CALL RelExpr and used R_HINT for R_ARM_NONE and R_MIPS_JALR.

It could be possible to get rid of R_TLSDESC_CALL by replacing "Expr == R_TLSDESC_CALL" by
"Expr == R_HINT && Target->isTlsDescCall(Type)"

However I think that R_TLSDESC_CALL is worth keeping individually as it is common to x86, ARM and AArch64 even if it is only implemented in AArch64 in lld.

[ruiu]

LGTM

ELF/Relocations.h

63–64 ↗

(On Diff #75135)

Sort

lld/trunk/ELF/InputSection.cpp

 }
 
 template <class ELFT>
 static typename ELFT::uint getSymVA(uint32_t Type, typename ELFT::uint A,
                                     typename ELFT::uint P,
                                     const SymbolBody &Body, RelExpr Expr) {
   switch (Expr) {
   case R_HINT:
+  case R_TLSDESC_CALL:
     llvm_unreachable("cannot relocate hint relocs");
   case R_TLSLD:
     return Out<ELFT>::Got->getTlsIndexOff() + A - Out<ELFT>::Got->getSize();
   case R_TLSLD_PC:
     return Out<ELFT>::Got->getTlsIndexVA() + A - P;
   case R_THUNK_ABS:
     return Body.getThunkVA<ELFT>() + A;
   case R_THUNK_PC:

lld/trunk/ELF/Relocations.h

enum RelExpr {
   R_RELAX_TLS_LD_TO_LE,
   R_SIZE,
   R_THUNK_ABS,
   R_THUNK_PC,
   R_THUNK_PLT_PC,
   R_TLS,
   R_TLSDESC,
   R_TLSDESC_PAGE,
+  R_TLSDESC_CALL,
   R_TLSGD,
   R_TLSGD_PC,
   R_TLSLD,
   R_TLSLD_PC
 };
 
 struct Relocation {
   RelExpr Expr;

lld/trunk/ELF/Relocations.cpp

if (!Body.isTls())
     return 0;
 
   typedef typename ELFT::uint uintX_t;
 
   if (Config->EMachine == EM_MIPS || Config->EMachine == EM_ARM)
     return handleNoRelaxTlsRelocation<ELFT>(Type, Body, C, Offset, Addend,
                                             Expr);
 
-  if ((Expr == R_TLSDESC || Expr == R_TLSDESC_PAGE || Expr == R_HINT) &&
+  if ((Expr == R_TLSDESC || Expr == R_TLSDESC_PAGE || Expr == R_TLSDESC_CALL) &&
       Config->Shared) {
     if (Out<ELFT>::Got->addDynTlsEntry(Body)) {
       uintX_t Off = Out<ELFT>::Got->getGlobalDynOffset(Body);
       Out<ELFT>::RelaDyn->addReloc(
           {Target->TlsDescRel, Out<ELFT>::Got, Off, false, &Body, 0});
     }
-    if (Expr != R_HINT)
+    if (Expr != R_TLSDESC_CALL)
       C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
     return 1;
   }
 
   if (Expr == R_TLSLD_PC || Expr == R_TLSLD) {
     // Local-Dynamic relocs can be relaxed to Local-Exec.
     if (!Config->Shared) {
       C.Relocations.push_back(
static unsigned handleTlsRelocation(uint32_t Type, SymbolBody &Body,
 
   // Local-Dynamic relocs can be relaxed to Local-Exec.
   if (Target->isTlsLocalDynamicRel(Type) && !Config->Shared) {
     C.Relocations.push_back(
         {R_RELAX_TLS_LD_TO_LE, Type, Offset, Addend, &Body});
     return 1;
   }
 
-  if (Expr == R_TLSDESC_PAGE || Expr == R_TLSDESC || Expr == R_HINT ||
+  if (Expr == R_TLSDESC_PAGE || Expr == R_TLSDESC || Expr == R_TLSDESC_CALL ||
       Target->isTlsGlobalDynamicRel(Type)) {
     if (Config->Shared) {
       if (Out<ELFT>::Got->addDynTlsEntry(Body)) {
         uintX_t Off = Out<ELFT>::Got->getGlobalDynOffset(Body);
         Out<ELFT>::RelaDyn->addReloc(
             {Target->TlsModuleIndexRel, Out<ELFT>::Got, Off, false, &Body, 0});
 
         // If the symbol is preemptible we need the dynamic linker to write

 }
 
 template <class ELFT>
 static bool isStaticLinkTimeConstant(RelExpr E, uint32_t Type,
                                      const SymbolBody &Body) {
   // These expressions always compute a constant
   if (E == R_SIZE || E == R_GOT_FROM_END || E == R_GOT_OFF ||
       E == R_MIPS_GOT_LOCAL_PAGE || E == R_MIPS_GOT_OFF || E == R_MIPS_TLSGD ||
-      E == R_GOT_PAGE_PC || E == R_GOT_PC || E == R_PLT_PC || E == R_TLSGD_PC ||
-      E == R_TLSGD || E == R_PPC_PLT_OPD || E == R_TLSDESC_PAGE ||
-      E == R_HINT || E == R_THUNK_PC || E == R_THUNK_PLT_PC)
+      E == R_GOT_PAGE_PC || E == R_GOT_PC || E == R_PLT_PC ||
+      E == R_TLSGD_PC || E == R_TLSGD || E == R_PPC_PLT_OPD ||
+      E == R_TLSDESC_CALL || E == R_TLSDESC_PAGE || E == R_HINT ||
+      E == R_THUNK_PC || E == R_THUNK_PLT_PC)
     return true;
 
   // These never do, except if the entire file is position dependent or if
   // only the low bits are used.
   if (E == R_GOT || E == R_PLT || E == R_TLSDESC)
     return Target->usesOnlyLowPageBits(Type) || !Config->Pic;
 
   if (isPreemptible(Body, Type))
for (auto I = Rels.begin(), E = Rels.end(); I != E; ++I) {
     uintX_t Addend = computeAddend(File, Buf, E, RI, Expr, Body);
 
     if (unsigned Processed =
             handleTlsRelocation<ELFT>(Type, Body, C, Offset, Addend, Expr)) {
       I += (Processed - 1);
       continue;
     }
 
-    // Ignore "hint" relocation because it is for optional code optimization.
-    if (Expr == R_HINT)
+    // Ignore "hint" and TLS Descriptor call relocation because they are
+    // only markers for relaxation.
+    if (Expr == R_HINT || Expr == R_TLSDESC_CALL)
       continue;
 
     if (needsPlt(Expr) || Expr == R_THUNK_ABS || Expr == R_THUNK_PC ||
         Expr == R_THUNK_PLT_PC || refersToGotEntry(Expr) ||
         !isPreemptible(Body, Type)) {
       // If the relocation points to something in the file, we can process it.
       bool Constant = isStaticLinkTimeConstant<ELFT>(Expr, Type, Body);
 

lld/trunk/ELF/Target.cpp

RelExpr AArch64TargetInfo::getRelExpr(uint32_t Type,
   default:
     return R_ABS;
   case R_AARCH64_TLSDESC_ADR_PAGE21:
     return R_TLSDESC_PAGE;
   case R_AARCH64_TLSDESC_LD64_LO12_NC:
   case R_AARCH64_TLSDESC_ADD_LO12_NC:
     return R_TLSDESC;
   case R_AARCH64_TLSDESC_CALL:
-    return R_HINT;
+    return R_TLSDESC_CALL;
   case R_AARCH64_TLSLE_ADD_TPREL_HI12:
   case R_AARCH64_TLSLE_ADD_TPREL_LO12_NC:
     return R_TLS;
   case R_AARCH64_CALL26:
   case R_AARCH64_CONDBR19:
   case R_AARCH64_JUMP26:
   case R_AARCH64_TSTBR14:
     return R_PLT_PC;
RelExpr ARMTargetInfo::getRelExpr(uint32_t Type, const SymbolBody &S) const {
   default:
     return R_ABS;
   case R_ARM_THM_JUMP11:
     return R_PC;
   case R_ARM_CALL:
   case R_ARM_JUMP24:
   case R_ARM_PC24:
   case R_ARM_PLT32:
+  case R_ARM_PREL31:
   case R_ARM_THM_JUMP19:
   case R_ARM_THM_JUMP24:
   case R_ARM_THM_CALL:
     return R_PLT_PC;
   case R_ARM_GOTOFF32:
     // (S + A) - GOT_ORG
     return R_GOTREL;
   case R_ARM_GOT_BREL:
case R_ARM_TLS_LDM32:
     return R_TLSLD_PC;
   case R_ARM_BASE_PREL:
     // B(S) + A - P
     // FIXME: currently B(S) assumed to be .got, this may not hold for all
     // platforms.
     return R_GOTONLY_PC;
   case R_ARM_MOVW_PREL_NC:
   case R_ARM_MOVT_PREL:
-  case R_ARM_PREL31:
   case R_ARM_REL32:
   case R_ARM_THM_MOVW_PREL_NC:
   case R_ARM_THM_MOVT_PREL:
     return R_PC;
+  case R_ARM_NONE:
+    return R_HINT;
   case R_ARM_TLS_LE32:
     return R_TLS;
   }
 }
 
 uint32_t ARMTargetInfo::getDynRel(uint32_t Type) const {
   if (Type == R_ARM_TARGET1 && !Config->Target1Rel)
     return R_ARM_ABS32;
case R_ARM_THM_JUMP24:
     break;
   }
   return Expr;
 }
 
 void ARMTargetInfo::relocateOne(uint8_t *Loc, uint32_t Type,
                                 uint64_t Val) const {
   switch (Type) {
-  case R_ARM_NONE:
-    break;
   case R_ARM_ABS32:
   case R_ARM_BASE_PREL:
   case R_ARM_GOTOFF32:
   case R_ARM_GOT_BREL:
   case R_ARM_GOT_PREL:
   case R_ARM_REL32:
   case R_ARM_TARGET1:
   case R_ARM_TARGET2:

lld/trunk/test/ELF/arm-exidx-shared.s

+// RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t
+// RUN: ld.lld %t --shared -o %t2 2>&1
+// RUN: llvm-readobj --relocations %t2 | FileCheck %s
+// RUN: llvm-objdump -s -triple=armv7a-none-linux-gnueabi %t2 | FileCheck -check-prefix=CHECK-EXTAB %s
+
+// Check that the relative R_ARM_PREL31 relocation can access a PLT entry
+// for when the personality routine is referenced from a shared library.
+// Also check that the R_ARM_NONE no-op relocation can be used in a shared
+// library.
+ .syntax unified
+// Will produce an ARM.exidx entry with an R_ARM_NONE relocation to
+// __aeabi_unwind_cpp_pr0
+ .section .text.func1, "ax",%progbits
+ .global func1
+func1:
+ .fnstart
+ bx lr
+ .fnend
+
+// Will produce a R_ARM_PREL31 relocation with respect to the PLT entry of
+// __gxx_personality_v0
+ .section .text.func2, "ax",%progbits
+ .global func2
+func2:
+ .fnstart
+ bx lr
+ .personality __gxx_personality_v0
+ .handlerdata
+ .long 0
+ .section .text.func2
+ .fnend
+
+ .section .text.__aeabi_unwind_cpp_pr0, "ax", %progbits
+ .global __aeabi_unwind_cpp_pr0
+__aeabi_unwind_cpp_pr0:
+ bx lr
+
+// CHECK: Relocations [
+// CHECK-NEXT:   Section (6) .rel.plt {
+// CHECK-NEXT:     0x300C R_ARM_JUMP_SLOT __gxx_personality_v0
+
+// CHECK-EXTAB: Contents of section .ARM.extab.text.func2:
+// 0144 + 0ee0 = 0x1024 = __gxx_personality_v0(PLT)
+// CHECK-EXTAB-NEXT:  0144 e00e0000 b0b0b000 00000000