[SystemZ] Support __builtin_thread_pointer.

[• koriakin]

This serves two purposes:

• __builtin_thread_pointer can be used from clang
• llvm.s390.thread.pointer can be used in IR, allowing us to implement proper stack protector support (aiming at TLS instead of __stack_chk_guard)

[uweigand]

I think this looks good as far as it goes (see minor coding style comments inline). However:

• I don't think this in itself will make __builtin_thread_pointer work in clang, there need to be additional changes to clang (at least adding the builtin to include/clang/Basic/BuiltinsSystemZ.def, providing some test cases). Are you planning on contributing a clang patch as well?

• It's a bit weird to define __builtin_thread_pointer as platform-specific intrinsic (on GCC it's a common intrinsic). But I see that ARM/AArch64 already have __builtin_thread_pointer as platform-specific intrinsic as well, so that may be precendent ... It would probably still be good to ask for feedback from the wider LLVM community how this should be handled.

include/llvm/IR/IntrinsicsSystemZ.td

20 ↗

(On Diff #53535)

Please move this further down after all the class/multiclass definitions, maybe into a new section "Miscellaneous intrinsics".

lib/Target/SystemZ/SystemZISelLowering.cpp

3409

For consistency with the coding style later on, please just do

return lowerThreadPointer(SDLoc(Op), DAG);

[• koriakin]

Yes, I'm preparing a clang patch as well.

As for making this target-independent: sounds like a good idea (I have a similiar patch for ppc in queue), but aarch64 already has it as target-specific - removing it would be a backwards compatibility break, right?

[uweigand]

In D19054#399661, @koriakin wrote:

Yes, I'm preparing a clang patch as well.

Very good, thanks.

As for making this target-independent: sounds like a good idea (I have a similiar patch for ppc in queue), but aarch64 already has it as target-specific - removing it would be a backwards compatibility break, right?

Well, we'd probably have to continue to accept the aarch64 LLVM IR intrinsic in the back-end to avoid breaking compatibility. But that would still allow for adding a new target-independent LLVM IR intrinsic, and using that in clang common code to implement __builtin_thread_pointer for all platforms ...

[• koriakin]

This version depends on D19098. I'll wait a bit with the clang patch, since I have thread pointer support patches lined up for a new more targets - let's add them all in one go.

[uweigand]

LGTM once the dependencies are in.

lib/Target/SystemZ/SystemZISelLowering.h

private:
   SDValue lowerSETCC(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerBR_CC(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerGlobalAddress(GlobalAddressSDNode *Node,
                              SelectionDAG &DAG) const;
   SDValue lowerTLSGetOffset(GlobalAddressSDNode *Node,
                             SelectionDAG &DAG, unsigned Opcode,
                             SDValue GOTOffset) const;
+  SDValue lowerThreadPointer(const SDLoc &DL, SelectionDAG &DAG) const;
   SDValue lowerGlobalTLSAddress(GlobalAddressSDNode *Node,
                                 SelectionDAG &DAG) const;
   SDValue lowerBlockAddress(BlockAddressSDNode *Node,
                             SelectionDAG &DAG) const;
   SDValue lowerJumpTable(JumpTableSDNode *JT, SelectionDAG &DAG) const;
   SDValue lowerConstantPool(ConstantPoolSDNode *CP, SelectionDAG &DAG) const;
   SDValue lowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;

lib/Target/SystemZ/SystemZISelLowering.cpp

SDValue SystemZTargetLowering::lowerTLSGetOffset(GlobalAddressSDNode *Node,
   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
   Chain = DAG.getNode(Opcode, DL, NodeTys, Ops);
   Glue = Chain.getValue(1);
 
   // Copy the return value from %r2.
   return DAG.getCopyFromReg(Chain, DL, SystemZ::R2D, PtrVT, Glue);
 }
 
-SDValue SystemZTargetLowering::lowerGlobalTLSAddress(GlobalAddressSDNode *Node,
-                                                     SelectionDAG &DAG) const {
-  if (DAG.getTarget().Options.EmulatedTLS)
-    return LowerToTLSEmulatedModel(Node, DAG);
-  SDLoc DL(Node);
-  const GlobalValue *GV = Node->getGlobal();
+SDValue SystemZTargetLowering::lowerThreadPointer(const SDLoc &DL,
   EVT PtrVT = getPointerTy(DAG.getDataLayout());
-  TLSModel::Model model = DAG.getTarget().getTLSModel(GV);
 
   // The high part of the thread pointer is in access register 0.
   SDValue TPHi = DAG.getNode(SystemZISD::EXTRACT_ACCESS, DL, MVT::i32,
                              DAG.getConstant(0, DL, MVT::i32));
   TPHi = DAG.getNode(ISD::ANY_EXTEND, DL, PtrVT, TPHi);
 
   // The low part of the thread pointer is in access register 1.
   SDValue TPLo = DAG.getNode(SystemZISD::EXTRACT_ACCESS, DL, MVT::i32,
                              DAG.getConstant(1, DL, MVT::i32));
   TPLo = DAG.getNode(ISD::ZERO_EXTEND, DL, PtrVT, TPLo);
 
   // Merge them into a single 64-bit address.
   SDValue TPHiShifted = DAG.getNode(ISD::SHL, DL, PtrVT, TPHi,
                                     DAG.getConstant(32, DL, PtrVT));
-  SDValue TP = DAG.getNode(ISD::OR, DL, PtrVT, TPHiShifted, TPLo);
+  return DAG.getNode(ISD::OR, DL, PtrVT, TPHiShifted, TPLo);
+}
+
+SDValue SystemZTargetLowering::lowerGlobalTLSAddress(GlobalAddressSDNode *Node,
+                                                     SelectionDAG &DAG) const {
+  if (DAG.getTarget().Options.EmulatedTLS)
+    return LowerToTLSEmulatedModel(Node, DAG);
+  SDLoc DL(Node);
+  const GlobalValue *GV = Node->getGlobal();
+  EVT PtrVT = getPointerTy(DAG.getDataLayout());
+  TLSModel::Model model = DAG.getTarget().getTLSModel(GV);
+
+  SDValue TP = lowerThreadPointer(DL, DAG);
 
   // Get the offset of GA from the thread pointer, based on the TLS model.
   SDValue Offset;
   switch (model) {
     case TLSModel::GeneralDynamic: {
       // Load the GOT offset of the tls_index (module ID / per-symbol offset).
       SystemZConstantPoolValue *CPV =
         SystemZConstantPoolValue::Create(GV, SystemZCP::TLSGD);
if (Op->getNumValues() == 1)
       return CC;
     assert(Op->getNumValues() == 2 && "Expected a CC and non-CC result");
     return DAG.getNode(ISD::MERGE_VALUES, SDLoc(Op), Op->getVTList(), Glued,
                        CC);
   }
 
   unsigned Id = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
   switch (Id) {
+  case Intrinsic::thread_pointer:
+    return lowerThreadPointer(SDLoc(Op), DAG);
+
   case Intrinsic::s390_vpdi:
     return DAG.getNode(SystemZISD::PERMUTE_DWORDS, SDLoc(Op), Op.getValueType(),
                        Op.getOperand(1), Op.getOperand(2), Op.getOperand(3));
 
   case Intrinsic::s390_vperm:
     return DAG.getNode(SystemZISD::PERMUTE, SDLoc(Op), Op.getValueType(),
                        Op.getOperand(1), Op.getOperand(2), Op.getOperand(3));
 
   case Intrinsic::s390_vuphb:

test/CodeGen/SystemZ/builtins.ll

+; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
+
+; Function Attrs: nounwind readnone
+declare i8* @llvm.thread.pointer() #1
+
+define i8* @thread_pointer() {
+; CHECK: thread_pointer:
+; CHECK: ear [[REG1:%r[0-5]]], %a0
+; CHECK: sllg %r2, [[REG1]], 32
+; CHECK: ear %r2, %a1
+; CHECK: br %r14
+  %1 = tail call i8* @llvm.thread.pointer()
+  ret i8* %1
+}