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

[LemonBoy]

Summary

Implement the regular GD sequence and the two relaxation forms, to IE or LE.

[jrtc27]

lld/ELF/Arch/SPARCV9.cpp

240–245

R_SPARC_TLS_IE_HI22/LO10? This is wrong, but I guess this is a hack that kinda works because IE isn't actually implemented yet? Which probably should happen before landing GD support... LD is less clear, but also seemingly unimplemented, only basic LE.

255

Do you mean add %g7, %r2, %r3?

lld/ELF/Driver.cpp

929 ↗

(On Diff #346815)

Please keep this sorted

lld/ELF/Relocations.cpp

289–292

Should this be more like hexagonNeedsTLSSymbol/hexagonTLSSymbolUpdate and combined with it, which has similar weirdness?

296–297

Why would it need a GOT entry? SPARC doesn't even use a .got.plt, it synthesises the addresses directly in the PLT entries, but even on .got.plt architectures calls don't use the real GOT other than MIPS abicalls.

[LemonBoy]

lld/ELF/Arch/SPARCV9.cpp

240–245

I wouldn't call this a hack, as long as the relocation type matches it's fine to use R_SPARC_HI22 or R_SPARC_LO10 here.
I have a patch for LD, I'll send it once this is merged. I don't need IE at the moment but I'll eventually look into it.

255

Yes, it's a typo I carried over from Gold as that's the only reference for the relaxation sequences.

lld/ELF/Driver.cpp

929 ↗

(On Diff #346815)

Will do, I didn't notice they were sorted.

lld/ELF/Relocations.cpp

289–292

No, I find this approach much cleaner than the late patching done for Hexagon.
I also found that adding a PLT entry that late will fail to generate a PLT section if there was none in the input files.

296–297

Ah, good catch, that was a leftover from some previous experiments.

[LemonBoy]

Address review comments.

[jrtc27]

lld/ELF/Arch/SPARCV9.cpp

255

The reference is the original Ulrich Drepper ELF TLS spec https://www.akkadia.org/drepper/tls.pdf

lld/ELF/Relocations.cpp

289–292

Hm, it's a bit ugly. Maybe @MaskRay has ideas. Does that mean Hexagon is buggy, too?

[jrtc27]

lld/ELF/Arch/SPARCV9.cpp

240–245

It's a bit of an abuse. I don't think it should be committed in this form. You should at least add the IE cases needed to support GD->IE so you can use the right relocations here even if you're not adding full IE support, though full IE support should be pretty straightforward to add too other than the tedium of test writing.

[MaskRay]

Is IE supported now? I think the correct order is LE, IE, GD/LD.

lld/ELF/Arch/SPARCV9.cpp

229

If you just want to make sparcv9 work, you don't need to implement TLS optimizations.
It is additional complexity without many benefits.

lld/ELF/Relocations.cpp

294

Avoid assert if the !call_sym path is reachable. You can call fatal

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

2

Just use #. Avoid !

You can use riscv-tls-gd.s or ppc-tls-gd.s as an example.

For simplicity, you can test just -no-pie or -pie, instead of both.

6

If a shared object is used as an input in a subsequent link, you need --soname=whatever to fix the DT_SONAME, otherwise the DT_NEEDED string will be %t, which is varying on different machines. Grep soname= in this directory.

[MaskRay]

lld/ELF/Arch/SPARCV9.cpp

61

Can you check whether gotHeaderEntriesNum/gotPltHeaderEntriesNum should be changed?

[MaskRay]

lld/ELF/Relocations.cpp

293

tlsGetAddr

[LemonBoy]

In D102862#2772849, @MaskRay wrote:

Is IE supported now? I think the correct order is LE, IE, GD/LD.

D102908 implements IE & its relaxation, once that's merged I'll rebase this patch.
LD is on the roadmap as I need it to link programs against glibc.
There's also one more GOT relocation that's blocked on D102575, the LLD's side is quite simple.

lld/ELF/Arch/SPARCV9.cpp

61

AFAICS the systemv ABI doesn't reserve any GOT entry (and .got.plt is not used). The only "quirk", 4 reserved PLT entries, is already taken into account.

lld/ELF/Relocations.cpp

294

Both llvm-mc and GAS add a __tls_get_addr symbol, hence the use of assert.
I'll switch to fatal as that's perhaps more robust against malformed input.

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

2

Will do, I used ! as the other SPARC test cases were using it.

6

Does that matter here? I'm not checking any offset in the RELOC checks.

[LemonBoy]

Rebased on top of D102908.
Correct computation of relaxed tp-relative offset.
Turn add into or/xor during the relaxation.

lld/ELF/Arch/SPARCV9.cpp

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;
+  void relaxTlsGdToIe(uint8_t *loc, const Relocation &rel,
+                      uint64_t val) const override;
+  void relaxTlsGdToLe(uint8_t *loc, const Relocation &rel,
+                      uint64_t val) const override;
+  RelExpr adjustTlsExpr(RelType type, RelExpr expr) 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;
+  tlsModuleIndexRel = R_SPARC_TLS_DTPMOD64;
+  tlsOffsetRel = R_SPARC_TLS_DTPOFF64;
 
   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::adjustTlsExpr(RelType type, RelExpr expr) const {
+  if (expr == R_RELAX_TLS_GD_TO_IE)
+    return R_RELAX_TLS_GD_TO_IE_GOT_OFF;
+  return expr;
+}
+
 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_UA64:
   case R_SPARC_H44:
RelExpr SPARCV9::getRelExpr(RelType type, const Symbol &s,
   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;
+  case R_SPARC_TLS_GD_HI22:
+  case R_SPARC_TLS_GD_LO10:
+  case R_SPARC_TLS_GD_ADD:
+  case R_SPARC_TLS_GD_CALL:
+    return R_TLSGD_GOT;
   default:
     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +
           ") against symbol " + toString(s));
     return R_NONE;
   }
 }
 
 void SPARCV9::relocate(uint8_t *loc, const Relocation &rel,
                        uint64_t val) const {
   switch (rel.type) {
   case R_SPARC_32:
   case R_SPARC_UA32:
     // V-word32
     checkUInt(loc, val, 32, rel);
     write32be(loc, val);
     break;
   case R_SPARC_DISP32:
     // V-disp32
     checkInt(loc, val, 32, rel);
     write32be(loc, val);
     break;
+  case R_SPARC_TLS_GD_CALL:
   case R_SPARC_WDISP30:
   case R_SPARC_WPLT30:
     // V-disp30
     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_TLS_GD_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_TLS_GD_LO10:
   case R_SPARC_LO10:
     // T-simm13
     write32be(loc, (read32be(loc) & ~0x00001fff) | (val & 0x000003ff));
     break;
   case R_SPARC_64:
   case R_SPARC_UA64:
+  case R_SPARC_TLS_DTPOFF64:
     // V-xword64
     write64be(loc, val);
     break;
   case R_SPARC_HH22:
     // V-imm22
     checkUInt(loc, val >> 42, 22, rel);
     write32be(loc, (read32be(loc) & ~0x003fffff) | ((val >> 42) & 0x003fffff));
     break;
case R_SPARC_TLS_LE_HIX22:
     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;
+  case R_SPARC_TLS_GD_ADD:
+    break;
+  default:
+    error(getErrorLocation(loc) + "unknown relocation (" + Twine(rel.type) +
+          ") against symbol " + toString(*rel.sym));
+  }
+}
+
+void SPARCV9::relaxTlsGdToIe(uint8_t *loc, const Relocation &rel,
+                             uint64_t val) const {
+  switch (rel.type) {
+  case R_SPARC_TLS_GD_ADD:
+    // add %r1, %r2, %r3 -> ldx [ %r1 + %r2 ], %r3
+    write32be(loc, read32be(loc) | 0xc0580000);
+    break;
+  case R_SPARC_TLS_GD_CALL:
+    // call __tls_get_addr -> add %g7, %o0, %o0
+    write32(loc, 0x9001c008);
+    break;
+  case R_SPARC_TLS_GD_HI22:
+    relocateNoSym(loc, R_SPARC_TLS_IE_HI22, val);
+    return;
+  case R_SPARC_TLS_GD_LO10:
+    // add %r1, %tgd_lo10(sym), %r2 -> or %r1, %tie_lo10(sym), %r2
+    write32be(loc, (read32be(loc) & ~0x01f80000) | 0x100000);
+    relocateNoSym(loc, R_SPARC_TLS_IE_LO10, val);
+    return;
+  default:
+    llvm_unreachable("unsupported relocation for TLS GD to IE relaxation");
+  }
+}
+
+void SPARCV9::relaxTlsGdToLe(uint8_t *loc, const Relocation &rel,
+                             uint64_t val) const {
+  switch (rel.type) {
+  case R_SPARC_TLS_GD_ADD:
+    // add %r1, %r2, %r3 -> add %g7, %r2, %r3
+    write32be(loc, (read32be(loc) & ~0x0007c000) | 0x0001c000);
+    break;
+  case R_SPARC_TLS_GD_CALL:
+    // call __tls_get_addr -> nop
+    write32(loc, 0x01000000);
+    break;
+  case R_SPARC_TLS_GD_HI22:
+    relocateNoSym(loc, R_SPARC_TLS_LE_HIX22, val);
+    return;
+  case R_SPARC_TLS_GD_LO10:
+    // add %r1, %tgd_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("unknown relocation");
+    llvm_unreachable("unsupported relocation for TLS GD to IE relaxation");
   }
 }
 
 void SPARCV9::relaxTlsIeToLe(uint8_t *loc, const Relocation &rel,
                              uint64_t val) const {
   switch (rel.type) {
   case R_SPARC_TLS_IE_ADD:
     return;

lld/ELF/Relocations.cpp

static unsigned handleMipsTlsRelocation(RelType type, Symbol &sym,
   if (expr == R_MIPS_TLSGD) {
     in.mipsGot->addDynTlsEntry(*c.file, sym);
     c.relocations.push_back({expr, type, offset, addend, &sym});
     return 1;
   }
   return 0;
 }
 
+template <class PltSection, class GotPltSection>
+static void addPltEntry(PltSection *plt, GotPltSection *gotPlt,
+                        RelocationBaseSection *rel, RelType type, Symbol &sym) {
+  plt->addEntry(sym);
+  gotPlt->addEntry(sym);
+  rel->addReloc(
+      {type, gotPlt, sym.getGotPltOffset(), !sym.isPreemptible, &sym, 0});
+}
+
 // Notes about General Dynamic and Local Dynamic TLS models below. They may
 // require the generation of a pair of GOT entries that have associated dynamic
 // relocations. The pair of GOT entries created are of the form GOT[e0] Module
 // Index (Used to find pointer to TLS block at run-time) GOT[e1] Offset of
 // symbol in TLS block.
 //
 // Returns the number of relocations processed.
 template <class ELFT>
if (expr == R_TLSLD_GOT_OFF) {
     }
     c.relocations.push_back({expr, type, offset, addend, &sym});
     return 1;
   }
 
   if (oneof<R_AARCH64_TLSDESC_PAGE, R_TLSDESC, R_TLSDESC_CALL, R_TLSDESC_PC,
             R_TLSGD_GOT, R_TLSGD_GOTPLT, R_TLSGD_PC>(expr)) {
     if (!toExecRelax) {
+      if (config->emachine == EM_SPARCV9 &&
+          (type == R_SPARC_TLS_GD_CALL || type == R_SPARC_TLS_LDM_CALL)) {
+        // These relocations are applied on call instructions like
+        //   call __tls_get_addr, %rel(sym)
+        // If this relocation won't be relaxed we have to replace it with a
+        // PLT-relative one to __tls_get_addr.
+        Symbol *tlsGetAddr = symtab->find("__tls_get_addr");
+        if (!tlsGetAddr)
+          fatal("__tls_get_addr symbol is not defined");
+
+        if (!tlsGetAddr->isInPlt())
+          addPltEntry(in.plt, in.gotPlt, in.relaPlt, target->pltRel,
+                      *tlsGetAddr);
+
+        c.relocations.push_back({R_PLT_PC, type, offset, 0, tlsGetAddr});
+        return 1;
+      }
+
       if (in.got->addDynTlsEntry(sym)) {
         uint64_t off = in.got->getGlobalDynOffset(sym);
 
         if (isLocalInExecutable)
           // Write one to the GOT slot.
           in.got->relocations.push_back(
               {R_ADDEND, target->symbolicRel, off, 1, &sym});
         else
if (part.relrDyn && isec->alignment >= 2 && offsetInSec % 2 == 0) {
     isec->relocations.push_back({expr, type, offsetInSec, addend, sym});
     part.relrDyn->relocs.push_back({isec, offsetInSec});
     return;
   }
   part.relaDyn->addReloc(target->relativeRel, isec, offsetInSec, sym, addend,
                          expr, type);
 }
 
-template <class PltSection, class GotPltSection>
-static void addPltEntry(PltSection *plt, GotPltSection *gotPlt,
-                        RelocationBaseSection *rel, RelType type, Symbol &sym) {
-  plt->addEntry(sym);
-  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_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.
if (expr != R_GOT_PC) {
       if (config->emachine == EM_PPC && expr == R_PPC32_PLTREL)
         addend &= ~0x8000;
       // R_HEX_GD_PLT_B22_PCREL (call a@GDPLT) is transformed into
       // call __tls_get_addr even if the symbol is non-preemptible.
       if (!(config->emachine == EM_HEXAGON &&
            (type == R_HEX_GD_PLT_B22_PCREL ||
             type == R_HEX_GD_PLT_B22_PCREL_X ||
             type == R_HEX_GD_PLT_B32_PCREL_X)))
         expr = fromPlt(expr);
     } else if (!isAbsoluteValue(sym)) {
       expr = target->adjustGotPcExpr(type, addend, relocatedAddr);
     }
   }
 
   // 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.
   //

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

+# REQUIRES: sparc
+# RUN: echo '.tbss; .globl y; y: .word 0' > %t.s
+# RUN: llvm-mc -filetype=obj -triple=sparcv9 %s -o %t.o
+# RUN: llvm-mc -filetype=obj -triple=sparcv9 %t.s -o %tx.o
+# RUN: ld.lld %tx.o -shared -o %tx.so
+# RUN: ld.lld %t.o %tx.o -shared -o %t.so
+# RUN: ld.lld %t.o %tx.so -o %t1.o
+# 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 %t1.o | FileCheck --check-prefix=RELAX %s
+
+# Call __tls_get_addr
+
+# CHECK:      sethi 0, %o0
+# CHECK-NEXT: add %o0, 24, %o0
+# CHECK-NEXT: add %l7, %o0, %o0
+# CHECK-NEXT: call 1048732
+# CHECK-NEXT: nop
+# CHECK-NEXT: sethi 0, %o0
+# CHECK-NEXT: add %o0, 40, %o0
+# CHECK-NEXT: add %l7, %o0, %o0
+# CHECK-NEXT: call 1048712
+# CHECK-NEXT: nop
+
+# GD -> LE Relaxation
+
+# RELAX:      sethi 1, %o0
+# RELAX-NEXT: xor %o0, -2, %o0
+# RELAX-NEXT: add %g7, %o0, %o0
+# RELAX-NEXT: nop
+# RELAX-NEXT: nop
+
+# GD -> IE Relaxation
+
+# RELAX-NEXT: sethi 0, %o0
+# RELAX-NEXT: or %o0, 24, %o0
+# RELAX-NEXT: ldx [%l7+%o0], %o0
+# RELAX-NEXT: add %g7, %o0, %o0
+# RELAX-NEXT: nop
+
+sethi %tgd_hi22(x), %o0
+add   %o0, %tgd_lo10(x), %o0
+add   %l7, %o0, %o0, %tgd_add(x)
+call  __tls_get_addr, %tgd_call(x)
+nop
+
+sethi %tgd_hi22(y), %o0
+add   %o0, %tgd_lo10(y), %o0
+add   %l7, %o0, %o0, %tgd_add(y)
+call  __tls_get_addr, %tgd_call(y)
+nop
+
+.section .tbss
+.globl x
+x:
+.zero 1024+2
+z:
+
+# RELOC: .rela.dyn {
+# RELOC-NEXT: R_SPARC_TLS_DTPMOD64 x 0x0
+# RELOC-NEXT: R_SPARC_TLS_DTPOFF64 x 0x0
+# RELOC-NEXT: R_SPARC_TLS_DTPMOD64 y 0x0
+# RELOC-NEXT: R_SPARC_TLS_DTPOFF64 y 0x0
+# RELOC-NEXT: }
+# RELOC: .rela.plt {
+# RELOC-NEXT: R_SPARC_JMP_SLOT __tls_get_addr
+# RELOC-NEXT: }