[ELF] - implemented @indntpoff (x86) relocation and its optimization.

[grimar]

Summary

@indntpoff is similar to @gotntpoff, but for use in position dependent code. While @gotntpoff resolves to GOT slot address relative to the
start of the GOT in the movl or addl instructions, @indntpoff resolves to the
absolute GOT slot address. ("ELF Handling For Thread-Local Storage", Ulrich Drepper).

Since this relocation resolves to the absolute GOT slot address it requires R_386_RELATIVE relocation for each place of using when linking shared library. Had to add Target::relocNeedsDynRelative() method that checks if a relocation requires R_386_RELATIVE relocation to be emited either.

[grimar]

ELF/OutputSections.cpp

282

Changes above mostly belongs to dependency patch http://reviews.llvm.org/D15453.
The difference is that IsDynRelative was added to conditions.

[ruiu]

ELF/Target.cpp

106–107

In other places we use unsigned for the symbol type.

351–353

You can combine these two ifs using ||.

517–518

Isn't the former a special case of the latter? (EAX is a REG?)

ELF/Target.h

48

Can you make the argument mandatory? Technically nothing wrong with the optional parameter, but that defines actually a shorthand for defining two different functions, getTlsGotReloc() and getTlsGotReloc(unsigned), thus it (slightly) increase program complexity.

[silvas]

ELF/Target.cpp

517–518

There is a special encoding for the EAX version, so from a linker's perspective (operations on machine code bytes) they are different. There are many x86 instructions for which eax is special (carry-over from old 8086 CISC stuff). Originally, ax = "accumulator" register and had a special "load accumulator" instruction which now is a special encoding pattern-matched by the assembler for assembly text mov $foo,%eax. Another example is use of cx "count" register as arg for variable bit shift.

[ruiu]

ELF/Target.cpp

517–518

But still it looks odd as a comment. Maybe we should add

// 0xA1 is RAX. RAX encoding is different from others

to

if (*RegSlot == 0xA1) {

?

[silvas]

ELF/Target.cpp

517–518

The comment does say "First one is special because when EAX is used the sequence is 5 bytes long, otherwise it is 6 bytes."

Also, I think the proposed wording "0xA1 is RAX" is confusing. 0xA1 is simply the opcode byte for the instruction MOV rAX, Ov (see Table A-2. One-byte Opcode Map: (00H — F7H) in the intel manual Vol. 2).

Note that movl $foo,%eax actually can be encoded two ways; in one case, *RegSlot is just the opcode byte (see entry for 0xA1 in Table A-2), in the other, it is an opcode extension byte (see entry 0xC7 in Table A-2 and also row C7 (in group 11) column 000 in Table A-6. Opcode Extensions for One- and Two-byte Opcodes by Group Number). Perhaps RegSlot needs a different name to reflect this situation.

[grimar]

• Rebased
• Review comments addressed.

ELF/Target.cpp

106–107

Changed to unsigned. Thats what we might want to change for all places I guess, since currently some methods uses uint32_t. others uses unsigned.
For example these ones uses uint32:

virtual bool isRelRelative(uint32_t Type) const;
virtual bool isSizeDynReloc(uint32_t Type, const SymbolBody &S) const;
virtual bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const;
virtual bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const = 0;
virtual bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const = 0

351–353

Done.

517–518

So movl $0x0,%eax can be encoded as
0xc7 0xc0 0x00 0x00 0x00 0x00
and
0xb8 0x00 0x00 0x00 0x00

We convert here from 0xA1 0x00 0x00 0x00 0x00 to 0xB8 0x00 0x00 0x00 0x00 (MOV eAX,Ov -> MOV eAX, see A.1.1, A.1.2, Table A-2).
So for us that A1 is always oppcode byte here it seems. Then I would call it OpCode but it used for other branches as well where has different meaning. Thus may be "Op" name would be fine here, combining both "Opcode" and "Operands" interpretations ?

ELF/Target.h

48

Done.
Problem here is that getTlsGotReloc is used in several places but requires special handling of Type only in one of them (where relocation calculation actually happens, for other places method returns dynamic relocation which is single).
That makes need of explicit using of arg = -1, what does not looks great for me.

[ruiu]

ELF/OutputSections.cpp

225

Oh this is worse than before. I didn't expect that you had to use a magic number instead of a default parameter. Default parameter is better.

[grimar]

Review comments addressed.

ELF/OutputSections.cpp

225

Yep. Reverted back.

[ruiu]

LGTM

ELF/InputSection.cpp

for (size_t I = 0; I < Num; ++I) {
 
     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);
       if (Body.isTLS())
-        Type = Target->getTlsGotReloc();
+        Type = Target->getTlsGotReloc(Type);
     } else if (!Target->relocNeedsCopy(Type, Body) &&
                isa<SharedSymbol<ELFT>>(Body)) {
       continue;
-    } else if (Target->isTlsDynReloc(Type) ||
+    } else if (Target->isTlsDynReloc(Type, Body) ||
                Target->isSizeDynReloc(Type, Body)) {
       continue;
     }
     uintX_t A = getAddend<ELFT>(RI);
     uintX_t Size = getSymSize<ELFT>(Body);
     Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA + A, Size + A,
                         findMipsPairedReloc(Buf, SymIndex, Type, NextRelocs));
   }

ELF/OutputSections.cpp

if (Target->isTlsLocalDynamicReloc(Type)) {
     return true;
   }
 
   if (!Body || !Target->isTlsGlobalDynamicReloc(Type))
     return false;
 
   if (Target->isTlsOptimized(Type, Body)) {
     P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
-                        Target->getTlsGotReloc(), Config->Mips64EL);
+                        Target->getTlsGotReloc(-1), Config->Mips64EL);
     P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
     return true;
   }
 
   P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
                       Target->getTlsModuleIndexReloc(), Config->Mips64EL);
   P->r_offset = Out<ELFT>::Got->getGlobalDynAddr(*Body);
   N->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
for (const DynamicReloc<ELFT> &Rel : Relocs) {
     uint32_t Type = RI.getType(Config->Mips64EL);
     if (applyTlsDynamicReloc(Body, Type, P, reinterpret_cast<Elf_Rel *>(Buf)))
       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);
+    bool IsDynRelative = Type == Target->getRelativeReloc();
 
     unsigned Sym = CanBePreempted ? Body->getDynamicSymbolTableIndex() : 0;
     unsigned Reloc;
-    if (!CanBePreempted)
+    if (!CanBePreempted || IsDynRelative)
       Reloc = Target->getRelativeReloc();
     else if (LazyReloc)
       Reloc = Target->getPltReloc();
     else if (NeedsGot)
-      Reloc = Body->isTLS() ? Target->getTlsGotReloc() : Target->getGotReloc();
+      Reloc =
+          Body->isTLS() ? Target->getTlsGotReloc(-1) : Target->getGotReloc();
     else if (NeedsCopy)
       Reloc = Target->getCopyReloc();
     else
       Reloc = Target->getDynReloc(Type);
     P->setSymbolAndType(Sym, Reloc, Config->Mips64EL);
 
     if (NeedsGot) {
       if (LazyReloc)
         P->r_offset = Out<ELFT>::GotPlt->getEntryAddr(*Body);
       else
         P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
     } else if (NeedsCopy) {
       P->r_offset = Out<ELFT>::Bss->getVA() +
                     dyn_cast<SharedSymbol<ELFT>>(Body)->OffsetInBSS;
     } else {
       P->r_offset = C.getOffset(RI.r_offset) + C.OutSec->getVA();
     }
 
     uintX_t OrigAddend = 0;
     if (IsRela && !NeedsGot)
       OrigAddend = static_cast<const Elf_Rela &>(RI).r_addend;
 
     uintX_t Addend;
     if (NeedsCopy)
       Addend = 0;
-    else if (CanBePreempted)
+    else if (CanBePreempted || IsDynRelative)
       Addend = OrigAddend;
     else if (Body)
       Addend = getSymVA<ELFT>(cast<ELFSymbolBody<ELFT>>(*Body)) + OrigAddend;
     else if (IsRela)
       Addend = getLocalRelTarget(File, static_cast<const Elf_Rela &>(RI));
     else
       Addend = getLocalRelTarget(File, RI);
 

ELF/Target.h

 class TargetInfo {
 public:
   unsigned getPageSize() const { return PageSize; }
   uint64_t getVAStart() const;
   unsigned getCopyReloc() const { return CopyReloc; }
   unsigned getGotReloc() const { return GotReloc; }
   unsigned getPltReloc() const { return PltReloc; }
   unsigned getRelativeReloc() const { return RelativeReloc; }
-  unsigned getTlsGotReloc() const { return TlsGotReloc; }
   bool isTlsLocalDynamicReloc(unsigned Type) const {
     return Type == TlsLocalDynamicReloc;
   }
   bool isTlsGlobalDynamicReloc(unsigned Type) const {
     return Type == 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; }
   unsigned getGotPltHeaderEntriesNum() const { return GotPltHeaderEntriesNum; }
   virtual unsigned getDynReloc(unsigned Type) const { return Type; }
-  virtual bool isTlsDynReloc(unsigned Type) const { return false; }
+  virtual bool isTlsDynReloc(unsigned Type, const SymbolBody &S) const {
+    return false;
+  }
   virtual unsigned getPltRefReloc(unsigned Type) const;
+  virtual unsigned getTlsGotReloc(unsigned Type) const { return TlsGotReloc; }
   virtual void writeGotHeaderEntries(uint8_t *Buf) const;
   virtual void writeGotPltHeaderEntries(uint8_t *Buf) const;
   virtual void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const = 0;
   virtual void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                  uint64_t PltEntryAddr) const = 0;
   virtual void writePltEntry(uint8_t *Buf, uint64_t GotAddr,
                              uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                              int32_t Index, unsigned RelOff) const = 0;
   virtual bool isRelRelative(uint32_t Type) const;
   virtual bool isSizeDynReloc(uint32_t Type, const SymbolBody &S) const;
   virtual bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const;
+  virtual bool relocNeedsDynRelative(unsigned Type) const { return false; }
   virtual bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const = 0;
   virtual bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const = 0;
   virtual void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                            uint64_t P, uint64_t SA, uint64_t ZA = 0,
                            uint8_t *PairedLoc = nullptr) const = 0;
   virtual bool isTlsOptimized(unsigned Type, const SymbolBody *S) const;
   virtual unsigned relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd,
                                        uint32_t Type, uint64_t P, uint64_t SA,

ELF/Target.cpp

 }
 
 namespace {
 class X86TargetInfo final : public TargetInfo {
 public:
   X86TargetInfo();
   void writeGotPltHeaderEntries(uint8_t *Buf) const override;
   unsigned getDynReloc(unsigned Type) const override;
-  bool isTlsDynReloc(unsigned Type) const override;
+  unsigned getTlsGotReloc(unsigned Type) const override;
+  bool isTlsDynReloc(unsigned Type, const SymbolBody &S) const override;
   void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                          uint64_t PltEntryAddr) const override;
   void writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index,
                      unsigned RelOff) const override;
   bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const override;
+  bool relocNeedsDynRelative(unsigned Type) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA, uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
   bool isTlsOptimized(unsigned Type, const SymbolBody *S) const override;
   unsigned relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                uint64_t P, uint64_t SA,
                                const SymbolBody &S) const override;
 
 private:
   void relocateTlsLdToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
                          uint64_t SA) const;
   void relocateTlsGdToIe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
                          uint64_t SA) const;
   void relocateTlsGdToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
                          uint64_t SA) const;
-  void relocateTlsIeToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
-                         uint64_t SA) const;
+  void relocateTlsIeToLe(unsigned Type, uint8_t *Loc, uint8_t *BufEnd,
+                         uint64_t P, uint64_t SA) const;
 };
 
 class X86_64TargetInfo final : public TargetInfo {
 public:
   X86_64TargetInfo();
   unsigned getPltRefReloc(unsigned Type) const override;
-  bool isTlsDynReloc(unsigned Type) const override;
+  bool isTlsDynReloc(unsigned Type, const SymbolBody &S) const override;
   void writeGotPltHeaderEntries(uint8_t *Buf) const override;
   void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                          uint64_t PltEntryAddr) const override;
   void writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index,
                      unsigned RelOff) const override;
   bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const override;

 
 void TargetInfo::writeGotPltHeaderEntries(uint8_t *Buf) const {}
 
 X86TargetInfo::X86TargetInfo() {
   CopyReloc = R_386_COPY;
   PCRelReloc = R_386_PC32;
   GotReloc = R_386_GLOB_DAT;
   PltReloc = R_386_JUMP_SLOT;
+  RelativeReloc = R_386_RELATIVE;
   TlsGotReloc = R_386_TLS_TPOFF;
   TlsGlobalDynamicReloc = R_386_TLS_GD;
   TlsLocalDynamicReloc = R_386_TLS_LDM;
   TlsModuleIndexReloc = R_386_TLS_DTPMOD32;
   TlsOffsetReloc = R_386_TLS_DTPOFF32;
   LazyRelocations = true;
   PltEntrySize = 16;
   PltZeroEntrySize = 16;

 unsigned X86TargetInfo::getDynReloc(unsigned Type) const {
   if (Type == R_386_TLS_LE)
     return R_386_TLS_TPOFF;
   if (Type == R_386_TLS_LE_32)
     return R_386_TLS_TPOFF32;
   return Type;
 }
 
-bool X86TargetInfo::isTlsDynReloc(unsigned Type) const {
+unsigned X86TargetInfo::getTlsGotReloc(unsigned Type) const {
+  if (Type == R_386_TLS_IE)
+    return Type;
+  return TlsGotReloc;
+}
+
+bool X86TargetInfo::isTlsDynReloc(unsigned Type, const SymbolBody &S) const {
   if (Type == R_386_TLS_LE || Type == R_386_TLS_LE_32 ||
       Type == R_386_TLS_GOTIE)
     return Config->Shared;
+  if (Type == R_386_TLS_IE)
+    return canBePreempted(&S, true);
   return Type == R_386_TLS_GD;
 }
 
 void X86TargetInfo::writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                       uint64_t PltEntryAddr) const {
   // Executable files and shared object files have
   // separate procedure linkage tables.
   if (Config->Shared) {
if (Type == R_386_32 || Type == R_386_16 || Type == R_386_8)
     if (auto *SS = dyn_cast<SharedSymbol<ELF32LE>>(&S))
       return SS->Sym.getType() == STT_OBJECT;
   return false;
 }
 
 bool X86TargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
   if (S.isTLS() && Type == R_386_TLS_GD)
     return Target->isTlsOptimized(Type, &S) && canBePreempted(&S, true);
-  if (Type == R_386_TLS_GOTIE)
+  if (Type == R_386_TLS_GOTIE || Type == R_386_TLS_IE)
     return !isTlsOptimized(Type, &S);
   return Type == R_386_GOT32 || relocNeedsPlt(Type, S);
 }
 
 bool X86TargetInfo::relocNeedsPlt(uint32_t Type, const SymbolBody &S) const {
   return (Type == R_386_PLT32 && canBePreempted(&S, true)) ||
          (Type == R_386_PC32 && S.isShared());
 }
 
 void X86TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
void X86TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
   case R_386_TLS_LDM:
   case R_386_TLS_TPOFF: {
     uint64_t V = SA - Out<ELF32LE>::Got->getVA() -
                  Out<ELF32LE>::Got->getNumEntries() * 4;
     checkInt<32>(V, Type);
     write32le(Loc, V);
     break;
   }
+  case R_386_TLS_IE:
   case R_386_TLS_LDO_32:
     write32le(Loc, SA);
     break;
   case R_386_TLS_LE:
     write32le(Loc, SA - Out<ELF32LE>::TlsPhdr->p_memsz);
     break;
   case R_386_TLS_LE_32:
     write32le(Loc, Out<ELF32LE>::TlsPhdr->p_memsz - SA);
     break;
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 bool X86TargetInfo::isTlsOptimized(unsigned Type, const SymbolBody *S) const {
   if (Config->Shared || (S && !S->isTLS()))
     return false;
   return Type == R_386_TLS_LDO_32 || Type == R_386_TLS_LDM ||
          Type == R_386_TLS_GD ||
+         (Type == R_386_TLS_IE && !canBePreempted(S, true)) ||
          (Type == R_386_TLS_GOTIE && !canBePreempted(S, true));
 }
 
+bool X86TargetInfo::relocNeedsDynRelative(unsigned Type) const {
+  return Config->Shared && Type == R_386_TLS_IE;
+}
+
 unsigned X86TargetInfo::relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd,
                                             uint32_t Type, uint64_t P,
                                             uint64_t SA,
                                             const SymbolBody &S) const {
   switch (Type) {
   case R_386_TLS_GD:
     if (canBePreempted(&S, true))
       relocateTlsGdToIe(Loc, BufEnd, P, SA);
     else
       relocateTlsGdToLe(Loc, BufEnd, P, SA);
     // The next relocation should be against __tls_get_addr, so skip it
     return 1;
   case R_386_TLS_GOTIE:
-    relocateTlsIeToLe(Loc, BufEnd, P, SA);
+  case R_386_TLS_IE:
+    relocateTlsIeToLe(Type, Loc, BufEnd, P, SA);
     return 0;
   case R_386_TLS_LDM:
     relocateTlsLdToLe(Loc, BufEnd, P, SA);
     // The next relocation should be against __tls_get_addr, so skip it
     return 1;
   case R_386_TLS_LDO_32:
     relocateOne(Loc, BufEnd, R_386_TLS_LE, P, SA);
     return 0;
void X86TargetInfo::relocateTlsLdToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
   const uint8_t Inst[] = {
       0x65, 0xa1, 0x00, 0x00, 0x00, 0x00, // movl %gs:0,%eax
       0x90,                               // nop
       0x8d, 0x74, 0x26, 0x00              // leal 0(%esi,1),%esi
   };
   memcpy(Loc - 2, Inst, sizeof(Inst));
 }
 
-// In some conditions, R_386_TLS_GOTIE relocation can be optimized to
-// R_386_TLS_LE so that it does not use GOT.
-// This function does that. Read "ELF Handling For Thread-Local Storage,
-// 5.1  IA-32 Linker Optimizations" (http://www.akkadia.org/drepper/tls.pdf)
+// In some conditions, relocations can be optimized to avoid using GOT.
+// This function does that for Initial Exec to Local Exec case.
+// Read "ELF Handling For Thread-Local Storage, 5.1
+// IA-32 Linker Optimizations" (http://www.akkadia.org/drepper/tls.pdf)
 // by Ulrich Drepper for details.
-void X86TargetInfo::relocateTlsIeToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
+void X86TargetInfo::relocateTlsIeToLe(unsigned Type, uint8_t *Loc,
+                                      uint8_t *BufEnd, uint64_t P,
                                       uint64_t SA) const {
-  // Ulrich's document section 6.2 says that @gotntpoff can be
-  // used with MOVL or ADDL instructions.
-  // "MOVL foo@GOTTPOFF(%RIP), %REG" is transformed to "MOVL $foo, %REG".
-  // "ADDL foo@GOTNTPOFF(%RIP), %REG" is transformed to "LEAL foo(%REG), %REG"
-  // Note: gold converts to ADDL instead of LEAL.
+  // Ulrich's document section 6.2 says that @gotntpoff can
+  // be used with MOVL or ADDL instructions.
+  // @indntpoff is similar to @gotntpoff, but for use in
+  // position dependent code.
   uint8_t *Inst = Loc - 2;
-  uint8_t *RegSlot = Loc - 1;
+  uint8_t *Op = Loc - 1;
   uint8_t Reg = (Loc[-1] >> 3) & 7;
   bool IsMov = *Inst == 0x8b;
+  if (Type == R_386_TLS_IE) {
+    // For R_386_TLS_IE relocation we perform the next transformations:
+    // MOVL foo@INDNTPOFF,%EAX is transformed to MOVL $foo,%EAX
+    // MOVL foo@INDNTPOFF,%REG is transformed to MOVL $foo,%REG
+    // ADDL foo@INDNTPOFF,%REG is transformed to ADDL $foo,%REG
+    // First one is special because when EAX is used the sequence is 5 bytes
+    // long, otherwise it is 6 bytes.
+    if (*Op == 0xa1) {
+      *Op = 0xb8;
+    } else {
+      *Inst = IsMov ? 0xc7 : 0x81;
+      *Op = 0xc0 | ((*Op >> 3) & 7);
+    }
+  } else {
+    // R_386_TLS_GOTIE relocation can be optimized to
+    // R_386_TLS_LE so that it does not use GOT.
+    // "MOVL foo@GOTTPOFF(%RIP), %REG" is transformed to "MOVL $foo, %REG".
+    // "ADDL foo@GOTNTPOFF(%RIP), %REG" is transformed to "LEAL foo(%REG), %REG"
+    // Note: gold converts to ADDL instead of LEAL.
     *Inst = IsMov ? 0xc7 : 0x8d;
     if (IsMov)
-    *RegSlot = 0xc0 | ((*RegSlot >> 3) & 7);
+      *Op = 0xc0 | ((*Op >> 3) & 7);
     else
-    *RegSlot = 0x80 | Reg | (Reg << 3);
+      *Op = 0x80 | Reg | (Reg << 3);
+  }
   relocateOne(Loc, BufEnd, R_386_TLS_LE, P, SA);
 }
 
 X86_64TargetInfo::X86_64TargetInfo() {
   CopyReloc = R_X86_64_COPY;
   PCRelReloc = R_X86_64_PC32;
   GotReloc = R_X86_64_GLOB_DAT;
   PltReloc = R_X86_64_JUMP_SLOT;

 bool X86_64TargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
   if (Type == R_X86_64_TLSGD)
     return Target->isTlsOptimized(Type, &S) && canBePreempted(&S, true);
   if (Type == R_X86_64_GOTTPOFF)
     return !isTlsOptimized(Type, &S);
   return Type == R_X86_64_GOTPCREL || relocNeedsPlt(Type, S);
 }
 
-bool X86_64TargetInfo::isTlsDynReloc(unsigned Type) const {
+bool X86_64TargetInfo::isTlsDynReloc(unsigned Type, const SymbolBody &S) const {
   return Type == R_X86_64_GOTTPOFF || Type == R_X86_64_TLSGD;
 }
 
 unsigned X86_64TargetInfo::getPltRefReloc(unsigned Type) const {
   if (Type == R_X86_64_PLT32)
     return R_X86_64_PC32;
   return Type;
 }

ELF/Writer.cpp

if (Body && Body->isTLS() && Target->isTlsGlobalDynamicReloc(Type)) {
         Out<ELFT>::RelaDyn->addReloc({nullptr, nullptr});
         Body->setUsedInDynamicReloc();
         continue;
       }
       if (!canBePreempted(Body, true))
         continue;
     }
 
-    if (Body && Body->isTLS() && !Target->isTlsDynReloc(Type))
+    if (Body && Body->isTLS() && !Target->isTlsDynReloc(Type, *Body))
       continue;
 
+    if (Target->relocNeedsDynRelative(Type)) {
+      RelType *Rel = new (Alloc) RelType;
+      Rel->setSymbolAndType(0, Target->getRelativeReloc(), Config->Mips64EL);
+      Rel->r_offset = RI.r_offset;
+      Out<ELFT>::RelaDyn->addReloc({&C, Rel});
+    }
+
     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;

test/ELF/Inputs/tls-opt-iele-i686-nopic.s

+.type tlsshared0,@object
+.section .tbss,"awT",@nobits
+.globl tlsshared0
+.align 4
+tlsshared0:
+ .long 0
+ .size tlsshared0, 4
+
+.type tlsshared1,@object
+.section .tbss,"awT",@nobits
+.globl tlsshared1
+.align 4
+tlsshared1:
+ .long 0
+ .size tlsshared1, 4

test/ELF/tls-opt-iele-i686-nopic.s

+// RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
+// RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %p/Inputs/tls-opt-iele-i686-nopic.s -o %tso.o
+// RUN: ld.lld -shared %tso.o -o %tso
+// RUN: ld.lld %t.o %tso -o %t1
+// RUN: llvm-readobj -s -r %t1 | FileCheck --check-prefix=GOTREL %s
+// RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASM %s
+// RUN: ld.lld -shared %t.o %tso -o %t1
+// RUN: llvm-readobj -s -r %t1 | FileCheck --check-prefix=GOTRELSHARED %s
+// RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASMSHARED %s
+
+// GOTREL:      Section {
+// GOTREL:        Index:
+// GOTREL:        Name: .got
+// GOTREL-NEXT:   Type: SHT_PROGBITS
+// GOTREL-NEXT:   Flags [
+// GOTREL-NEXT:     SHF_ALLOC
+// GOTREL-NEXT:     SHF_WRITE
+// GOTREL-NEXT:   ]
+// GOTREL-NEXT:   Address: 0x12050
+// GOTREL-NEXT:   Offset: 0x2050
+// GOTREL-NEXT:   Size: 8
+// GOTREL-NEXT:   Link: 0
+// GOTREL-NEXT:   Info: 0
+// GOTREL-NEXT:   AddressAlignment: 4
+// GOTREL-NEXT:   EntrySize: 0
+// GOTREL-NEXT: }
+// GOTREL:      Relocations [
+// GOTREL-NEXT: Section ({{.*}}) .rel.dyn {
+// GOTREL-NEXT:   0x12050 R_386_TLS_TPOFF tlsshared0 0x0
+// GOTREL-NEXT:   0x12054 R_386_TLS_TPOFF tlsshared1 0x0
+// GOTREL-NEXT:  }
+// GOTREL-NEXT: ]
+
+// DISASM:      Disassembly of section .text:
+// DISASM-NEXT: _start:
+// 4294967288 = 0xFFFFFFF8
+// 4294967292 = 0xFFFFFFFC
+// 73808 = (.got)[0] = 0x12050
+// 73812 = (.got)[1] = 0x12054
+// DISASM-NEXT: 11000: c7 c1 f8 ff ff ff movl $4294967288, %ecx
+// DISASM-NEXT: 11006: 65 8b 01          movl %gs:(%ecx), %eax
+// DISASM-NEXT: 11009: b8 f8 ff ff ff    movl $4294967288, %eax
+// DISASM-NEXT: 1100e: 65 8b 00          movl %gs:(%eax), %eax
+// DISASM-NEXT: 11011: 81 c1 f8 ff ff ff addl $4294967288, %ecx
+// DISASM-NEXT: 11017: 65 8b 01          movl %gs:(%ecx), %eax
+// DISASM-NEXT: 1101a: c7 c1 fc ff ff ff movl $4294967292, %ecx
+// DISASM-NEXT: 11020: 65 8b 01          movl %gs:(%ecx), %eax
+// DISASM-NEXT: 11023: b8 fc ff ff ff    movl $4294967292, %eax
+// DISASM-NEXT: 11028: 65 8b 00          movl %gs:(%eax), %eax
+// DISASM-NEXT: 1102b: 81 c1 fc ff ff ff addl $4294967292, %ecx
+// DISASM-NEXT: 11031: 65 8b 01          movl %gs:(%ecx), %eax
+// DISASM-NEXT: 11034: 8b 0d 50 20 01 00 movl 73808, %ecx
+// DISASM-NEXT: 1103a: 65 8b 01          movl %gs:(%ecx), %eax
+// DISASM-NEXT: 1103d: 03 0d 54 20 01 00 addl 73812, %ecx
+// DISASM-NEXT: 11043: 65 8b 01          movl %gs:(%ecx), %eax
+
+// GOTRELSHARED:     Section {
+// GOTRELSHARED:      Index: 8
+// GOTRELSHARED:      Name: .got
+// GOTRELSHARED-NEXT:   Type: SHT_PROGBITS
+// GOTRELSHARED-NEXT:   Flags [
+// GOTRELSHARED-NEXT:     SHF_ALLOC
+// GOTRELSHARED-NEXT:     SHF_WRITE
+// GOTRELSHARED-NEXT:   ]
+// GOTRELSHARED-NEXT:   Address: 0x2050
+// GOTRELSHARED-NEXT:   Offset: 0x2050
+// GOTRELSHARED-NEXT:   Size: 16
+// GOTRELSHARED-NEXT:   Link: 0
+// GOTRELSHARED-NEXT:   Info: 0
+// GOTRELSHARED-NEXT:   AddressAlignment: 4
+// GOTRELSHARED-NEXT:   EntrySize: 0
+// GOTRELSHARED-NEXT: }
+// GOTRELSHARED:      Relocations [
+// GOTRELSHARED-NEXT:   Section ({{.*}}) .rel.dyn {
+// GOTRELSHARED-NEXT:     0x1002 R_386_RELATIVE - 0x0
+// GOTRELSHARED-NEXT:     0x2050 R_386_TLS_TPOFF tlslocal0 0x0
+// GOTRELSHARED-NEXT:     0x100A R_386_RELATIVE - 0x0
+// GOTRELSHARED-NEXT:     0x1013 R_386_RELATIVE - 0x0
+// GOTRELSHARED-NEXT:     0x101C R_386_RELATIVE - 0x0
+// GOTRELSHARED-NEXT:     0x2054 R_386_TLS_TPOFF tlslocal1 0x0
+// GOTRELSHARED-NEXT:     0x1024 R_386_RELATIVE - 0x0
+// GOTRELSHARED-NEXT:     0x102D R_386_RELATIVE - 0x0
+// GOTRELSHARED-NEXT:     0x1036 R_386_RELATIVE - 0x0
+// GOTRELSHARED-NEXT:     0x2058 R_386_TLS_TPOFF tlsshared0 0x0
+// GOTRELSHARED-NEXT:     0x103F R_386_RELATIVE - 0x0
+// GOTRELSHARED-NEXT:     0x205C R_386_TLS_TPOFF tlsshared1 0x0
+// GOTRELSHARED-NEXT:   }
+// GOTRELSHARED-NEXT: ]
+
+// DISASMSHARED:       Disassembly of section .text:
+// DISASMSHARED-NEXT:  _start:
+// (.got)[0] = 0x2050 = 8272
+// (.got)[1] = 0x2054 = 8276
+// (.got)[2] = 0x2058 = 8280
+// (.got)[3] = 0x205C = 8284
+// DISASMSHARED-NEXT:  1000: 8b 0d 50 20 00 00 movl 8272, %ecx
+// DISASMSHARED-NEXT:  1006: 65 8b 01          movl %gs:(%ecx), %eax
+// DISASMSHARED-NEXT:  1009: a1 50 20 00 00    movl 8272, %eax
+// DISASMSHARED-NEXT:  100e: 65 8b 00          movl %gs:(%eax), %eax
+// DISASMSHARED-NEXT:  1011: 03 0d 50 20 00 00 addl 8272, %ecx
+// DISASMSHARED-NEXT:  1017: 65 8b 01          movl %gs:(%ecx), %eax
+// DISASMSHARED-NEXT:  101a: 8b 0d 54 20 00 00 movl 8276, %ecx
+// DISASMSHARED-NEXT:  1020: 65 8b 01          movl %gs:(%ecx), %eax
+// DISASMSHARED-NEXT:  1023: a1 54 20 00 00    movl 8276, %eax
+// DISASMSHARED-NEXT:  1028: 65 8b 00          movl %gs:(%eax), %eax
+// DISASMSHARED-NEXT:  102b: 03 0d 54 20 00 00 addl 8276, %ecx
+// DISASMSHARED-NEXT:  1031: 65 8b 01          movl %gs:(%ecx), %eax
+// DISASMSHARED-NEXT:  1034: 8b 0d 58 20 00 00 movl 8280, %ecx
+// DISASMSHARED-NEXT:  103a: 65 8b 01          movl %gs:(%ecx), %eax
+// DISASMSHARED-NEXT:  103d: 03 0d 5c 20 00 00 addl 8284, %ecx
+// DISASMSHARED-NEXT:  1043: 65 8b 01          movl %gs:(%ecx), %eax
+
+.type tlslocal0,@object
+.section .tbss,"awT",@nobits
+.globl tlslocal0
+.align 4
+tlslocal0:
+ .long 0
+ .size tlslocal0, 4
+
+.type tlslocal1,@object
+.section .tbss,"awT",@nobits
+.globl tlslocal1
+.align 4
+tlslocal1:
+ .long 0
+ .size tlslocal1, 4
+
+.section .text
+.globl ___tls_get_addr
+.type ___tls_get_addr,@function
+___tls_get_addr:
+
+.section .text
+.globl _start
+_start:
+movl tlslocal0@indntpoff,%ecx
+movl %gs:(%ecx),%eax
+
+movl tlslocal0@indntpoff,%eax
+movl %gs:(%eax),%eax
+
+addl tlslocal0@indntpoff,%ecx
+movl %gs:(%ecx),%eax
+
+movl tlslocal1@indntpoff,%ecx
+movl %gs:(%ecx),%eax
+
+movl tlslocal1@indntpoff,%eax
+movl %gs:(%eax),%eax
+
+addl tlslocal1@indntpoff,%ecx
+movl %gs:(%ecx),%eax
+
+movl tlsshared0@indntpoff,%ecx
+movl %gs:(%ecx),%eax
+
+addl tlsshared1@indntpoff,%ecx
+movl %gs:(%ecx),%eax