[ELF2] - Implemented R_X86_64_GOTTPOFF relocation

[grimar]

Summary

Generates GOT entry, R_X86_64_TPOFF64 is added to RelaDyn.

[ruiu]

LGTM

[grimar]

I was need to upgrade it because of code changes in r252979. Could this please be reviewed again ?

[• rafael]

LGTM with a nit.

ELF/InputSection.cpp

143

Maybe just pass body to getGotReloc?

[grimar]

ELF/InputSection.cpp

143

Target->getGotReloc(Body) ?

[• rafael]

Maybe just pass body to getGotReloc?

Target->getGotReloc(Body) ?

Yes.

Cheers,
Rafael

[grimar]

In D14621#288863, @rafael wrote:

Maybe just pass body to getGotReloc?

Target->getGotReloc(Body) ?

Yes.

Cheers,
Rafael

It looks good but let me think about that a bit later please.

[• rafael]

Sure. A second patch is fine.

[grimar]

In D14621#288857, @rafael wrote:

LGTM with a nit.
Maybe just pass body to getGotReloc?

Problem here is that currently there are two places in code that looks very similiar:

1) Type = Body.isTLS() ? Target->getTlsGotReloc() : Target->getGotRefReloc();
...
2) unsigned GotReloc =
  Body->isTLS() ? Target->getTlsGotReloc() : Target->getGotReloc();

But getGotRefReloc() and getGotReloc() are different calls. And it seems I cant just use the body argument to know which one relocation return for them in that places.

[• rafael]

Problem here is that currently there are two places in code that looks very similiar:

1. Type = Body.isTLS() ? Target->getTlsGotReloc() : Target->getGotRefReloc(); ...
2. unsigned GotReloc = Body->isTLS() ? Target->getTlsGotReloc() : Target->getGotReloc();

But getGotRefReloc() and getGotReloc() are different calls. And it seems I cant just use the body argument to know which one relocation return for them in that places.

Fair enough.

ELF/InputSection.cpp

for (const RelType &RI : Rels) {
     }
 
     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);
-      Type = Target->getGotRefReloc();
+      Type = Body.isTLS() ? Target->getTlsGotReloc() : Target->getGotRefReloc();
     } else if (Target->relocPointsToGot(Type)) {
       SymVA = Out<ELFT>::Got->getVA();
       Type = Target->getPCRelReloc();
     } else if (!Target->relocNeedsCopy(Type, Body) &&
                isa<SharedSymbol<ELFT>>(Body)) {
       continue;
     }
     Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,

ELF/OutputSections.h

template <class ELFT> class GotSection final : public OutputSectionBase<ELFT> {
   typedef OutputSectionBase<ELFT> Base;
   typedef typename Base::uintX_t uintX_t;
 
 public:
   GotSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody *Sym);
+  void addDynTlsEntry(SymbolBody *Sym);
   uint32_t addLocalModuleTlsIndex();
   bool empty() const { return Entries.empty(); }
   uintX_t getEntryAddr(const SymbolBody &B) const;
 
   // 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.

ELF/OutputSections.cpp

GotSection<ELFT>::GotSection()
   if (Config->EMachine == EM_MIPS)
     this->Header.sh_flags |= llvm::ELF::SHF_MIPS_GPREL;
   this->Header.sh_addralign = sizeof(uintX_t);
 }
 
 template <class ELFT> void GotSection<ELFT>::addEntry(SymbolBody *Sym) {
   Sym->GotIndex = Target->getGotHeaderEntriesNum() + Entries.size();
   Entries.push_back(Sym);
+}
+
+template <class ELFT> void GotSection<ELFT>::addDynTlsEntry(SymbolBody *Sym) {
+  Sym->GotIndex = Target->getGotHeaderEntriesNum() + Entries.size();
   // Global Dynamic TLS entries take two GOT slots.
-  if (Sym->isTLS())
-    Entries.push_back(nullptr);
+  Entries.push_back(Sym);
 }
 
 template <class ELFT> uint32_t GotSection<ELFT>::addLocalModuleTlsIndex() {
   Entries.push_back(nullptr);
   Entries.push_back(nullptr);
   return (Entries.size() - 2) * sizeof(uintX_t);
 }
 
for (const DynamicReloc<ELFT> &Rel : Relocs) {
 
     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);
 
     if (CanBePreempted) {
+      unsigned GotReloc =
+          Body->isTLS() ? Target->getTlsGotReloc() : Target->getGotReloc();
       if (NeedsGot)
         P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
-                            LazyReloc ? Target->getPltReloc()
-                                      : Target->getGotReloc(),
+                            LazyReloc ? Target->getPltReloc() : GotReloc,
                             Config->Mips64EL);
       else
         P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
                             NeedsCopy ? Target->getCopyReloc() : Type,
                             Config->Mips64EL);
     } else {
       P->setSymbolAndType(0, Target->getRelativeReloc(), Config->Mips64EL);
     }

ELF/Target.h

public:
   unsigned getPageSize() const { return PageSize; }
   uint64_t getVAStart() const;
   unsigned getCopyReloc() const { return CopyReloc; }
   unsigned getPCRelReloc() const { return PCRelReloc; }
   unsigned getGotReloc() const { return GotReloc; }
   unsigned getPltReloc() const { return PltReloc; }
   unsigned getGotRefReloc() const { return GotRefReloc; }
   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; }
protected:
   uint64_t VAStart = 0x10000;
 
   unsigned CopyReloc;
   unsigned PCRelReloc;
   unsigned GotRefReloc;
   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;
   bool LazyRelocations = false;
 };
 
 uint64_t getPPC64TocBase();
 

ELF/Target.cpp

 
 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::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {
   // Skip 6 bytes of "jmpq *got(%rip)"
   write32le(Buf, Plt + 6);
bool X86_64TargetInfo::relocNeedsCopy(uint32_t Type,
   if (Type == R_X86_64_32S || Type == R_X86_64_32 || Type == R_X86_64_PC32 ||
       Type == R_X86_64_64)
     if (auto *SS = dyn_cast<SharedSymbol<ELF64LE>>(&S))
       return SS->Sym.getType() == STT_OBJECT;
   return false;
 }
 
 bool X86_64TargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
-  return Type == R_X86_64_GOTPCREL || relocNeedsPlt(Type, S);
+  return Type == R_X86_64_GOTTPOFF || Type == R_X86_64_GOTPCREL ||
+         relocNeedsPlt(Type, S);
 }
 
 unsigned X86_64TargetInfo::getPLTRefReloc(unsigned Type) const {
   if (Type == R_X86_64_PLT32)
     return R_X86_64_PC32;
   return Type;
 }
 

 void X86_64TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                    uint64_t P, uint64_t SA) const {
   switch (Type) {
   case R_X86_64_PC32:
   case R_X86_64_GOTPCREL:
   case R_X86_64_PLT32:
   case R_X86_64_TLSLD:
   case R_X86_64_TLSGD:
+  case R_X86_64_TPOFF64:
     write32le(Loc, SA - P);
     break;
   case R_X86_64_64:
   case R_X86_64_DTPOFF64:
     write64le(Loc, SA);
     break;
   case R_X86_64_32:
   case R_X86_64_32S:

ELF/Writer.cpp

for (const RelType &RI : Rels) {
     // Set "used" bit for --as-needed.
     if (Body && Body->isUndefined() && !Body->isWeak())
       if (auto *S = dyn_cast<SharedSymbol<ELFT>>(Body->repl()))
         S->File->IsUsed = true;
 
     if (Body)
       Body = Body->repl();
 
-    if (Body && Body->isTLS()) {
-      if (!Target->isTlsGlobalDynamicReloc(Type))
-        continue;
+    if (Body && Body->isTLS() && Target->isTlsGlobalDynamicReloc(Type)) {
       if (Body->isInGot())
         continue;
-      Out<ELFT>::Got->addEntry(Body);
+      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())
+      continue;
+
     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/elf2/Inputs/tls-got.s

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

test/elf2/tls-got.s

+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/tls-got.s -o %t2.o
+// RUN: ld.lld2 -shared %t2.o -o %t2.so
+// RUN: ld.lld2 -e main %t1.o %t2.so -o %t3
+// RUN: llvm-readobj -s -r %t3 | FileCheck %s
+// RUN: llvm-objdump -d %t3 | FileCheck --check-prefix=DISASM %s
+
+// CHECK:      Section {
+// CHECK:      Index: 8
+// CHECK-NEXT: Name: .got
+// CHECK-NEXT: Type: SHT_PROGBITS
+// CHECK-NEXT: Flags [
+// CHECK-NEXT:   SHF_ALLOC
+// CHECK-NEXT:   SHF_WRITE
+// CHECK-NEXT: ]
+// CHECK-NEXT: Address: [[ADDR:.*]]
+// CHECK-NEXT: Offset: 0x20A0
+// CHECK-NEXT: Size: 16
+// CHECK-NEXT: Link: 0
+// CHECK-NEXT: Info: 0
+// CHECK-NEXT: AddressAlignment: 8
+// CHECK-NEXT: EntrySize: 0
+// CHECK-NEXT: }
+
+// CHECK:      Relocations [
+// CHECK-NEXT:   Section (4) .rela.dyn {
+// CHECK-NEXT:     [[ADDR]] R_X86_64_TPOFF64 tls1 0x0
+// CHECK-NEXT:     0x120A8 R_X86_64_TPOFF64 tls0 0x0
+// CHECK-NEXT:   }
+// CHECK-NEXT: ]
+
+//0x11000 + 4249 + 7 = 0x120A0
+//0x1100A + 4247 + 7 = 0x120A8
+//0x11014 + 4237 + 7 = 0x120A8
+//DISASM:      Disassembly of section .text:
+//DISASM-NEXT: main:
+//DISASM-NEXT: 11000: 48 8b 05 99 10 00 00 movq 4249(%rip), %rax
+//DISASM-NEXT: 11007: 64 8b 00 movl %fs:(%rax), %eax
+//DISASM-NEXT: 1100a: 48 8b 05 97 10 00 00 movq 4247(%rip), %rax
+//DISASM-NEXT: 11011: 64 8b 00 movl %fs:(%rax), %eax
+//DISASM-NEXT: 11014: 48 8b 05 8d 10 00 00 movq 4237(%rip), %rax
+//DISASM-NEXT: 1101b: 64 8b 00 movl %fs:(%rax), %eax
+//DISASM-NEXT: 1101e: c3 retq
+
+.section .tdata,"awT",@progbits
+
+.text
+ .globl main
+ .align 16, 0x90
+ .type main,@function
+main:
+ movq tls1@GOTTPOFF(%rip), %rax
+ movl %fs:0(%rax), %eax
+ movq tls0@GOTTPOFF(%rip), %rax
+ movl %fs:0(%rax), %eax
+ movq tls0@GOTTPOFF(%rip), %rax
+ movl %fs:0(%rax), %eax
+ ret