[LLD][ARM] Correct ARM TLS GOT entries without dynamic relocations.

[peter.smith]

Summary

ARM has three dynamic relocations for TLS:

• R_ARM_TPOFF32 (Offset of S from Thread Pointer)
• R_ARM_DTPMOD32 (Module-Id, always 1 for executables)
• R_ARM_DTPOFF32 (Offset of S from TLS block)

When static linking we must resolve these relocations statically by writing the values directly into the .got. In many ways ARM is similar to Mips:

• TLS is not relaxable so the linker can't rely on relaxing global and local dynamic away.
• ARM is type 1 TLS (TLS block is immediately after Thread Pointer and precedes TLS data) so the TCB size has to be accounted for when resolving R_ARM_TPOFF32.
• The R_ARM_DTPMOD32 needs to be hard coded to 1 in applications.

To implement this I've:

• Removed the fixme in handleNoRelaxTlsRelocation() which always added dynamic relocations for ARM TLS
• Recorded where symbols have been relocated by a Target->TlsGotRel, R_ARM_TLS_TPOFF32 for ARM
• Introduce a writeARMGot(), similar to writeMipsGot() to isolate the special cases from the other Targets.
  • Write the module index to be 1 (from Global Dynamic or Local Dynamic)
  • Account for the Target->TcbSize when writing the value of a symbol that has been recorded as being referenced by R_ARM_TPOFF32.

The changes show up in the existing tests. As we no longer need the dynamic relocation for the module index and the GOT entries that are statically resolved R_ARM_TLS_TPOFF32 relocations include the ARM TcbSize of 8.

The implementation of writeARMGot() is similar to writeMipsGot() in the way it handles TLS.

The Mips implementation uses Config->Pic consistently to use dynamic relocations. For ARM I've used Config->Shared as an executable can still use Pic, and can still be statically linked with Pic.

[• rafael]

ELF/OutputSections.cpp

394

This is the same value as what R_TLS would compute, no?

now that the got is a synthetic section, it has a Relocations array. Could we maybe use that instead of Entries? So the code for having a non zero value in the got would become something like

In<ELFT>::Got.Relocations.push_back({R_ABS, Target->?, }Body.getGotPltOffset<ELFT>() , 0, &Body})

Do you think that would be better? If not something like this (rebase now that .got is a synthetic section) is probably ok.

[peter.smith]

Thanks very much for the comments.

I hope to rewrite this and my ifunc patch shortly using the refactored Input Sections.

I've been spending some time using lld on ARM as an ld replacement on a Chromebook running Ubuntu via crouton. Some of the programs I've not been able to execute without some instability problems after linking are the llvm-* tools such llvm-mc etc. One possible source of problems is TLS so I may not have got this completely right yet.

ELF/OutputSections.cpp

394

Yes that is correct. We are in effect resolving the relocation at static link time.

The difficulty with this approach at the time was how to avoid writing the relocation into the file as well as statically resolving it. I thought that this would probably be messier than localising it here. With the new refactoring this might be easier so it will be worth taking another look.

[peter.smith]

This is no longer needed, it was implemented as part of D27213

ELF/OutputSections.h

private:
   typedef std::vector<MipsGotEntry> MipsGotEntries;
   llvm::DenseMap<MipsGotEntry, size_t> MipsGotMap;
   MipsGotEntries MipsLocal;
   MipsGotEntries MipsLocal32;
   MipsGotEntries MipsGlobal;
 
   // Write MIPS-specific parts of the GOT.
   void writeMipsGot(uint8_t *Buf);
+  // Write ARM-specific parts of the GOT.
+  void writeARMGot(uint8_t *Buf);
 };
 
 template <class ELFT>
 class GotPltSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::uint uintX_t;
   typedef OutputSectionBase<ELFT> Base;
 
 public:

ELF/OutputSections.cpp

if (B->GlobalDynIndex != -1U) {
       uint8_t *Entry = Buf + B->GlobalDynIndex * sizeof(uintX_t);
       writeUint<ELFT>(Entry, 1);
       Entry += sizeof(uintX_t);
       writeUint<ELFT>(Entry, VA - 0x8000);
     }
   }
 }
 
+template <class ELFT> void GotSection<ELFT>::writeARMGot(uint8_t *Buf) {
+  if (TlsIndexOff != -1U && !Config->Shared)
+    writeUint<ELFT>(Buf + TlsIndexOff, 1);
+  for (const SymbolBody *B : Entries) {
+    if (!B || B->isPreemptible())
+      // The dynamic linker will take care of preemptible entries
+      continue;
+    uintX_t VA = B->getVA<ELFT>();
+    if (B->GotIndex != -1U) {
+      if (B->IsTlsGotRel)
+        VA += alignTo(Target->TcbSize, Out<ELFT>::TlsPhdr->p_align);
+      uint8_t *Entry = Buf + B->GotIndex * sizeof(uintX_t);
+      writeUint<ELFT>(Entry, VA);
+    }
+    if (B->GlobalDynIndex != -1U) {
+      uint8_t *Entry = Buf + B->GlobalDynIndex * sizeof(uintX_t);
+      if (!Config->Shared)
+        writeUint<ELFT>(Entry, 1);
+      Entry += sizeof(uintX_t);
+      writeUint<ELFT>(Entry, VA);
+    }
+  }
+}
+
 template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
   if (Config->EMachine == EM_MIPS) {
     writeMipsGot(Buf);
     return;
   }
+  if (Config->EMachine == EM_ARM) {
+    writeARMGot(Buf);
+    return;
+  }
   for (const SymbolBody *B : Entries) {
     uint8_t *Entry = Buf;
     Buf += sizeof(uintX_t);
     if (!B)
       continue;
     if (B->isPreemptible())
       continue; // The dynamic linker will take care of it.
     uintX_t VA = B->getVA<ELFT>();

ELF/Relocations.cpp

if (Config->EMachine == EM_MIPS && (Type & 0xff) == R_MIPS_GPREL16)
     return false;
   return Body.isPreemptible();
 }
 
 // This function is similar to the `handleTlsRelocation`. ARM and MIPS do not
 // support any relaxations for TLS relocations so by factoring out ARM and MIPS
 // handling in to the separate function we can simplify the code and do not
 // pollute `handleTlsRelocation` by ARM and MIPS `ifs` statements.
-// FIXME: The ARM implementation always adds the module index dynamic
-// relocation even for non-preemptible symbols in applications. For static
-// linking support we must either resolve the module index relocation at static
-// link time, or hard code the module index (1) for the application in the GOT.
 template <class ELFT>
 static unsigned handleNoRelaxTlsRelocation(uint32_t Type, SymbolBody &Body,
                                            InputSectionBase<ELFT> &C,
                                            typename ELFT::uint Offset,
                                            typename ELFT::uint Addend,
                                            RelExpr Expr) {
   if (Expr == R_MIPS_TLSLD || Expr == R_TLSLD_PC) {
     if (Out<ELFT>::Got->addTlsIndex() &&
-        (Config->Pic || Config->EMachine == EM_ARM))
+        ((Config->EMachine == EM_MIPS && Config->Pic) ||
+         (Config->EMachine == EM_ARM && Config->Shared)))
       Out<ELFT>::RelaDyn->addReloc({Target->TlsModuleIndexRel, Out<ELFT>::Got,
                                     Out<ELFT>::Got->getTlsIndexOff(), false,
                                     nullptr, 0});
     C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
     return 1;
   }
   typedef typename ELFT::uint uintX_t;
   if (Target->isTlsGlobalDynamicRel(Type)) {
     if (Out<ELFT>::Got->addDynTlsEntry(Body) &&
-        (Body.isPreemptible() || Config->EMachine == EM_ARM)) {
+        (Body.isPreemptible() ||
+         (Config->EMachine == EM_ARM && Config->Shared))) {
       uintX_t Off = Out<ELFT>::Got->getGlobalDynOffset(Body);
       Out<ELFT>::RelaDyn->addReloc(
           {Target->TlsModuleIndexRel, Out<ELFT>::Got, Off, false, &Body, 0});
       if (Body.isPreemptible())
         Out<ELFT>::RelaDyn->addReloc({Target->TlsOffsetRel, Out<ELFT>::Got,
                                       Off + (uintX_t)sizeof(uintX_t), false,
                                       &Body, 0});
     }
if (refersToGotEntry(Expr)) {
                   false, &Body, 0});
         continue;
       }
 
       if (Body.isInGot())
         continue;
 
       Out<ELFT>::Got->addEntry(Body);
+      if (Body.isTls())
+        Body.IsTlsGotRel = true;
       if (Preemptible || (Config->Pic && !isAbsolute<ELFT>(Body))) {
         uint32_t DynType;
         if (Body.isTls())
           DynType = Target->TlsGotRel;
         else if (Preemptible)
           DynType = Target->GotRel;
         else
           DynType = Target->RelativeRel;

ELF/Symbols.h

public:
   unsigned IsLocal : 1;
 
   // True if this symbol has an entry in the global part of MIPS GOT.
   unsigned IsInGlobalMipsGot : 1;
 
   // True if this symbol is referenced by 32-bit GOT relocations.
   unsigned Is32BitMipsGot : 1;
 
+  // True if this symbol is referenced by TlsGotRel relocations.
+  unsigned IsTlsGotRel : 1;
+
   // The following fields have the same meaning as the ELF symbol attributes.
   uint8_t Type;    // symbol type
   uint8_t StOther; // st_other field value
 
   // The Type field may also have this value. It means that we have not yet seen
   // a non-Lazy symbol with this name, so we don't know what its type is. The
   // Type field is normally set to this value for Lazy symbols unless we saw a
   // weak undefined symbol first, in which case we need to remember the original

test/ELF/arm-tls-norelax-gd-le.s

 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %p/Inputs/arm-tls-get-addr.s -o %t1
 // RUN: ld.lld %t1 --shared -o %t1.so
 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=armv7a-linux-gnueabi
 // RUN: ld.lld %t1.so %t.o -o %t
-// RUN: llvm-readobj -s -dyn-relocations %t | FileCheck %s
+// RUN: llvm-objdump -s %t | FileCheck %s
 // REQUIRES: arm
 
 // This tls global-dynamic sequence is with respect to a non-preemptible
 // symbol in an application so a relaxation to Local Exec would normally be
 // possible. This would result in an assertion failure on ARM as the
 // relaxation functions can't be implemented on ARM. Check that the sequence
 // is handled as global dynamic
 

 
  .globl  x
 .section       .tbss,"awT",%nobits
  .p2align  2
 x:
  .space 4
  .type  x, %object
 
-// CHECK: Dynamic Relocations {
-// CHECK-NEXT:   0x12078 R_ARM_TLS_DTPMOD32
-// CHECK-NEXT:   0x1300C R_ARM_JUMP_SLOT __tls_get_addr
+// CHECK:       Contents of section .got:
+// Module index is always 1 for executable
+// CHECK-NEXT:  12060 01000000 00000000
 

test/ELF/arm-tls-norelax-ie-le.s

 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %p/Inputs/arm-tls-get-addr.s -o %t1
 // RUN: ld.lld %t1 --shared -o %t1.so
 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=armv7a-linux-gnueabi
 // RUN: ld.lld %t1.so %t.o -o %t
-// RUN: llvm-objdump -s -triple=armv7a-linux-gnueabi %t
+// RUN: llvm-objdump -s -triple=armv7a-linux-gnueabi %t | FileCheck %s
 // REQUIRES: arm
 
 // This tls Initial Exec sequence is with respect to a non-preemptible symbol
 // so a relaxation would normally be possible. This would result in an assertion
 // failure on ARM as the relaxation functions can't be implemented on ARM.
 // Check that the sequence is handled as initial exec
  .text
  .syntax unified

  .globl x2
  .section       .tbss,"awT",%nobits
  .type  x1, %object
 x2:
  .space 4
  .type x2, %object
 
 // CHECK: Contents of section .got
-// x1 at offset 0 from TP, x2 at offset 4 from TP
-// 12064 00000000 04000000
+// x1 at offset 8 from TP, x2 at offset c from TP. Offsets include TCB size of 8
+// CHECK-NEXT: 12064 08000000 0c000000

test/ELF/arm-tls-norelax-ld-le.s

 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %p/Inputs/arm-tls-get-addr.s -o %t1
 // RUN: ld.lld %t1 --shared -o %t1.so
 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=armv7a-linux-gnueabi
 // RUN: ld.lld %t1.so %t.o -o %t
-// RUN: llvm-readobj -s -dyn-relocations %t | FileCheck %s
+// RUN: llvm-objdump -s %t | FileCheck %s
 // REQUIRES: arm
 
  .global __tls_get_addr
  .text
  .p2align  2
  .global _start
  .syntax unified
  .arm

 y:
  .space  4
  .section        .tdata,"awT",%progbits
  .p2align  2
  .type   x, %object
 x:
  .word   10
 
-// CHECK: Dynamic Relocations {
-// CHECK-NEXT:   0x1207C R_ARM_TLS_DTPMOD32 - 0x0
-// CHECK-NEXT:   0x1300C R_ARM_JUMP_SLOT __tls_get_addr 0x0
+// CHECK: Contents of section .got:
+// CHECK-NEXT:  12064 01000000 00000000