[ELF] - Remove R_X86_64_GOTTPOFF from static relocation proccessing

[grimar]

Summary

R_X86_64_TPOFF64 is a dynamic relocation,
it should not appear in static relocation proccessing.
Patch fixes it.

[ruiu]

ELF/Target.h

29 ↗

(On Diff #46890)

The other dynamic relocation for GOT is "GotRel", so we don't need to add "Dyn", no?

Also, since this is now just an accessor that does nothing, please remove this function and use the field directly.

[grimar]

• Rebased
• Addressed review comments.

ELF/Target.h

29 ↗

(On Diff #46890)

I am already using the field directly, but there is still one place where accessor is required.
It is used directly for place (after rebase it is the only one place I think) where dynamic relocation is created. That is why I added "Dyn" to field name.
'Accessor' is still used in InputSectionBase<ELFT>::relocate() where static relocation calculation is applied, it is not an accessor though, because it returns result depending on argument for static relocation resolving.

[• rafael]

LGTM if you keep the TlsGotRel name.

[grimar]

In D16880#349605, @rafael wrote:

LGTM if you keep the TlsGotRel name.

Done. Thanks for review !

lld/trunk/ELF/Target.h

 
 class TargetInfo {
 public:
   uint64_t getVAStart() const;
   bool isTlsLocalDynamicRel(unsigned Type) const;
   bool isTlsGlobalDynamicRel(unsigned Type) const;
   virtual unsigned getDynRel(unsigned Type) const { return Type; }
   virtual bool isTlsDynRel(unsigned Type, const SymbolBody &S) const;
-  virtual unsigned getTlsGotRel(unsigned Type = -1) const { return TlsGotRel; }
+  virtual unsigned getTlsGotRel(unsigned Type) const { return TlsGotRel; }
   virtual void writeGotHeader(uint8_t *Buf) const {}
   virtual void writeGotPltHeader(uint8_t *Buf) const {}
   virtual void writeGotPlt(uint8_t *Buf, uint64_t Plt) const {};
 
   // If lazy binding is supported, the first entry of the PLT has code
   // to call the dynamic linker to resolve PLT entries the first time
   // they are called. This function writes that code.
   virtual void writePltZero(uint8_t *Buf) const {}

lld/trunk/ELF/Target.cpp

void relocateTlsGdToLe(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 getTlsGotRel(unsigned Type) const override;
   bool isTlsDynRel(unsigned Type, const SymbolBody &S) const override;
   void writeGotPltHeader(uint8_t *Buf) const override;
   void writeGotPlt(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZero(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   bool needsCopyRel(uint32_t Type, const SymbolBody &S) const override;
   bool needsGot(uint32_t Type, SymbolBody &S) const override;

 class AArch64TargetInfo final : public TargetInfo {
 public:
   AArch64TargetInfo();
   unsigned getDynRel(unsigned Type) const override;
   void writeGotPlt(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZero(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
-  unsigned getTlsGotRel(unsigned Type = -1) const override;
+  unsigned getTlsGotRel(unsigned Type) const override;
   bool isTlsDynRel(unsigned Type, const SymbolBody &S) const override;
   bool needsCopyRel(uint32_t Type, const SymbolBody &S) const override;
   bool needsGot(uint32_t Type, SymbolBody &S) const override;
   bool needsPlt(uint32_t Type, 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 X86_64TargetInfo::needsGot(uint32_t Type, SymbolBody &S) const {
   if (Type == R_X86_64_TLSGD)
     return Target->canRelaxTls(Type, &S) && canBePreempted(&S, true);
   if (Type == R_X86_64_GOTTPOFF)
     return !canRelaxTls(Type, &S);
   return Type == R_X86_64_GOTPCREL || needsPlt(Type, S);
 }
 
+unsigned X86_64TargetInfo::getTlsGotRel(unsigned Type) const {
+  // No other types of TLS relocations requiring GOT should
+  // reach here.
+  assert(Type == R_X86_64_GOTTPOFF);
+  return R_X86_64_PC32;
+}
+
 bool X86_64TargetInfo::isTlsDynRel(unsigned Type, const SymbolBody &S) const {
   return Type == R_X86_64_GOTTPOFF || Type == R_X86_64_TLSGD;
 }
 
 bool X86_64TargetInfo::needsPlt(uint32_t Type, SymbolBody &S) const {
   if (needsCopyRel(Type, S))
     return false;
   if (isGnuIFunc<ELF64LE>(S))

 //  addq x@tpoff,%rax
 void X86_64TargetInfo::relocateTlsGdToIe(uint8_t *Loc, uint8_t *BufEnd,
                                          uint64_t P, uint64_t SA) const {
   const uint8_t Inst[] = {
       0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00, // mov %fs:0x0,%rax
       0x48, 0x03, 0x05, 0x00, 0x00, 0x00, 0x00              // addq x@tpoff,%rax
   };
   memcpy(Loc - 4, Inst, sizeof(Inst));
-  relocateOne(Loc + 8, BufEnd, R_X86_64_TPOFF64, P + 12, SA);
+  relocateOne(Loc + 8, BufEnd, R_X86_64_PC32, P + 12, SA);
 }
 
 // In some conditions, R_X86_64_GOTTPOFF relocation can be optimized to
 // R_X86_64_TPOFF32 so that it does not use GOT.
 // This function does that. Read "ELF Handling For Thread-Local Storage,
 // 5.5 x86-x64 linker optimizations" (http://www.akkadia.org/drepper/tls.pdf)
 // by Ulrich Drepper for details.
 void X86_64TargetInfo::relocateTlsIeToLe(uint8_t *Loc, uint8_t *BufEnd,
case R_X86_64_SIZE64:
     write64le(Loc, ZA);
     break;
   case R_X86_64_TPOFF32: {
     uint64_t Val = SA - Out<ELF64LE>::TlsPhdr->p_memsz;
     checkInt<32>(Val, Type);
     write32le(Loc, Val);
     break;
   }
-  case R_X86_64_TPOFF64:
-    write32le(Loc, SA - P);
-    break;
   default:
     fatal("unrecognized reloc " + Twine(Type));
   }
 }
 
 // Relocation masks following the #lo(value), #hi(value), #ha(value),
 // #higher(value), #highera(value), #highest(value), and #highesta(value)
 // macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi
relocateOne(Buf, Buf + 4, R_AARCH64_ADR_PREL_PG_HI21, PltEntryAddr,
               GotEntryAddr);
   relocateOne(Buf + 4, Buf + 8, R_AARCH64_LDST64_ABS_LO12_NC, PltEntryAddr + 4,
               GotEntryAddr);
   relocateOne(Buf + 8, Buf + 12, R_AARCH64_ADD_ABS_LO12_NC, PltEntryAddr + 8,
               GotEntryAddr);
 }
 
 unsigned AArch64TargetInfo::getTlsGotRel(unsigned Type) const {
-  if (Type == R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 ||
-      Type == R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC)
+  assert(Type == R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 ||
+    Type == R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC);
     return Type;
-  return TlsGotRel;
 }
 
 bool AArch64TargetInfo::isTlsDynRel(unsigned Type, const SymbolBody &S) const {
   return Type == R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 ||
          Type == R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC;
 }
 
 bool AArch64TargetInfo::needsCopyRel(uint32_t Type, const SymbolBody &S) const {

lld/trunk/ELF/Writer.cpp

if (Body && Target->needsGot(Type, *Body)) {
       }
 
       bool CBP = canBePreempted(Body, /*NeedsGot=*/true);
       bool Dynrel = Config->Shared && !Target->isRelRelative(Type) &&
                     !Target->isSizeRel(Type);
       if (CBP || Dynrel) {
         uint32_t DynType;
         if (CBP)
-          DynType = Body->isTls() ? Target->getTlsGotRel() : Target->GotRel;
+          DynType = Body->isTls() ? Target->TlsGotRel : Target->GotRel;
         else
           DynType = Target->RelativeRel;
         Out<ELFT>::RelaDyn->addReloc(
             {DynType, DynamicReloc<ELFT>::Off_Got, !CBP, Body});
       }
       continue;
     }