[PPC64] Add TLS global dynamic to local exec relaxation

[syzaara]

Summary

This patch adds the target call back relaxTlsGdToLe to support TLS relaxation from global dynamic to local exec model.

[sfertile]

lld/ELF/Arch/PPC64.cpp

172

minor nit: Could use a ternary here instead of an if.

lld/ELF/Relocations.cpp

937–939

This comment should be updated to reflect that we are only skipping the non-tls hints since the tls hints need the following processing.

lld/ELF/Relocations.h

47

I think we are better off to call it R_TLSGD_HINT and add it with the other General dynamic relocation below.

[ruiu]

lld/ELF/Arch/PPC64.cpp

162

I found this comment a bit confusing. Does this mean the first instruction is one of

addis r3, r2, a@got@tlsgd@ha [R_PPC64_GOT_TLSGD16_HA]

addi r3, r3, a@got@tlsgd@l [R_PPC64_GOT_TLSGD16_LO]

bl __tls_get_addr(a@tlsgd) [R_PPC64_TLSGD]

followed by a nop? Or, do we expect the following four instructions?

addis r3, r2, a@got@tlsgd@ha [R_PPC64_GOT_TLSGD16_HA]
addi r3, r3, a@got@tlsgd@l [R_PPC64_GOT_TLSGD16_LO]
bl __tls_get_addr(a@tlsgd) [R_PPC64_TLSGD]
nop

[ruiu]

LGTM

lld/ELF/Arch/PPC64.cpp

187–188

I believe clang-format would vertically align these comments.

lld/ELF/Arch/PPC64.cpp

RelExpr getRelExpr(RelType Type, const Symbol &S,
                      const uint8_t *Loc) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
   void writeGotHeader(uint8_t *Buf) const override;
   bool needsThunk(RelExpr Expr, RelType Type, const InputFile *File,
                   uint64_t BranchAddr, const Symbol &S) const override;
+  void relaxTlsGdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
 };
 } // namespace
 
 // Relocation masks following the #lo(value), #hi(value), #ha(value),
 // #higher(value), #highera(value), #highest(value), and #highesta(value)
 // macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi
 // document.
 static uint16_t applyPPCLo(uint64_t V) { return V; }
uint32_t PPC64::calcEFlags() const {
   if (NonZeroFlag == 1) {
     error("PPC64 V1 ABI not supported");
     return 0;
   }
 
   return 2;
 }
 
+void PPC64::relaxTlsGdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const {
+  // Global-Dynamic relocations are in the form:
+  // addis r3, r2, a@got@tlsgd@ha [R_PPC64_GOT_TLSGD16_HA]
+  // addi r3, r3, a@got@tlsgd@l [R_PPC64_GOT_TLSGD16_LO]
+  // bl __tls_get_addr(a@tlsgd) [R_PPC64_TLSGD]
+  // nop
+  // And can be optimized to:
+  // nop
+  // addis r3, r13, a@tprel@ha [R_PPC64_TPREL16_HA]
+  // nop
+  // addi r3, r3, a@tprel@l [R_PPC64_TPREL16_LO]
+
+  unsigned Offset = (Config->EKind == ELF64BEKind) ? 2 : 0;
+
+  switch (Type) {
+  case R_PPC64_GOT_TLSGD16_HA: {
+    write32(Loc - Offset, 0x60000000); // nop
+    break;
+  }
+  case R_PPC64_GOT_TLSGD16_LO: {
+    write32(Loc - Offset, 0x3c6d0000); // addis r3, r13
+    relocateOne(Loc, R_PPC64_TPREL16_HA, Val);
+    break;
+  }
+  case R_PPC64_TLSGD: {
+    write32(Loc, 0x60000000); // nop
+    write32(Loc + 4, 0x38630000); // addi r3, r3
+    relocateOne(Loc + 4 + Offset, R_PPC64_TPREL16_LO, Val);
+    break;
+  }
+  default: {
+    llvm_unreachable("unsupported relocation for TLS GD to LE relaxation");
+  }
+  }
+}
+
 RelExpr PPC64::getRelExpr(RelType Type, const Symbol &S,
                           const uint8_t *Loc) const {
   switch (Type) {
   case R_PPC64_TOC16:
   case R_PPC64_TOC16_DS:
   case R_PPC64_TOC16_HA:
   case R_PPC64_TOC16_HI:
   case R_PPC64_TOC16_LO:
RelExpr PPC64::getRelExpr(RelType Type, const Symbol &S,
   case R_PPC64_DTPREL16_HIGHER:
   case R_PPC64_DTPREL16_HIGHERA:
   case R_PPC64_DTPREL16_HIGHEST:
   case R_PPC64_DTPREL16_HIGHESTA:
   case R_PPC64_DTPREL16_LO:
   case R_PPC64_DTPREL16_LO_DS:
     return R_ABS;
   case R_PPC64_TLSGD:
+    return R_TLSGD_HINT;
   case R_PPC64_TLSLD:
   case R_PPC64_TLS:
     return R_HINT;
   default:
     return R_ABS;
   }
 }
 

lld/ELF/InputSection.cpp

case R_GOT_OFF:
     return Sym.getGotOffset() + A;
   case R_GOT_PAGE_PC:
   case R_RELAX_TLS_GD_TO_IE_PAGE_PC:
     return getAArch64Page(Sym.getGotVA() + A) - getAArch64Page(P);
   case R_GOT_PC:
   case R_RELAX_TLS_GD_TO_IE:
     return Sym.getGotVA() + A - P;
   case R_HINT:
+  case R_TLSGD_HINT:
   case R_NONE:
   case R_TLSDESC_CALL:
     llvm_unreachable("cannot relocate hint relocs");
   case R_MIPS_GOTREL:
     return Sym.getVA(A) - InX::MipsGot->getGp(File);
   case R_MIPS_GOT_GP:
     return InX::MipsGot->getGp(File) + A;
   case R_MIPS_GOT_GP_PC: {
case R_RELAX_TLS_GD_TO_LE_NEG:
       break;
     case R_RELAX_TLS_GD_TO_IE:
     case R_RELAX_TLS_GD_TO_IE_ABS:
     case R_RELAX_TLS_GD_TO_IE_PAGE_PC:
     case R_RELAX_TLS_GD_TO_IE_END:
       Target->relaxTlsGdToIe(BufLoc, Type, TargetVA);
       break;
     case R_PPC_CALL:
+      //  If this is a call to __tls_get_addr, it may be part of a TLS
+      // sequence that has been relaxed and turned into a nop. In this
+      // case, we don't want to handle it as a call.
+      if (read32(BufLoc) == 0x60000000) // nop
+        break;
+
       // Patch a nop (0x60000000) to a ld.
       if (Rel.Sym->NeedsTocRestore) {
         if (BufLoc + 8 > BufEnd || read32(BufLoc + 4) != 0x60000000) {
           error(getErrorLocation(BufLoc) + "call lacks nop, can't restore toc");
           break;
         }
         write32(BufLoc + 4, 0xe8410018); // ld %r2, 24(%r1)
       }

lld/ELF/Relocations.h

enum RelExpr {
   R_GOTONLY_PC_FROM_END,
   R_GOTREL,
   R_GOTREL_FROM_END,
   R_GOT_FROM_END,
   R_GOT_OFF,
   R_GOT_PAGE_PC,
   R_GOT_PC,
   R_HINT,
   R_MIPS_GOTREL,
   R_MIPS_GOT_GP,
   R_MIPS_GOT_GP_PC,
   R_MIPS_GOT_LOCAL_PAGE,
   R_MIPS_GOT_OFF,
   R_MIPS_GOT_OFF32,
   R_MIPS_TLSGD,
   R_MIPS_TLSLD,
   R_NEG_TLS,
enum RelExpr {
   R_RELAX_TLS_LD_TO_LE,
   R_SIZE,
   R_TLS,
   R_TLSDESC,
   R_TLSDESC_CALL,
   R_TLSDESC_PAGE,
   R_TLSGD_GOT,
   R_TLSGD_GOT_FROM_END,
+  R_TLSGD_HINT,
   R_TLSGD_PC,
   R_TLSLD_GOT_FROM_END,
   R_TLSLD_GOT,
   R_TLSLD_PC,
 };
 
 // Build a bitmask with one bit set for each RelExpr.
 //

lld/ELF/Relocations.cpp

handleTlsRelocation(RelType Type, Symbol &Sym, InputSectionBase &C,
   // Local-Dynamic relocs can be relaxed to Local-Exec.
   if (isRelExprOneOf<R_ABS, R_TLSLD_GOT_FROM_END, R_TLSLD_PC>(Expr) &&
       !Config->Shared) {
     C.Relocations.push_back({R_RELAX_TLS_LD_TO_LE, Type, Offset, Addend, &Sym});
     return 1;
   }
 
   if (isRelExprOneOf<R_TLSDESC, R_TLSDESC_PAGE, R_TLSDESC_CALL, R_TLSGD_GOT,
-                     R_TLSGD_GOT_FROM_END, R_TLSGD_PC>(Expr)) {
+                     R_TLSGD_GOT_FROM_END, R_TLSGD_PC, R_TLSGD_HINT>(Expr)) {
     if (Config->Shared) {
+      if (Expr == R_TLSGD_HINT)
+        return 1;
       if (InX::Got->addDynTlsEntry(Sym)) {
         uint64_t Off = InX::Got->getGlobalDynOffset(Sym);
         InX::RelaDyn->addReloc(Target->TlsModuleIndexRel, InX::Got, Off, &Sym);
 
         // If the symbol is preemptible we need the dynamic linker to write
         // the offset too.
         uint64_t OffsetOff = Off + Config->Wordsize;
         if (Sym.IsPreemptible)

 static bool isStaticLinkTimeConstant(RelExpr E, RelType Type, const Symbol &Sym,
                                      InputSectionBase &S, uint64_t RelOff) {
   // These expressions always compute a constant
   if (isRelExprOneOf<R_GOT_FROM_END, 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_MIPS_TLSGD, R_GOT_PAGE_PC, R_GOT_PC,
                      R_GOTONLY_PC, R_GOTONLY_PC_FROM_END, R_PLT_PC, R_TLSGD_GOT,
                      R_TLSGD_GOT_FROM_END, R_TLSGD_PC, R_PPC_CALL_PLT,
-                     R_TLSDESC_CALL, R_TLSDESC_PAGE, R_HINT>(E))
+                     R_TLSDESC_CALL, R_TLSDESC_PAGE, R_HINT, R_TLSGD_HINT>(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 || E == R_TLSDESC)
     return Target->usesOnlyLowPageBits(Type) || !Config->Pic;
 
   if (Sym.IsPreemptible)
static void scanReloc(InputSectionBase &Sec, OffsetGetter &GetOffset, RelTy *&I,
 
   // Skip if the target symbol is an erroneous undefined symbol.
   if (maybeReportUndefined(Sym, Sec, Rel.r_offset))
     return;
 
   const uint8_t *RelocatedAddr = Sec.Data.begin() + Rel.r_offset;
   RelExpr Expr = Target->getRelExpr(Type, Sym, RelocatedAddr);
 
   // Ignore "hint" relocations because they are only markers for relaxation.
+  // The TLS hint relocations are not ignored since they are required to be
+  // processed for relaxation.
   if (isRelExprOneOf<R_HINT, R_NONE>(Expr))
     return;
 
   // Strenghten or relax relocations.
   //
   // GNU ifunc symbols must be accessed via PLT because their addresses
   // are determined by runtime.
   //

lld/test/ELF/ppc64-tls-gd-le.s

+// REQUIRES: ppc
+
+// RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t.o
+// RUN: llvm-readelf -relocations --wide %t.o | FileCheck --check-prefix=InputRelocs %s
+// RUN: ld.lld  %t.o -o %t
+// RUN: llvm-objdump -D %t | FileCheck --check-prefix=Dis %s
+// RUN: llvm-readelf -relocations --wide %t | FileCheck --check-prefix=OutputRelocs %s
+
+// RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t.o
+// RUN: llvm-readelf -relocations --wide %t.o | FileCheck --check-prefix=InputRelocs %s
+// RUN: ld.lld  %t.o -o %t
+// RUN: llvm-objdump -D %t | FileCheck --check-prefix=Dis %s
+// RUN: llvm-readelf -relocations --wide %t | FileCheck --check-prefix=OutputRelocs %s
+
+  .text
+  .abiversion 2
+  .globl  _start                    # -- Begin function _start
+  .p2align  4
+  .type _start,@function
+_start:                                   # @_start
+.Lfunc_begin0:
+.Lfunc_gep0:
+  addis 2, 12, .TOC.-.Lfunc_gep0@ha
+  addi 2, 2, .TOC.-.Lfunc_gep0@l
+.Lfunc_lep0:
+  .localentry _start, .Lfunc_lep0-.Lfunc_gep0
+# %bb.0:                                # %entry
+  mflr 0
+  std 31, -8(1)
+  std 0, 16(1)
+  stdu 1, -64(1)
+  mr 31, 1
+  std 30, 48(31)                  # 8-byte Folded Spill
+  li 3, 0
+  stw 3, 44(31)
+  addis 3, 2, a@got@tlsgd@ha
+  addi 3, 3, a@got@tlsgd@l
+  bl __tls_get_addr(a@tlsgd)
+  nop
+  lwz 30, 0(3)
+  extsw 3, 30
+  ld 30, 48(31)                   # 8-byte Folded Reload
+  addi 1, 1, 64
+  ld 0, 16(1)
+  ld 31, -8(1)
+  mtlr 0
+  blr
+  .long 0
+  .quad 0
+.Lfunc_end0:
+  .size _start, .Lfunc_end0-.Lfunc_begin0
+
+.globl __tls_get_addr
+.type __tls_get_addr,@function
+__tls_get_addr:
+
+                                        # -- End function
+  .type a,@object               # @a
+  .section  .tdata,"awT",@progbits
+  .globl  a
+  .p2align  2
+a:
+  .long 55                      # 0x37
+  .size a, 4
+
+// Verify that the input has general-dynamic tls relocation types
+// InputRelocs:  Relocation section '.rela.text'
+// InputRelocs: R_PPC64_GOT_TLSGD16_HA  {{0+}}  a + 0
+// InputRelocs: R_PPC64_GOT_TLSGD16_LO  {{0+}}  a + 0
+// InputRelocs: R_PPC64_TLSGD           {{0+}}  a + 0
+
+// Verify that the general-dynamic sequence is  relaxed to local exec.
+// #ha(a@tprel) --> (0 - 0x7000 + 0x8000) >> 16 = 0
+// #lo(a@tprel)) --> (0 - 0x7000) &  0xFFFF =  -0x7000 = -28672
+// Dis: _start:
+// Dis: nop
+// Dis: addis 3, 13, 0
+// Dis: nop
+// Dis: addi 3, 3, -28672
+
+// Verify that no general-dynamic relocations exist for the dynamic linker.
+// OutputRelocs-NOT: R_PPC64_DTPMOD64
+// OutputRelocs-NOT: R_PPC64_DTPREL64