[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

63–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

80

EntriesSize

322

Not formatted.

338–349

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

151

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

DynReloc_JumpSlot,
DynReloc_TlsDesc,
DynReloc_NumKind

ELF/Symbols.cpp

172

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

ELF/Target.cpp

177 ↗

(On Diff #53226)

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

291

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

ELF/OutputSections.h

160–161

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

160–161

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

291

Ack.

ELF/OutputSections.cpp

63–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.

80

Ack.

338–349

Ack.

ELF/OutputSections.h

151

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.

160–161

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

172

Ack.

ELF/Target.cpp

177 ↗

(On Diff #53226)

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

284

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

87–89

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.

285

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–113

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.

159

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.

249–250

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.

421

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

46–53

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

392

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

284–285

Ack.

ELF/OutputSections.cpp

87–89

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'.

285

What about something like:

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

ELF/OutputSections.h

112–114

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.

159

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.

249–250

I think it is, I will change it.

421

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

ELF/Target.h

46–54

I will add it.

ELF/Writer.cpp

392

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

181–182

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

180–182

You are not using T_TLSDESC_PAGE. Please remove.

ELF/OutputSections.cpp

709

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

ELF/OutputSections.h

140

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

ELF/Writer.cpp

277

GD -> Gd

295

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

180

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

ELF/OutputSections.h

252

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

[emaste]

ELF/OutputSections.h

252

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

enum RelExpr {
   R_RELAX_TLS_GD_TO_LE,
   R_RELAX_TLS_IE_TO_LE,
   R_RELAX_TLS_LD_TO_LE,
   R_SIZE,
   R_THUNK,
   R_TLS,
   R_TLSGD,
   R_TLSGD_PC,
+  R_TLSDESC,
+  R_TLSDESC_PAGE,
   R_TLSLD,
   R_TLSLD_PC
 };
 
 inline bool refersToGotEntry(RelExpr Expr) {
   return Expr == R_GOT || Expr == R_GOT_OFF || Expr == R_MIPS_GOT ||
          Expr == R_MIPS_GOT_LOCAL || Expr == R_GOT_PAGE_PC ||
          Expr == R_GOT_PC || Expr == R_GOT_FROM_END;

ELF/InputSection.cpp

case R_THUNK:
     return Body.getThunkVA<ELFT>();
   case R_PPC_TOC:
     return getPPC64TocBase() + A;
   case R_TLSGD:
     return Out<ELFT>::Got->getGlobalDynOffset(Body) + A -
            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:
   case R_PPC_PLT_OPD:
     return Body.getPltVA<ELFT>() + A - P;
   case R_SIZE:
     return Body.getSize<ELFT>() + A;
   case R_GOTREL:
for (const Relocation &Rel : Relocations) {
     if (Expr == R_RELAX_TLS_GD_TO_LE) {
       Target->relaxTlsGdToLe(BufLoc, Type, SymVA);
       continue;
     }
     if (Expr == R_RELAX_TLS_GD_TO_IE_PC || Expr == R_RELAX_TLS_GD_TO_IE) {
       Target->relaxTlsGdToIe(BufLoc, Type, SymVA);
       continue;
     }
 
     if (Expr == R_PPC_PLT_OPD) {
       uint32_t Nop = 0x60000000;
       if (BufLoc + 8 <= BufEnd && read32be(BufLoc + 4) == Nop)
         write32be(BufLoc + 4, 0xe8410028); // ld %r2, 40(%r1)
     }
 
     Target->relocateOne(BufLoc, Type, SymVA);
   }
 }
 
 template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
   if (this->Header->sh_type == SHT_NOBITS)
     return;
   ELFFile<ELFT> &EObj = this->File->getObj();
 

ELF/OutputSections.h

template <class ELFT> class GotSection final : public OutputSectionBase<ELFT> {
   typedef OutputSectionBase<ELFT> Base;
   typedef typename ELFT::uint uintX_t;
 
 public:
   GotSection();
   void finalize() override;
   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 getMipsLocalEntryOffset(uintX_t EntryValue);
   uintX_t getMipsLocalPageOffset(uintX_t Addr);
   uintX_t getGlobalDynAddr(const SymbolBody &B) const;
   uintX_t getGlobalDynOffset(const SymbolBody &B) const;
   uintX_t getNumEntries() const { return Entries.size(); }
 
   // Returns the symbol which corresponds to the first entry of the global part
   // of GOT on MIPS platform. It is required to fill up MIPS-specific dynamic
   // table properties.
   // Returns nullptr if the global part is empty.
   const SymbolBody *getMipsFirstGlobalEntry() const;
 
   // Returns the number of entries in the local part of GOT including
   // the number of reserved entries. This method is MIPS-specific.
   unsigned getMipsLocalEntriesNum() const;
 
   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;
   llvm::DenseMap<uintX_t, size_t> MipsLocalGotPos;
 };
 
 template <class ELFT>
 class GotPltSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::uint uintX_t;
 
 public:
   GotPltSection();
   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> {
   typedef OutputSectionBase<ELFT> Base;
   typedef typename ELFT::uint uintX_t;
 
 public:
   PltSection();
   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;
 };
 
 template <class ELFT> struct DynamicReloc {
   typedef typename ELFT::uint uintX_t;
   uint32_t Type;

 class RelocationSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
   typedef typename ELFT::uint uintX_t;
 
 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>
 class OutputSection final : public OutputSectionBase<ELFT> {
 public:
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::Rel Elf_Rel;
class DynamicSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::uint uintX_t;
 
   // 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 {
       OutputSectionBase<ELFT> *OutSec;
       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()
   // cannot directly create final section contents because when the
   // function is called, symbol or section addresses are not fixed yet.
   std::vector<Entry> Entries;
 
 public:

ELF/OutputSections.cpp

 }
 
 template <class ELFT>
 GotPltSection<ELFT>::GotPltSection()
     : OutputSectionBase<ELFT>(".got.plt", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE) {
   this->Header.sh_addralign = sizeof(uintX_t);
 }
 
 template <class ELFT> void GotPltSection<ELFT>::addEntry(SymbolBody &Sym) {
   Sym.GotPltIndex = Target->GotPltHeaderEntriesNum + Entries.size();
   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);
   }
 }
 
 template <class ELFT>
 GotSection<ELFT>::GotSection()
if (Sym.hasGlobalDynIndex())
     return false;
   Sym.GlobalDynIndex = Target->GotHeaderEntriesNum + Entries.size();
   // Global Dynamic TLS entries take two GOT slots.
   Entries.push_back(&Sym);
   Entries.push_back(nullptr);
   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() {
   if (TlsIndexOff != uint32_t(-1))
     return false;
   TlsIndexOff = Entries.size() * sizeof(uintX_t);
   Entries.push_back(nullptr);
   Entries.push_back(nullptr);
for (auto &I : Entries) {
     const SymbolBody *B = I.first;
     unsigned RelOff = I.second;
     uint64_t Got =
         Target->UseLazyBinding ? B->getGotPltVA<ELFT>() : B->getGotVA<ELFT>();
     uint64_t Plt = this->getVA() + Off;
     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) {
   Sym.PltIndex = Entries.size();
   unsigned RelOff = Target->UseLazyBinding
                         ? Out<ELFT>::RelaPlt->getRelocOffset()
                         : Out<ELFT>::RelaDyn->getRelocOffset();
   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>
 RelocationSection<ELFT>::RelocationSection(StringRef Name)
     : OutputSectionBase<ELFT>(Name, Config->Rela ? SHT_RELA : SHT_REL,
                               SHF_ALLOC) {
   this->Header.sh_entsize = Config->Rela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
   this->Header.sh_addralign = sizeof(uintX_t);
 }
 
 template <class ELFT>
 void RelocationSection<ELFT>::addReloc(const DynamicReloc<ELFT> &Reloc) {
   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) {
+  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>
 InterpSection<ELFT>::InterpSection()
     : OutputSectionBase<ELFT>(".interp", SHT_PROGBITS, SHF_ALLOC) {
   this->Header.sh_size = Config->DynamicLinker.size() + 1;
   this->Header.sh_addralign = 1;
 }
template <class ELFT> void DynamicSection<ELFT>::finalize() {
   if (Out<ELFT>::RelaPlt && Out<ELFT>::RelaPlt->hasRelocs()) {
     Add({DT_JMPREL, Out<ELFT>::RelaPlt});
     Add({DT_PLTRELSZ, Out<ELFT>::RelaPlt->getSize()});
     Add({Config->EMachine == EM_MIPS ? DT_MIPS_PLTGOT : DT_PLTGOT,
          Out<ELFT>::GotPlt});
     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});
   Add({DT_STRSZ, Out<ELFT>::DynStrTab->getSize()});
   if (Out<ELFT>::GnuHashTab)
     Add({DT_GNU_HASH, Out<ELFT>::GnuHashTab});
   if (Out<ELFT>::HashTab)
     Add({DT_HASH, Out<ELFT>::HashTab});
if (Config->EMachine == EM_MIPS) {
     if (Out<ELFT>::MipsRldMap)
       Add({DT_MIPS_RLD_MAP, Out<ELFT>::MipsRldMap});
   }
 
   // +1 for DT_NULL
   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);
 
   for (const Entry &E : Entries) {
     P->d_tag = E.Tag;
     switch (E.Kind) {
     case Entry::SecAddr:
       P->d_un.d_ptr = E.OutSec->getVA();
       break;
     case Entry::SymAddr:
       P->d_un.d_ptr = E.Sym->template getVA<ELFT>();
       break;
     case Entry::PlainInt:
       P->d_un.d_val = E.Val;
       break;
+    case Entry::Special:
+      handleSpecialDynamic<ELFT>(E, P);
+      break;
     }
     ++P;
   }
 }
 
 template <class ELFT>
 EhFrameHeader<ELFT>::EhFrameHeader()
     : OutputSectionBase<ELFT>(".eh_frame_hdr", llvm::ELF::SHT_PROGBITS,

ELF/Symbols.h

public:
   unsigned DynsymIndex = 0;
   uint32_t GlobalDynIndex = -1;
   uint32_t GotIndex = -1;
   uint32_t GotPltIndex = -1;
   uint32_t PltIndex = -1;
   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; }
 
   void setUsedInRegularObj() { IsUsedInRegularObj = true; }
 
   template <class ELFT>
   typename ELFT::uint getVA(typename ELFT::uint Addend = 0) const;
 
   template <class ELFT> typename ELFT::uint getGotOffset() const;
   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;
 
   // A SymbolBody has a backreference to a Symbol. Originally they are
   // doubly-linked. A backreference will never change. But the pointer
   // in the Symbol may be mutated by the resolver. If you have a
   // pointer P to a SymbolBody and are not sure whether the resolver

ELF/Symbols.cpp

 template <class ELFT> typename ELFT::uint SymbolBody::getGotPltVA() const {
   return Out<ELFT>::GotPlt->getVA() + getGotPltOffset<ELFT>();
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getGotPltOffset() const {
   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 <class ELFT> typename ELFT::uint SymbolBody::getThunkVA() const {
   auto *D = cast<DefinedRegular<ELFT>>(this);
   auto *S = cast<InputSection<ELFT>>(D->Section);

 template uint64_t SymbolBody::template getGotPltVA<ELF64LE>() const;
 template uint64_t SymbolBody::template getGotPltVA<ELF64BE>() const;
 
 template uint32_t SymbolBody::template getGotPltOffset<ELF32LE>() const;
 template uint32_t SymbolBody::template getGotPltOffset<ELF32BE>() const;
 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;
 template uint64_t SymbolBody::template getPltVA<ELF64BE>() const;
 
 template uint32_t SymbolBody::template getSize<ELF32LE>() const;
 template uint32_t SymbolBody::template getSize<ELF32BE>() const;
 template uint64_t SymbolBody::template getSize<ELF64LE>() const;

ELF/Target.h

 
 class TargetInfo {
 public:
   uint64_t getVAStart() const;
   virtual bool isTlsInitialExecRel(uint32_t Type) const;
   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 {}
   virtual void writeGotPlt(uint8_t *Buf, uint64_t Plt) const {};
   virtual uint64_t getImplicitAddend(const uint8_t *Buf, uint32_t Type) const;
 
   // If lazy binding is supported, the first entry of the PLT has code
   // to call the dynamic linker to resolve PLT entries the first time
   // they are called. This function writes that code.
   virtual void writePltZero(uint8_t *Buf) const {}
 
   virtual void writePlt(uint8_t *Buf, uint64_t GotEntryAddr,
                         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.
   virtual bool isHintRel(uint32_t Type) const;
 
   // Returns true if a relocation is relative to the place being relocated,
   // such as relocations used for PC-relative instructions. Such relocations
   // need not be fixed up if an image is loaded to a different address than
   // the link-time address. So we don't have to emit a relocation for the
public:
   // 0x200000, but it looks like every OS uses 4k pages for executables.
   uint64_t VAStart = 0x10000;
 
   uint32_t CopyRel;
   uint32_t GotRel;
   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;
   uint32_t ThunkSize = 0;
   bool UseLazyBinding = false;
 
   virtual void relaxTlsGdToIe(uint8_t *Loc, uint32_t Type, uint64_t Val) const;
   virtual void relaxTlsGdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const;

ELF/Writer.cpp

static bool isEqual(const SectionKey<Is64Bits> &LHS,
                       const SectionKey<Is64Bits> &RHS) {
     return DenseMapInfo<StringRef>::isEqual(LHS.Name, RHS.Name) &&
            LHS.Type == RHS.Type && LHS.Flags == RHS.Flags &&
            LHS.Alignment == RHS.Alignment;
   }
 };
 }
 
+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});
+  }
+  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,
                                     InputSectionBase<ELFT> &C,
                                     typename ELFT::uint Offset,
                                     typename ELFT::uint Addend, RelExpr Expr) {
   if (!(C.getSectionHdr()->sh_flags & SHF_ALLOC))
     return 0;
 
   if (!Body.isTls())
     return 0;
 
-  typedef typename ELFT::uint uintX_t;
   if (Expr == R_TLSLD_PC || Expr == R_TLSLD) {
     // Local-Dynamic relocs can be relaxed to Local-Exec.
     if (!Config->Shared) {
       C.Relocations.push_back(
           {R_RELAX_TLS_LD_TO_LE, Type, Offset, Addend, &Body});
       return 2;
     }
     if (Out<ELFT>::Got->addTlsIndex())
       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;
   }
 
   // Local-Dynamic relocs can be relaxed to Local-Exec.
   if (Target->isTlsLocalDynamicRel(Type) && !Config->Shared) {
     C.Relocations.push_back(
         {R_RELAX_TLS_LD_TO_LE, Type, Offset, Addend, &Body});
     return 1;
   }
 
-  if (Target->isTlsGlobalDynamicRel(Type)) {
+  bool IsTlsGlobal = Target->isTlsGlobalDynamicRel(Type);
+  bool IsTlsDesc = Target->isTlsDescRel(Type);
+  if (IsTlsGlobal || IsTlsDesc) {
     if (Config->Shared) {
-      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});
-      }
-      C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
-      return 1;
+      if (IsTlsGlobal)
+        return handleTlsGDReloc<ELFT>(Type, Body, C, Offset, Addend, Expr);
+      else
+        return handleTLSDescReloc<ELFT>(Type, Body, C, Offset, Addend, Expr);
     }
 
     // Global-Dynamic relocs can be relaxed to Initial-Exec or Local-Exec
     // depending on the symbol being locally defined or not.
     if (Body.isPreemptible()) {
       Expr =
           Expr == R_TLSGD_PC ? R_RELAX_TLS_GD_TO_IE_PC : R_RELAX_TLS_GD_TO_IE;
       C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
static unsigned handleTlsRelocation(uint32_t Type, SymbolBody &Body,
   // Initial-Exec relocs can be relaxed to Local-Exec if the symbol is locally
   // defined.
   if (Target->isTlsInitialExecRel(Type) && !Config->Shared &&
       !Body.isPreemptible()) {
     C.Relocations.push_back(
         {R_RELAX_TLS_IE_TO_LE, Type, Offset, Addend, &Body});
     return 1;
   }
+
   return 0;
 }
 
 // Some targets might require creation of thunks for relocations. Now we
 // support only MIPS which requires LA25 thunk to call PIC code from non-PIC
 // one. Scan relocations to find each one requires thunk.
 template <class ELFT>
 template <class RelTy>