[ELF] Rename R_TLS to R_TPREL and R_NEG_TLS to R_TPREL_NEG. NFC

[MaskRay]

Summary

The scope of R_TLS (TP offset relocation types (TPREL/TPOFF) used for the
local-exec TLS model) is actually narrower than its name may imply. R_TLS_NEG
is only used by Solaris R_386_TLS_LE_32.

Rename them so that they will be less confusing.

[psmith]

No objections from me, looks like a sensible change.

Going to be on holiday till the end of the year so may be a bit slow to respond to reviews.

[rprichard]

I also think this is a good change.

Maybe R_TPREL_NEG, so it sorts next to R_TPREL in ELF/Relocations.h? We also have R_RELAX_TLS_GD_TO_LE[_NEG].

[MaskRay]

R_TPREL_NEG

[grimar]

Looks fine to me either.

lld/ELF/Arch/AArch64.cpp

RelExpr AArch64::getRelExpr(RelType type, const Symbol &s,
   case R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC:
   case R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC:
   case R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC:
   case R_AARCH64_TLSLE_MOVW_TPREL_G0:
   case R_AARCH64_TLSLE_MOVW_TPREL_G0_NC:
   case R_AARCH64_TLSLE_MOVW_TPREL_G1:
   case R_AARCH64_TLSLE_MOVW_TPREL_G1_NC:
   case R_AARCH64_TLSLE_MOVW_TPREL_G2:
-    return R_TLS;
+    return R_TPREL;
   case R_AARCH64_CALL26:
   case R_AARCH64_CONDBR19:
   case R_AARCH64_JUMP26:
   case R_AARCH64_TSTBR14:
   case R_AARCH64_PLT32:
     return R_PLT_PC;
   case R_AARCH64_PREL16:
   case R_AARCH64_PREL32:

lld/ELF/Arch/ARM.cpp

RelExpr ARM::getRelExpr(RelType type, const Symbol &s,
   case R_ARM_MOVT_BREL:
   case R_ARM_THM_MOVW_BREL_NC:
   case R_ARM_THM_MOVW_BREL:
   case R_ARM_THM_MOVT_BREL:
     return R_ARM_SBREL;
   case R_ARM_NONE:
     return R_NONE;
   case R_ARM_TLS_LE32:
-    return R_TLS;
+    return R_TPREL;
   case R_ARM_V4BX:
     // V4BX is just a marker to indicate there's a "bx rN" instruction at the
     // given address. It can be used to implement a special linker mode which
     // rewrites ARMv4T inputs to ARMv4. Since we support only ARMv4 input and
     // not ARMv4 output, we can just ignore it.
     return R_NONE;
   default:
     return R_ABS;

lld/ELF/Arch/Hexagon.cpp

case R_HEX_IE_GOT_LO16:
     config->hasStaticTlsModel = true;
     return R_GOTPLT;
   case R_HEX_TPREL_11_X:
   case R_HEX_TPREL_16:
   case R_HEX_TPREL_16_X:
   case R_HEX_TPREL_32_6_X:
   case R_HEX_TPREL_HI16:
   case R_HEX_TPREL_LO16:
-    return R_TLS;
+    return R_TPREL;
   default:
     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +
           ") against symbol " + toString(s));
     return R_NONE;
   }
 }
 
 static bool isDuplex(uint32_t insn) {

lld/ELF/Arch/Mips.cpp

RelExpr MIPS<ELFT>::getRelExpr(RelType type, const Symbol &s,
   case R_MICROMIPS_TLS_DTPREL_LO16:
     return R_ABS;
   case R_MIPS_TLS_TPREL_HI16:
   case R_MIPS_TLS_TPREL_LO16:
   case R_MIPS_TLS_TPREL32:
   case R_MIPS_TLS_TPREL64:
   case R_MICROMIPS_TLS_TPREL_HI16:
   case R_MICROMIPS_TLS_TPREL_LO16:
-    return R_TLS;
+    return R_TPREL;
   case R_MIPS_PC32:
   case R_MIPS_PC16:
   case R_MIPS_PC19_S2:
   case R_MIPS_PC21_S2:
   case R_MIPS_PC26_S2:
   case R_MIPS_PCHI16:
   case R_MIPS_PCLO16:
   case R_MICROMIPS_PC7_S1:

lld/ELF/Arch/PPC.cpp

RelExpr PPC::getRelExpr(RelType type, const Symbol &s,
   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:
   case R_PPC_TPREL16_LO:
   case R_PPC_TPREL16_HI:
-    return R_TLS;
+    return R_TPREL;
   default:
     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +
           ") against symbol " + toString(s));
     return R_NONE;
   }
 }
 
 RelType PPC::getDynRel(RelType type) const {

lld/ELF/Arch/PPC64.cpp

RelExpr PPC64::getRelExpr(RelType type, const Symbol &s,
   case R_PPC64_TPREL16_HI:
   case R_PPC64_TPREL16_DS:
   case R_PPC64_TPREL16_LO_DS:
   case R_PPC64_TPREL16_HIGHER:
   case R_PPC64_TPREL16_HIGHERA:
   case R_PPC64_TPREL16_HIGHEST:
   case R_PPC64_TPREL16_HIGHESTA:
   case R_PPC64_TPREL34:
-    return R_TLS;
+    return R_TPREL;
   case R_PPC64_DTPREL16:
   case R_PPC64_DTPREL16_DS:
   case R_PPC64_DTPREL16_HA:
   case R_PPC64_DTPREL16_HI:
   case R_PPC64_DTPREL16_HIGHER:
   case R_PPC64_DTPREL16_HIGHERA:
   case R_PPC64_DTPREL16_HIGHEST:
   case R_PPC64_DTPREL16_HIGHESTA:

lld/ELF/Arch/RISCV.cpp

RelExpr RISCV::getRelExpr(const RelType type, const Symbol &s,
   case R_RISCV_TLS_GD_HI20:
     return R_TLSGD_PC;
   case R_RISCV_TLS_GOT_HI20:
     config->hasStaticTlsModel = true;
     return R_GOT_PC;
   case R_RISCV_TPREL_HI20:
   case R_RISCV_TPREL_LO12_I:
   case R_RISCV_TPREL_LO12_S:
-    return R_TLS;
+    return R_TPREL;
   case R_RISCV_RELAX:
   case R_RISCV_TPREL_ADD:
     return R_NONE;
   case R_RISCV_ALIGN:
     // Not just a hint; always padded to the worst-case number of NOPs, so may
     // not currently be aligned, and without linker relaxation support we can't
     // delete NOPs to realign.
     errorOrWarn(getErrorLocation(loc) + "relocation R_RISCV_ALIGN requires "

lld/ELF/Arch/SPARCV9.cpp

RelExpr SPARCV9::getRelExpr(RelType type, const Symbol &s,
   case R_SPARC_GOT22:
     return R_GOT_OFF;
   case R_SPARC_WPLT30:
     return R_PLT_PC;
   case R_SPARC_NONE:
     return R_NONE;
   case R_SPARC_TLS_LE_HIX22:
   case R_SPARC_TLS_LE_LOX10:
-    return R_TLS;
+    return R_TPREL;
   default:
     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +
           ") against symbol " + toString(s));
     return R_NONE;
   }
 }
 
 void SPARCV9::relocate(uint8_t *loc, const Relocation &rel,

lld/ELF/Arch/X86.cpp

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_GOTIE:
     return R_GOTPLT;
   case R_386_GOTOFF:
     return R_GOTPLTREL;
   case R_386_TLS_LE:
-    return R_TLS;
+    return R_TPREL;
   case R_386_TLS_LE_32:
-    return R_NEG_TLS;
+    return R_NEG_TPREL;
   case R_386_NONE:
     return R_NONE;
   default:
     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +
           ") against symbol " + toString(s));
     return R_NONE;
   }
 }

lld/ELF/Arch/X86_64.cpp

RelExpr X86_64::getRelExpr(RelType type, const Symbol &s,
   case R_X86_64_32:
   case R_X86_64_32S:
   case R_X86_64_64:
     return R_ABS;
   case R_X86_64_DTPOFF32:
   case R_X86_64_DTPOFF64:
     return R_DTPREL;
   case R_X86_64_TPOFF32:
-    return R_TLS;
+    return R_TPREL;
   case R_X86_64_TLSDESC_CALL:
     return R_TLSDESC_CALL;
   case R_X86_64_TLSLD:
     return R_TLSLD_PC;
   case R_X86_64_TLSGD:
     return R_TLSGD_PC;
   case R_X86_64_SIZE32:
   case R_X86_64_SIZE64:

lld/ELF/InputSection.cpp

uint64_t InputSectionBase::getRelocTargetVA(const InputFile *file, RelType type,
   case R_PPC64_TOCBASE:
     return getPPC64TocBase() + a;
   case R_RELAX_GOT_PC:
   case R_PPC64_RELAX_GOT_PC:
     return sym.getVA(a) - p;
   case R_RELAX_TLS_GD_TO_LE:
   case R_RELAX_TLS_IE_TO_LE:
   case R_RELAX_TLS_LD_TO_LE:
-  case R_TLS:
+  case R_TPREL:
     // It is not very clear what to return if the symbol is undefined. With
     // --noinhibit-exec, even a non-weak undefined reference may reach here.
     // Just return A, which matches R_ABS, and the behavior of some dynamic
     // loaders.
     if (sym.isUndefined() || sym.isLazy())
       return a;
     return getTlsTpOffset(sym) + a;
   case R_RELAX_TLS_GD_TO_LE_NEG:
-  case R_NEG_TLS:
+  case R_NEG_TPREL:
     if (sym.isUndefined())
       return a;
     return -getTlsTpOffset(sym) + a;
   case R_SIZE:
     return sym.getSize() + a;
   case R_TLSDESC:
     return in.got->getGlobalDynAddr(sym) + a;
   case R_TLSDESC_PC:

lld/ELF/Relocations.h

enum RelExpr {
   R_GOT,
   R_GOT_OFF,
   R_GOT_PC,
   R_GOTONLY_PC,
   R_GOTPLTONLY_PC,
   R_GOTPLT,
   R_GOTPLTREL,
   R_GOTREL,
-  R_NEG_TLS,
+  R_NEG_TPREL,
   R_NONE,
   R_PC,
   R_PLT,
   R_PLT_PC,
   R_RELAX_GOT_PC,
   R_RELAX_GOT_PC_NOPIC,
   R_RELAX_TLS_GD_TO_IE,
   R_RELAX_TLS_GD_TO_IE_ABS,
   R_RELAX_TLS_GD_TO_IE_GOT_OFF,
   R_RELAX_TLS_GD_TO_IE_GOTPLT,
   R_RELAX_TLS_GD_TO_LE,
   R_RELAX_TLS_GD_TO_LE_NEG,
   R_RELAX_TLS_IE_TO_LE,
   R_RELAX_TLS_LD_TO_LE,
   R_RELAX_TLS_LD_TO_LE_ABS,
   R_SIZE,
-  R_TLS,
+  R_TPREL,
   R_TLSDESC,
   R_TLSDESC_CALL,
   R_TLSDESC_PC,
   R_TLSGD_GOT,
   R_TLSGD_GOTPLT,
   R_TLSGD_PC,
   R_TLSIE_HINT,
   R_TLSLD_GOT,

lld/ELF/Relocations.cpp

static void addPltEntry(PltSection *plt, GotPltSection *gotPlt,
   gotPlt->addEntry(sym);
   rel->addReloc(
       {type, gotPlt, sym.getGotPltOffset(), !sym.isPreemptible, &sym, 0});
 }
 
 static void addGotEntry(Symbol &sym) {
   in.got->addEntry(sym);
 
-  RelExpr expr = sym.isTls() ? R_TLS : R_ABS;
+  RelExpr expr = sym.isTls() ? R_TPREL : R_ABS;
   uint64_t off = sym.getGotOffset();
 
   // If a GOT slot value can be calculated at link-time, which is now,
   // we can just fill that out.
   //
   // (We don't actually write a value to a GOT slot right now, but we
   // add a static relocation to a Relocations vector so that
   // InputSection::relocate will do the work for us. We may be able