[ELF] - implemented R_386_TLS_IE_32 relocation.

[grimar]

Summary

R_386_TLS_IE_32 is generated in such sequence:

movl %gs:0,%eax
addl tls0@gottpoff(%ebx),%eax

Urlich has the only mention of it as #define R_386_TLS_IE_32 /* GOT entry for static TLS block */ and no other info, so main source of information was gold output and source code mostly.
Patch has one problem I would like to discuss. Will add comment below.

[grimar]

So problem I have in this patch is next. Assume we have the code below:

movl %gs:0,%eax
addl tls0@gottpoff(%ebx),%eax

movl %gs:0,%eax
addl tls0@gotntpoff(%ebx),%eax

First sequence generates R_386_TLS_IE_32, second generates R_386_TLS_IE. And the problem is
that such part of code looks to require 2 got entries. First one is entry for positive TLS offset,
second is GOT entry for positive TLS offset.
gold implementation contains enum allowing it to generate different GOT entries:

enum Got_type
 {
   GOT_TYPE_STANDARD = 0,      // GOT entry for a regular symbol
   GOT_TYPE_TLS_NOFFSET = 1,   // GOT entry for negative TLS offset
   GOT_TYPE_TLS_OFFSET = 2,    // GOT entry for positive TLS offset
   GOT_TYPE_TLS_PAIR = 3,      // GOT entry for TLS module/offset pair
   GOT_TYPE_TLS_DESC = 4       // GOT entry for TLS_DESC pair
 };

We don`t have types of GOT entries. All we have now is uint32_t GotPltIndex; in SymbolBody.
Currently gold`s GOT_TYPE_TLS_OFFSET is only used for i386 R_386_TLS_IE_32 relocation so it is corner case.
I dont know how much is possible for one symbol to reproduce the case like above and require 2 entries.
So far I would suggest to check somehow that corner case and produce an "unsupported" error for now.
We could rewrite code in next way:
bool Regular = Target->requiresRegularGot(Type);

...
unsigned IsRegularGot : 1;
bool SymbolBody::isInGot(bool Regular) const {
  if (GotIndex == -1U)
    return false;
  if (IsRegularGot != Regular)
    error("...");
  return true;
}
...
template <class ELFT> void GotSection<ELFT>::addEntry(SymbolBody *Sym, bool Regular) {
  Sym->GotIndex = Target->getGotHeaderEntriesNum() + Entries.size();
  Sym->IsRegularGot = Regular;
  Entries.push_back(Sym);
}

Another option would be to implement GOT entries types I think.

[• rafael]

Do you know what uses gottpoff in x86? Looking at llvm it seems we
always produce gotntpoff.

Cheers,
Rafel

[grimar]

Do you know what uses gottpoff in x86? Looking at llvm it seems we
always produce gotntpoff.

Cheers,
Rafel

No, I dont. I just assumed that if relocation exist (and not marked as not supported/depricated in ABI) then
its worth to support it for potential users.
Do you think we should not do that ?

[grimar]

That relocation seems to be not used in real life atm.

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);
+        Type = Target->getTlsGotReloc(Type, true);
     } else if (!Target->needsCopyRel(Type, *Body) &&
                isa<SharedSymbol<ELFT>>(*Body)) {
       continue;
     } else if (Target->isTlsDynReloc(Type, *Body) ||
                Target->isSizeDynReloc(Type, *Body)) {
       continue;
     } else if (Config->EMachine == EM_MIPS) {
       if (Type == R_MIPS_HI16 && Body == Config->MipsGpDisp)

ELF/OutputSections.cpp

template <class ELFT> bool GotSection<ELFT>::addCurrentModuleTlsIndex() {
   Entries.push_back(nullptr);
   LocalTlsIndexOff = (Entries.size() - 2) * sizeof(uintX_t);
   return true;
 }
 
 template <class ELFT>
 typename GotSection<ELFT>::uintX_t
 GotSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
+  assert(B.GotIndex != (uint32_t)-1);
   return this->getVA() + B.GotIndex * sizeof(uintX_t);
 }
 
 template <class ELFT>
 typename GotSection<ELFT>::uintX_t
 GotSection<ELFT>::getGlobalDynAddr(const SymbolBody &B) const {
   return this->getVA() + B.GlobalDynIndex * sizeof(uintX_t);
 }
if (Target->isTlsLocalDynamicReloc(Type)) {
     return true;
   }
 
   if (!Body || !Target->isTlsGlobalDynamicReloc(Type))
     return false;
 
   if (Target->isTlsOptimized(Type, Body)) {
     P->setSymbolAndType(Body->DynamicSymbolTableIndex,
-                        Target->getTlsGotReloc(), Config->Mips64EL);
+                        Target->getTlsGotReloc(Type), Config->Mips64EL);
     P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
     return true;
   }
 
   P->setSymbolAndType(Body->DynamicSymbolTableIndex,
                       Target->getTlsModuleIndexReloc(), Config->Mips64EL);
   P->r_offset = Out<ELFT>::Got->getGlobalDynAddr(*Body);
   N->setSymbolAndType(Body->DynamicSymbolTableIndex,
for (const DynamicReloc<ELFT> &Rel : Relocs) {
     unsigned Reloc;
     if (!CanBePreempted && Body && isGnuIFunc<ELFT>(*Body))
       Reloc = Target->getIRelativeReloc();
     else 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(Type) : Target->getGotReloc();
     else if (NeedsCopy)
       Reloc = Target->getCopyReloc();
     else
       Reloc = Target->getDynReloc(Type);
     P->setSymbolAndType(Sym, Reloc, Config->Mips64EL);
 
     if (NeedsGot) {
       if (LazyReloc)

ELF/Target.h

public:
   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 SymbolBody &S) const {
     return false;
   }
   virtual unsigned getPltRefReloc(unsigned Type) const;
-  virtual unsigned getTlsGotReloc(unsigned Type = -1) const {
+  virtual unsigned getTlsGotReloc(unsigned Type, bool Static = false) 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,

ELF/Target.cpp

 template bool isGnuIFunc<ELF64BE>(const SymbolBody &S);
 
 namespace {
 class X86TargetInfo final : public TargetInfo {
 public:
   X86TargetInfo();
   void writeGotPltHeaderEntries(uint8_t *Buf) const override;
   unsigned getDynReloc(unsigned Type) const override;
-  unsigned getTlsGotReloc(unsigned Type) const override;
+  unsigned getTlsGotReloc(unsigned Type, bool Static) 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 needsCopyRel(uint32_t Type, const SymbolBody &S) const override;

 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;
 }
 
-unsigned X86TargetInfo::getTlsGotReloc(unsigned Type) const {
-  if (Type == R_386_TLS_IE)
+unsigned X86TargetInfo::getTlsGotReloc(unsigned Type, bool Static) const {
+  if (Static && Type == R_386_TLS_IE)
     return Type;
+  if (Type == R_386_TLS_IE_32)
+    return R_386_TLS_TPOFF32;
   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)
+  if (Type == R_386_TLS_IE || Type == R_386_TLS_IE_32)
     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 (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 || Type == R_386_TLS_IE)
+  if (Type == R_386_TLS_GOTIE || Type == R_386_TLS_IE ||
+      Type == R_386_TLS_IE_32)
     return !isTlsOptimized(Type, &S);
   return Type == R_386_GOT32 || relocNeedsPlt(Type, S);
 }
 
 bool X86TargetInfo::relocNeedsPlt(uint32_t Type, const SymbolBody &S) const {
   return isGnuIFunc<ELF32LE>(S) ||
          (Type == R_386_PLT32 && canBePreempted(&S, true)) ||
          (Type == R_386_PC32 && S.isShared());
case R_386_GOTPC:
     add32le(Loc, SA + Out<ELF32LE>::Got->getVA() - P);
     break;
   case R_386_PC32:
   case R_386_PLT32:
     add32le(Loc, SA - P);
     break;
   case R_386_TLS_GD:
   case R_386_TLS_LDM:
-  case R_386_TLS_TPOFF: {
+  case R_386_TLS_TPOFF:
+  case R_386_TLS_TPOFF32: {
     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;
+  if (Type == R_386_TLS_IE || Type == R_386_TLS_IE_32)
+    return !canBePreempted(S, true);
   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:
   case R_386_TLS_IE:
+  case R_386_TLS_IE_32:
     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);
if (*Op == 0xa1) {
       *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.
+    // In the same way R_386_TLS_IE_32 relocation is optimized to
+    // R_386_TLS_LE_32 here.
     *Inst = IsMov ? 0xc7 : 0x8d;
     if (IsMov)
       *Op = 0xc0 | ((*Op >> 3) & 7);
     else
       *Op = 0x80 | Reg | (Reg << 3);
   }
-  relocateOne(Loc, BufEnd, R_386_TLS_LE, P, SA);
+  uint32_t Reloc = (Type == R_386_TLS_IE_32) ? R_386_TLS_LE_32 : R_386_TLS_LE;
+  relocateOne(Loc, BufEnd, Reloc, 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;
   RelativeReloc = R_X86_64_RELATIVE;

test/ELF/tls-opt-ie32le-i686.s

+// RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
+// RUN: ld.lld -shared %t.o -o %tso
+// RUN: llvm-readobj -s -r %tso | FileCheck --check-prefix=DSO %s
+// RUN: llvm-objdump -d %tso | FileCheck --check-prefix=DISASMDSO %s
+// RUN: ld.lld %t.o -o %t
+// RUN: llvm-readobj -s -r %t | FileCheck --check-prefix=EXE %s
+// RUN: llvm-objdump -d %t | FileCheck --check-prefix=DISASMEXE %s
+
+// DSO:     Section {
+// DSO:      Index: 8
+// DSO:      Name: .got
+// DSO-NEXT:   Type: SHT_PROGBITS
+// DSO-NEXT:   Flags [
+// DSO-NEXT:     SHF_ALLOC
+// DSO-NEXT:     SHF_WRITE
+// DSO-NEXT:   ]
+// DSO-NEXT:   Address: 0x2048
+// DSO-NEXT:   Offset: 0x2048
+// DSO-NEXT:   Size: 8
+// DSO-NEXT:   Link: 0
+// DSO-NEXT:   Info: 0
+// DSO-NEXT:   AddressAlignment: 4
+// DSO-NEXT:   EntrySize: 0
+// DSO-NEXT: }
+// DSO:      Relocations [
+// DSO-NEXT:   Section ({{.*}}) .rel.dyn {
+// DSO-NEXT:    0x2048 R_386_TLS_TPOFF32 tls0 0x0
+// DSO-NEXT:    0x204C R_386_TLS_TPOFF32 tls1 0x0
+// DSO-NEXT:   }
+// DSO-NEXT: ]
+
+// DISASMDSO:       Disassembly of section .text:
+// DISASMDSO-NEXT:  _start:
+// DISASMDSO-NEXT:   1000: 65 a1 00 00 00 00 movl %gs:0, %eax
+// DISASMDSO-NEXT:   1006: 03 83 f8 ff ff ff addl -8(%ebx), %eax
+// DISASMDSO-NEXT:   100c: 65 a1 00 00 00 00 movl %gs:0, %eax
+// DISASMDSO-NEXT:   1012: 8b 83 f8 ff ff ff movl -8(%ebx), %eax
+// DISASMDSO-NEXT:   1018: 65 a1 00 00 00 00 movl %gs:0, %eax
+// DISASMDSO-NEXT:   101e: 03 83 fc ff ff ff addl -4(%ebx), %eax
+// DISASMDSO-NEXT:   1024: 65 a1 00 00 00 00 movl %gs:0, %eax
+// DISASMDSO-NEXT:   102a: 8b 83 fc ff ff ff movl -4(%ebx), %eax
+
+// EXE:     Section {
+// EXE-NOT: Name: .got
+
+// DISASMEXE:     Disassembly of section .text:
+// DISASMEXE-NEXT:  _start:
+// DISASMEXE-NEXT:   11000: 65 a1 00 00 00 00 movl %gs:0, %eax
+// DISASMEXE-NEXT:   11006: 8d 80 08 00 00 00 leal 8(%eax), %eax
+// DISASMEXE-NEXT:   1100c: 65 a1 00 00 00 00 movl %gs:0, %eax
+// DISASMEXE-NEXT:   11012: c7 c0 08 00 00 00 movl $8, %eax
+// DISASMEXE-NEXT:   11018: 65 a1 00 00 00 00 movl %gs:0, %eax
+// DISASMEXE-NEXT:   1101e: 8d 80 04 00 00 00 leal 4(%eax), %eax
+// DISASMEXE-NEXT:   11024: 65 a1 00 00 00 00 movl %gs:0, %eax
+// DISASMEXE-NEXT:   1102a: c7 c0 04 00 00 00 movl $4, %eax
+
+.type tls0,@object
+.section .tbss,"awT",@nobits
+.globl tls0
+.align 4
+tls0:
+ .long 0
+ .size tls0, 4
+
+.type  tls1,@object
+.globl tls1
+.align 4
+tls1:
+ .long 0
+ .size tls1, 4
+
+.section .text
+.globl _start
+_start:
+movl %gs:0,%eax
+addl tls0@gottpoff(%ebx),%eax
+movl %gs:0,%eax
+movl tls0@gottpoff(%ebx),%eax
+
+movl %gs:0,%eax
+addl tls1@gottpoff(%ebx),%eax
+movl %gs:0,%eax
+movl tls1@gottpoff(%ebx),%eax