[elf2] Add support for R_X86_64_TLSLD.

[Bigcheese]

Summary

leaq symbol@tlsld(%rip), %rdi
call __tls_get_addr@plt

symbol@tlsld (R_X86_64_TLSLD) instructs the linker to generate a tls_index entry (two GOT slots) in the GOT for the entire module (shared object or executable) with an offset of 0. The symbol for this GOT entry doesn't matter (as long as it's either local to the module or null), and gold doesn't put a symbol in the dynamic R_X86_64_DTPMOD64 relocation for the GOT entry.

All other platforms defined in http://www.akkadia.org/drepper/tls.pdf except for Itanium use a similar model where global and local dynamic GOT entries take up 2 contiguous GOT slots, so we can handle this in a unified manner if we don't care about Itanium.

While scanning relocations we need to identify local dynamic relocations and generate a single tls_index entry in the GOT for the module and store the address of it somewhere so we can later statically resolve the offset for R_X86_64_TLSLD relocations. We also need to generate a R_X86_64_DTPMOD64 relocation in the RelaDyn relocation section.

This implementation is a bit hacky. It side steps the issue of GotSection and RelocationSection only handling SymbolBody entries by relying on a specific relocation type. The alternative to this seemed to be completely rewriting how GotSection and RelocationSection work, or using a different hacky signaling method.

[• rafael]

rebased the patch and fixed the warnings.

• t.diff7 KBDownload

[• rafael]

test/elf2/tls-dynamic.s

4

When producing an executable gold produces no dynamic relocations. I understand that is just an optimization that we don't have yet. To avoid changing this test is the future, can you change it to use -shared? With that you can also remove

​ .text

		​  .globl  _start
		​_start:

[• rafael]

Please add a second " leaq b@tlsld(%rip), %rdi" to show that only a
single R_X86_64_DTPMOD64 is created.

[• rafael]

ELF/InputSection.cpp

106

Buf + RI.r_offset is now used 3 times is this function. Please factor it into a variable above, commit that and rebase.

The same is true for BaseAddr + RI.r_offset

ELF/OutputSections.cpp

85

Will this also be used for global tls? Change the name if so.

[ruiu]

I'm out of office today. I'll review this in a few days. Sorry for the
delay.

[Bigcheese]

ELF/OutputSections.cpp

85

No. Global Dynamic symbols can be handled by addEntry already. Just needs to check the symbol type.

test/elf2/tls-dynamic.s

4

It's already -shared, I'll remove the _start symbol.

[Bigcheese]

Strengthened test and removed redundancy.

[• rafael]

LGTM with the {} removed.

ELF/Target.h

72

No other entry uses {}

[Bigcheese]

ELF/Target.h

72

The other entries don't require a default value. This is only set for x86-64, and needs to be defaulted to zero otherwise. TlsModuleIndexReloc doesn't need it though.

[• rafael]

Use = 0.

[ruiu]

LGTM

ELF/InputSection.cpp

 void InputSection<ELFT>::relocate(
     uint8_t *Buf, uint8_t *BufEnd,
     iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels,
     const ObjectFile<ELFT> &File, uintX_t BaseAddr) {
   typedef Elf_Rel_Impl<ELFT, isRela> RelType;
   for (const RelType &RI : Rels) {
     uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
     uint32_t Type = RI.getType(Config->Mips64EL);
+    uint8_t *BufLoc = Buf + RI.r_offset;
+    uintX_t AddrLoc = BaseAddr + RI.r_offset;
+
+    if (Type == Target->getTlsLocalDynamicReloc()) {
+      Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
+                          Out<ELFT>::Got->getVA() +
+                              Out<ELFT>::LocalModuleTlsIndexOffset +
+                              getAddend<ELFT>(RI));
+      continue;
+    }
 
     // Handle relocations for local symbols -- they never get
     // resolved so we don't allocate a SymbolBody.
     const Elf_Shdr *SymTab = File.getSymbolTable();
     if (SymIndex < SymTab->sh_info) {
       uintX_t SymVA = getLocalRelTarget(File, RI);
-      Target->relocateOne(Buf + RI.r_offset, BufEnd, Type,
-                          BaseAddr + RI.r_offset, SymVA);
+      Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA);
       continue;
     }
 
     SymbolBody &Body = *File.getSymbolBody(SymIndex)->repl();
     uintX_t SymVA = getSymVA<ELFT>(Body);
     if (Target->relocNeedsPlt(Type, Body)) {
       SymVA = Out<ELFT>::Plt->getEntryAddr(Body);
       Type = Target->getPLTRefReloc(Type);
     } else if (Target->relocNeedsGot(Type, Body)) {
       SymVA = Out<ELFT>::Got->getEntryAddr(Body);
       Type = Target->getGotRefReloc();
     } else if (Target->relocPointsToGot(Type)) {
       SymVA = Out<ELFT>::Got->getVA();
       Type = Target->getPCRelReloc();
     } else if (!Target->relocNeedsCopy(Type, Body) &&
                isa<SharedSymbol<ELFT>>(Body)) {
       continue;
     }
-    Target->relocateOne(Buf + RI.r_offset, BufEnd, Type, BaseAddr + RI.r_offset,
+    Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
                         SymVA + getAddend<ELFT>(RI));
   }
 }
 
 template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
   if (this->Header->sh_type == SHT_NOBITS)
     return;
   // Copy section contents from source object file to output file.

ELF/OutputSections.h

template <class ELFT> class GotSection final : public OutputSectionBase<ELFT> {
   typedef OutputSectionBase<ELFT> Base;
   typedef typename Base::uintX_t uintX_t;
 
 public:
   GotSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody *Sym);
+  uint32_t addLocalModuleTlsIndex();
   bool empty() const { return Entries.empty(); }
   uintX_t getEntryAddr(const SymbolBody &B) const;
 
 private:
   std::vector<const SymbolBody *> Entries;
 };
 
 template <class ELFT>
template <class ELFT> struct Out {
   static RelocationSection<ELFT> *RelaDyn;
   static RelocationSection<ELFT> *RelaPlt;
   static StringTableSection<ELFT> *DynStrTab;
   static StringTableSection<ELFT> *ShStrTab;
   static StringTableSection<ELFT> *StrTab;
   static SymbolTableSection<ELFT> *DynSymTab;
   static SymbolTableSection<ELFT> *SymTab;
   static Elf_Phdr *TlsPhdr;
+  static uint32_t LocalModuleTlsIndexOffset;
 };
 
 template <class ELFT> DynamicSection<ELFT> *Out<ELFT>::Dynamic;
 template <class ELFT> GnuHashTableSection<ELFT> *Out<ELFT>::GnuHashTab;
 template <class ELFT> GotPltSection<ELFT> *Out<ELFT>::GotPlt;
 template <class ELFT> GotSection<ELFT> *Out<ELFT>::Got;
 template <class ELFT> HashTableSection<ELFT> *Out<ELFT>::HashTab;
 template <class ELFT> InterpSection<ELFT> *Out<ELFT>::Interp;
 template <class ELFT> OutputSection<ELFT> *Out<ELFT>::Bss;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::Opd;
 template <class ELFT> uint8_t *Out<ELFT>::OpdBuf;
 template <class ELFT> PltSection<ELFT> *Out<ELFT>::Plt;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaDyn;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaPlt;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::DynStrTab;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::ShStrTab;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::StrTab;
 template <class ELFT> SymbolTableSection<ELFT> *Out<ELFT>::DynSymTab;
 template <class ELFT> SymbolTableSection<ELFT> *Out<ELFT>::SymTab;
 template <class ELFT> typename Out<ELFT>::Elf_Phdr *Out<ELFT>::TlsPhdr;
+template <class ELFT> uint32_t Out<ELFT>::LocalModuleTlsIndexOffset = -1;
 
 } // namespace elf2
 } // namespace lld
 
 #endif // LLD_ELF_OUTPUT_SECTIONS_H

ELF/OutputSections.cpp

GotSection<ELFT>::GotSection()
   this->Header.sh_addralign = sizeof(uintX_t);
 }
 
 template <class ELFT> void GotSection<ELFT>::addEntry(SymbolBody *Sym) {
   Sym->GotIndex = Target->getGotHeaderEntriesNum() + Entries.size();
   Entries.push_back(Sym);
 }
 
+template <class ELFT> uint32_t GotSection<ELFT>::addLocalModuleTlsIndex() {
+  Entries.push_back(nullptr);
+  Entries.push_back(nullptr);
+  return (Entries.size() - 2) * sizeof(uintX_t);
+}
+
 template <class ELFT>
 typename GotSection<ELFT>::uintX_t
 GotSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
   return this->getVA() + B.GotIndex * sizeof(uintX_t);
 }
 
 template <class ELFT> void GotSection<ELFT>::finalize() {
   this->Header.sh_size =
       (Target->getGotHeaderEntriesNum() + Entries.size()) * sizeof(uintX_t);
 }
 
 template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
   Target->writeGotHeaderEntries(Buf);
   Buf += Target->getGotHeaderEntriesNum() * sizeof(uintX_t);
   for (const SymbolBody *B : Entries) {
     uint8_t *Entry = Buf;
     Buf += sizeof(uintX_t);
+    if (!B)
+      continue;
     // MIPS has special rules to fill up GOT entries.
     // See "Global Offset Table" in Chapter 5 in the following document
     // for detailed description:
     // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
     // As the first approach, we can just store addresses for all symbols.
     if (Config->EMachine != EM_MIPS && canBePreempted(B, false))
       continue; // The dynamic linker will take care of it.
     uintX_t VA = getSymVA<ELFT>(*B);
for (const DynamicReloc<ELFT> &Rel : Relocs) {
     const Elf_Rel &RI = Rel.RI;
     uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
     const ObjectFile<ELFT> &File = *C.getFile();
     SymbolBody *Body = File.getSymbolBody(SymIndex);
     if (Body)
       Body = Body->repl();
 
     uint32_t Type = RI.getType(Config->Mips64EL);
+
+    if (Type == Target->getTlsLocalDynamicReloc()) {
+      P->setSymbolAndType(0, Target->getTlsModuleIndexReloc(),
+                          Config->Mips64EL);
+      P->r_offset =
+          Out<ELFT>::Got->getVA() + Out<ELFT>::LocalModuleTlsIndexOffset;
+      continue;
+    }
+
     bool NeedsCopy = Body && Target->relocNeedsCopy(Type, *Body);
     bool NeedsGot = Body && Target->relocNeedsGot(Type, *Body);
     bool CanBePreempted = canBePreempted(Body, NeedsGot);
     bool LazyReloc = Body && Target->supportsLazyRelocations() &&
                      Target->relocNeedsPlt(Type, *Body);
 
     if (CanBePreempted) {
       if (NeedsGot)

ELF/Target.h

public:
   unsigned getPageSize() const { return PageSize; }
   uint64_t getVAStart() const { return VAStart; }
   unsigned getCopyReloc() const { return CopyReloc; }
   unsigned getPCRelReloc() const { return PCRelReloc; }
   unsigned getGotReloc() const { return GotReloc; }
   unsigned getPltReloc() const { return PltReloc; }
   unsigned getGotRefReloc() const { return GotRefReloc; }
   unsigned getRelativeReloc() const { return RelativeReloc; }
+  unsigned getTlsLocalDynamicReloc() const { return TlsLocalDynamicReloc; }
+  unsigned getTlsModuleIndexReloc() const { return TlsModuleIndexReloc; }
   unsigned getPltZeroEntrySize() const { return PltZeroEntrySize; }
   unsigned getPltEntrySize() const { return PltEntrySize; }
   bool supportsLazyRelocations() const { return LazyRelocations; }
   unsigned getGotHeaderEntriesNum() const { return GotHeaderEntriesNum; }
   virtual unsigned getPLTRefReloc(unsigned Type) const;
   virtual void writeGotHeaderEntries(uint8_t *Buf) const;
   virtual void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const = 0;
   virtual void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
protected:
   uint64_t VAStart = 0x10000;
 
   unsigned CopyReloc;
   unsigned PCRelReloc;
   unsigned GotRefReloc;
   unsigned GotReloc;
   unsigned PltReloc;
   unsigned RelativeReloc;
+  unsigned TlsLocalDynamicReloc{};
+  unsigned TlsModuleIndexReloc{};
   unsigned PltEntrySize = 8;
   unsigned PltZeroEntrySize = 0;
   unsigned GotHeaderEntriesNum = 0;
   bool LazyRelocations = false;
 };
 
 uint64_t getPPC64TocBase();
 

ELF/Target.cpp

 
 X86_64TargetInfo::X86_64TargetInfo() {
   CopyReloc = R_X86_64_COPY;
   PCRelReloc = R_X86_64_PC32;
   GotReloc = R_X86_64_GLOB_DAT;
   GotRefReloc = R_X86_64_PC32;
   PltReloc = R_X86_64_JUMP_SLOT;
   RelativeReloc = R_X86_64_RELATIVE;
+  TlsLocalDynamicReloc = R_X86_64_TLSLD;
+  TlsModuleIndexReloc = R_X86_64_DTPMOD64;
   LazyRelocations = true;
   PltEntrySize = 16;
   PltZeroEntrySize = 16;
 }
 
 void X86_64TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {
   // Skip 6 bytes of "jmpq *got(%rip)"
   write32le(Buf, Plt + 6);

 }
 
 void X86_64TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                    uint64_t P, uint64_t SA) const {
   switch (Type) {
   case R_X86_64_PC32:
   case R_X86_64_GOTPCREL:
   case R_X86_64_PLT32:
+  case R_X86_64_TLSLD:
     write32le(Loc, SA - P);
     break;
   case R_X86_64_64:
     write64le(Loc, SA);
     break;
   case R_X86_64_32:
   case R_X86_64_32S:
     if (Type == R_X86_64_32 && !isUInt<32>(SA))

ELF/Writer.cpp

void Writer<ELFT>::scanRelocs(
     iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels) {
   typedef Elf_Rel_Impl<ELFT, isRela> RelType;
   const ObjectFile<ELFT> &File = *C.getFile();
   for (const RelType &RI : Rels) {
     uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
     SymbolBody *Body = File.getSymbolBody(SymIndex);
     uint32_t Type = RI.getType(Config->Mips64EL);
 
+    if (Type == Target->getTlsLocalDynamicReloc()) {
+      if (Out<ELFT>::LocalModuleTlsIndexOffset == uint32_t(-1)) {
+        Out<ELFT>::LocalModuleTlsIndexOffset =
+            Out<ELFT>::Got->addLocalModuleTlsIndex();
+        Out<ELFT>::RelaDyn->addReloc({C, RI});
+      }
+      continue;
+    }
+
     // Set "used" bit for --as-needed.
     if (Body && Body->isUndefined() && !Body->isWeak())
       if (auto *S = dyn_cast<SharedSymbol<ELFT>>(Body->repl()))
         S->File->IsUsed = true;
 
     if (Body)
       Body = Body->repl();
     bool NeedsGot = false;

test/elf2/tls-dynamic.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+// RUN: ld.lld2 -shared %t -o %tout
+// RUN: llvm-readobj -sections -relocations %tout | FileCheck %s
+// RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DIS
+
+  leaq  a@tlsld(%rip), %rdi
+  callq __tls_get_addr@PLT
+  leaq  b@tlsld(%rip), %rdi
+  callq __tls_get_addr@PLT
+
+  .global a
+  .section  .tbss,"awT",@nobits
+  .align 4
+a:
+  .long 0
+  
+  .global b
+  .section  .tbss,"awT",@nobits
+  .align 4
+b:
+  .long 0
+
+// Get the address of the got, and check that it has two entries.
+
+// CHECK:      Sections [
+// CHECK:          Name: .got
+// CHECK-NEXT:     Type: SHT_PROGBITS
+// CHECK-NEXT:     Flags [
+// CHECK-NEXT:       SHF_ALLOC
+// CHECK-NEXT:       SHF_WRITE
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address: 0x20D0
+// CHECK-NEXT:     Offset:
+// CHECK-NEXT:     Size: 16
+
+// CHECK:      Relocations [
+// CHECK:        Section ({{.+}}) .rela.dyn {
+// CHECK-NEXT:     0x20D0 R_X86_64_DTPMOD64 - 0x0
+// CHECK-NEXT:   }
+
+// 4297 = (0x20D0 + -4) - (0x1000 + 3) // PC relative offset to got entry.
+
+// DIS:      Disassembly of section .text:
+// DIS-NEXT: .text:
+// DIS-NEXT:     1000: {{.+}} leaq    4297(%rip), %rdi
+// DIS-NEXT:     1007: {{.+}} callq
+// DIS-NEXT:     100c: {{.+}} leaq    4285(%rip), %rdi