[SystemZ] Implement llvm.get.dynamic.area.offset

[• koriakin]

Summary

To be used for AddressSanitizer.

[uweigand]

LGTM.

lib/Target/SystemZ/SystemZISelDAGToDAG.cpp

bool SystemZDAGToDAGISel::selectAddress(SDValue Addr,
   // then try to extend it as much as we can.
   AM.Base = Addr;
 
   // First try treating the address as a constant.
   if (Addr.getOpcode() == ISD::Constant &&
       expandDisp(AM, true, SDValue(),
                  cast<ConstantSDNode>(Addr)->getSExtValue()))
     ;
+  // Also see if it's a bare ADJDYNALLOC.
+  else if (Addr.getOpcode() == SystemZISD::ADJDYNALLOC &&
+           expandAdjDynAlloc(AM, true, SDValue()))
+    ;
   else
     // Otherwise try expanding each component.
     while (expandAddress(AM, true) ||
            (AM.Index.getNode() && expandAddress(AM, false)))
       continue;
 
   // Reject cases where it isn't profitable to use LA(Y).
   if (AM.Form == SystemZAddressingMode::FormBDXLA &&

lib/Target/SystemZ/SystemZISelLowering.h

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;
   SDValue lowerVASTART(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerVACOPY(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const;
+  SDValue lowerGET_DYNAMIC_AREA_OFFSET(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerSMUL_LOHI(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerUMUL_LOHI(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerSDIVREM(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerUDIVREM(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerBITCAST(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerOR(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerCTPOP(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerATOMIC_FENCE(SDValue Op, SelectionDAG &DAG) const;

lib/Target/SystemZ/SystemZISelLowering.cpp

SystemZTargetLowering::SystemZTargetLowering(const TargetMachine &TM,
   setOperationAction(ISD::GlobalAddress,    PtrVT, Custom);
   setOperationAction(ISD::GlobalTLSAddress, PtrVT, Custom);
   setOperationAction(ISD::BlockAddress,     PtrVT, Custom);
   setOperationAction(ISD::JumpTable,        PtrVT, Custom);
 
   // We need to handle dynamic allocations specially because of the
   // 160-byte area at the bottom of the stack.
   setOperationAction(ISD::DYNAMIC_STACKALLOC, PtrVT, Custom);
+  setOperationAction(ISD::GET_DYNAMIC_AREA_OFFSET, PtrVT, Custom);
 
   // Use custom expanders so that we can force the function to use
   // a frame pointer.
   setOperationAction(ISD::STACKSAVE,    MVT::Other, Custom);
   setOperationAction(ISD::STACKRESTORE, MVT::Other, Custom);
 
   // Handle prefetches with PFD or PFDRL.
   setOperationAction(ISD::PREFETCH, MVT::Other, Custom);
Result =
       DAG.getNode(ISD::AND, DL, MVT::i64, Result,
                   DAG.getConstant(~(RequiredAlign - 1), DL, MVT::i64));
   }
 
   SDValue Ops[2] = { Result, Chain };
   return DAG.getMergeValues(Ops, DL);
 }
 
+SDValue SystemZTargetLowering::lowerGET_DYNAMIC_AREA_OFFSET(
+    SDValue Op, SelectionDAG &DAG) const {
+  SDLoc DL(Op);
+
+  return DAG.getNode(SystemZISD::ADJDYNALLOC, DL, MVT::i64);
+}
+
 SDValue SystemZTargetLowering::lowerSMUL_LOHI(SDValue Op,
                                               SelectionDAG &DAG) const {
   EVT VT = Op.getValueType();
   SDLoc DL(Op);
   SDValue Ops[2];
   if (is32Bit(VT))
     // Just do a normal 64-bit multiplication and extract the results.
     // We define this so that it can be used for constant division.
SDValue SystemZTargetLowering::LowerOperation(SDValue Op,
   case ISD::BITCAST:
     return lowerBITCAST(Op, DAG);
   case ISD::VASTART:
     return lowerVASTART(Op, DAG);
   case ISD::VACOPY:
     return lowerVACOPY(Op, DAG);
   case ISD::DYNAMIC_STACKALLOC:
     return lowerDYNAMIC_STACKALLOC(Op, DAG);
+  case ISD::GET_DYNAMIC_AREA_OFFSET:
+    return lowerGET_DYNAMIC_AREA_OFFSET(Op, DAG);
   case ISD::SMUL_LOHI:
     return lowerSMUL_LOHI(Op, DAG);
   case ISD::UMUL_LOHI:
     return lowerUMUL_LOHI(Op, DAG);
   case ISD::SDIVREM:
     return lowerSDIVREM(Op, DAG);
   case ISD::UDIVREM:
     return lowerUDIVREM(Op, DAG);

test/CodeGen/SystemZ/dyn-alloca-offset.ll

+; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
+
+declare i64 @llvm.get.dynamic.area.offset.i64()
+
+declare void @use(i64)
+
+define void @f1() {
+; CHECK-LABEL: f1
+; CHECK: la %r2, 160
+; CHECK: brasl %r14, use
+; CHECK: br %r14
+  %tmp = alloca i64, align 32
+  %dynamic_area_offset = call i64 @llvm.get.dynamic.area.offset.i64()
+  call void @use(i64 %dynamic_area_offset)
+  ret void
+}
+
+define void @f2(i64 %arg) {
+; CHECK-LABEL: f2
+; CHECK: la %r2, 160(%r2)
+; CHECK: brasl %r14, use
+; CHECK: br %r14
+  %tmp = alloca i64, align 32
+  %dynamic_area_offset = call i64 @llvm.get.dynamic.area.offset.i64()
+  %param = add i64 %dynamic_area_offset, %arg
+  call void @use(i64 %param)
+  ret void
+}
+
+declare void @eatsalot(i64, i64, i64, i64, i64, i64)
+
+define void @f3() {
+; CHECK-LABEL: f3
+; CHECK: la %r2, 168
+; CHECK: brasl %r14, use
+; CHECK: br %r14
+  %tmp = alloca i64, align 32
+  call void @eatsalot(i64 0, i64 0, i64 0, i64 0, i64 0, i64 0)
+  %dynamic_area_offset = call i64 @llvm.get.dynamic.area.offset.i64()
+  call void @use(i64 %dynamic_area_offset)
+  ret void
+}