[ELF/x86] Implemented R_386_TLS_LE_32, R_386_TLS_LE relocations.

[grimar]

Summary

This patch implements next relocations:
R_386_TLS_LE - Negative offset relative to static TLS (GNU version).
R_386_TLS_LE_32 - Offset relative to static TLS block.

These ones are created when using next code sequences:

• @tpoff - The operator must be used to compute an immediate value. The linker will report

an error if the referenced variable is not defined or it is not code for the executable
itself. No GOT entry is created in this case.

• @ntpoff Calculate the negative offset of the variable it is added to relative to the static TLS block.

The operator must be used to compute an immediate value. The linker will report
an error if the referenced variable is not defined or it is not code for the executable
itself. No GOT entry is created in this case.

Information was found in Ulrich Drepper, ELF Handling For Thread-Local Storage, http://www.akkadia.org/drepper/tls.pdf, (6.2, p76)

[ruiu]

Can you write a description of this change to the commit message?

[grimar]

In D14930#295165, @ruiu wrote:

Can you write a description of this change to the commit message?

Updated description. Is it fine now or should I extend it ?

[ruiu]

ELF/InputSection.cpp

150 ↗

(On Diff #40947)

require -> requires (since we use "needs" in other places.)

But maybe isTlsDynReloc is better?

ELF/OutputSections.cpp

245 ↗

(On Diff #40947)

replaceDynReloc -> getDynReloc

[grimar]

Review comments addressed.

ELF/InputSection.cpp

150 ↗

(On Diff #40947)

Changed to isTlsDynReloc, thats shorter.

ELF/OutputSections.cpp

245 ↗

(On Diff #40947)

Done.

[ruiu]

LGTM

lld/trunk/ELF/InputSection.cpp

if (Target->relocNeedsPlt(Type, Body)) {
       Type = Target->getPltRefReloc(Type);
     } else if (Target->relocNeedsGot(Type, Body)) {
       SymVA = Out<ELFT>::Got->getEntryAddr(Body);
       Type = Body.isTLS() ? Target->getTlsGotReloc()
                           : Target->getGotRefReloc(Type);
     } else if (!Target->relocNeedsCopy(Type, Body) &&
                isa<SharedSymbol<ELFT>>(Body)) {
       continue;
+    } else if (Target->isTlsDynReloc(Type)) {
+      continue;
     }
     Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
                         SymVA + getAddend<ELFT>(RI));
   }
 }
 
 template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
   if (this->Header->sh_type == SHT_NOBITS)

lld/trunk/ELF/OutputSections.cpp

if (CanBePreempted) {
       unsigned GotReloc =
           Body->isTLS() ? Target->getTlsGotReloc() : Target->getGotReloc();
       if (NeedsGot)
         P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
                             LazyReloc ? Target->getPltReloc() : GotReloc,
                             Config->Mips64EL);
       else
         P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
-                            NeedsCopy ? Target->getCopyReloc() : Type,
+                            NeedsCopy ? Target->getCopyReloc()
+                                      : Target->getDynReloc(Type),
                             Config->Mips64EL);
     } else {
       P->setSymbolAndType(0, Target->getRelativeReloc(), Config->Mips64EL);
     }
 
     if (NeedsGot) {
       if (LazyReloc)
         P->r_offset = Out<ELFT>::GotPlt->getEntryAddr(*Body);

lld/trunk/ELF/Target.h

 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; }
-  unsigned getTlsPcRelGotReloc() const { return TlsPcRelGotReloc; }
   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 unsigned getGotRefReloc(unsigned Type) const;
   virtual unsigned getPltRefReloc(unsigned Type) const;
   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 GotEntryAddr,
protected:
   unsigned GotReloc;
   unsigned PltReloc;
   unsigned RelativeReloc;
   unsigned TlsGotReloc = 0;
   unsigned TlsLocalDynamicReloc = 0;
   unsigned TlsGlobalDynamicReloc = 0;
   unsigned TlsModuleIndexReloc;
   unsigned TlsOffsetReloc;
-  unsigned TlsPcRelGotReloc = 0;
   unsigned PltEntrySize = 8;
   unsigned PltZeroEntrySize = 0;
   unsigned GotHeaderEntriesNum = 0;
   unsigned GotPltHeaderEntriesNum = 3;
   bool LazyRelocations = false;
 };
 
 uint64_t getPPC64TocBase();

lld/trunk/ELF/Target.cpp

 
 static void add32le(uint8_t *P, int32_t V) { add32<support::little>(P, V); }
 static void or32le(uint8_t *P, int32_t V) { write32le(P, read32le(P) | V); }
 
 namespace {
 class X86TargetInfo final : public TargetInfo {
 public:
   X86TargetInfo();
+  unsigned getDynReloc(unsigned Type) const override;
+  bool isTlsDynReloc(unsigned Type) 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 GotEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index) const override;
   bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) 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) const override;
 };
 
 class X86_64TargetInfo final : public TargetInfo {
 public:
   X86_64TargetInfo();
   unsigned getPltRefReloc(unsigned Type) const override;
+  bool isTlsDynReloc(unsigned Type) 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 GotEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index) const override;
   bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;

 X86TargetInfo::X86TargetInfo() {
   CopyReloc = R_386_COPY;
   PCRelReloc = R_386_PC32;
   GotReloc = R_386_GLOB_DAT;
   GotRefReloc = R_386_GOT32;
   PltReloc = R_386_JUMP_SLOT;
 }
 
+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 {
+  if (Type == R_386_TLS_LE || Type == R_386_TLS_LE_32)
+    return Config->Shared;
+  return false;
+}
+
 void X86TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
 void X86TargetInfo::writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                       uint64_t PltEntryAddr) const {}
 
 void X86TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                   uint64_t PltEntryAddr, int32_t Index) const {
   // jmpl *val; nop; nop
   const uint8_t Inst[] = {0xff, 0x25, 0, 0, 0, 0, 0x90, 0x90};
case R_386_GOTPC:
     add32le(Loc, SA + Out<ELF32LE>::Got->getVA() - P);
     break;
   case R_386_PC32:
     add32le(Loc, SA - P);
     break;
   case R_386_32:
     add32le(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));
   }
 }
 
 X86_64TargetInfo::X86_64TargetInfo() {
   CopyReloc = R_X86_64_COPY;
   PCRelReloc = R_X86_64_PC32;
   GotReloc = R_X86_64_GLOB_DAT;
   GotRefReloc = R_X86_64_PC32;
   PltReloc = R_X86_64_JUMP_SLOT;
   RelativeReloc = R_X86_64_RELATIVE;
   TlsGotReloc = R_X86_64_TPOFF64;
   TlsLocalDynamicReloc = R_X86_64_TLSLD;
   TlsGlobalDynamicReloc = R_X86_64_TLSGD;
   TlsModuleIndexReloc = R_X86_64_DTPMOD64;
   TlsOffsetReloc = R_X86_64_DTPOFF64;
-  TlsPcRelGotReloc = R_X86_64_GOTTPOFF;
   LazyRelocations = true;
   PltEntrySize = 16;
   PltZeroEntrySize = 16;
 }
 
 void X86_64TargetInfo::writeGotPltHeaderEntries(uint8_t *Buf) const {
   write64le(Buf, Out<ELF64LE>::Dynamic->getVA());
 }

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

lld/trunk/ELF/Writer.cpp

if (Body && Body->isTLS() && Target->isTlsGlobalDynamicReloc(Type)) {
         continue;
       Out<ELFT>::Got->addDynTlsEntry(Body);
       Out<ELFT>::RelaDyn->addReloc({&C, &RI});
       Out<ELFT>::RelaDyn->addReloc({nullptr, nullptr});
       Body->setUsedInDynamicReloc();
       continue;
     }
 
-    if ((Body && Body->isTLS()) && Type != Target->getTlsPcRelGotReloc())
+    if ((Body && Body->isTLS()) && !Target->isTlsDynReloc(Type))
       continue;
 
     bool NeedsGot = false;
     bool NeedsPlt = false;
     if (Body) {
       if (auto *E = dyn_cast<SharedSymbol<ELFT>>(Body)) {
         if (E->needsCopy())
           continue;

lld/trunk/test/ELF/tls-i686.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t
+// RUN: ld.lld %t -o %tout
+// RUN: ld.lld %t -shared -o %tsharedout
+// RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DIS
+// RUN: llvm-readobj -r %tout | FileCheck %s --check-prefix=RELOC
+// RUN: llvm-objdump -d %tsharedout | FileCheck %s --check-prefix=DISSHARED
+// RUN: llvm-readobj -r %tsharedout | FileCheck %s --check-prefix=RELOCSHARED
+
+.section ".tdata", "awT", @progbits
+.globl var
+.globl var1
+var:
+.long 0
+var1:
+.long 1
+
+.text
+.global _start
+_start:
+ movl $var@tpoff, %edx
+ movl %gs:0, %ecx
+ subl %edx, %eax
+ movl $var1@tpoff, %edx
+ movl %gs:0, %ecx
+ subl %edx, %eax
+
+ movl %gs:0, %ecx
+ leal var@ntpoff(%ecx), %eax
+ movl %gs:0, %ecx
+ leal var1@ntpoff(%ecx), %eax
+
+// DIS:      Disassembly of section .text:
+// DIS-NEXT: _start:
+// DIS-NEXT: 11000: ba 08 00 00 00       movl $8, %edx
+// DIS-NEXT: 11005: 65 8b 0d 00 00 00 00 movl %gs:0, %ecx
+// DIS-NEXT: 1100c: 29 d0                subl %edx, %eax
+// DIS-NEXT: 1100e: ba 04 00 00 00       movl $4, %edx
+// DIS-NEXT: 11013: 65 8b 0d 00 00 00 00 movl %gs:0, %ecx
+// DIS-NEXT: 1101a: 29 d0                subl %edx, %eax
+// DIS-NEXT: 1101c: 65 8b 0d 00 00 00 00 movl %gs:0, %ecx
+// DIS-NEXT: 11023: 8d 81 f8 ff ff ff    leal -8(%ecx), %eax
+// DIS-NEXT: 11029: 65 8b 0d 00 00 00 00 movl %gs:0, %ecx
+// DIS-NEXT: 11030: 8d 81 fc ff ff ff    leal -4(%ecx), %eax
+
+// RELOC: Relocations [
+// RELOC-NEXT: ]
+
+// DISSHARED: Disassembly of section .text:
+// DISSHARED-NEXT: _start:
+// DISSHARED-NEXT: 1000: ba 00 00 00 00 movl   $0, %edx
+// DISSHARED-NEXT: 1005: 65 8b 0d 00 00 00 00  movl %gs:0, %ecx
+// DISSHARED-NEXT: 100c: 29 d0 subl            %edx, %eax
+// DISSHARED-NEXT: 100e: ba 00 00 00 00        movl $0, %edx
+// DISSHARED-NEXT: 1013: 65 8b 0d 00 00 00 00  movl %gs:0, %ecx
+// DISSHARED-NEXT: 101a: 29 d0 subl            %edx, %eax
+// DISSHARED-NEXT: 101c: 65 8b 0d 00 00 00 00  movl %gs:0, %ecx
+// DISSHARED-NEXT: 1023: 8d 81 00 00 00 00     leal (%ecx), %eax
+// DISSHARED-NEXT: 1029: 65 8b 0d 00 00 00 00  movl %gs:0, %ecx
+// DISSHARED-NEXT: 1030: 8d 81 00 00 00 00     leal (%ecx), %eax
+
+// RELOCSHARED:      Relocations [
+// RELOCSHARED-NEXT: Section (4) .rel.dyn {
+// RELOCSHARED-NEXT:   0x1001 R_386_TLS_TPOFF32 var 0x0
+// RELOCSHARED-NEXT:   0x100F R_386_TLS_TPOFF32 var1 0x0
+// RELOCSHARED-NEXT:   0x1025 R_386_TLS_TPOFF var 0x0
+// RELOCSHARED-NEXT:   0x1032 R_386_TLS_TPOFF var1 0x0
+// RELOCSHARED-NEXT:  }
+// RELOCSHARED-NEXT: ]