[lld][ELF][SPARC] Support TLS IE relocations

[LemonBoy]

Summary

Implement the Initial-Executable model and its relaxation to the Local-Executable one.

[MaskRay]

lld/test/ELF/sparcv9-tls-ie.s

10

align the instructions

See the style of new tests.

33

Useful to check the addend 0x0

[LemonBoy]

Fix test formatting.
Force use of rela over rel, forgot to commit this change with the previous patch.

[MaskRay]

Looks great!

[jrtc27]

lld/ELF/Arch/SPARCV9.cpp

217

lld/ELF/Driver.cpp

929

This should probably be its own commit, it's unrelated to TLS.

lld/test/ELF/sparcv9-tls-ie.s

26

All directives are normally indented to the same level

[LemonBoy]

lld/ELF/Driver.cpp

929

This _is_ related to TLS as, without this change, the R_SPARC_TLS_TPOFF64 would end up in REL form and the resulting program be rejected by ld.so.

[LemonBoy]

Reserve 3 slots in the GOT, this detail was well-hidden in the documentation.
Address some stylistic nits.

[jrtc27]

lld/ELF/Driver.cpp

929

Why is R_SPARC_TLS_TPOFF64 special? Surely that's true of any dynamic relocation.

[LemonBoy]

lld/ELF/Driver.cpp

929

It's not special, it's only the first dynamic relocation that's covered by a test (for the SPARC target, that is). Splitting this patch into many interdependent pieces is going to be a pain, especially since I already have other patches rebased on top of this.

[LemonBoy]

I apparently misunderstood the description about reserved GOT entries.

[jrtc27]

lld/ELF/Driver.cpp

929

So this is a bug fix for the fact that LLD already emits ABI-violating binaries (e.g. just have static int x; static int *p = &x; and link that as a shared object, then you'll get an R_SPARC_RELATIVE as rel rather than rela). Hence why this should be decoupled. It's a trivial one-line patch to commit.

[LemonBoy]

Make this patch depend on D102985

lld/ELF/Arch/SPARCV9.cpp

 using namespace lld::elf;
 
 namespace {
 class SPARCV9 final : public TargetInfo {
 public:
   SPARCV9();
   RelExpr getRelExpr(RelType type, const Symbol &s,
                      const uint8_t *loc) const override;
+  void writeGotHeader(uint8_t *buf) const override;
   void writePlt(uint8_t *buf, const Symbol &sym,
                 uint64_t pltEntryAddr) const override;
   void relocate(uint8_t *loc, const Relocation &rel,
                 uint64_t val) const override;
+  void relaxTlsIeToLe(uint8_t *loc, const Relocation &,
+                      uint64_t val) const override;
 };
 } // namespace
 
 SPARCV9::SPARCV9() {
   copyRel = R_SPARC_COPY;
   gotRel = R_SPARC_GLOB_DAT;
   noneRel = R_SPARC_NONE;
   pltRel = R_SPARC_JMP_SLOT;
   relativeRel = R_SPARC_RELATIVE;
   symbolicRel = R_SPARC_64;
   pltEntrySize = 32;
   pltHeaderSize = 4 * pltEntrySize;
 
+  tlsGotRel = R_SPARC_TLS_TPOFF64;
+
   defaultCommonPageSize = 8192;
   defaultMaxPageSize = 0x100000;
   defaultImageBase = 0x100000;
+
+  // .got[0] = _DYNAMIC
+  // .got[1] = _dl_runtime_resolve
+  // .got[2] = link_map
+  gotBaseSymInGotPlt = false;
+  gotHeaderEntriesNum = 3;
+}
+
+void SPARCV9::writeGotHeader(uint8_t *buf) const {
+  write32(buf, mainPart->dynamic->getVA());
 }
 
 RelExpr SPARCV9::getRelExpr(RelType type, const Symbol &s,
                             const uint8_t *loc) const {
   switch (type) {
   case R_SPARC_32:
   case R_SPARC_UA32:
   case R_SPARC_64:
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_TPREL;
+  case R_SPARC_TLS_IE_HI22:
+  case R_SPARC_TLS_IE_LO10:
+  case R_SPARC_TLS_IE_LDX:
+  case R_SPARC_TLS_IE_ADD:
+    return R_GOT_OFF;
   default:
     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +
           ") against symbol " + toString(s));
     return R_NONE;
   }
 }
 
 void SPARCV9::relocate(uint8_t *loc, const Relocation &rel,
case R_SPARC_WPLT30:
     checkInt(loc, val, 32, rel);
     write32be(loc, (read32be(loc) & ~0x3fffffff) | ((val >> 2) & 0x3fffffff));
     break;
   case R_SPARC_22:
     // V-imm22
     checkUInt(loc, val, 22, rel);
     write32be(loc, (read32be(loc) & ~0x003fffff) | (val & 0x003fffff));
     break;
+  case R_SPARC_TLS_IE_HI22:
   case R_SPARC_GOT22:
   case R_SPARC_PC22:
   case R_SPARC_LM22:
     // T-imm22
     write32be(loc, (read32be(loc) & ~0x003fffff) | ((val >> 10) & 0x003fffff));
     break;
   case R_SPARC_HI22:
     // V-imm22
     checkUInt(loc, val >> 10, 22, rel);
     write32be(loc, (read32be(loc) & ~0x003fffff) | ((val >> 10) & 0x003fffff));
     break;
   case R_SPARC_WDISP19:
     // V-disp19
     checkInt(loc, val, 21, rel);
     write32be(loc, (read32be(loc) & ~0x0007ffff) | ((val >> 2) & 0x0007ffff));
     break;
   case R_SPARC_GOT10:
   case R_SPARC_PC10:
     // T-simm10
     write32be(loc, (read32be(loc) & ~0x000003ff) | (val & 0x000003ff));
     break;
+  case R_SPARC_TLS_IE_LO10:
   case R_SPARC_LO10:
     // T-simm13
     write32be(loc, (read32be(loc) & ~0x00001fff) | (val & 0x000003ff));
     break;
   case R_SPARC_64:
   case R_SPARC_UA64:
     // V-xword64
     write64be(loc, val);
void SPARCV9::relocate(uint8_t *loc, const Relocation &rel,
   case R_SPARC_TLS_LE_HIX22:
     // T-imm22
     write32be(loc, (read32be(loc) & ~0x003fffff) | ((~val >> 10) & 0x003fffff));
     break;
   case R_SPARC_TLS_LE_LOX10:
     // T-simm13
     write32be(loc, (read32be(loc) & ~0x00001fff) | (val & 0x000003ff) | 0x1C00);
     break;
+  case R_SPARC_TLS_IE_LDX:
+  case R_SPARC_TLS_IE_ADD:
+    break;
   default:
     llvm_unreachable("unknown relocation");
   }
 }
 
+void SPARCV9::relaxTlsIeToLe(uint8_t *loc, const Relocation &rel,
+                             uint64_t val) const {
+  switch (rel.type) {
+  case R_SPARC_TLS_IE_ADD:
+    return;
+  case R_SPARC_TLS_IE_LDX:
+    // call ldx [%r1 + %r2], %r3 -> nop
+    write32(loc, 0x01000000);
+    return;
+  case R_SPARC_TLS_IE_HI22:
+    relocateNoSym(loc, R_SPARC_TLS_LE_HIX22, val);
+    return;
+  case R_SPARC_TLS_IE_LO10:
+    // or %r1, %tie_lo10(sym), %r2 -> xor %r1, %tle_lox10(sym), %r2
+    write32be(loc, (read32be(loc) & ~0x01f80000) | 0x180000);
+    relocateNoSym(loc, R_SPARC_TLS_LE_LOX10, val);
+    return;
+  default:
+    llvm_unreachable("unsupported relocation for TLS IE to LE relaxation");
+  }
+}
+
 void SPARCV9::writePlt(uint8_t *buf, const Symbol & /*sym*/,
                        uint64_t pltEntryAddr) const {
   const uint8_t pltData[] = {
       0x03, 0x00, 0x00, 0x00, // sethi   (. - .PLT0), %g1
       0x30, 0x68, 0x00, 0x00, // ba,a    %xcc, .PLT1
       0x01, 0x00, 0x00, 0x00, // nop
       0x01, 0x00, 0x00, 0x00, // nop
       0x01, 0x00, 0x00, 0x00, // nop

lld/ELF/Driver.cpp

if (s == "rel")
       return false;
     if (s == "rela")
       return true;
   }
 
   // Otherwise use the psABI defined relocation entry format.
   uint16_t m = config->emachine;
   return m == EM_AARCH64 || m == EM_AMDGPU || m == EM_HEXAGON || m == EM_PPC ||
-         m == EM_PPC64 || m == EM_RISCV || m == EM_X86_64;
+         m == EM_PPC64 || m == EM_RISCV || m == EM_SPARCV9 || m == EM_X86_64;
 }
 
 static void parseClangOption(StringRef opt, const Twine &msg) {
   std::string err;
   raw_string_ostream os(err);
 
   const char *argv[] = {config->progName.data(), opt.data()};
   if (cl::ParseCommandLineOptions(2, argv, "", &os))

lld/test/ELF/sparcv9-tls-ie.s

+# REQUIRES: sparc
+# RUN: llvm-mc -filetype=obj -triple=sparcv9 %s -o %t.o
+# RUN: ld.lld %t.o -o %t
+# RUN: ld.lld -shared %t.o -o %t.so
+# RUN: llvm-readobj -r %t.so | FileCheck --check-prefix=RELOC %s
+# RUN: llvm-objdump -d --no-show-raw-insn %t.so | FileCheck %s
+# RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck --check-prefix=RELAX %s
+
+# CHECK:      sethi 0, %o0
+# CHECK-NEXT: or %o0, 24, %o0
+# CHECK-NEXT: ldx [%l7+%o0], %o0
+# CHECK-NEXT: add %g7, %o0, %o0
+
+# IE -> LE Relaxation
+
+# RELAX:      sethi 1, %o0
+# RELAX-NEXT: xor %o0, -2, %o0
+# RELAX-NEXT: nop
+# RELAX-NEXT: add %g7, %o0, %o0
+sethi %tie_hi22(a), %o0
+or %o0, %tie_lo10(a), %o0
+ldx [%l7 + %o0], %o0, %tie_ldx(a)
+add %g7, %o0, %o0, %tie_add(a)
+
+.section .tbss
+.globl a
+a:
+.zero 1024+2
+b:
+
+# RELOC: .rela.dyn {
+# RELOC-NEXT: R_SPARC_TLS_TPOFF64 a 0x0
+# RELOC-NEXT: }