[VE] Support llvm.eh.sjlj.lsda

[kaz7]

Summary

In order to support SJLJ exception, implement llvm.eh.sjlj.lsda first.
Add regression test also.

[simoll]

llvm/lib/Target/VE/VEISelLowering.cpp

1541

I suppose you could re-use the type of Op here

1545

typo Creat

1557

style: else after return

[kaz7]

llvm/lib/Target/VE/VEISelLowering.cpp

1541

I'm not sure about it. Do you have any strategies to decide either Op.getValueType() or TLI.getPointerTy()? All other architectures use TLI.getPointerTy() to implement lsda. It's really difficult to decide it with certain reasons.

[kaz7]

Update following suggestions. Use TLI.getPoitnerTy() this time since
lsda expansion uses machine value type (MVT) instead of value type
structure (EVT) here. Using EVT may require some conversions later.

[simoll]

llvm/lib/Target/VE/VEISelLowering.cpp

1541

When isel calls LowerOperation, all types are MVTs because all EVTs have been legalized. Op.getValueType() should give you the exact same MVT as TLI.getPointerTy().
AFAIK only LowerOperationWrapper is where you have to be careful about operand EVTs but we are not using this in upstream (yet).

[kaz7]

Change to use Op.getSimpleValueType() as suggested.

[kaz7]

llvm/lib/Target/VE/VEISelLowering.cpp

1541

I don't understand the point of this. If you say re-using Op's type is better, I think it may be true. Then, I watch other architectures using TLI.getPointerTy a lot, I think following others may be better. Do you know why other architectures use TLI.getPoitnerTy so often? For historical reason or something? Anyway, I change it as you suggested.

[simoll]

llvm/lib/Target/VE/VEISelLowering.cpp

1541

Yeah, it really is more a bikeshedding discussion given how rarely this is called in practice.. the point of using Op.getValueType() is that it's non-virtual and the MVT object already exists. TLI.getPointerTy() is virtual and the default implementation constructs the MVT from scratch every time.

[kaz7]

llvm/lib/Target/VE/VEISelLowering.cpp

1541

virtual. That makes sense to not using it.

llvm/lib/Target/VE/VEISelLowering.h

public:
 
   SDValue lowerATOMIC_FENCE(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerATOMIC_SWAP(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
+  SDValue lowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerLOAD(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerSTORE(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerToTLSGeneralDynamicModel(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerVASTART(SDValue Op, SelectionDAG &DAG) const;
   SDValue lowerVAARG(SDValue Op, SelectionDAG &DAG) const;
 
   SDValue lowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;

llvm/lib/Target/VE/VEISelLowering.cpp

for (MVT VT : MVT::integer_valuetypes()) {
     setOperationAction(ISD::ATOMIC_LOAD_NAND, VT, Expand);
     setOperationAction(ISD::ATOMIC_LOAD_MIN, VT, Expand);
     setOperationAction(ISD::ATOMIC_LOAD_MAX, VT, Expand);
     setOperationAction(ISD::ATOMIC_LOAD_UMIN, VT, Expand);
     setOperationAction(ISD::ATOMIC_LOAD_UMAX, VT, Expand);
   }
 
   /// } Atomic isntructions
+
+  // Intrinsic instructions
+  setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
 }
 
 void VETargetLowering::initVPUActions() {
   for (MVT LegalVecVT : AllVectorVTs) {
     setOperationAction(ISD::BUILD_VECTOR, LegalVecVT, Custom);
     // Translate all vector instructions with legal element types to VVP_*
     // nodes.
     // TODO We will custom-widen into VVP_* nodes in the future. While we are
static SDValue lowerRETURNADDR(SDValue Op, SelectionDAG &DAG,
   SDLoc DL(Op);
   EVT VT = Op.getValueType();
   SDValue Offset = DAG.getConstant(8, DL, VT);
   return DAG.getLoad(VT, DL, DAG.getEntryNode(),
                      DAG.getNode(ISD::ADD, DL, VT, FrameAddr, Offset),
                      MachinePointerInfo());
 }
 
+SDValue VETargetLowering::lowerINTRINSIC_WO_CHAIN(SDValue Op,
+                                                  SelectionDAG &DAG) const {
+  SDLoc DL(Op);
+  unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
+  switch (IntNo) {
+  default: // Don't custom lower most intrinsics.
+    return SDValue();
+  case Intrinsic::eh_sjlj_lsda: {
+    MachineFunction &MF = DAG.getMachineFunction();
+    MVT VT = Op.getSimpleValueType();
+    const VETargetMachine *TM =
+        static_cast<const VETargetMachine *>(&DAG.getTarget());
+
+    // Create GCC_except_tableXX string.  The real symbol for that will be
+    // generated in EHStreamer::emitExceptionTable() later.  So, we just
+    // borrow it's name here.
+    TM->getStrList()->push_back(std::string(
+        (Twine("GCC_except_table") + Twine(MF.getFunctionNumber())).str()));
+    SDValue Addr =
+        DAG.getTargetExternalSymbol(TM->getStrList()->back().c_str(), VT, 0);
+    if (isPositionIndependent()) {
+      Addr = makeHiLoPair(Addr, VEMCExpr::VK_VE_GOTOFF_HI32,
+                          VEMCExpr::VK_VE_GOTOFF_LO32, DAG);
+      SDValue GlobalBase = DAG.getNode(VEISD::GLOBAL_BASE_REG, DL, VT);
+      return DAG.getNode(ISD::ADD, DL, VT, GlobalBase, Addr);
+    }
+    return makeHiLoPair(Addr, VEMCExpr::VK_VE_HI32, VEMCExpr::VK_VE_LO32, DAG);
+  }
+  }
+}
+
 static SDValue getSplatValue(SDNode *N) {
   if (auto *BuildVec = dyn_cast<BuildVectorSDNode>(N)) {
     return BuildVec->getSplatValue();
   }
   return SDValue();
 }
 
 SDValue VETargetLowering::lowerBUILD_VECTOR(SDValue Op,
SDValue VETargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
   case ISD::DYNAMIC_STACKALLOC:
     return lowerDYNAMIC_STACKALLOC(Op, DAG);
   case ISD::FRAMEADDR:
     return lowerFRAMEADDR(Op, DAG, *this, Subtarget);
   case ISD::GlobalAddress:
     return lowerGlobalAddress(Op, DAG);
   case ISD::GlobalTLSAddress:
     return lowerGlobalTLSAddress(Op, DAG);
+  case ISD::INTRINSIC_WO_CHAIN:
+    return lowerINTRINSIC_WO_CHAIN(Op, DAG);
   case ISD::JumpTable:
     return lowerJumpTable(Op, DAG);
   case ISD::LOAD:
     return lowerLOAD(Op, DAG);
   case ISD::RETURNADDR:
     return lowerRETURNADDR(Op, DAG, *this, Subtarget);
   case ISD::BUILD_VECTOR:
     return lowerBUILD_VECTOR(Op, DAG);

llvm/test/CodeGen/VE/Scalar/builtin_sjlj_lsda.ll

+; RUN: llc < %s -mtriple=ve -exception-model sjlj | FileCheck %s
+
+; Function Attrs: noinline nounwind optnone
+define i8* @test_lsda() {
+; CHECK-LABEL: test_lsda:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    lea %s0, GCC_except_table0@lo
+; CHECK-NEXT:    and %s0, %s0, (32)0
+; CHECK-NEXT:    lea.sl %s0, GCC_except_table0@hi(, %s0)
+; CHECK-NEXT:    b.l.t (, %s10)
+  %ret = call i8* @llvm.eh.sjlj.lsda()
+  ret i8* %ret
+}
+
+; Function Attrs: nounwind
+declare i8* @llvm.eh.sjlj.lsda()