[VE] VECustomDAG builder class

[simoll]

Summary

VECustomDAG's functions simplify emitting VE custom ISD nodes. The class is just a stub now. We add more functions, in particular for the VP->VVP->VE lowering, to VECustomDAG as we build up vector isel.

[kaz7]

I have several quesions.

1. What is the purpose of this CustomDAG? What is the differences from SelectionDAG.getNode()?
2. Do we really need CustomDAG although all other architectures works well with SelectionDAG.
3. Is it possible to extend SelectionDAG for us and probablly other vector architectures?

[simoll]

In D116103#3206720, @kaz7 wrote:

I have several quesions.

1. What is the purpose of this CustomDAG? What is the differences from SelectionDAG.getNode()?

CustomDAG provides VE-specific functions for building and legalizing SDNodes.
In this patch, it's just a stub that fowards getNode/getConstant to the underlying DAG, which already needs less parameters.

2. Do we really need CustomDAG although all other architectures works well with SelectionDAG.

CustomDAG does not replace SelectionDAG. It wraps around it and provides convenience functions. In the future, there will also be functions for VE-specific SDNodes kinds (VVP_* and VEC_*).

3. Is it possible to extend SelectionDAG for us and probablly other vector architectures?

Yes. CustomDAG functions that were implemented in a VE-specific way in downstream could be generalized to be available for all VP-based backends. For example, VP_UREM expansion. Most functions in CustomDAG, however, are tailored to VE and have VE-specific lowering and architecture knowledge built in.

[kaz7]

Please apply clang-format suggestsions.

I'm still thinking to ask other professional who knows SelectionDAG to review these modifications, since I really don't know it enough to review it... But, it is limited for only VE, so it is possible to accept it... Isn't it possible to other professionals to review this?

[lebedev.ri]

Please follow the patterns that can be observed in other backends - how do they deal with this problem?
If nothing else, the name is wrong, it's a bit too generic.

[simoll]

In D116103#3207866, @lebedev.ri wrote:

Please follow the patterns that can be observed in other backends - how do they deal with this problem?

It's custom to have static functions in <Target>ISelLowering.cpp with the following pattern:

static SDValue get|splat|convert|createSTUFF(.. SDValue Op, SelectionDAG &DAG);

Grep for static SDValue in the targets isellowerings. This is any function that isn't directly called from LowerOperation.
We just put those functions in a class since all of them take a DAG and proceed to construct a DL from the SDValue that is lowered. I don't see how this pattern is much different from what the other backends are doing.

If nothing else, the name is wrong, it's a bit too generic.

Fair. Is VECustomDAG good?

[simoll]

In D116103#3207879, @simoll wrote:

In D116103#3207866, @lebedev.ri wrote:

Please follow the patterns that can be observed in other backends - how do they deal with this problem?

It's custom to have static functions in <Target>ISelLowering.cpp with the following pattern:

static SDValue get|splat|convert|createSTUFF(.. SDValue Op, SelectionDAG &DAG);

Grep for static SDValue in the targets isellowerings. This is any function that isn't directly called from LowerOperation.
We just put those functions in a class since all of them take a DAG and proceed to construct a DL from the SDValue that is lowered. I don't see how this pattern is much different from what the other backends are doing.

If nothing else, the name is wrong, it's a bit too generic.

Fair. Is VECustomDAG good?

Ping @lebedev.ri

[lebedev.ri]

In D116103#3230809, @simoll wrote:

In D116103#3207879, @simoll wrote:

In D116103#3207866, @lebedev.ri wrote:

Please follow the patterns that can be observed in other backends - how do they deal with this problem?

It's custom to have static functions in <Target>ISelLowering.cpp with the following pattern:

static SDValue get|splat|convert|createSTUFF(.. SDValue Op, SelectionDAG &DAG);

Grep for static SDValue in the targets isellowerings. This is any function that isn't directly called from LowerOperation.
We just put those functions in a class since all of them take a DAG and proceed to construct a DL from the SDValue that is lowered. I don't see how this pattern is much different from what the other backends are doing.

If nothing else, the name is wrong, it's a bit too generic.

Fair. Is VECustomDAG good?

Ping @lebedev.ri

I guess that's better than nothing, yes.

[simoll]

Rebased CustomDAG -> VECustomDAG

[kaz7]

Sorry for delay of reviewing. Please add little more explanation to a head file.

llvm/lib/Target/VE/VECustomDAG.h

10–11

How about explaining this like. It's much better to work to lower expectation from the name "CustomDAG".

This file defines the helper functions that VE uses to lower LLVM code into
a selection DAG.  For example, hiding SDLoc, and easy to use SDNodeFlags.

[simoll]

Changing header comment as suggested / rebased

llvm/lib/Target/VE/VECustomDAG.h

10–11

That's a good idea. I'll take your suggestion.

[kaz7]

LGTM

llvm/lib/Target/VE/CMakeLists.txt

 tablegen(LLVM VEGenDAGISel.inc -gen-dag-isel)
 tablegen(LLVM VEGenSubtargetInfo.inc -gen-subtarget)
 tablegen(LLVM VEGenCallingConv.inc -gen-callingconv)
 add_public_tablegen_target(VECommonTableGen)
 
 add_llvm_target(VECodeGen
   LVLGen.cpp
   VEAsmPrinter.cpp
+  VECustomDAG.cpp
   VEFrameLowering.cpp
   VEISelDAGToDAG.cpp
   VEISelLowering.cpp
   VEInstrInfo.cpp
   VEMachineFunctionInfo.cpp
   VEMCInstLower.cpp
   VERegisterInfo.cpp
   VESubtarget.cpp

llvm/lib/Target/VE/VECustomDAG.h

+//===------------ VECustomDAG.h - VE Custom DAG Nodes -----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the helper functions that VE uses to lower LLVM code into a
+// selection DAG.  For example, hiding SDLoc, and easy to use SDNodeFlags.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_VE_VECUSTOMDAG_H
+#define LLVM_LIB_TARGET_VE_VECUSTOMDAG_H
+
+#include "VE.h"
+#include "VEISelLowering.h"
+#include "llvm/CodeGen/SelectionDAG.h"
+#include "llvm/CodeGen/TargetLowering.h"
+
+namespace llvm {
+
+class VECustomDAG {
+  SelectionDAG &DAG;
+  SDLoc DL;
+
+public:
+  SelectionDAG *getDAG() const { return &DAG; }
+
+  VECustomDAG(SelectionDAG &DAG, SDLoc DL) : DAG(DAG), DL(DL) {}
+
+  VECustomDAG(SelectionDAG &DAG, SDValue WhereOp) : DAG(DAG), DL(WhereOp) {}
+
+  VECustomDAG(SelectionDAG &DAG, const SDNode *WhereN) : DAG(DAG), DL(WhereN) {}
+
+  /// getNode {
+  SDValue getNode(unsigned OC, SDVTList VTL, ArrayRef<SDValue> OpV,
+                  Optional<SDNodeFlags> Flags = None) const {
+    auto N = DAG.getNode(OC, DL, VTL, OpV);
+    if (Flags)
+      N->setFlags(*Flags);
+    return N;
+  }
+
+  SDValue getNode(unsigned OC, ArrayRef<EVT> ResVT, ArrayRef<SDValue> OpV,
+                  Optional<SDNodeFlags> Flags = None) const {
+    auto N = DAG.getNode(OC, DL, ResVT, OpV);
+    if (Flags)
+      N->setFlags(*Flags);
+    return N;
+  }
+
+  SDValue getNode(unsigned OC, EVT ResVT, ArrayRef<SDValue> OpV,
+                  Optional<SDNodeFlags> Flags = None) const {
+    auto N = DAG.getNode(OC, DL, ResVT, OpV);
+    if (Flags)
+      N->setFlags(*Flags);
+    return N;
+  }
+
+  SDValue getUNDEF(EVT VT) const { return DAG.getUNDEF(VT); }
+  /// } getNode
+
+  SDValue getConstant(uint64_t Val, EVT VT, bool IsTarget = false,
+                      bool IsOpaque = false) const;
+};
+
+} // namespace llvm
+
+#endif // LLVM_LIB_TARGET_VE_VECUSTOMDAG_H

llvm/lib/Target/VE/VECustomDAG.cpp

+//===-- VECustomDAG.h - VE Custom DAG Nodes ------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the interfaces that VE uses to lower LLVM code into a
+// selection DAG.
+//
+//===----------------------------------------------------------------------===//
+
+#include "VECustomDAG.h"
+
+#ifndef DEBUG_TYPE
+#define DEBUG_TYPE "vecustomdag"
+#endif
+
+namespace llvm {
+
+SDValue VECustomDAG::getConstant(uint64_t Val, EVT VT, bool IsTarget,
+                                 bool IsOpaque) const {
+  return DAG.getConstant(Val, DL, VT, IsTarget, IsOpaque);
+}
+
+} // namespace llvm

llvm/lib/Target/VE/VEISelLowering.cpp

 //===-- VEISelLowering.cpp - VE DAG Lowering Implementation ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the interfaces that VE uses to lower LLVM code into a
 // selection DAG.
 //
 //===----------------------------------------------------------------------===//
 
+#include "VECustomDAG.h"
 #include "VEISelLowering.h"
 #include "MCTargetDesc/VEMCExpr.h"
 #include "VEInstrBuilder.h"
 #include "VEMachineFunctionInfo.h"
 #include "VERegisterInfo.h"
 #include "VETargetMachine.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/CodeGen/CallingConvLower.h"
static SDValue getSplatValue(SDNode *N) {
   if (auto *BuildVec = dyn_cast<BuildVectorSDNode>(N)) {
     return BuildVec->getSplatValue();
   }
   return SDValue();
 }
 
 SDValue VETargetLowering::lowerBUILD_VECTOR(SDValue Op,
                                             SelectionDAG &DAG) const {
-  SDLoc DL(Op);
+  VECustomDAG CDAG(DAG, Op);
   unsigned NumEls = Op.getValueType().getVectorNumElements();
   MVT ElemVT = Op.getSimpleValueType().getVectorElementType();
 
   // If there is just one element, expand to INSERT_VECTOR_ELT.
   unsigned UniqueIdx;
   if (getUniqueInsertion(Op.getNode(), UniqueIdx)) {
-    SDValue AccuV = DAG.getUNDEF(Op.getValueType());
+    SDValue AccuV = CDAG.getUNDEF(Op.getValueType());
     auto ElemV = Op->getOperand(UniqueIdx);
-    SDValue IdxV = DAG.getConstant(UniqueIdx, DL, MVT::i64);
-    return DAG.getNode(ISD::INSERT_VECTOR_ELT, DL, Op.getValueType(), AccuV,
-                       ElemV, IdxV);
+    SDValue IdxV = CDAG.getConstant(UniqueIdx, MVT::i64);
+    return CDAG.getNode(ISD::INSERT_VECTOR_ELT, Op.getValueType(),
+                        {AccuV, ElemV, IdxV});
   }
 
   // Else emit a broadcast.
   if (SDValue ScalarV = getSplatValue(Op.getNode())) {
     // lower to VEC_BROADCAST
     MVT LegalResVT = MVT::getVectorVT(ElemVT, 256);
 
-    auto AVL = DAG.getConstant(NumEls, DL, MVT::i32);
-    return DAG.getNode(VEISD::VEC_BROADCAST, DL, LegalResVT, Op.getOperand(0),
-                       AVL);
+    auto AVL = CDAG.getConstant(NumEls, MVT::i32);
+    return CDAG.getNode(VEISD::VEC_BROADCAST, LegalResVT,
+                        {Op.getOperand(0), AVL});
   }
 
   // Expand
   return SDValue();
 }
 
 SDValue VETargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
   unsigned Opcode = Op.getOpcode();
SDValue VETargetLowering::lowerToVVP(SDValue Op, SelectionDAG &DAG) const {
   const unsigned Opcode = Op->getOpcode();
   auto VVPOpcodeOpt = getVVPOpcode(Opcode);
   if (!VVPOpcodeOpt.hasValue())
     return SDValue();
   unsigned VVPOpcode = VVPOpcodeOpt.getValue();
   const bool FromVP = ISD::isVPOpcode(Opcode);
 
   // The representative and legalized vector type of this operation.
-  SDLoc DL(Op);
+  VECustomDAG CDAG(DAG, Op);
   MVT MaskVT = MVT::v256i1; // TODO: packed mode.
   EVT OpVecVT = Op.getValueType();
   EVT LegalVecVT = getTypeToTransformTo(*DAG.getContext(), OpVecVT);
 
   SDValue AVL;
   SDValue Mask;
 
   if (FromVP) {
     // All upstream VP SDNodes always have a mask and avl.
     auto MaskIdx = ISD::getVPMaskIdx(Opcode).getValue();
     auto AVLIdx = ISD::getVPExplicitVectorLengthIdx(Opcode).getValue();
     Mask = Op->getOperand(MaskIdx);
     AVL = Op->getOperand(AVLIdx);
 
   } else {
     // Materialize the VL parameter.
-    AVL = DAG.getConstant(OpVecVT.getVectorNumElements(), DL, MVT::i32);
-    SDValue ConstTrue = DAG.getConstant(1, DL, MVT::i32);
-    Mask = DAG.getNode(VEISD::VEC_BROADCAST, DL, MaskVT,
+    AVL = CDAG.getConstant(OpVecVT.getVectorNumElements(), MVT::i32);
+    SDValue ConstTrue = CDAG.getConstant(1, MVT::i32);
+    Mask = CDAG.getNode(VEISD::VEC_BROADCAST, MaskVT,
                         ConstTrue); // emit a VEISD::VEC_BROADCAST here.
   }
 
   // Categories we are interested in.
   bool IsBinaryOp = false;
 
   switch (VVPOpcode) {
 #define ADD_BINARY_VVP_OP(VVPNAME, ...)                                        \
   case VEISD::VVPNAME:                                                         \
     IsBinaryOp = true;                                                         \
     break;
 #include "VVPNodes.def"
   }
 
   if (IsBinaryOp) {
     assert(LegalVecVT.isSimple());
-    return DAG.getNode(VVPOpcode, DL, LegalVecVT, Op->getOperand(0),
-                       Op->getOperand(1), Mask, AVL);
+    return CDAG.getNode(VVPOpcode, LegalVecVT,
+                        {Op->getOperand(0), Op->getOperand(1), Mask, AVL});
   } else if (VVPOpcode == VEISD::VVP_SELECT) {
     auto Mask = Op->getOperand(0);
     auto OnTrue = Op->getOperand(1);
     auto OnFalse = Op->getOperand(2);
-    return DAG.getNode(VVPOpcode, DL, LegalVecVT, OnTrue, OnFalse, Mask, AVL);
+    return CDAG.getNode(VVPOpcode, LegalVecVT, {OnTrue, OnFalse, Mask, AVL});
   }
   llvm_unreachable("lowerToVVP called for unexpected SDNode.");
 }
 
 SDValue VETargetLowering::lowerEXTRACT_VECTOR_ELT(SDValue Op,
                                                   SelectionDAG &DAG) const {
   assert(Op.getOpcode() == ISD::EXTRACT_VECTOR_ELT && "Unknown opcode!");
   MVT VT = Op.getOperand(0).getSimpleValueType();