[ELF] - Cleanup Target::getTlsGotRel using logic

[grimar]

Summary

Previously getTlsGotRel(unsigned Type = -1) had a bit confusing
behavior. It returned different result depending on argument, assuming
that if there is no argument then it was a dynamic relocation branch case.
This patch simplifies the logic a bit.

[grimar]

http://reviews.llvm.org/D16880 was commited which consumed this one.

ELF/OutputSections.cpp

if (Target->isTlsLocalDynamicRel(Type)) {
     P->r_offset = Out<ELFT>::Got->getLocalTlsIndexVA();
     return true;
   }
 
   if (!Body || !Target->isTlsGlobalDynamicRel(Type))
     return false;
 
   if (Target->canRelaxTls(Type, Body)) {
-    P->setSymbolAndType(Body->DynsymIndex, Target->getTlsGotRel(),
+    P->setSymbolAndType(Body->DynsymIndex, Target->TlsGotDynRel,
                         Config->Mips64EL);
     P->r_offset = Body->getGotVA<ELFT>();
     return true;
   }
 
   P->setSymbolAndType(Body->DynsymIndex, Target->TlsModuleIndexRel,
                       Config->Mips64EL);
   P->r_offset = Out<ELFT>::Got->getGlobalDynAddr(*Body);
bool LazyReloc =
         Body && Target->UseLazyBinding && Target->needsPlt(Type, *Body);
 
     unsigned Reloc;
     if (!CBP)
       Reloc = Target->RelativeRel;
     else if (LazyReloc)
       Reloc = Target->PltRel;
     else if (NeedsGot)
-      Reloc = Body->isTls() ? Target->getTlsGotRel() : Target->GotRel;
+      Reloc = Body->isTls() ? Target->TlsGotDynRel : Target->GotRel;
     else
       Reloc = Target->getDynRel(Type);
     P->setSymbolAndType(CBP ? Body->DynsymIndex : 0, Reloc, Config->Mips64EL);
 
     if (LazyReloc)
       P->r_offset = Body->getGotPltVA<ELFT>();
     else if (NeedsGot)
       P->r_offset = Body->getGotVA<ELFT>();

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 TlsGotDynRel; }
   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 {}
public:
   // 0x200000, but it looks like every OS uses 4k pages for executables.
   uint64_t VAStart = 0x10000;
 
   unsigned CopyRel;
   unsigned GotRel;
   unsigned PltRel;
   unsigned RelativeRel;
   unsigned IRelativeRel;
-  unsigned TlsGotRel = 0;
+  unsigned TlsGotDynRel = 0;
   unsigned TlsLocalDynamicRel = 0;
   unsigned TlsGlobalDynamicRel = 0;
   unsigned TlsModuleIndexRel;
   unsigned TlsOffsetRel;
   unsigned PltEntrySize = 8;
   unsigned PltZeroSize = 0;
   unsigned GotHeaderEntriesNum = 0;
   unsigned GotPltHeaderEntriesNum = 3;

ELF/Target.cpp

 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, const SymbolBody &S) const override;
   bool needsPlt(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;
 };

 }
 
 X86TargetInfo::X86TargetInfo() {
   CopyRel = R_386_COPY;
   GotRel = R_386_GLOB_DAT;
   PltRel = R_386_JUMP_SLOT;
   IRelativeRel = R_386_IRELATIVE;
   RelativeRel = R_386_RELATIVE;
-  TlsGotRel = R_386_TLS_TPOFF;
+  TlsGotDynRel = R_386_TLS_TPOFF;
   TlsGlobalDynamicRel = R_386_TLS_GD;
   TlsLocalDynamicRel = R_386_TLS_LDM;
   TlsModuleIndexRel = R_386_TLS_DTPMOD32;
   TlsOffsetRel = R_386_TLS_DTPOFF32;
   UseLazyBinding = true;
   PltEntrySize = 16;
   PltZeroSize = 16;
 }
unsigned X86TargetInfo::getDynRel(unsigned Type) const {
   if (Type == R_386_TLS_LE_32)
     return R_386_TLS_TPOFF32;
   return Type;
 }
 
 unsigned X86TargetInfo::getTlsGotRel(unsigned Type) const {
   if (Type == R_386_TLS_IE)
     return Type;
-  return TlsGotRel;
+  return TlsGotDynRel;
 }
 
 bool X86TargetInfo::isTlsDynRel(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);

 }
 
 X86_64TargetInfo::X86_64TargetInfo() {
   CopyRel = R_X86_64_COPY;
   GotRel = R_X86_64_GLOB_DAT;
   PltRel = R_X86_64_JUMP_SLOT;
   RelativeRel = R_X86_64_RELATIVE;
   IRelativeRel = R_X86_64_IRELATIVE;
-  TlsGotRel = R_X86_64_TPOFF64;
+  TlsGotDynRel = R_X86_64_TPOFF64;
   TlsLocalDynamicRel = R_X86_64_TLSLD;
   TlsGlobalDynamicRel = R_X86_64_TLSGD;
   TlsModuleIndexRel = R_X86_64_DTPMOD64;
   TlsOffsetRel = R_X86_64_DTPOFF64;
   UseLazyBinding = true;
   PltEntrySize = 16;
   PltZeroSize = 16;
 }
void PPC64TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
   }
 }
 
 AArch64TargetInfo::AArch64TargetInfo() {
   CopyRel = R_AARCH64_COPY;
   IRelativeRel = R_AARCH64_IRELATIVE;
   GotRel = R_AARCH64_GLOB_DAT;
   PltRel = R_AARCH64_JUMP_SLOT;
-  TlsGotRel = R_AARCH64_TLS_TPREL64;
+  TlsGotDynRel = R_AARCH64_TLS_TPREL64;
   UseLazyBinding = true;
   PltEntrySize = 16;
   PltZeroSize = 32;
 }
 
 unsigned AArch64TargetInfo::getDynRel(unsigned Type) const {
   if (Type == R_AARCH64_ABS32 || Type == R_AARCH64_ABS64)
     return Type;
void AArch64TargetInfo::writePlt(uint8_t *Buf, uint64_t 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)
     return Type;
-  return TlsGotRel;
+  return TlsGotDynRel;
 }
 
 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 {