[PowerPC][PCRelative] Thread Local Storage Support for Local Exec

[Conanap]

Summary

This patch is the initial support for the Local Exec Thread Local
Storage model to produce code sequence and relocations correct
to the ABI for the model when using PC relative memory operations.

[amyk]

llvm/lib/Target/PowerPC/PPCISelLowering.h

444

I think this might make more sense:

/// TLS_LOCAL_EXEC_MAT_ADDR = Materialize an address for TLS global address
/// when using local exec access models, and when prefixed instructions are
/// available. This is used with ADD_TLS to produce an add like PADDI.

llvm/test/CodeGen/PowerPC/pcrel-tls-local-exec.ll

10

nit: for the Local Exec TLS Model.

llvm/test/MC/PowerPC/pcrel-tls-local-exec-address-load-reloc.s

8

nit: with the address loaded.

[NeHuang]

llvm/test/MC/PowerPC/pcrel-tls-local-exec-address-load-reloc.s

7

nit x@TPREL

20

Please only keep the necessary assembly in the test and rename the function accordingly.

llvm/test/MC/PowerPC/pcrel-tls-local-exec-value-load-reloc.s

7

ditto

20

ditto

[kamaub]

Rebasing on most recent D81947 and addressing review comments:

• rebasing on the updated version of D81947
• updating test cases according to review comments
• updating comments in code
• updating llvm-readobj run lines to follow new interface

[stefanp]

Only minor nits form me.
LGTM.

llvm/test/CodeGen/PowerPC/pcrel-tls-local-exec.ll

6

I think you are missing -enable-ppc-pcrel-tls here and in the command above.

llvm/test/MC/PowerPC/pcrel-tls-local-exec-address-load-reloc.s

14

nit:
You can remove the comment: # @LocalExec

llvm/test/MC/PowerPC/pcrel-tls-local-exec-value-load-reloc.s

14

nit:
Similarly I think you can remove the comment # @LocalExecLoad.

[MaskRay]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFObjectWriter.cpp

424

Is this unreachable? If yes, assert may be better

llvm/test/CodeGen/PowerPC/pcrel-tls-local-exec.ll

7

Consider --no-show-raw-insn

[stefanp]

Also, please add a test where the offset is not zero.
So the assembly would be for example:

paddi 3, 13, x@TPREL+8, 0

Sorry to have approved it and then requested changes. :(

llvm/test/CodeGen/PowerPC/pcrel-tls-local-exec.ll

31

I just realized this issue this morning.
We can probably do better here.
Instead of:

paddi r3, r13, x@TPREL, 0
lwz r3, <OFFSET>(r3)

we can probably generate:

plwz r3, x@TPREL+<OFFSET>(r13)

Where <OFFSET> is just some value.

[stefanp]

llvm/test/CodeGen/PowerPC/pcrel-tls-local-exec.ll

31

After an internal discussion it has been decided that we can leave this improvement for another patch. At this point I would say that we should just extend the test case to include offsets but not implement the merging of those two instructions.

[kamaub]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFObjectWriter.cpp

424

This switch was originally commit in rGbd2068031121adf5a0e28d9306a1741d6f0bbd87 but was reverted by rGce1e4853b5a15d679bd662ac5777a2390daf0391 because of failures in Release+Asserts mode with an assert. So rG97470897c436a6a5d682fb8ab296d0bcdc6e32a4 committed it as an report_fatal_error() to resolve the problem. I am not sure that assert() won't cause a similar problem as llvm_unreable() since we replaced llvm_unreachable() with report_fatal_error() for similar reason to why they suggest using assert() with llvm_unreachable() in

https://llvm.org/docs/CodingStandards.html#assert-liberally:
This has a few issues, the main one being that some compilers might not understand the assertion, or warn about a missing return in builds where assertions are compiled out.

Today, we have something much better: llvm_unreachable:

I could be wrong though, should we still replace it with an assert? I think the answer to your question is yes, it was reachable.

[Conanap]

Taking over for the patch

[Conanap]

Added test case for non-zero offset, added a few flags to the RUN lines and removed some unecessary comments.

[Conanap]

Added an extra test case

[Conanap]

Added back the test files that were accidentally removed in prev diff

[stefanp]

This mostly LGTM.
From my perspective you can add no-show-raw-insn on commit.

llvm/test/CodeGen/PowerPC/pcrel-tls-local-exec.ll

7

I agree. Please use no-show-raw-insn!

66

Thank you for adding this test.
I think we should be able to do better here (as we can merge the offset from the add into the paddi) but I think that should be a separate patch.

[Conanap]

Added --no-show-raw-insn and updated test case accordingly

llvm/include/llvm/BinaryFormat/ELFRelocs/PowerPC64.def

 #undef R_PPC64_TPREL16_HIGH
 #undef R_PPC64_TPREL16_HIGHA
 #undef R_PPC64_DTPREL16_HIGH
 #undef R_PPC64_DTPREL16_HIGHA
 #undef R_PPC64_REL24_NOTOC
 #undef R_PPC64_PCREL_OPT
 #undef R_PPC64_PCREL34
 #undef R_PPC64_GOT_PCREL34
+#undef R_PPC64_TPREL34
 #undef R_PPC64_GOT_TLSGD_PCREL34
 #undef R_PPC64_GOT_TPREL_PCREL34
 #undef R_PPC64_IRELATIVE
 #undef R_PPC64_REL16
 #undef R_PPC64_REL16_LO
 #undef R_PPC64_REL16_HI
 #undef R_PPC64_REL16_HA
 

 ELF_RELOC(R_PPC64_TPREL16_HIGH,         112)
 ELF_RELOC(R_PPC64_TPREL16_HIGHA,        113)
 ELF_RELOC(R_PPC64_DTPREL16_HIGH,        114)
 ELF_RELOC(R_PPC64_DTPREL16_HIGHA,       115)
 ELF_RELOC(R_PPC64_REL24_NOTOC,          116)
 ELF_RELOC(R_PPC64_PCREL_OPT,            123)
 ELF_RELOC(R_PPC64_PCREL34,              132)
 ELF_RELOC(R_PPC64_GOT_PCREL34,          133)
+ELF_RELOC(R_PPC64_TPREL34,              146)
 ELF_RELOC(R_PPC64_GOT_TLSGD_PCREL34,    148)
 ELF_RELOC(R_PPC64_GOT_TPREL_PCREL34,    150)
 ELF_RELOC(R_PPC64_IRELATIVE,            248)
 ELF_RELOC(R_PPC64_REL16,                249)
 ELF_RELOC(R_PPC64_REL16_LO,             250)
 ELF_RELOC(R_PPC64_REL16_HI,             251)
 ELF_RELOC(R_PPC64_REL16_HA,             252)

llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFObjectWriter.cpp

case PPC::fixup_ppc_nofixup:
           Type = ELF::R_PPC_TLS;
         break;
       case MCSymbolRefExpr::VK_PPC_TLS_PCREL:
         Type = ELF::R_PPC64_TLS;
         break;
       }
       break;
     case PPC::fixup_ppc_imm34:
+      switch (Modifier) {
+      default:
         report_fatal_error("Unsupported Modifier for fixup_ppc_imm34.");
+      case MCSymbolRefExpr::VK_TPREL:
+        Type = ELF::R_PPC64_TPREL34;
+        break;
+      }
       break;
     case FK_Data_8:
       switch (Modifier) {
       default: llvm_unreachable("Unsupported Modifier");
       case MCSymbolRefExpr::VK_PPC_TOCBASE:
         Type = ELF::R_PPC64_TOC;
         break;
       case MCSymbolRefExpr::VK_None:

llvm/lib/Target/PowerPC/PPCISelDAGToDAG.cpp

 
 bool PPCDAGToDAGISel::tryTLSXFormLoad(LoadSDNode *LD) {
   SDValue Base = LD->getBasePtr();
   if (Base.getOpcode() != PPCISD::ADD_TLS)
     return false;
   SDValue Offset = LD->getOffset();
   if (!Offset.isUndef())
     return false;
+  if (Base.getOperand(1).getOpcode() == PPCISD::TLS_LOCAL_EXEC_MAT_ADDR)
+    return false;
 
   SDLoc dl(LD);
   EVT MemVT = LD->getMemoryVT();
   EVT RegVT = LD->getValueType(0);
   unsigned Opcode;
   switch (MemVT.getSimpleVT().SimpleTy) {
     default:
       return false;

llvm/lib/Target/PowerPC/PPCISelLowering.h

enum NodeType : unsigned {
     /// PLD.
     MAT_PCREL_ADDR,
 
     /// TLS_DYNAMIC_MAT_PCREL_ADDR = Materialize a PC Relative address for
     /// TLS global address when using dynamic access models. This can be done
     /// through an add like PADDI.
     TLS_DYNAMIC_MAT_PCREL_ADDR,
 
+    /// TLS_LOCAL_EXEC_MAT_ADDR = Materialize an address for TLS global address
+    /// when using local exec access models, and when prefixed instructions are
+    /// available. This is used with ADD_TLS to produce an add like PADDI.
+    TLS_LOCAL_EXEC_MAT_ADDR,
+
     // Constrained conversion from floating point to int
     STRICT_FCTIDZ = ISD::FIRST_TARGET_STRICTFP_OPCODE,
     STRICT_FCTIWZ,
     STRICT_FCTIDUZ,
     STRICT_FCTIWUZ,
 
     /// Constrained integer-to-floating-point conversion instructions.
     STRICT_FCFID,

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

const char *PPCTargetLowering::getTargetNodeName(unsigned Opcode) const {
   case PPCISD::BUILD_SPE64:     return "PPCISD::BUILD_SPE64";
   case PPCISD::EXTRACT_SPE:     return "PPCISD::EXTRACT_SPE";
   case PPCISD::EXTSWSLI:        return "PPCISD::EXTSWSLI";
   case PPCISD::LD_VSX_LH:       return "PPCISD::LD_VSX_LH";
   case PPCISD::FP_EXTEND_HALF:  return "PPCISD::FP_EXTEND_HALF";
   case PPCISD::MAT_PCREL_ADDR:  return "PPCISD::MAT_PCREL_ADDR";
   case PPCISD::TLS_DYNAMIC_MAT_PCREL_ADDR:
     return "PPCISD::TLS_DYNAMIC_MAT_PCREL_ADDR";
+  case PPCISD::TLS_LOCAL_EXEC_MAT_ADDR:
+    return "PPCISD::TLS_LOCAL_EXEC_MAT_ADDR";
   case PPCISD::LD_SPLAT:        return "PPCISD::LD_SPLAT";
   case PPCISD::FNMSUB:          return "PPCISD::FNMSUB";
   case PPCISD::STRICT_FADDRTZ:
     return "PPCISD::STRICT_FADDRTZ";
   case PPCISD::STRICT_FCTIDZ:
     return "PPCISD::STRICT_FCTIDZ";
   case PPCISD::STRICT_FCTIWZ:
     return "PPCISD::STRICT_FCTIWZ";
SDValue PPCTargetLowering::LowerGlobalTLSAddress(SDValue Op,
   bool is64bit = Subtarget.isPPC64();
   const Module *M = DAG.getMachineFunction().getFunction().getParent();
   PICLevel::Level picLevel = M->getPICLevel();
 
   const TargetMachine &TM = getTargetMachine();
   TLSModel::Model Model = TM.getTLSModel(GV);
 
   if (Model == TLSModel::LocalExec) {
+    if (Subtarget.isUsingPCRelativeCalls()) {
+      SDValue TLSReg = DAG.getRegister(PPC::X13, MVT::i64);
+      SDValue TGA = DAG.getTargetGlobalAddress(
+          GV, dl, PtrVT, 0, (PPCII::MO_PCREL_FLAG | PPCII::MO_TPREL_FLAG));
+      SDValue MatAddr =
+          DAG.getNode(PPCISD::TLS_LOCAL_EXEC_MAT_ADDR, dl, PtrVT, TGA);
+      return DAG.getNode(PPCISD::ADD_TLS, dl, PtrVT, TLSReg, MatAddr);
+    }
+
     SDValue TGAHi = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0,
                                                PPCII::MO_TPREL_HA);
     SDValue TGALo = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0,
                                                PPCII::MO_TPREL_LO);
     SDValue TLSReg = is64bit ? DAG.getRegister(PPC::X13, MVT::i64)
                              : DAG.getRegister(PPC::R2, MVT::i32);
 
     SDValue Hi = DAG.getNode(PPCISD::Hi, dl, PtrVT, TGAHi, TLSReg);

llvm/lib/Target/PowerPC/PPCInstrInfo.td

 def PPCdynalloc   : SDNode<"PPCISD::DYNALLOC", SDTDynOp, [SDNPHasChain]>;
 def PPCdynareaoffset   : SDNode<"PPCISD::DYNAREAOFFSET", SDTDynAreaOp, [SDNPHasChain]>;
 def PPCprobedalloca : SDNode<"PPCISD::PROBED_ALLOCA", SDTDynOp, [SDNPHasChain]>;
 
 // PC Relative Specific Nodes
 def PPCmatpcreladdr : SDNode<"PPCISD::MAT_PCREL_ADDR", SDTIntUnaryOp, []>;
 def PPCtlsdynamatpcreladdr : SDNode<"PPCISD::TLS_DYNAMIC_MAT_PCREL_ADDR",
                                     SDTIntUnaryOp, []>;
+def PPCtlslocalexecmataddr : SDNode<"PPCISD::TLS_LOCAL_EXEC_MAT_ADDR",
+                                    SDTIntUnaryOp, []>;
 
 //===----------------------------------------------------------------------===//
 // PowerPC specific transformation functions and pattern fragments.
 //
 
 // A floating point immediate that is not a positive zero and can be converted
 // to a single precision floating point non-denormal immediate without loss of
 // information.

llvm/lib/Target/PowerPC/PPCInstrPrefix.td

def : Pat<(PPCstore_scal_int_from_vsr
             (PSTXSDpc (COPY_TO_REGCLASS (XSCVQPUDZ f128:$src), VFRC), $dst, 0)>;
 
   // If the PPCmatpcreladdr node is not caught by any other pattern it should be
   // caught here and turned into a paddi instruction to materialize the address.
   def : Pat<(PPCmatpcreladdr pcreladdr:$addr), (PADDI8pc 0, $addr)>;
   // PPCtlsdynamatpcreladdr node is used for TLS dynamic models to materialize
   // tls global address with paddi instruction.
   def : Pat<(PPCtlsdynamatpcreladdr pcreladdr:$addr), (PADDI8pc 0, $addr)>;
+  // PPCtlslocalexecmataddr node is used for TLS local exec models to
+  // materialize tls global address with paddi instruction.
+  def : Pat<(PPCaddTls i64:$in, (PPCtlslocalexecmataddr tglobaltlsaddr:$addr)),
+            (PADDI8 $in, $addr)>;
 }
 
 let Predicates = [PrefixInstrs] in {
   def XXSPLTIW : 8RR_DForm_IMM32_XT6<32, 3, (outs vsrc:$XT),
                                      (ins i32imm:$IMM32),
                                      "xxspltiw $XT, $IMM32", IIC_VecGeneral,
                                      []>;
   def XXSPLTIDP : 8RR_DForm_IMM32_XT6<32, 2, (outs vsrc:$XT),

llvm/lib/Target/PowerPC/PPCMCInstLower.cpp

static MCOperand GetSymbolRef(const MachineOperand &MO, const MCSymbol *Symbol,
   }
 
   if (MO.getTargetFlags() == PPCII::MO_PLT)
     RefKind = MCSymbolRefExpr::VK_PLT;
   else if (MO.getTargetFlags() == PPCII::MO_PCREL_FLAG)
     RefKind = MCSymbolRefExpr::VK_PCREL;
   else if (MO.getTargetFlags() == (PPCII::MO_PCREL_FLAG | PPCII::MO_GOT_FLAG))
     RefKind = MCSymbolRefExpr::VK_PPC_GOT_PCREL;
+  else if (MO.getTargetFlags() == (PPCII::MO_PCREL_FLAG | PPCII::MO_TPREL_FLAG))
+    RefKind = MCSymbolRefExpr::VK_TPREL;
   else if (MO.getTargetFlags() == PPCII::MO_GOT_TLSGD_PCREL_FLAG)
     RefKind = MCSymbolRefExpr::VK_PPC_GOT_TLSGD_PCREL;
   else if (MO.getTargetFlags() == PPCII::MO_GOT_TPREL_PCREL_FLAG)
     RefKind = MCSymbolRefExpr::VK_PPC_GOT_TPREL_PCREL;
 
   const MachineInstr *MI = MO.getParent();
   const MachineFunction *MF = MI->getMF();
   const Module *M = MF->getFunction().getParent();

llvm/test/CodeGen/PowerPC/pcrel-tls-local-exec.ll

+; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
+; RUN:   -enable-ppc-pcrel-tls -mcpu=pwr10 -ppc-asm-full-reg-names \
+; RUN:   < %s | FileCheck %s --check-prefix=CHECK-S
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
+; RUN:   -enable-ppc-pcrel-tls -mcpu=pwr10 -ppc-asm-full-reg-names \
+; RUN:   --filetype=obj < %s | llvm-objdump --no-show-raw-insn --mcpu=pwr10 -dr - \
+; RUN:   | FileCheck %s --check-prefix=CHECK-O
+
+; These test cases are to ensure that when using pc relative memory operations
+; ABI correct code and relocations are produced for the Local Exec TLS Model.
+
+@x = thread_local global i32 0, align 4
+@y = thread_local global [5 x i32] [i32 0, i32 0, i32 0, i32 0, i32 0], align 4
+
+define i32* @LocalExecAddressLoad() {
+; CHECK-S-LABEL: LocalExecAddressLoad:
+; CHECK-S:       # %bb.0: # %entry
+; CHECK-S-NEXT:    paddi r3, r13, x@TPREL, 0
+; CHECK-S-NEXT:    blr
+; CHECK-O-LABEL: <LocalExecAddressLoad>:
+; CHECK-O:         0: paddi 3, 13, 0, 0
+; CHECK-O-NEXT:    0000000000000000:  R_PPC64_TPREL34 x
+; CHECK-O-NEXT:    8: blr
+entry:
+  ret i32* @x
+}
+
+define i32 @LocalExecValueLoad() {
+; CHECK-S-LABEL: LocalExecValueLoad:
+; CHECK-S:       # %bb.0: # %entry
+; CHECK-S-NEXT:    paddi r3, r13, x@TPREL, 0
+; CHECK-S-NEXT:    lwz r3, 0(r3)
+; CHECK-S-NEXT:    blr
+; CHECK-O-LABEL: <LocalExecValueLoad>:
+; CHECK-O:         20: paddi 3, 13, 0, 0
+; CHECK-O-NEXT:    0000000000000020:  R_PPC64_TPREL34 x
+; CHECK-O-NEXT:    28: lwz 3, 0(3)
+; CHECK-O-NEXT:    2c: blr
+entry:
+  %0 = load i32, i32* @x, align 4
+  ret i32 %0
+}
+
+define i32 @LocalExecValueLoadOffset() {
+; CHECK-S-LABEL: LocalExecValueLoadOffset:
+; CHECK-S:       # %bb.0: # %entry
+; CHECK-S-NEXT:    paddi r3, r13, y@TPREL, 0
+; CHECK-S-NEXT:    lwz r3, 12(r3)
+; CHECK-S-NEXT:    blr
+; CHECK-O-LABEL: <LocalExecValueLoadOffset>:
+; CHECK-O:         40: paddi 3, 13, 0, 0
+; CHECK-O-NEXT:    0000000000000040:  R_PPC64_TPREL34 y
+; CHECK-O-NEXT:    48: lwz 3, 12(3)
+; CHECK-O-NEXT:    4c: blr
+entry:
+  %0 = load i32, i32* getelementptr inbounds ([5 x i32], [5 x i32]* @y, i64 0, i64 3), align 4
+  ret i32 %0
+}
+
+
+define i32* @LocalExecValueLoadOffsetNoLoad() {
+; CHECK-S-LABEL: LocalExecValueLoadOffsetNoLoad:
+; CHECK-S:       # %bb.0: # %entry
+; CHECK-S-NEXT:    paddi r3, r13, y@TPREL, 0
+; CHECK-S-NEXT:    addi r3, r3, 12
+; CHECK-S-NEXT:    blr
+; CHECK-O-LABEL: <LocalExecValueLoadOffsetNoLoad>:
+; CHECK-O:         60: paddi 3, 13, 0, 0
+; CHECK-O-NEXT:    0000000000000060:  R_PPC64_TPREL34 y
+; CHECK-O-NEXT:    68: addi 3, 3, 12
+; CHECK-O-NEXT:    6c: blr
+entry:
+  ret i32* getelementptr inbounds ([5 x i32], [5 x i32]* @y, i64 0, i64 3)
+}

llvm/test/MC/PowerPC/pcrel-tls-local-exec-address-load-reloc.s

+# RUN: llvm-mc -triple=powerpc64le-unknown-unknown -filetype=obj %s 2>&1 | \
+# RUN: FileCheck %s -check-prefix=MC
+# RUN: llvm-mc -triple=powerpc64le-unknown-unknown -filetype=obj %s | \
+# RUN: llvm-readobj -r - | FileCheck %s -check-prefix=READOBJ
+
+# This test checks that on Power PC we can correctly convert x@TPREL
+# into R_PPC64_TPREL34 for local exec relocations with address loaded.
+
+# MC-NOT:    error: invalid variant
+
+# READOBJ:        0x0 R_PPC64_TPREL34 x 0x0
+
+LocalExec:
+  paddi 3, 13, x@TPREL, 0
+  blr

llvm/test/MC/PowerPC/pcrel-tls-local-exec-value-load-reloc.s

+# RUN: llvm-mc -triple=powerpc64le-unknown-unknown -filetype=obj %s 2>&1 | \
+# RUN: FileCheck %s -check-prefix=MC
+# RUN: llvm-mc -triple=powerpc64le-unknown-unknown -filetype=obj %s | \
+# RUN: llvm-readobj -r - | FileCheck %s -check-prefix=READOBJ
+
+# This test checks that on Power PC we can correctly convert x@TPREL
+# into R_PPC64_TPREL34 for local exec relocations with the value loaded.
+
+# MC-NOT:    error: invalid variant
+
+# READOBJ:        0x0 R_PPC64_TPREL34 x 0x0
+
+LocalExecLoad:
+  paddi 3, 13, x@TPREL, 0
+  lwz 3, 0(3)
+  blr