Index: ELF/InputSection.h
===================================================================
--- ELF/InputSection.h
+++ ELF/InputSection.h
@@ -55,6 +55,8 @@
   R_TLS,
   R_TLSGD,
   R_TLSGD_PC,
+  R_TLSDESC,
+  R_TLSDESC_PAGE,
   R_TLSLD,
   R_TLSLD_PC
 };
Index: ELF/InputSection.cpp
===================================================================
--- ELF/InputSection.cpp
+++ ELF/InputSection.cpp
@@ -175,6 +175,11 @@
            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:
Index: ELF/OutputSections.h
===================================================================
--- ELF/OutputSections.h
+++ ELF/OutputSections.h
@@ -110,6 +110,7 @@
   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);
@@ -130,10 +131,13 @@
 
   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;
@@ -149,10 +153,12 @@
   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> {
@@ -164,7 +170,8 @@
   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;
@@ -231,15 +238,18 @@
 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>
@@ -409,7 +419,9 @@
   // 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 {
@@ -417,12 +429,13 @@
       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()
Index: ELF/OutputSections.cpp
===================================================================
--- ELF/OutputSections.cpp
+++ ELF/OutputSections.cpp
@@ -64,18 +64,28 @@
   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);
@@ -152,6 +162,13 @@
   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() {
@@ -264,6 +281,13 @@
     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) {
@@ -274,9 +298,21 @@
   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>
@@ -292,28 +328,39 @@
   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>
@@ -583,6 +630,11 @@
     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});
@@ -652,6 +704,20 @@
   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);
 
@@ -667,6 +733,9 @@
     case Entry::PlainInt:
       P->d_un.d_val = E.Val;
       break;
+    case Entry::Special:
+      handleSpecialDynamic<ELFT>(E, P);
+      break;
     }
     ++P;
   }
Index: ELF/Symbols.h
===================================================================
--- ELF/Symbols.h
+++ ELF/Symbols.h
@@ -99,6 +99,7 @@
   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; }
 
@@ -111,6 +112,7 @@
   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;
Index: ELF/Symbols.cpp
===================================================================
--- ELF/Symbols.cpp
+++ ELF/Symbols.cpp
@@ -168,6 +168,13 @@
   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;
@@ -379,6 +386,11 @@
 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;
Index: ELF/Target.h
===================================================================
--- ELF/Target.h
+++ ELF/Target.h
@@ -28,6 +28,7 @@
   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 {}
@@ -43,6 +44,13 @@
                         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.
@@ -89,10 +97,12 @@
   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;
Index: ELF/Target.cpp
===================================================================
--- ELF/Target.cpp
+++ ELF/Target.cpp
@@ -237,7 +237,7 @@
 
   // 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.
Index: ELF/Writer.cpp
===================================================================
--- ELF/Writer.cpp
+++ ELF/Writer.cpp
@@ -273,6 +273,52 @@
 };
 }
 
+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,
@@ -282,7 +328,6 @@
   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(
@@ -307,8 +352,9 @@
     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(
@@ -319,6 +365,12 @@
       }
       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()) {
@@ -342,6 +394,7 @@
         {R_RELAX_TLS_IE_TO_LE, Type, Offset, Addend, &Body});
     return 1;
   }
+
   return 0;
 }