[LLD][ELF] Fix ARM TLS global dynamic TlsOffsetRel for non-preemtible symbols

[peter.smith]

Summary

When the target of the TlsOffsetRel is non-preemptible we can write the offset directly into the GOT without needing a dynamic relocation. This is optional for dynamically linked executables but is required for static linking.

We used to rely on the GOTSection::writeTo member function to get the TLS offset of the symbol when writing the VA of the symbol. However in r288107 the GOTSection::writeTo was changed to only use relocations for writing values. Unfortunately we were missing the GOT relocation so all TLS offsets were being written as 0. This change adds the relocation to the GOT entry and a test case for non-0 offsets.

This was split out of D31672, it is based off the refactoring change in D31748.

[• rafael]

LGTM assuming the previous one is approved.

[ruiu]

ELF/Relocations.cpp

192 ↗

(On Diff #94341)

Can this be more regular relocation rathe rthan TlsOffsetRel? What we want to do is to set a symbol value to the got offset, so it doesn't have to be a TLS relocation, no?

[peter.smith]

I've used the regular relocation code for this change.

ELF/Relocations.cpp

192 ↗

(On Diff #94341)

It can be, but doing so makes the later refactoring to have one AddTlsReloc() function more difficult as we can give that function the same relocation code in both cases. Given that refactoring D31751 isn't approved yet I'll use a more regular code, we can always change it back in D31751.

lld/trunk/ELF/Relocations.cpp

static unsigned handleARMTlsRelocation(GotSection<ELFT> *Got, uint32_t Type,
   // using static GOT relocations.
   if (Expr == R_TLSGD_PC) {
     if (Got->addDynTlsEntry(Body)) {
       uint64_t Off = Got->getGlobalDynOffset(Body);
       addModuleReloc(Off, false);
       if (Body.isPreemptible())
         In<ELFT>::RelaDyn->addReloc({Target->TlsOffsetRel, Got,
                                      Off + Config->Wordsize, false, &Body, 0});
+      else
+        Got->Relocations.push_back(
+            {R_ABS, R_ARM_ABS32, Off + Config->Wordsize, 0, &Body});
     }
     C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
     return 1;
   }
   return 0;
 }
 
 // Returns the number of relocations processed.

lld/trunk/test/ELF/arm-tls-gd-nonpreemptible.s

+// RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t
+// RUN: ld.lld %t -o %t2
+// RUN: llvm-mc %s -o %t.o -filetype=obj -triple=armv7a-linux-gnueabi
+// RUN: llvm-objdump -s %t2 | FileCheck %s
+// RUN: ld.lld %t --shared -o %t3.so
+// RUN: llvm-objdump -s %t3.so | FileCheck -check-prefix=CHECK-SHARED %s
+// REQUIRES: arm
+
+// For an executable, we write the module index 1 and the offset into the TLS
+// directly into the GOT. For a shared library we can only write the offset
+// into the TLS directly if the symbol is non-preemptible
+
+ .text
+ .syntax unified
+ .globl __tls_get_addr
+ .type __tls_get_addr,%function
+__tls_get_addr:
+ bx lr
+
+ .globl  _start
+ .p2align        2
+ .type   _start,%function
+func:
+.L0:
+ nop
+.L1:
+ nop
+.L2:
+ nop
+.L3:
+ nop
+ .p2align        2
+// Generate R_ARM_TLS_GD32 relocations
+// These can be resolved at static link time for executables as 1 is always the
+// module index and the offset into tls is known at static link time
+.Lt0: .word   x1(TLSGD) + (. - .L0 - 8)
+.Lt1: .word   x2(TLSGD) + (. - .L1 - 8)
+.Lt2: .word   x3(TLSGD) + (. - .L2 - 8)
+.Lt3: .word   x4(TLSGD) + (. - .L3 - 8)
+ .hidden x1
+ .globl  x1
+ .hidden x2
+ .globl  x2
+ .globl  x3
+ .globl  x4
+
+ .section       .tdata,"awT",%progbits
+ .p2align  2
+.TLSSTART:
+ .type  x1, %object
+x1:
+ .word 10
+ .type  x2, %object
+x2:
+ .word 20
+
+ .section       .tbss,"awT",%nobits
+ .p2align 2
+ .type  x3, %object
+x3:
+ .space 4
+ .type  x4, %object
+x4:
+ .space 4
+
+// CHECK: Contents of section .got:
+// CHECK-NEXT:  12008 01000000 00000000 01000000 04000000
+// CHECK-NEXT:  12018 01000000 08000000 01000000 0c000000
+
+// CHECK-SHARED: Contents of section .got:
+// CHECK-SHARED-NEXT:  2050 00000000 00000000 00000000 04000000
+// CHECK-SHARED-NEXT:  2060 00000000 00000000 00000000 00000000