Merge pull request #146 from sx-aurora-dev/merge/ve-cdag-refactor

Merge/ve cdag refactor

Author: kaz7

llvm/lib/Target/VE/ShuffleSynthesis.cpp

@@ -769,7 +769,7 @@ struct PatternShuffleOp final : public AbstractShuffleOp {
       LLVM_DEBUG(dbgs() << "::Broadcast\n");
       SDValue ScaVal = MV.getSourceElem(FirstDef).V;
       LLVM_DEBUG(ScaVal->dump());
-      return CDAG.createBroadcast(LegalResVT, ScaVal, AVL);
+      return CDAG.getBroadcast(LegalResVT, ScaVal, AVL);
     }
 
     case BVKind::Seq: {
@@ -782,7 +782,7 @@ struct PatternShuffleOp final : public AbstractShuffleOp {
         return SeqV;
       }
 
-      SDValue StrideV = CDAG.createBroadcast(
+      SDValue StrideV = CDAG.getBroadcast(
           LegalResVT, CDAG.getConstant(Stride, ElemTy), AVL);
       SDValue ret = CDAG.getNode(VEISD::VVP_MUL, LegalResVT,
                                  {SeqV, StrideV, TrueMask, AVL});
@@ -797,7 +797,7 @@ struct PatternShuffleOp final : public AbstractShuffleOp {
       // codegen for <0, 1, .., 15, 0, 1, .., ..... > constant patterns
       // constant == VSEQ % blockLength
       SDValue sequence = CDAG.createSeq(LegalResVT, AVL);
-      SDValue modulobroadcast = CDAG.createBroadcast(
+      SDValue modulobroadcast = CDAG.getBroadcast(
           LegalResVT, CDAG.getConstant(BlockLength - 1, ElemTy),
           AVL);
 
@@ -818,7 +818,7 @@ struct PatternShuffleOp final : public AbstractShuffleOp {
       // constant == VSEQ >> log2(blockLength)
       int64_t blockLengthLog = log2(BlockLength);
       SDValue sequence = CDAG.createSeq(LegalResVT, AVL);
-      SDValue shiftbroadcast = CDAG.createBroadcast(
+      SDValue shiftbroadcast = CDAG.getBroadcast(
           LegalResVT, CDAG.getConstant(blockLengthLog, ElemTy), AVL);
 
       SDValue shift =
@@ -915,7 +915,7 @@ struct BroadcastOp final : public AbstractShuffleOp {
 
     const SDValue PivotV = CDAG.getConstEVL(MaxAVL);
     SDValue BlendMaskV = CDAG.createConstMask(NumElems, TargetLanes);
-    SDValue BroadcastV = CDAG.createBroadcast(VecTy, ScalarSrcV, PivotV);
+    SDValue BroadcastV = CDAG.getBroadcast(VecTy, ScalarSrcV, PivotV);
     return CDAG.createSelect(VecTy, BroadcastV, PartialV, BlendMaskV, PivotV);
   }
 
@@ -1173,7 +1173,7 @@ struct GatherShuffleOp final : public AbstractShuffleOp {
     }
 
     SDValue MaxVLV = CDAG.getConstEVL(MaxVL);
-    SDValue BasePtrV = CDAG.createBroadcast(PtrVecVT, VecSlotPtr);
+    SDValue BasePtrV = CDAG.getBroadcast(PtrVecVT, VecSlotPtr);
     SDValue OffsetV = CDAG.getNode(
         ISD::BUILD_VECTOR, PtrVecVT,
         GatherOffsets); // TODO directly call into constant vector generation

llvm/lib/Target/VE/VECustomDAG.cpp

@@ -25,7 +25,6 @@
 
 namespace llvm {
 
-
 /// Packing {
 
 bool isPackedMaskType(EVT SomeVT) {
@@ -888,7 +887,7 @@ static SDValue foldUnpackFromBroadcast(SDValue Vec, PackElem Part, EVT DestVT,
 
   // Fold unpack from an overpacked or mask broadcast.
   if (isOverPackedType(Vec.getValueType()) || isMaskType(Vec.getValueType()))
-    return CDAG.createBroadcast(DestVT, Scalar, AVL);
+    return CDAG.getBroadcast(DestVT, Scalar, AVL);
 
   // Fold unpack from broadcast from replication.
   if (SDValue Simplified = combineUnpackLoHi(Vec, Part, DestVT, AVL, CDAG))
@@ -919,7 +918,7 @@ SDValue VECustomDAG::createSwap(EVT DestVT, SDValue V, SDValue AVL) const {
   return DAG.getNode(VEISD::VEC_SWAP, DL, DestVT, V, AVL);
 }
 
-SDValue VECustomDAG::createBroadcast(EVT ResTy, SDValue S, SDValue AVL) const {
+SDValue VECustomDAG::getBroadcast(EVT ResTy, SDValue S, SDValue AVL) const {
 
   // Pick VL
   if (!AVL) {
@@ -965,7 +964,7 @@ SDValue VECustomDAG::createBroadcast(EVT ResTy, SDValue S, SDValue AVL) const {
   SDValue BCVec =
       DAG.getNode(VEISD::VEC_BROADCAST, DL, CmpVecTy, {CmpElem, AVL});
   SDValue ZeroVec =
-      createBroadcast(CmpVecTy, {DAG.getConstant(0, DL, BoolTy)}, AVL);
+      getBroadcast(CmpVecTy, {DAG.getConstant(0, DL, BoolTy)}, AVL);
 
   MVT BoolVecTy = MVT::getVectorVT(MVT::i1, ElemCount);
 
@@ -1410,4 +1409,5 @@ raw_ostream &VECustomDAG::print(raw_ostream &Out, SDValue V) const {
 }
 
 /// } class VECustomDAG
+
 } // namespace llvm

llvm/lib/Target/VE/VECustomDAG.h

@@ -246,8 +246,7 @@ struct VECustomDAG {
   SDValue foldAndUnpackMask(SDValue MaskVector, SDValue Mask, PackElem Part,
                             SDValue AVL) const;
   /// } Mask Insert/Extract
-
-  SDValue createBroadcast(EVT ResTy, SDValue S, SDValue AVL = SDValue()) const;
+  SDValue getBroadcast(EVT ResultVT, SDValue Scalar, SDValue AVL = SDValue()) const;
 
   // Extract an SX register from a mask
   SDValue createMaskExtract(SDValue MaskV, SDValue Idx) const;

llvm/lib/Target/VE/VVPCombine.cpp

@@ -337,7 +337,7 @@ SDValue llvm::combineUnpackLoHi(SDValue PackedVec, PackElem UnpackPart,
   match_ReplLoHi(ReplV, ReplPart);
   if (UsedDestPart != ReplPart) return SDValue();
 
-  return CDAG.createBroadcast(DestVT, ReplV->getOperand(0), AVL);
+  return CDAG.getBroadcast(DestVT, ReplV->getOperand(0), AVL);
 }
 
 SDValue VETargetLowering::combinePacking(SDNode *N,

llvm/lib/Target/VE/VVPISelLowering.cpp

@@ -401,7 +401,7 @@ VETargetLowering::computeGatherScatterAddress(VECustomDAG &CDAG, SDValue BasePtr
   if (!Scale || isOneConstant(Scale)) {
     ScaledIndex = Index;
   } else {
-    SDValue ScaleBroadcast = CDAG.createBroadcast(IndexVT, Scale, AVL);
+    SDValue ScaleBroadcast = CDAG.getBroadcast(IndexVT, Scale, AVL);
     ScaledIndex = CDAG.getNode(VEISD::VVP_MUL, IndexVT,
                                {Index, ScaleBroadcast, Mask, AVL});
     if (SplitOps)
@@ -414,7 +414,7 @@ VETargetLowering::computeGatherScatterAddress(VECustomDAG &CDAG, SDValue BasePtr
     return ScaledIndex;
   }
   // re-constitute pointer vector (basePtr + index * scale)
-  SDValue BaseBroadcast = CDAG.createBroadcast(IndexVT, BasePtr, AVL);
+  SDValue BaseBroadcast = CDAG.getBroadcast(IndexVT, BasePtr, AVL);
   auto ResPtr = CDAG.getNode(VEISD::VVP_ADD, IndexVT,
                              {BaseBroadcast, ScaledIndex, Mask, AVL});
   if (!SplitOps)
@@ -1043,7 +1043,7 @@ SDValue VETargetLowering::expandSELECT(SDValue MaskV, SDValue OnTrueV, SDValue O
       CDAG.getVectorVT(MVT::i1, LegalResVT.getVectorNumElements());
 
   if (!MaskV.getValueType().isVector()) {
-    CondVecV = CDAG.createBroadcast(LegalMaskVT, MaskV, AVL);
+    CondVecV = CDAG.getBroadcast(LegalMaskVT, MaskV, AVL);
     CondVecV = CDAG.createMaskCast(CondVecV, AVL);
   } else {
     CondVecV = MaskV;
@@ -1102,12 +1102,12 @@ VETargetLowering::lowerSETCCInVectorArithmetic(SDValue Op,
     // materialize an integer expansion
     // vselect (MaskReplacement, VEC_BROADCAST(1), VEC_BROADCAST(0))
     auto ConstZero = CDAG.getConstant(0, ElemTy);
-    auto ZeroBroadcast = CDAG.createBroadcast(Ty, ConstZero, AVL);
+    auto ZeroBroadcast = CDAG.getBroadcast(Ty, ConstZero, AVL);
     if (!PackLegalized)
       Created.push_back(ZeroBroadcast);
 
     auto ConstOne = CDAG.getConstant(1, ElemTy);
-    auto OneBroadcast = CDAG.createBroadcast(Ty, ConstOne, AVL);
+    auto OneBroadcast = CDAG.getBroadcast(Ty, ConstOne, AVL);
     if (!PackLegalized)
       Created.push_back(OneBroadcast);
 
@@ -1144,7 +1144,7 @@ VETargetLowering::lowerVVP_SCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG,
   SDValue AVL = CDAG.getConstEVL(
       *minVectorLength(ResTy.getVectorNumElements(), VecLenHint));
 
-  return CDAG.createBroadcast(NativeResTy, Op.getOperand(0), AVL);
+  return CDAG.getBroadcast(NativeResTy, Op.getOperand(0), AVL);
 }
 
 TargetLowering::LegalizeAction