[lld] Initial implementation of TLSDESC relocation handling

[zatrazz]

Summary

This patch implements the initial lld support for TLSDESC relocation
types. They have lazy relocation nature, so require entries in got.plt.
Each one is double sized. Also special Plt entry with resolver is created in
addition to single got entry. A module that uses lazy TLSDESC relocations
must define next two entries in dynamic section:

• DT_TLSDESC_PLT - Location of PLT entry for TLS descriptor resolver calls.
• DT_TLSDESC_GOT - Location of GOT entry used by TLS descriptor resolver PLT entry.

More information can be found in "Thread-Local Storage Descriptors for IA32 and
AMD64/EM64T" and "Thread-Local Storage Descriptors for the ARM platform"
(http://www.fsfla.org/~lxoliva/writeups/TLS/RFC-TLSDESC-x86.txt,
http://www.fsfla.org/~lxoliva/writeups/TLS/RFC-TLSDESC-ARM.txt)

[grimar]

ELF/OutputSections.cpp

64

Method does not seem to be clang formatted.

76

I would write:

Entries[DynReloc_TlsDesc].insert(Entries[DynReloc_TlsDesc].end(), { nullptr, nullptr });

As in fact this is single entry

84

EntriesSize

335

Not formatted.

351

I don't think we use auto in such cases as type is not obvious here. So I would use

for (std::vector<DynamicReloc<ELFT>> &Vec : Relocs) {
  for (const DynamicReloc<ELFT> &Rel : Vec) {

ELF/OutputSections.h

153

Do you really need direct assignmens here ? Why don't write like:

DynReloc_JumpSlot,
DynReloc_TlsDesc,
DynReloc_NumKind

ELF/Symbols.cpp

171

This one not formatted either. Please use clang-format for this patch.

ELF/Target.cpp

177

Remove the empty line please.

[zatrazz]

Updated patch based on previous comment.

[ruiu]

This seems to conflict with http://reviews.llvm.org/D18711, so you may want to wait for that.

ELF/InputSection.cpp

301

I'd name this getTlsDescVA rather than getGotPltTlsDescVA if there's no reason to include "GotPlt".

ELF/OutputSections.h

164

This code is hard to understand. If I understand it correctly, it is a vector of vectors binned according to their DynReloc_* types. Is this correct?

There seems to be no reason to aggregate multiple vectors into one vector (of vectors) here. Why don't you define multiple vectors?

[emaste]

ELF/OutputSections.h

164

I think this comes out of a discussion in D18330: http://reviews.llvm.org/D18330#inline-153615 @grimar or @zatrazz?

[zatrazz]

In D18960#397780, @ruiu wrote:

This seems to conflict with http://reviews.llvm.org/D18711, so you may want to wait for that.

Right, I will rebase using this patch as base.

ELF/InputSection.cpp

301

Ack.

ELF/OutputSections.cpp

64

Indeed, I will fix it and other parts as well (I forgot to use clang-format-diff in this patch).

76

I think this is slight worse regarding readability, but I will change it.

84

Ack.

351

Ack.

ELF/OutputSections.h

153

It is just to make it explicit, since C++11 does state first enum is 0 and next one will have the value incremented by 1. I will change it.

164

It is correct and I thought about adding default vector for each type of relocation, I used this approach mainly to no tie relocation types to a specific vector. Although I think now using different vectors seems a better alternative, I will change it.

ELF/Symbols.cpp

171

Ack.

ELF/Target.cpp

177

Ack.

[peter.smith]

I'm looking at this from an AARCH64 perspective. I've also checked to the best of my knowledge that the architecture independent parts of the descriptor model implemented here are compatible with other architectures such as X86.

This is my first time looking at LLD, so I hope any misunderstandings of the code-base don't show through too heavily.

General comments:

• it looks like you are only implementing the case where lazy specialization of TLS is permitted. Is this intentional?
• it looks like you are not defining _TLS_MODULE_BASE_ (points at beginning of TLS segment for module) which I think is used by the local dynamic model (local dynamic is not well supported for AARCH64 I belive)

I've left some comments above where I found it more difficult than usual to follow the code. Feel free to ignore.

Some more references that I found useful when looking at this and the (now abandoned http://reviews.llvm.org/D18839):

ARM doesn't have much public documentation on AARCH64 TLS besides the relocations defined in the ABI, the best alternative source of information I have seen is in https://llvm.org/bugs/show_bug.cgi?id=22408 clang no longer bootstraps itself on AArch64 linux.

Paper "Speeding Up Thread-Local Storage Access in Dynamic Libraries in the ARM platform": http://www.fsfla.org/~lxoliva/writeups/TLS/paper-lk2006.pdf

Relocations for AARCH64 are defined in ELF for the ARM 64-bit Architecture (AArch64) Table 4.6.10.5 Thread-local storage descriptors:
http://infocenter.arm.com/help/topic/com.arm.doc.ihi0056b/IHI0056B_aaelf64.pdf

ELF/InputSection.cpp

294

A descriptor can only have one parameter (2nd word in .got.plt) in the comment below would it be better to say "a function pointer and its argument",

ELF/OutputSections.cpp

92

Position of this comment is a bit confusing as the TLS Desc entries come after the Jump Slot entries. Perhaps move after the for loop?

I assume that nullptr will be written out as zero or some other padding value in the actual file.

296

I found this comment a bit confusing.

The double .got.plt entries are for the TLS descriptors, but we are talking about the PLT entry for the lazy resolver here. The writePltDescEntry() from what I can see of your aarch64 patch is really writing the contents of the _dl_tlsdesc_lazy_trampoline function, and nothing else. The DT_TLSDESC_PLT is created somewhere else.

Would it be worth simplifying the comment to what the code is doing locally?

ELF/OutputSections.h

112

both Got and PltGot have an addTlsDescEntry member function that do different things.

In GotSection::addTlsDescEntry() we are reserving a single entry in the GOT that DT_TLSDESC_GOT will refer to. This member function will only add this entry once.

In GotPltSection::addTlsDescEntry(SymbolBody&) we are adding a TLS Descriptor to the .got.plt section for the symbol.

Would it be better to rename one of these member functions to capture the difference in meaning. Or perhaps add a comment.

167

Is a vector of vectors really needed here? For example you could have two separate vectors: JumpSlotEntries and TlsDescEntries. I can't see too much advantage in the vector here.

https://sourceware.org/bugzilla/show_bug.cgi?id=13302 IRELATIVE relocation should come last shows that there is at least one more sub-section that will be needed, but I'm not aware of more than 3.

I've not been able to find a reference to why the Jump Slot entries and TlsDesc entries must be separated, although Gold does make the same separation. Do you happen to know? It might be worth adding a comment if there is a reason as in your AARCH64 review you explicitly test for the order.

256

As a first time look at the code base I had to check whether size meant number of relocs or size of relocs in bytes. Would getNumRelocs() work better? Apologies if this is an lld convention I've missed.

427

Rather than add special which doesn't help you much when you see special in isolation, would it be better to introduce 2 separate kinds, one for each of DT_TLSDESC_PLT and DT_TLSDESC_GOT?

ELF/Target.h

48

Is it worth a comment on what the PltDescEntry must do, seeing as it is a target specific function that we don't have an implementation for (in this patch anyway)?

ELF/Writer.cpp

311

Would it be worth splitting the comment so that 1. appeared alongside Got->addTlsDescEntry() and 2. Appeared alongside GotPlt->addTlsDescEntry(Body).

[zatrazz]

ELF/InputSection.cpp

294–304

Ack.

ELF/OutputSections.cpp

93

I will change this class to contain two internal vector representing both the jump slot and tlcdesc relocation. And the the idea here is just to write down the Entries VA from actually symbols, the size will be computed 'finalize'.

297

What about something like:

// If module uses TLS description relocations writes down the architecture specific
// lazy relocation entrypoint.

ELF/OutputSections.h

112–113

I think the idea is to follow the same one for addEntry, which will also for GotSection reserve a entry and for GotPltSection will add on the .got.plt. I do not see why changes their names.

163

Yes, from Rui comments I think just adding two vectors seems a better strategy and for IRELATIVE I think we can just add another vector if is the case.

I am trying to found out exactly why gold is doing this separation and based on IRELATIVE issue I am assuming it some dependency issue, so I assumed it would be wiser to follow up gold example.

252

I think it is, I will change it.

423

Yes I think is would be better indeed, I will change it.

ELF/Target.h

46–50

I will add it.

ELF/Writer.cpp

311

Indeed, I will change it.

[zatrazz]

This is an updated patch based on previous comments and rebased against master.
From Peter's comments, the main points I did not add on this change is the inclusion
of _TLS_MODULE_BASE_. Although I have patch to include it, I am still checking
if the code if fully correct and on which circumstances the symbol is used for aarch64.
Also this is not preventing any test and the bootstrap itself, so I think we can postpone
its implementation.

[ruiu]

ELF/Writer.cpp

357

Can you upload this again? This patch contains merge conflict markers.

[zatrazz]

Sorry about that, correct patch uploaded now.

[ruiu]

Hi Adhemerval,

As this change heavily relies on the code that Rafael recently updated, I'll defer him to review this.

[zatrazz]

Alright, that's fine. I am rebasing the patch based on recent modifications.

[emaste]

Current status linking FreeBSD/arm64 buildworld with lld, with this patch included:

--- libc.so.7.full ---
unrecognized reloc 562
cc: error: linker command failed with exit code 1 (use -v to see invocation)
*** [libc.so.7.full] Error code 1

That is, libc.so linking fails due to R_AARCH64_TLSDESC_ADR_PAGE21

ELF/Writer.cpp

392

extra blank line left over from rebasing?

[zatrazz]

In D18960#409361, @emaste wrote:

Current status linking FreeBSD/arm64 buildworld with lld, with this patch included:

--- libc.so.7.full ---
unrecognized reloc 562

Yes I split the original patch in TLSDESC arch independent support and aarch64 specific bits. I did not upload to review the aarch64 bits yet to avoid diverge review efforts. To actually bootstrap on linux I am using two more fixes (one to implement R_AARCH64_TLSDESC_* relocations and another to Add GD to IE TLS relax optimization).

cc: error: linker command failed with exit code 1 (use -v to see invocation)

• [libc.so.7.full] Error code 1

That is, libc.so linking fails due to `R_AARCH64_TLSDESC_ADR_PAGE21`

[emaste]

(Needs updating after rL268178)

[zatrazz]

Updated patch against master branch. Basically it changes how the Symbol GlobalDynIndex is set (since it was moved to Symbol class) and add the R_TLSDESC{_PAGE} to refersToGotEntry.

[emaste]

ELF/InputSection.cpp

161–162

This is the MI part; why does it reference AArch64?

ELF/InputSection.h

58–59

Keep in alpha order

ELF/OutputSections.cpp

88

Comment is unclear to me.

[emaste]

Needs to be updated again.

@ruiu, @rafael, what do you think of this patch? I'm really hopeful that we can make progress with this and the AArch64 TLSDESC change.

[ruiu]

Rafael should know more about relocations, so you want to have him take a look.

ELF/InputSection.cpp

160–162

You are not using T_TLSDESC_PAGE. Please remove.

ELF/OutputSections.cpp

735

"Special" is not a good name. Once this code is submitted, this code becomes a regular part of the linker.

ELF/OutputSections.h

142

Use uint32_t instead of uintX_t. Realistically, we'll never have a GOT which contains more than 2^32 entries.

ELF/Writer.cpp

282

GD -> Gd

300

TLS -> Tls

[• rafael]

The main issue is that this adds the notion of tls descriptor base relocations while the code for the existing relocation processing is still not finalized.

I would like to make sure we at least have a clean framework for creating and optimizing relocations before adding more kinds of them.

ELF/InputSection.cpp

160

I would call it PAGE_PC since it is relative to the PC.

ELF/OutputSections.h

297

Why do you need the second vector? It seems you just relocate it at the same time as Relocs.

[emaste]

ELF/OutputSections.h

297

The TLSDESC relocs have to follow the others; earlier versions of the patch kept track of the number of different types and inserted at the appropriate point in the vector (and a middle version had a vector of reloc vectors), but this way seems more clear to me.

[• rafael]

BTW, I setting up an aarch64 dev env. This is the first patch to review, right?

Cheers,
Rafael

[emaste]

In D18960#446420, @rafael wrote:

BTW, I setting up an aarch64 dev env. This is the first patch to review, right?

Yes, I believe it is.

[zatrazz]

Since Rafael implemented it in another patch, I will just drop...

ELF/InputSection.h

   R_TLS,
   R_TLSGD,
   R_TLSGD_PC,
+  R_TLSDESC,
+  R_TLSDESC_PAGE,
   R_TLSLD,
   R_TLSLD_PC
 };

ELF/InputSection.cpp

            Out<ELFT>::Got->getNumEntries() * sizeof(uintX_t);
   case R_TLSGD_PC:
     return Out<ELFT>::Got->getGlobalDynAddr(Body) + A - P;
+  case R_TLSDESC:
+    return Body.getGotPltTlsDescVA<ELFT>() + A;
+  case R_TLSDESC_PAGE:
+    return getAArch64Page(Body.getGotPltTlsDescVA<ELFT>() + A) -
+           getAArch64Page(P);
   case R_PLT:
     return Body.getPltVA<ELFT>() + A;
   case R_PLT_PC:

ELF/OutputSections.h

   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody &Sym);
   bool addDynTlsEntry(SymbolBody &Sym);
+  void addTlsDescEntry();
   bool addTlsIndex();
   bool empty() const { return MipsLocalEntries == 0 && Entries.empty(); }
   uintX_t getMipsLocalEntryAddr(uintX_t EntryValue);

 
   uintX_t getTlsIndexVA() { return Base::getVA() + TlsIndexOff; }
   uint32_t getTlsIndexOff() { return TlsIndexOff; }
+  uintX_t getTlsDescEntryVA() const { return Base::getVA() + TlsDescEntryOff; }
+  bool hasTlsDescEntry() const { return TlsDescEntryOff != (uintX_t)-1; }
 
 private:
   std::vector<const SymbolBody *> Entries;
   uint32_t TlsIndexOff = -1;
+  uintX_t TlsDescEntryOff = -1;
   uint32_t MipsLocalEntries = 0;
   // Output sections referenced by MIPS GOT relocations.
   llvm::SmallPtrSet<const OutputSectionBase<ELFT> *, 10> MipsOutSections;

   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody &Sym);
+  void addTlsDescEntry(SymbolBody &Sym);
   bool empty() const;
 
 private:
   std::vector<const SymbolBody *> Entries;
+  std::vector<const SymbolBody *> TlsDescEntries;
 };
 
 template <class ELFT> class PltSection final : public OutputSectionBase<ELFT> {

   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody &Sym);
-  bool empty() const { return Entries.empty(); }
+  bool empty() const;
+  uintX_t getTlsDescEntryVA() const;
 
 private:
   std::vector<std::pair<const SymbolBody *, unsigned>> Entries;

 public:
   RelocationSection(StringRef Name);
   void addReloc(const DynamicReloc<ELFT> &Reloc);
+  void addTlsDescReloc(const DynamicReloc<ELFT> &Reloc);
   unsigned getRelocOffset();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
-  bool hasRelocs() const { return !Relocs.empty(); }
+  bool hasRelocs() const { return getNumRelocs() != 0; }
 
   bool Static = false;
 
 private:
+  size_t getNumRelocs() const;
   std::vector<DynamicReloc<ELFT>> Relocs;
+  std::vector<DynamicReloc<ELFT>> TlsDescRelocs;
 };
 
 template <class ELFT>

   // The .dynamic section contains information for the dynamic linker.
   // The section consists of fixed size entries, which consist of
   // type and value fields. Value are one of plain integers, symbol
-  // addresses, or section addresses. This struct represents the entry.
+  // addresses, or section addresses. Also value can be of special type.
+  // Such ones are handled depending on Tag value in writeTo(). This struct
+  // represents the entry.
   struct Entry {
     int32_t Tag;
     union {

       uint64_t Val;
       const SymbolBody *Sym;
     };
-    enum KindT { SecAddr, SymAddr, PlainInt } Kind;
+    enum KindT { SecAddr, SymAddr, PlainInt, Special } Kind;
     Entry(int32_t Tag, OutputSectionBase<ELFT> *OutSec)
         : Tag(Tag), OutSec(OutSec), Kind(SecAddr) {}
     Entry(int32_t Tag, uint64_t Val) : Tag(Tag), Val(Val), Kind(PlainInt) {}
     Entry(int32_t Tag, const SymbolBody *Sym)
         : Tag(Tag), Sym(Sym), Kind(SymAddr) {}
+    Entry(int32_t Tag) : Tag(Tag), Kind(Special) {}
   };
 
   // finalize() fills this vector with the section contents. finalize()

ELF/OutputSections.cpp

   Entries.push_back(&Sym);
 }
 
+template <class ELFT>
+void GotPltSection<ELFT>::addTlsDescEntry(SymbolBody &Sym) {
+  Sym.GlobalDynIndex = Target->GotPltHeaderEntriesNum + Entries.size();
+  Sym.GotPltIndex = TlsDescEntries.size();
+  TlsDescEntries.insert(TlsDescEntries.end(), {nullptr, nullptr});
+}
+
 template <class ELFT> bool GotPltSection<ELFT>::empty() const {
-  return Entries.empty();
+  return Entries.empty() && TlsDescEntries.empty();
 }
 
 template <class ELFT> void GotPltSection<ELFT>::finalize() {
+  size_t EntriesSize = Entries.size() + TlsDescEntries.size();
   this->Header.sh_size =
-      (Target->GotPltHeaderEntriesNum + Entries.size()) * sizeof(uintX_t);
+      (Target->GotPltHeaderEntriesNum + EntriesSize) * sizeof(uintX_t);
 }
 
 template <class ELFT> void GotPltSection<ELFT>::writeTo(uint8_t *Buf) {
   Target->writeGotPltHeader(Buf);
   Buf += Target->GotPltHeaderEntriesNum * sizeof(uintX_t);
+  // Since TLSDESC entries will contains nullptr SymbolBody there is no
+  // need to write them down.
   for (const SymbolBody *B : Entries) {
     Target->writeGotPlt(Buf, B->getPltVA<ELFT>());
     Buf += sizeof(uintX_t);

   return true;
 }
 
+template <class ELFT> void GotSection<ELFT>::addTlsDescEntry() {
+  if (TlsDescEntryOff != uintX_t(-1))
+    return;
+  Entries.push_back(nullptr);
+  TlsDescEntryOff = (Entries.size() - 1) * sizeof(uintX_t);
+}
+
 // Reserves TLS entries for a TLS module ID and a TLS block offset.
 // In total it takes two GOT slots.
 template <class ELFT> bool GotSection<ELFT>::addTlsIndex() {

     Target->writePlt(Buf + Off, Got, Plt, B->PltIndex, RelOff);
     Off += Target->PltEntrySize;
   }
+
+  // If module uses TLS description relocations writes down the architecture
+  // specific lazy relocation entrypoint.
+  if (Out<ELFT>::Got->hasTlsDescEntry())
+    Target->writePltTlsDescEntry(Buf + Off, this->getVA() + Off,
+                                 Out<ELFT>::Got->getTlsDescEntryVA(),
+                                 Out<ELFT>::GotPlt->getVA());
 }
 
 template <class ELFT> void PltSection<ELFT>::addEntry(SymbolBody &Sym) {

   Entries.push_back(std::make_pair(&Sym, RelOff));
 }
 
+template <class ELFT> bool PltSection<ELFT>::empty() const {
+  return Entries.empty() && !Out<ELFT>::Got->hasTlsDescEntry();
+}
+
+template <class ELFT>
+typename PltSection<ELFT>::uintX_t PltSection<ELFT>::getTlsDescEntryVA() const {
+  return this->getVA() + Target->PltZeroSize +
+         Entries.size() * Target->PltEntrySize;
+}
+
 template <class ELFT> void PltSection<ELFT>::finalize() {
   this->Header.sh_size =
       Target->PltZeroSize + Entries.size() * Target->PltEntrySize;
+  if (Out<ELFT>::Got->hasTlsDescEntry())
+    this->Header.sh_size += Target->PltTlsDescSize;
 }
 
 template <class ELFT>

   Relocs.push_back(Reloc);
 }
 
+template <class ELFT>
+void RelocationSection<ELFT>::addTlsDescReloc(const DynamicReloc<ELFT> &Reloc) {
+  TlsDescRelocs.push_back(Reloc);
+}
+
 template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
-  for (const DynamicReloc<ELFT> &Rel : Relocs) {
-    auto *P = reinterpret_cast<Elf_Rela *>(Buf);
-    Buf += Config->Rela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
-    SymbolBody *Sym = Rel.Sym;
-
-    if (Config->Rela)
-      P->r_addend = Rel.UseSymVA ? Sym->getVA<ELFT>(Rel.Addend) : Rel.Addend;
-    P->r_offset = Rel.OffsetInSec + Rel.OffsetSec->getVA();
-    uint32_t SymIdx = (!Rel.UseSymVA && Sym) ? Sym->DynsymIndex : 0;
-    P->setSymbolAndType(SymIdx, Rel.Type, Config->Mips64EL);
+  for (const std::vector<DynamicReloc<ELFT>> &Vec : {Relocs, TlsDescRelocs}) {
+    for (const DynamicReloc<ELFT> &Rel : Vec) {
+      auto *P = reinterpret_cast<Elf_Rela *>(Buf);
+      Buf += Config->Rela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
+      SymbolBody *Sym = Rel.Sym;
+
+      if (Config->Rela)
+        P->r_addend = Rel.UseSymVA ? Sym->getVA<ELFT>(Rel.Addend) : Rel.Addend;
+      P->r_offset = Rel.OffsetInSec + Rel.OffsetSec->getVA();
+      uint32_t SymIdx = (!Rel.UseSymVA && Sym) ? Sym->DynsymIndex : 0;
+      P->setSymbolAndType(SymIdx, Rel.Type, Config->Mips64EL);
+    }
   }
 }
 
+template <class ELFT> size_t RelocationSection<ELFT>::getNumRelocs() const {
+  return Relocs.size() + TlsDescRelocs.size();
+}
+
 template <class ELFT> unsigned RelocationSection<ELFT>::getRelocOffset() {
-  return this->Header.sh_entsize * Relocs.size();
+  return this->Header.sh_entsize * getNumRelocs();
 }
 
 template <class ELFT> void RelocationSection<ELFT>::finalize() {
   this->Header.sh_link = Static ? Out<ELFT>::SymTab->SectionIndex
                                 : Out<ELFT>::DynSymTab->SectionIndex;
-  this->Header.sh_size = Relocs.size() * this->Header.sh_entsize;
+  this->Header.sh_size = getNumRelocs() * this->Header.sh_entsize;
 }
 
 template <class ELFT>

     Add({DT_PLTREL, uint64_t(Config->Rela ? DT_RELA : DT_REL)});
   }
 
+  if (Out<ELFT>::Got->hasTlsDescEntry()) {
+    Add({DT_TLSDESC_GOT});
+    Add({DT_TLSDESC_PLT});
+  }
+
   Add({DT_SYMTAB, Out<ELFT>::DynSymTab});
   Add({DT_SYMENT, sizeof(Elf_Sym)});
   Add({DT_STRTAB, Out<ELFT>::DynStrTab});

   Header.sh_size = (Entries.size() + 1) * Header.sh_entsize;
 }
 
+template <class ELFT, class Entry, class ElfDyn>
+static void handleSpecialDynamic(const Entry &E, ElfDyn *P) {
+  switch (E.Tag) {
+  case DT_TLSDESC_GOT:
+    P->d_un.d_ptr = Out<ELFT>::Got->getTlsDescEntryVA();
+    break;
+  case DT_TLSDESC_PLT:
+    P->d_un.d_ptr = Out<ELFT>::Plt->getTlsDescEntryVA();
+    break;
+  default:
+    assert(false && "Unknown special dynamic section entry");
+  }
+}
+
 template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
   auto *P = reinterpret_cast<Elf_Dyn *>(Buf);
 

     case Entry::PlainInt:
       P->d_un.d_val = E.Val;
       break;
+    case Entry::Special:
+      handleSpecialDynamic<ELFT>(E, P);
+      break;
     }
     ++P;
   }

ELF/Symbols.h

   uint32_t ThunkIndex = -1;
   bool hasGlobalDynIndex() { return GlobalDynIndex != uint32_t(-1); }
   bool isInGot() const { return GotIndex != -1U; }
+  bool isInGotPlt() const { return GotPltIndex != -1U; }
   bool isInPlt() const { return PltIndex != -1U; }
   bool hasThunk() const { return ThunkIndex != -1U; }
 

   template <class ELFT> typename ELFT::uint getGotVA() const;
   template <class ELFT> typename ELFT::uint getGotPltOffset() const;
   template <class ELFT> typename ELFT::uint getGotPltVA() const;
+  template <class ELFT> typename ELFT::uint getGotPltTlsDescVA() const;
   template <class ELFT> typename ELFT::uint getPltVA() const;
   template <class ELFT> typename ELFT::uint getThunkVA() const;
   template <class ELFT> typename ELFT::uint getSize() const;

ELF/Symbols.cpp

   return GotPltIndex * sizeof(typename ELFT::uint);
 }
 
+template <class ELFT>
+typename ELFT::uint SymbolBody::getGotPltTlsDescVA() const {
+  return Out<ELFT>::GotPlt->getVA() +
+         (GlobalDynIndex + GotPltIndex) *
+             sizeof(typename ELFFile<ELFT>::uintX_t);
+}
+
 template <class ELFT> typename ELFT::uint SymbolBody::getPltVA() const {
   return Out<ELFT>::Plt->getVA() + Target->PltZeroSize +
          PltIndex * Target->PltEntrySize;

 template uint64_t SymbolBody::template getGotPltOffset<ELF64LE>() const;
 template uint64_t SymbolBody::template getGotPltOffset<ELF64BE>() const;
 
+template uint32_t SymbolBody::template getGotPltTlsDescVA<ELF32LE>() const;
+template uint32_t SymbolBody::template getGotPltTlsDescVA<ELF32BE>() const;
+template uint64_t SymbolBody::template getGotPltTlsDescVA<ELF64LE>() const;
+template uint64_t SymbolBody::template getGotPltTlsDescVA<ELF64BE>() const;
+
 template uint32_t SymbolBody::template getPltVA<ELF32LE>() const;
 template uint32_t SymbolBody::template getPltVA<ELF32BE>() const;
 template uint64_t SymbolBody::template getPltVA<ELF64LE>() const;

ELF/Target.h

   virtual bool isTlsLocalDynamicRel(uint32_t Type) const;
   virtual bool isTlsGlobalDynamicRel(uint32_t Type) const;
   virtual uint32_t getDynRel(uint32_t Type) const { return Type; }
+  virtual bool isTlsDescRel(uint32_t Type) const { return false; }
   virtual uint32_t getTlsGotRel(uint32_t Type) const { return TlsGotRel; }
   virtual void writeGotHeader(uint8_t *Buf) const {}
   virtual void writeGotPltHeader(uint8_t *Buf) const {}

                         uint64_t PltEntryAddr, int32_t Index,
                         unsigned RelOff) const {}
 
+  // This function writes down the PLT entrypoint for default lazy tls
+  // descriptor relocation. It is used if GOT section contains a TLS
+  // descriptor entry.
+  virtual void writePltTlsDescEntry(uint8_t *Buf, uint64_t PltEntryAddr,
+                                    uint64_t GotTlsDescEntryAddr,
+                                    uint64_t GotPltVA) const {};
+
   // Returns true if a relocation is just a hint for linker to make for example
   // some code optimization. Such relocations should not be handled as a regular
   // ones and lead to dynamic relocation creation etc.

   uint32_t PltRel;
   uint32_t RelativeRel;
   uint32_t IRelativeRel;
+  uint32_t TlsDescRel;
   uint32_t TlsGotRel = 0;
   uint32_t TlsModuleIndexRel;
   uint32_t TlsOffsetRel;
   unsigned PltEntrySize = 8;
+  unsigned PltTlsDescSize = 0;
   unsigned PltZeroSize = 0;
   unsigned GotHeaderEntriesNum = 0;
   unsigned GotPltHeaderEntriesNum = 3;

ELF/Target.cpp

 
   // Global-Dynamic relocs can be relaxed to Initial-Exec or Local-Exec
   // depending on the symbol being locally defined or not.
-  if (isTlsGlobalDynamicRel(Type))
+  if (isTlsDescRel(Type) || isTlsGlobalDynamicRel(Type))
     return true;
 
   // Local-Dynamic relocs can be relaxed to Local-Exec.

ELF/Writer.cpp

 };
 }
 
+template <class ELFT>
+static unsigned handleTlsGDReloc(uint32_t Type, SymbolBody &Body,
+                                 InputSectionBase<ELFT> &C,
+                                 typename ELFT::uint Offset,
+                                 typename ELFT::uint Addend, RelExpr Expr) {
+  typedef typename ELFT::uint uintX_t;
+  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});
+    Out<ELFT>::RelaDyn->addReloc({Target->TlsOffsetRel, Out<ELFT>::Got,
+                                  Off + (uintX_t)sizeof(uintX_t), false, &Body,
+                                  0});
+  }
+  Expr = Expr == R_PC ? R_TLSGD_PC : R_TLSGD;
+  C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
+  return 1;
+}
+
+template <class ELFT>
+static unsigned handleTLSDescReloc(uint32_t Type, SymbolBody &Body,
+                                   InputSectionBase<ELFT> &C,
+                                   typename ELFT::uint Offset,
+                                   typename ELFT::uint Addend, RelExpr Expr) {
+  // If module uses TLS descriptor relocations, then special entries are
+  // created for module:
+  // 1) .got entry to be filled in by the dynamic loader with the
+  //    address of the internal function to be used for lazy relocation of TLS
+  //    descriptors.
+  Out<ELFT>::Got->addTlsDescEntry();
+  if (!Body.isInGotPlt()) {
+    // 2) Special .plt entry that pushes onto the stack the module's link map
+    //    address, located in the GOT portion reserved for the dynamic loader
+    //    to use, and then jumps to the lazy relocation function, using the
+    //    address stored in the TLSDESC_GOT entry.
+    // For each Body itself two words are allocated in .got.plt instead of
+    // usual .got, because these relocations are lazy ones.
+    Out<ELFT>::GotPlt->addTlsDescEntry(Body);
+    Out<ELFT>::RelaPlt->addTlsDescReloc({Target->TlsDescRel, Out<ELFT>::GotPlt,
+                                         Body.getGotPltTlsDescVA<ELFT>(), false,
+                                         &Body, 0});
+  }
+  C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
+  return 1;
+}
+
 // Returns the number of relocations processed.
 template <class ELFT>
 static unsigned handleTlsRelocation(uint32_t Type, SymbolBody &Body,

   if (!(C.getSectionHdr()->sh_flags & SHF_ALLOC))
     return 0;
 
-  typedef typename ELFT::uint uintX_t;
   if (Expr == R_TLSLD_PC || Expr == R_TLSLD) {
     if (Target->canRelaxTls(Type, nullptr)) {
       C.Relocations.push_back(

     return 1;
   }
 
-  if (Target->isTlsGlobalDynamicRel(Type)) {
+  if (Target->isTlsGlobalDynamicRel(Type) || Target->isTlsDescRel(Type)) {
     if (!Target->canRelaxTls(Type, &Body)) {
+<<<<<<< HEAD
       if (Out<ELFT>::Got->addDynTlsEntry(Body)) {
         uintX_t Off = Out<ELFT>::Got->getGlobalDynOffset(Body);
         Out<ELFT>::RelaDyn->addReloc(

       }
       C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
       return 1;
+=======
+      if (Target->isTlsGlobalDynamicRel(Type))
+        return handleTlsGDReloc<ELFT>(Type, Body, C, Offset, Addend, Expr);
+      else
+        return handleTLSDescReloc<ELFT>(Type, Body, C, Offset, Addend, Expr);
+>>>>>>> ELF: Initial implementation of TLSDESC relocation handling
     }
 
     if (Body.isPreemptible()) {

         {R_RELAX_TLS_IE_TO_LE, Type, Offset, Addend, &Body});
     return 1;
   }
+
   return 0;
 }