[ELF] Split TLS RelExpr. NFC

[jrtc27]

OOI what do you intend to do with the fact that they're now split?

[MaskRay]

Rebase

lld/ELF/Arch/AArch64.cpp

RelExpr AArch64::getRelExpr(RelType type, const Symbol &s,
   case R_AARCH64_MOVW_PREL_G2:
   case R_AARCH64_MOVW_PREL_G2_NC:
   case R_AARCH64_MOVW_PREL_G3:
     return R_PC;
   case R_AARCH64_ADR_PREL_PG_HI21:
   case R_AARCH64_ADR_PREL_PG_HI21_NC:
     return R_AARCH64_PAGE_PC;
   case R_AARCH64_LD64_GOT_LO12_NC:
-  case R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
     return R_GOT;
+  case R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
+    return R_TLS_GOT;
   case R_AARCH64_LD64_GOTPAGE_LO15:
     return R_AARCH64_GOT_PAGE;
   case R_AARCH64_ADR_GOT_PAGE:
   case R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
     return R_AARCH64_GOT_PAGE_PC;
   case R_AARCH64_NONE:
     return R_NONE;
   default:

lld/ELF/Arch/ARM.cpp

case R_ARM_THM_CALL:
     return R_PLT_PC;
   case R_ARM_GOTOFF32:
     // (S + A) - GOT_ORG
     return R_GOTREL;
   case R_ARM_GOT_BREL:
     // GOT(S) + A - GOT_ORG
     return R_GOT_OFF;
   case R_ARM_GOT_PREL:
-  case R_ARM_TLS_IE32:
     // GOT(S) + A - P
     return R_GOT_PC;
+  case R_ARM_TLS_IE32:
+    return R_TLS_GOT_PC;
   case R_ARM_SBREL32:
     return R_ARM_SBREL;
   case R_ARM_TARGET1:
     return config->target1Rel ? R_PC : R_ABS;
   case R_ARM_TARGET2:
     if (config->target2 == Target2Policy::Rel)
       return R_PC;
     if (config->target2 == Target2Policy::Abs)

lld/ELF/Arch/Hexagon.cpp

RelExpr Hexagon::getRelExpr(RelType type, const Symbol &s,
   case R_HEX_GD_PLT_B22_PCREL:
   case R_HEX_GD_PLT_B22_PCREL_X:
   case R_HEX_GD_PLT_B32_PCREL_X:
     return R_PLT_PC;
   case R_HEX_IE_32_6_X:
   case R_HEX_IE_16_X:
   case R_HEX_IE_HI16:
   case R_HEX_IE_LO16:
-    return R_GOT;
+    return R_TLS_GOT;
   case R_HEX_GD_GOT_11_X:
   case R_HEX_GD_GOT_16_X:
   case R_HEX_GD_GOT_32_6_X:
     return R_TLSGD_GOTPLT;
   case R_HEX_GOTREL_11_X:
   case R_HEX_GOTREL_16_X:
   case R_HEX_GOTREL_32_6_X:
   case R_HEX_GOTREL_HI16:

lld/ELF/Arch/PPC.cpp

case R_PPC_REL24:
     return R_PLT_PC;
   case R_PPC_PLTREL24:
     return R_PPC32_PLTREL;
   case R_PPC_GOT_TLSGD16:
     return R_TLSGD_GOT;
   case R_PPC_GOT_TLSLD16:
     return R_TLSLD_GOT;
   case R_PPC_GOT_TPREL16:
-    return R_GOT_OFF;
+    return R_TLS_GOTOFF;
   case R_PPC_TLS:
     return R_TLSIE_HINT;
   case R_PPC_TLSGD:
     return R_TLSDESC_CALL;
   case R_PPC_TLSLD:
     return R_TLSLD_HINT;
   case R_PPC_TPREL16:
   case R_PPC_TPREL16_HA:

lld/ELF/Arch/PPC64.cpp

RelExpr PPC64::getRelExpr(RelType type, const Symbol &s,
   case R_PPC64_GOT16_LO_DS:
     return R_GOT_OFF;
   case R_PPC64_TOC16:
   case R_PPC64_TOC16_DS:
   case R_PPC64_TOC16_HI:
   case R_PPC64_TOC16_LO:
     return R_GOTREL;
   case R_PPC64_GOT_PCREL34:
-  case R_PPC64_GOT_TPREL_PCREL34:
   case R_PPC64_PCREL_OPT:
     return R_GOT_PC;
+  case R_PPC64_GOT_TPREL_PCREL34:
+    return R_TLS_GOT_PC;
   case R_PPC64_TOC16_HA:
   case R_PPC64_TOC16_LO_DS:
     return config->tocOptimize ? R_PPC64_RELAX_TOC : R_GOTREL;
   case R_PPC64_TOC:
     return R_PPC64_TOCBASE;
   case R_PPC64_REL14:
   case R_PPC64_REL24:
     return R_PPC64_CALL_PLT;
RelExpr PPC64::getRelExpr(RelType type, const Symbol &s,
   case R_PPC64_GOT_TLSLD16_LO:
     return R_TLSLD_GOT;
   case R_PPC64_GOT_TLSLD_PCREL34:
     return R_TLSLD_PC;
   case R_PPC64_GOT_TPREL16_HA:
   case R_PPC64_GOT_TPREL16_LO_DS:
   case R_PPC64_GOT_TPREL16_DS:
   case R_PPC64_GOT_TPREL16_HI:
-    return R_GOT_OFF;
+    return R_TLS_GOTOFF;
   case R_PPC64_GOT_DTPREL16_HA:
   case R_PPC64_GOT_DTPREL16_LO_DS:
   case R_PPC64_GOT_DTPREL16_DS:
   case R_PPC64_GOT_DTPREL16_HI:
     return R_TLSLD_GOT_OFF;
   case R_PPC64_TPREL16:
   case R_PPC64_TPREL16_HA:
   case R_PPC64_TPREL16_LO:

lld/ELF/Arch/RISCV.cpp

case R_RISCV_GOT_HI20:
     return R_GOT_PC;
   case R_RISCV_PCREL_LO12_I:
   case R_RISCV_PCREL_LO12_S:
     return R_RISCV_PC_INDIRECT;
   case R_RISCV_TLS_GD_HI20:
     return R_TLSGD_PC;
   case R_RISCV_TLS_GOT_HI20:
     config->hasStaticTlsModel = true;
-    return R_GOT_PC;
+    return R_TLS_GOT_PC;
   case R_RISCV_TPREL_HI20:
   case R_RISCV_TPREL_LO12_I:
   case R_RISCV_TPREL_LO12_S:
     return R_TPREL;
   case R_RISCV_RELAX:
   case R_RISCV_TPREL_ADD:
     return R_NONE;
   case R_RISCV_ALIGN:

lld/ELF/Arch/X86.cpp

case R_386_PLT32:
     return R_PLT_PC;
   case R_386_PC8:
   case R_386_PC16:
   case R_386_PC32:
     return R_PC;
   case R_386_GOTPC:
     return R_GOTPLTONLY_PC;
   case R_386_TLS_IE:
-    return R_GOT;
+    return R_TLS_GOT;
   case R_386_GOT32:
   case R_386_GOT32X:
     // These relocations are arguably mis-designed because their calculations
     // depend on the instructions they are applied to. This is bad because we
     // usually don't care about whether the target section contains valid
     // machine instructions or not. But this is part of the documented ABI, so
     // we had to implement as the standard requires.
     //
case R_386_GOT32X:
     // the byte, we can determine whether the instruction uses the operand as an
     // absolute address (R_GOT) or a register-relative address (R_GOTPLT).
     return (loc[-1] & 0xc7) == 0x5 ? R_GOT : R_GOTPLT;
   case R_386_TLS_GOTDESC:
     return R_TLSDESC_GOTPLT;
   case R_386_TLS_DESC_CALL:
     return R_TLSDESC_CALL;
   case R_386_TLS_GOTIE:
-    return R_GOTPLT;
+    return R_TLS_GOT_GOTPLT;
   case R_386_GOTOFF:
     return R_GOTPLTREL;
   case R_386_TLS_LE:
     return R_TPREL;
   case R_386_TLS_LE_32:
     return R_TPREL_NEG;
   case R_386_NONE:
     return R_NONE;

lld/ELF/Arch/X86_64.cpp

RelExpr X86_64::getRelExpr(RelType type, const Symbol &s,
   case R_X86_64_GOT32:
   case R_X86_64_GOT64:
     return R_GOTPLT;
   case R_X86_64_GOTPC32_TLSDESC:
     return R_TLSDESC_PC;
   case R_X86_64_GOTPCREL:
   case R_X86_64_GOTPCRELX:
   case R_X86_64_REX_GOTPCRELX:
-  case R_X86_64_GOTTPOFF:
     return R_GOT_PC;
+  case R_X86_64_GOTTPOFF:
+    return R_TLS_GOT_PC;
   case R_X86_64_GOTOFF64:
     return R_GOTPLTREL;
   case R_X86_64_PLTOFF64:
     return R_PLT_GOTPLT;
   case R_X86_64_GOTPC32:
   case R_X86_64_GOTPC64:
     return R_GOTPLTONLY_PC;
   case R_X86_64_NONE:

lld/ELF/InputSection.cpp

uint64_t InputSectionBase::getRelocTargetVA(const InputFile *file, RelType type,
   case R_RELAX_GOT_PC_NOPIC:
   case R_RISCV_ADD:
     return sym.getVA(a);
   case R_ADDEND:
     return a;
   case R_ARM_SBREL:
     return sym.getVA(a) - getARMStaticBase(sym);
   case R_GOT:
+  case R_TLS_GOT:
   case R_RELAX_TLS_GD_TO_IE_ABS:
     return sym.getGotVA() + a;
   case R_GOTONLY_PC:
     return in.got->getVA() + a - p;
   case R_GOTPLTONLY_PC:
     return in.gotPlt->getVA() + a - p;
   case R_GOTREL:
   case R_PPC64_RELAX_TOC:
     return sym.getVA(a) - in.got->getVA();
   case R_GOTPLTREL:
     return sym.getVA(a) - in.gotPlt->getVA();
   case R_GOTPLT:
+  case R_TLS_GOT_GOTPLT:
   case R_RELAX_TLS_GD_TO_IE_GOTPLT:
     return sym.getGotVA() + a - in.gotPlt->getVA();
   case R_TLSLD_GOT_OFF:
   case R_GOT_OFF:
+  case R_TLS_GOTOFF:
   case R_RELAX_TLS_GD_TO_IE_GOT_OFF:
     return sym.getGotOffset() + a;
   case R_AARCH64_GOT_PAGE_PC:
   case R_AARCH64_RELAX_TLS_GD_TO_IE_PAGE_PC:
     return getAArch64Page(sym.getGotVA() + a) - getAArch64Page(p);
   case R_AARCH64_GOT_PAGE:
     return sym.getGotVA() + a - getAArch64Page(in.got->getVA());
   case R_GOT_PC:
+  case R_TLS_GOT_PC:
   case R_RELAX_TLS_GD_TO_IE:
     return sym.getGotVA() + a - p;
   case R_MIPS_GOTREL:
     return sym.getVA(a) - in.mipsGot->getGp(file);
   case R_MIPS_GOT_GP:
     return in.mipsGot->getGp(file) + a;
   case R_MIPS_GOT_GP_PC: {
     // R_MIPS_LO16 expression has R_MIPS_GOT_GP_PC type iif the target

lld/ELF/Relocations.h

enum RelExpr {
   R_TLSGD_GOTPLT,
   R_TLSGD_PC,
   R_TLSIE_HINT,
   R_TLSLD_GOT,
   R_TLSLD_GOTPLT,
   R_TLSLD_GOT_OFF,
   R_TLSLD_HINT,
   R_TLSLD_PC,
+  R_TLS_GOT,
+  R_TLS_GOT_PC,
+  R_TLS_GOT_GOTPLT,
+  R_TLS_GOTOFF,
 
   // The following is abstract relocation types used for only one target.
   //
   // Even though RelExpr is intended to be a target-neutral representation
   // of a relocation type, there are some relocations whose semantics are
   // unique to a target. Such relocation are marked with R_<TARGET_NAME>.
   R_AARCH64_GOT_PAGE_PC,
   R_AARCH64_GOT_PAGE,

lld/ELF/Relocations.cpp

 // True if this expression is of the form Sym - X, where X is a position in the
 // file (PC, or GOT for example).
 static bool isRelExpr(RelExpr expr) {
   return oneof<R_PC, R_GOTREL, R_GOTPLTREL, R_MIPS_GOTREL, R_PPC64_CALL,
                R_PPC64_RELAX_TOC, R_AARCH64_PAGE_PC, R_RELAX_GOT_PC,
                R_RISCV_PC_INDIRECT, R_PPC64_RELAX_GOT_PC>(expr);
 }
 
-
 static RelExpr toPlt(RelExpr expr) {
   switch (expr) {
   case R_PPC64_CALL:
     return R_PPC64_CALL_PLT;
   case R_PC:
     return R_PLT_PC;
   case R_ABS:
     return R_PLT;

 //
 // If this function returns false, that means we need to emit a
 // dynamic relocation so that the relocation will be fixed at load-time.
 static bool isStaticLinkTimeConstant(RelExpr e, RelType type, const Symbol &sym,
                                      InputSectionBase &s, uint64_t relOff) {
   // These expressions always compute a constant
   if (oneof<R_GOTPLT, R_GOT_OFF, R_MIPS_GOT_LOCAL_PAGE, R_MIPS_GOTREL,
             R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_MIPS_GOT_GP_PC,
-            R_AARCH64_GOT_PAGE_PC, R_GOT_PC, R_GOTONLY_PC, R_GOTPLTONLY_PC,
-            R_PLT_PC, R_PLT_GOTPLT, R_PPC32_PLTREL, R_PPC64_CALL_PLT,
-            R_PPC64_RELAX_TOC, R_RISCV_ADD, R_AARCH64_GOT_PAGE>(e))
+            R_AARCH64_GOT_PAGE, R_AARCH64_GOT_PAGE_PC, R_GOT_PC, R_GOTONLY_PC,
+            R_GOTPLTONLY_PC, R_PLT_PC, R_PLT_GOTPLT, R_PPC32_PLTREL,
+            R_PPC64_CALL_PLT, R_PPC64_RELAX_TOC, R_RISCV_ADD>(e))
     return true;
 
   // These never do, except if the entire file is position dependent or if
   // only the low bits are used.
-  if (e == R_GOT || e == R_PLT)
+  if (e == R_GOT || e == R_PLT || e == R_TLS_GOT)
     return target->usesOnlyLowPageBits(type) || !config->isPic;
 
   if (sym.isPreemptible)
     return false;
   if (!config->isPic)
     return true;
 
   // The size of a non preemptible symbol is a constant.
if (oneof<R_AARCH64_TLSDESC_PAGE, R_TLSDESC, R_TLSDESC_CALL, R_TLSDESC_PC,
     } else {
       c.relocations.push_back(
           {target->adjustTlsExpr(type, R_RELAX_TLS_GD_TO_LE), type, offset,
            addend, &sym});
     }
     return target->getTlsGdRelaxSkip(type);
   }
 
-  if (oneof<R_GOT, R_GOTPLT, R_GOT_PC, R_AARCH64_GOT_PAGE_PC, R_GOT_OFF,
-            R_TLSIE_HINT>(expr)) {
+  if (oneof<R_TLS_GOT, R_TLS_GOT_GOTPLT, R_TLS_GOT_PC, R_AARCH64_GOT_PAGE_PC,
+            R_TLS_GOTOFF, R_TLSIE_HINT>(expr)) {
     // Initial-Exec relocs can be relaxed to Local-Exec if the symbol is locally
     // defined.
     if (toExecRelax && isLocalInExecutable) {
       c.relocations.push_back(
           {R_RELAX_TLS_IE_TO_LE, type, offset, addend, &sym});
     } else if (expr != R_TLSIE_HINT) {
       if (!sym.isInGot())
         addTpOffsetGotEntry(sym);
-      // R_GOT needs a relative relocation for PIC on i386 and Hexagon.
-      if (expr == R_GOT && config->isPic && !target->usesOnlyLowPageBits(type))
+      // R_TLS_GOT needs a relative relocation for PIC on i386 and Hexagon.
+      if (expr == R_TLS_GOT && config->isPic &&
+          !target->usesOnlyLowPageBits(type))
         addRelativeReloc(&c, offset, sym, addend, expr, type);
       else
         c.relocations.push_back({expr, type, offset, addend, &sym});
     }
     return 1;
   }
 
   return 0;
if (!sym.isPreemptible && (!sym.isGnuIFunc() || config->zIfuncNoplt)) {
     }
   }
 
   // If the relocation does not emit a GOT or GOTPLT entry but its computation
   // uses their addresses, we need GOT or GOTPLT to be created.
   //
   // The 5 types that relative GOTPLT are all x86 and x86-64 specific.
   if (oneof<R_GOTPLTONLY_PC, R_GOTPLTREL, R_GOTPLT, R_PLT_GOTPLT,
-            R_TLSDESC_GOTPLT, R_TLSGD_GOTPLT>(expr)) {
+            R_TLSDESC_GOTPLT, R_TLSGD_GOTPLT, R_TLS_GOT_GOTPLT>(expr)) {
     in.gotPlt->hasGotPltOffRel = true;
   } else if (oneof<R_GOTONLY_PC, R_GOTREL, R_PPC64_TOCBASE, R_PPC64_RELAX_TOC>(
                  expr)) {
     in.got->hasGotOffRel = true;
   }
 
   // Process TLS relocations, including relaxing TLS relocations. Note that
   // R_TPREL and R_TPREL_NEG relocations are resolved in processRelocAux.

lld/ELF/SyntheticSections.cpp

 }
 
 void RelocationBaseSection::addRelativeReloc(
     RelType dynType, InputSectionBase *inputSec, uint64_t offsetInSec,
     Symbol &sym, int64_t addend, RelType addendRelType, RelExpr expr) {
   // This function should only be called for non-preemptible symbols or
   // RelExpr values that refer to an address inside the output file (e.g. the
   // address of the GOT entry for a potentially preemptible symbol).
-  assert((!sym.isPreemptible || expr == R_GOT) &&
+  assert((!sym.isPreemptible || expr == R_GOT || expr == R_TLS_GOT) &&
          "cannot add relative relocation against preemptible symbol");
   assert(expr != R_ADDEND && "expected non-addend relocation expression");
   addReloc(DynamicReloc::AddendOnlyWithTargetVA, dynType, inputSec, offsetInSec,
            sym, addend, expr, addendRelType);
 }
 
 void RelocationBaseSection::addAddendOnlyRelocIfNonPreemptible(
     RelType dynType, InputSectionBase *isec, uint64_t offsetInSec, Symbol &sym,