[elf2] Implement global dynamic tls.

[ruiu]

ELF/InputSection.cpp

129

You are not using a return value of getTlsGlobalDynamicReloc except comparing it with Type. Isn't isTlsGlobalDynamicReloc(uint32_t) better than getTlsGlobalDynamicReloc()?

ELF/OutputSections.cpp

210–212

(PNext) -> PNext

[• rafael]

ELF/OutputSections.cpp

182–188

Add a comment about this being a placeholder for the second entry in a gd pair (which was handled in the previous iteration.

[Bigcheese]

ELF/InputSection.cpp

129

Probably. We would need to change getTlsLocalDynamicReloc too.

[• rafael]

LGTM, but please change getTlsLocalDynamicReloc to isTlsLocalDynamicReloc (and global equivalent) in a followup commit.

[ruiu]

LGTM

[grimar]

ELF/OutputSections.cpp

86

Probably would be better to make another method for that case because it is still possible for symbol to be TLS but consume only one GOT entry. I fixed this for my patch:
http://reviews.llvm.org/D14621

185

I would use && here, its more strict check. There should be no other cases when one of these is null but other is not.
More strict way would be to have some static relocation used as allowed stub:

static DynamicReloc<ELFT> TlsDynamicRelocationPlaceholder;
...
Out<ELFT>::RelaDyn->addReloc({&C, &RI});
Out<ELFT>::RelaDyn->addReloc(TlsDynamicRelocationPlaceholder);
...
 if (&Rel == &TlsDynamicRelocationPlaceholder)
      continue;

test/elf2/tls-dynamic.s

75

Its not visible here but tabs are used instead of spaces in test in few places. Other tests dont has tabs I think.

[davide]

Close, this is was committed.

ELF/InputSection.cpp

for (const RelType &RI : Rels) {
     const Elf_Shdr *SymTab = File->getSymbolTable();
     if (SymIndex < SymTab->sh_info) {
       uintX_t SymVA = getLocalRelTarget(*File, RI);
       Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA);
       continue;
     }
 
     SymbolBody &Body = *File->getSymbolBody(SymIndex)->repl();
+
+    if (Type == Target->getTlsGlobalDynamicReloc()) {
+      Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
+                          Out<ELFT>::Got->getEntryAddr(Body) +
+                              getAddend<ELFT>(RI));
+      continue;
+    }
+
     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)) {

ELF/OutputSections.h

public:
   uintX_t getEntryAddr(const SymbolBody &B) const;
 
 private:
   std::vector<const SymbolBody *> Entries;
 };
 
 template <class ELFT> struct DynamicReloc {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
-  InputSectionBase<ELFT> &C;
-  const Elf_Rel &RI;
+  InputSectionBase<ELFT> *C;
+  const Elf_Rel *RI;
 };
 
 template <class ELFT>
 class SymbolTableSection final : public OutputSectionBase<ELFT> {
 public:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;

ELF/OutputSections.cpp

GotSection<ELFT>::GotSection()
   if (Config->EMachine == EM_MIPS)
     this->Header.sh_flags |= llvm::ELF::SHF_MIPS_GPREL;
   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);
+  // Global Dynamic TLS entries take two GOT slots.
+  if (Sym->isTLS())
+    Entries.push_back(nullptr);
 }
 
 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>

 }
 
 template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
   const unsigned EntrySize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
   for (const DynamicReloc<ELFT> &Rel : Relocs) {
     auto *P = reinterpret_cast<Elf_Rel *>(Buf);
     Buf += EntrySize;
 
-    InputSectionBase<ELFT> &C = Rel.C;
-    const Elf_Rel &RI = Rel.RI;
+    // Skip placeholder for global dynamic TLS relocation pair. It was already
+    // handled by the previous relocation.
+    if (!Rel.C || !Rel.RI)
+      continue;
+
+    InputSectionBase<ELFT> &C = *Rel.C;
+    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;
     }
 
+    if (Body && Type == Target->getTlsGlobalDynamicReloc()) {
+      P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
+                          Target->getTlsModuleIndexReloc(), Config->Mips64EL);
+      P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
+      auto *PNext = reinterpret_cast<Elf_Rel *>(Buf);
+      PNext->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
+                              Target->getTlsOffsetReloc(), Config->Mips64EL);
+      PNext->r_offset = Out<ELFT>::Got->getEntryAddr(*Body) + sizeof(uintX_t);
+      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:
   uint64_t getVAStart() const;
   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 getTlsGlobalDynamicReloc() const { return TlsGlobalDynamicReloc; }
   unsigned getTlsModuleIndexReloc() const { return TlsModuleIndexReloc; }
+  unsigned getTlsOffsetReloc() const { return TlsOffsetReloc; }
   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:
 
   unsigned CopyReloc;
   unsigned PCRelReloc;
   unsigned GotRefReloc;
   unsigned GotReloc;
   unsigned PltReloc;
   unsigned RelativeReloc;
   unsigned TlsLocalDynamicReloc = 0;
+  unsigned TlsGlobalDynamicReloc = 0;
   unsigned TlsModuleIndexReloc;
+  unsigned TlsOffsetReloc;
   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;
+  TlsGlobalDynamicReloc = R_X86_64_TLSGD;
   TlsModuleIndexReloc = R_X86_64_DTPMOD64;
+  TlsOffsetReloc = R_X86_64_DTPOFF64;
   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:
+  case R_X86_64_TLSGD:
     write32le(Loc, SA - P);
     break;
   case R_X86_64_64:
   case R_X86_64_DTPOFF64:
     write64le(Loc, SA);
     break;
   case R_X86_64_32:
   case R_X86_64_32S:

ELF/Writer.cpp

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});
+        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();
+
+    if (Body && Body->isTLS()) {
+      if (Type != Target->getTlsGlobalDynamicReloc())
+        continue;
+      if (Body->isInGot())
+        continue;
+      Out<ELFT>::Got->addEntry(Body);
+      Out<ELFT>::RelaDyn->addReloc({&C, &RI});
+      Out<ELFT>::RelaDyn->addReloc({nullptr, nullptr});
+      Body->setUsedInDynamicReloc();
+      continue;
+    }
+
     bool NeedsGot = false;
     bool NeedsPlt = false;
     if (Body) {
       if (auto *E = dyn_cast<SharedSymbol<ELFT>>(Body)) {
         if (E->needsCopy())
           continue;
         if (Target->relocNeedsCopy(Type, *Body))
           E->OffsetInBSS = 0;
if (Config->EMachine == EM_MIPS && NeedsGot) {
       continue;
     }
     bool CBP = canBePreempted(Body, NeedsGot);
     if (!CBP && (!Config->Shared || Target->isRelRelative(Type)))
       continue;
     if (CBP)
       Body->setUsedInDynamicReloc();
     if (NeedsPlt && Target->supportsLazyRelocations())
-      Out<ELFT>::RelaPlt->addReloc({C, RI});
+      Out<ELFT>::RelaPlt->addReloc({&C, &RI});
     else
-      Out<ELFT>::RelaDyn->addReloc({C, RI});
+      Out<ELFT>::RelaDyn->addReloc({&C, &RI});
   }
 }
 
 template <class ELFT> void Writer<ELFT>::scanRelocs(InputSection<ELFT> &C) {
   if (!(C.getSectionHdr()->sh_flags & SHF_ALLOC))
     return;
 
   for (const Elf_Shdr *RelSec : C.RelocSections)

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
   leaq  a@dtpoff(%rax), %rcx
   leaq  b@dtpoff(%rax), %rcx
   .long b@dtpoff, 0
+  leaq  c@tlsgd(%rip), %rdi
+  rex64
+  callq __tls_get_addr@PLT
+  leaq  c@dtpoff(%rax), %rcx
 
   .global a
   .hidden a
   .section  .tbss,"awT",@nobits
   .align 4
 a:
   .long 0
 
   .section  .tbss,"awT",@nobits
   .align 4
 b:
   .long 0
   
-// Get the address of the got, and check that it has two entries.
+  .global c
+  .section  .tbss,"awT",@nobits
+  .align 4
+c:
+  .long 0
+
+// Get the address of the got, and check that it has 4 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-NEXT:     Size: 32
 
 // CHECK:      Relocations [
 // CHECK:        Section ({{.+}}) .rela.dyn {
 // CHECK-NEXT:     0x20D0 R_X86_64_DTPMOD64 - 0x0
+// CHECK-NEXT:     0x20E0 R_X86_64_DTPMOD64 c 0x0
+// CHECK-NEXT:     0x20E8 R_X86_64_DTPOFF64 c 0x0
 // CHECK-NEXT:   }
 
 // 4297 = (0x20D0 + -4) - (0x1000 + 3) // PC relative offset to got entry.
 // 4285 = (0x20D0 + -4) - (0x100c + 3) // PC relative offset to got entry.
+// 4267 = (0x20E0 + -4) - (0x102e + 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
 // DIS-NEXT:     1013: {{.+}} callq
 // DIS-NEXT:     1018: {{.+}} leaq    (%rax), %rcx
 // DIS-NEXT:     101f: {{.+}} leaq    4(%rax), %rcx
 // DIS-NEXT:     1026: 04 00
 // DIS-NEXT:     1028: 00 00
 // DIS-NEXT:     102a: 00 00
 // DIS-NEXT:     102c: 00 00
+// DIS-NEXT:     102e: {{.+}} leaq    4267(%rip), %rdi
+// DIS-NEXT:     1035: {{.+}} callq
+// DIS-NEXT:     103b: {{.+}} leaq    8(%rax), %rcx