From e9199c9ddf4b988f737b903456e9c40b0ed01e1c Mon Sep 17 00:00:00 2001 From: Philip Reames Date: Thu, 24 Apr 2025 10:57:39 -0700 Subject: [PATCH 1/3] [DAG] Add utilities for inserting and extracting low sub-vectors [nfc] Mechanical change to introduce the new utilities, and add enough users to make the usage pattern clear. Once this lands, I'm going to do a further pass to adjust many more callsites as a separate change. --- llvm/include/llvm/CodeGen/SelectionDAG.h | 12 ++ .../lib/CodeGen/SelectionDAG/SelectionDAG.cpp | 9 +- llvm/lib/Target/RISCV/RISCVISelLowering.cpp | 137 ++++++------------ 3 files changed, 59 insertions(+), 99 deletions(-) diff --git a/llvm/include/llvm/CodeGen/SelectionDAG.h b/llvm/include/llvm/CodeGen/SelectionDAG.h index c183149b0863a..2b0d928035851 100644 --- a/llvm/include/llvm/CodeGen/SelectionDAG.h +++ b/llvm/include/llvm/CodeGen/SelectionDAG.h @@ -924,6 +924,18 @@ class SelectionDAG { /// Example: shuffle A, B, <0,5,2,7> -> shuffle B, A, <4,1,6,3> SDValue getCommutedVectorShuffle(const ShuffleVectorSDNode &SV); + /// Insert SubVec into the lowest sub-vector of Vec. + SDValue getInsertLowSubvector(const SDLoc &DL, SDValue Vec, SDValue SubVec) { + return getNode(ISD::INSERT_SUBVECTOR, DL, Vec.getValueType(), Vec, SubVec, + getVectorIdxConstant(0, DL)); + } + + /// Return the lowest VT typed sub-vector of Vec. + SDValue getExtractLowSubvector(const SDLoc &DL, EVT VT, SDValue Vec) { + return getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, Vec, + getVectorIdxConstant(0, DL)); + } + /// Convert Op, which must be of float type, to the /// float type VT, by either extending or rounding (by truncation). SDValue getFPExtendOrRound(SDValue Op, const SDLoc &DL, EVT VT); diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp index cf88c1f4ae937..f10ad5224346e 100644 --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -12671,8 +12671,7 @@ SelectionDAG::matchBinOpReduction(SDNode *Extract, ISD::NodeType &BinOp, if (!TLI->isExtractSubvectorCheap(SubVT, OpVT, 0)) return SDValue(); BinOp = (ISD::NodeType)CandidateBinOp; - return getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(Op), SubVT, Op, - getVectorIdxConstant(0, SDLoc(Op))); + return getExtractLowSubvector(SDLoc(Op), SubVT, Op); }; // At each stage, we're looking for something that looks like: @@ -13042,8 +13041,7 @@ SelectionDAG::SplitVector(const SDValue &N, const SDLoc &DL, const EVT &LoVT, N.getValueType().getVectorMinNumElements() && "More vector elements requested than available!"); SDValue Lo, Hi; - Lo = - getNode(ISD::EXTRACT_SUBVECTOR, DL, LoVT, N, getVectorIdxConstant(0, DL)); + Lo = getExtractLowSubvector(DL, LoVT, N); // For scalable vectors it is safe to use LoVT.getVectorMinNumElements() // (rather than having to use ElementCount), because EXTRACT_SUBVECTOR scales // IDX with the runtime scaling factor of the result vector type. For @@ -13075,8 +13073,7 @@ SDValue SelectionDAG::WidenVector(const SDValue &N, const SDLoc &DL) { EVT VT = N.getValueType(); EVT WideVT = EVT::getVectorVT(*getContext(), VT.getVectorElementType(), NextPowerOf2(VT.getVectorNumElements())); - return getNode(ISD::INSERT_SUBVECTOR, DL, WideVT, getUNDEF(WideVT), N, - getVectorIdxConstant(0, DL)); + return getInsertLowSubvector(DL, getUNDEF(WideVT), N); } void SelectionDAG::ExtractVectorElements(SDValue Op, diff --git a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp index c440df5a3e638..17e2c3b6f82f3 100644 --- a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp +++ b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp @@ -2780,8 +2780,7 @@ static SDValue convertToScalableVector(EVT VT, SDValue V, SelectionDAG &DAG, assert(V.getValueType().isFixedLengthVector() && "Expected a fixed length vector operand!"); SDLoc DL(V); - SDValue Zero = DAG.getVectorIdxConstant(0, DL); - return DAG.getNode(ISD::INSERT_SUBVECTOR, DL, VT, DAG.getUNDEF(VT), V, Zero); + return DAG.getInsertLowSubvector(DL, DAG.getUNDEF(VT), V); } // Shrink V so it's just big enough to maintain a VT's worth of data. @@ -3625,12 +3624,9 @@ static SDValue matchSplatAsGather(SDValue SplatVal, MVT VT, const SDLoc &DL, // Put Vec in a VT sized vector if (SrcContainerVT.getVectorMinNumElements() < ContainerVT.getVectorMinNumElements()) - Src = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, ContainerVT, - DAG.getUNDEF(ContainerVT), Src, - DAG.getVectorIdxConstant(0, DL)); + Src = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(ContainerVT), Src); else - Src = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, ContainerVT, Src, - DAG.getVectorIdxConstant(0, DL)); + Src = DAG.getExtractLowSubvector(DL, ContainerVT, Src); // We checked that Idx fits inside VT earlier auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget); @@ -4555,17 +4551,14 @@ static SDValue lowerScalarInsert(SDValue Scalar, SDValue VL, MVT VT, ExtractedVal, DAG, Subtarget); } if (ExtractedContainerVT.bitsLE(VT)) - return DAG.getNode(ISD::INSERT_SUBVECTOR, DL, VT, Passthru, - ExtractedVal, DAG.getVectorIdxConstant(0, DL)); - return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, ExtractedVal, - DAG.getVectorIdxConstant(0, DL)); + return DAG.getInsertLowSubvector(DL, Passthru, ExtractedVal); + return DAG.getExtractLowSubvector(DL, VT, ExtractedVal); } } - if (VT.isFloatingPoint()) - return DAG.getNode(RISCVISD::VFMV_S_F_VL, DL, VT, - DAG.getUNDEF(VT), Scalar, VL); + return DAG.getNode(RISCVISD::VFMV_S_F_VL, DL, VT, DAG.getUNDEF(VT), Scalar, + VL); // Avoid the tricky legalization cases by falling back to using the // splat code which already handles it gracefully. @@ -4764,8 +4757,7 @@ static SDValue getDeinterleaveShiftAndTrunc(const SDLoc &DL, MVT VT, Res = DAG.getNode(ISD::TRUNCATE, DL, ResVT, Res); MVT CastVT = ResVT.changeVectorElementType(VT.getVectorElementType()); Res = DAG.getBitcast(CastVT, Res); - return DAG.getNode(ISD::INSERT_SUBVECTOR, DL, VT, DAG.getUNDEF(VT), Res, - DAG.getVectorIdxConstant(0, DL)); + return DAG.getInsertLowSubvector(DL, DAG.getUNDEF(VT), Res); } /// Match a single source shuffle which is an identity except that some @@ -5225,8 +5217,7 @@ static SDValue lowerBitreverseShuffle(ShuffleVectorSDNode *SVN, // to insert it into the larger vector and then shift up the reversed bits // afterwards to get rid of the gap introduced. if (ViaEltSize > NumElts) - V = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, ViaBitVT, DAG.getUNDEF(ViaBitVT), - V, DAG.getVectorIdxConstant(0, DL)); + V = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(ViaBitVT), V); SDValue Res = DAG.getNode(ISD::BITREVERSE, DL, ViaVT, DAG.getBitcast(ViaVT, V)); @@ -5240,8 +5231,7 @@ static SDValue lowerBitreverseShuffle(ShuffleVectorSDNode *SVN, Res = DAG.getBitcast(ViaBitVT, Res); if (ViaEltSize > NumElts) - Res = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, Res, - DAG.getVectorIdxConstant(0, DL)); + Res = DAG.getExtractLowSubvector(DL, VT, Res); return Res; } @@ -5761,8 +5751,7 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, return Concat; SDValue Vec = DAG.getUNDEF(VT); - return DAG.getNode(ISD::INSERT_SUBVECTOR, DL, VT, Vec, Concat, - DAG.getVectorIdxConstant(0, DL)); + return DAG.getInsertLowSubvector(DL, Vec, Concat); } } } @@ -5811,10 +5800,8 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, // Prefer vzip2a if available. // TODO: Extend to matching zip2b if EvenSrc and OddSrc allow. if (Subtarget.hasVendorXRivosVizip()) { - EvenV = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, VT, DAG.getUNDEF(VT), - EvenV, DAG.getVectorIdxConstant(0, DL)); - OddV = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, VT, DAG.getUNDEF(VT), OddV, - DAG.getVectorIdxConstant(0, DL)); + EvenV = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(VT), EvenV); + OddV = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(VT), OddV); return lowerVZIP(RISCVISD::RI_VZIP2A_VL, EvenV, OddV, DL, DAG, Subtarget); } return getWideningInterleave(EvenV, OddV, DL, DAG, Subtarget); @@ -5949,8 +5936,7 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, if (isSpreadMask(Mask, Factor, Index)) { MVT NarrowVT = MVT::getVectorVT(VT.getVectorElementType(), NumElts / Factor); - SDValue Src = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NarrowVT, V1, - DAG.getVectorIdxConstant(0, DL)); + SDValue Src = DAG.getExtractLowSubvector(DL, NarrowVT, V1); return getWideningSpread(Src, Factor, Index, DL, DAG); } } @@ -5971,12 +5957,10 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, std::max((uint64_t)MinVLMAX, PowerOf2Ceil(MaxIdx + 1)); if (NewNumElts != NumElts) { MVT NewVT = MVT::getVectorVT(VT.getVectorElementType(), NewNumElts); - SDValue ZeroIdx = DAG.getVectorIdxConstant(0, DL); - V1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NewVT, V1, ZeroIdx); + V1 = DAG.getExtractLowSubvector(DL, NewVT, V1); SDValue Res = DAG.getVectorShuffle(NewVT, DL, V1, DAG.getUNDEF(NewVT), Mask.take_front(NewNumElts)); - return DAG.getNode(ISD::INSERT_SUBVECTOR, DL, VT, DAG.getUNDEF(VT), Res, - ZeroIdx); + return DAG.getInsertLowSubvector(DL, DAG.getUNDEF(VT), Res); } } @@ -6056,9 +6040,7 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, // source register group. TODO: This generalizes to m2, and m4. const MVT M1VT = getLMUL1VT(ContainerVT); EVT SubIndexVT = M1VT.changeVectorElementType(IndexVT.getScalarType()); - SDValue SubIndex = - DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubIndexVT, LHSIndices, - DAG.getVectorIdxConstant(0, DL)); + SDValue SubIndex = DAG.getExtractLowSubvector(DL, SubIndexVT, LHSIndices); auto [InnerTrueMask, InnerVL] = getDefaultScalableVLOps(M1VT, DL, DAG, Subtarget); int N = ContainerVT.getVectorMinNumElements() / @@ -6091,11 +6073,8 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, int N = ContainerVT.getVectorMinNumElements() / M1VT.getVectorMinNumElements(); assert(isPowerOf2_32(N) && N <= 8); - SDValue SubV1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, M1VT, V1, - DAG.getVectorIdxConstant(0, DL)); - SDValue SubIndex = - DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubIndexVT, LHSIndices, - DAG.getVectorIdxConstant(0, DL)); + SDValue SubV1 = DAG.getExtractLowSubvector(DL, M1VT, V1); + SDValue SubIndex = DAG.getExtractLowSubvector(DL, SubIndexVT, LHSIndices); SDValue SubVec = DAG.getNode(GatherVVOpc, DL, M1VT, SubV1, SubIndex, DAG.getUNDEF(M1VT), InnerTrueMask, InnerVL); Gather = DAG.getUNDEF(ContainerVT); @@ -6121,17 +6100,14 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, Gather = DAG.getUNDEF(ContainerVT); SDValue SlideAmt = DAG.getElementCount(DL, XLenVT, M1VT.getVectorElementCount()); - SDValue SubV1 = - DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, M1VT, V1, - DAG.getVectorIdxConstant(0, DL)); + SDValue SubV1 = DAG.getExtractLowSubvector(DL, M1VT, V1); for (int i = 0; i < N; i++) { if (i != 0) LHSIndices = getVSlidedown(DAG, Subtarget, DL, IndexContainerVT, DAG.getUNDEF(IndexContainerVT), LHSIndices, SlideAmt, TrueMask, VL); SDValue SubIndex = - DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubIndexVT, LHSIndices, - DAG.getVectorIdxConstant(0, DL)); + DAG.getExtractLowSubvector(DL, SubIndexVT, LHSIndices); SDValue SubVec = DAG.getNode(GatherVVOpc, DL, M1VT, SubV1, SubIndex, DAG.getUNDEF(M1VT), InnerTrueMask, InnerVL); @@ -9899,8 +9875,7 @@ SDValue RISCVTargetLowering::lowerEXTRACT_VECTOR_ELT(SDValue Op, if (auto SmallerVT = getSmallestVTForIndex(ContainerVT, *MaxIdx, DL, DAG, Subtarget)) { ContainerVT = *SmallerVT; - Vec = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, ContainerVT, Vec, - DAG.getConstant(0, DL, XLenVT)); + Vec = DAG.getExtractLowSubvector(DL, ContainerVT, Vec); } } @@ -10843,12 +10818,11 @@ static SDValue lowerReductionSeq(unsigned RVVOpcode, MVT ResVT, // prove it is non-zero. For the AVL=0 case, we need the scalar to // be the result of the reduction operation. auto InnerVL = NonZeroAVL ? VL : DAG.getConstant(1, DL, XLenVT); - SDValue InitialValue = lowerScalarInsert(StartValue, InnerVL, InnerVT, DL, - DAG, Subtarget); + SDValue InitialValue = + lowerScalarInsert(StartValue, InnerVL, InnerVT, DL, DAG, Subtarget); if (M1VT != InnerVT) InitialValue = - DAG.getNode(ISD::INSERT_SUBVECTOR, DL, M1VT, DAG.getUNDEF(M1VT), - InitialValue, DAG.getVectorIdxConstant(0, DL)); + DAG.getInsertLowSubvector(DL, DAG.getUNDEF(M1VT), InitialValue); SDValue PassThru = NonZeroAVL ? DAG.getUNDEF(M1VT) : InitialValue; SDValue Policy = DAG.getTargetConstant(RISCVVType::TAIL_AGNOSTIC, DL, XLenVT); SDValue Ops[] = {PassThru, Vec, InitialValue, Mask, VL, Policy}; @@ -11098,9 +11072,7 @@ SDValue RISCVTargetLowering::lowerINSERT_SUBVECTOR(SDValue Op, Vec = convertToScalableVector(ContainerVT, Vec, DAG, Subtarget); } - SubVec = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, ContainerVT, - DAG.getUNDEF(ContainerVT), SubVec, - DAG.getVectorIdxConstant(0, DL)); + SubVec = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(ContainerVT), SubVec); SDValue Mask = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget).first; @@ -11226,9 +11198,7 @@ SDValue RISCVTargetLowering::lowerINSERT_SUBVECTOR(SDValue Op, DAG.getVectorIdxConstant(AlignedIdx, DL)); } - SubVec = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, InterSubVT, - DAG.getUNDEF(InterSubVT), SubVec, - DAG.getVectorIdxConstant(0, DL)); + SubVec = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(InterSubVT), SubVec); auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVecVT, DL, DAG, Subtarget); @@ -11342,8 +11312,7 @@ SDValue RISCVTargetLowering::lowerEXTRACT_SUBVECTOR(SDValue Op, if (auto ShrunkVT = getSmallestVTForIndex(ContainerVT, LastIdx, DL, DAG, Subtarget)) { ContainerVT = *ShrunkVT; - Vec = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, ContainerVT, Vec, - DAG.getVectorIdxConstant(0, DL)); + Vec = DAG.getExtractLowSubvector(DL, ContainerVT, Vec); } SDValue Mask = @@ -11356,8 +11325,7 @@ SDValue RISCVTargetLowering::lowerEXTRACT_SUBVECTOR(SDValue Op, getVSlidedown(DAG, Subtarget, DL, ContainerVT, DAG.getUNDEF(ContainerVT), Vec, SlidedownAmt, Mask, VL); // Now we can use a cast-like subvector extract to get the result. - Slidedown = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVecVT, Slidedown, - DAG.getVectorIdxConstant(0, DL)); + Slidedown = DAG.getExtractLowSubvector(DL, SubVecVT, Slidedown); return DAG.getBitcast(Op.getValueType(), Slidedown); } @@ -11444,8 +11412,7 @@ SDValue RISCVTargetLowering::lowerEXTRACT_SUBVECTOR(SDValue Op, // Now the vector is in the right position, extract our final subvector. This // should resolve to a COPY. - Slidedown = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVecVT, Slidedown, - DAG.getVectorIdxConstant(0, DL)); + Slidedown = DAG.getExtractLowSubvector(DL, SubVecVT, Slidedown); // We might have bitcast from a mask type: cast back to the original type if // required. @@ -11548,16 +11515,15 @@ SDValue RISCVTargetLowering::lowerVECTOR_DEINTERLEAVE(SDValue Op, if (SDValue Src = foldConcatVector(V1, V2); Src && getLMUL1VT(VT).bitsGT(VT)) { EVT NewVT = VT.getDoubleNumVectorElementsVT(); - SDValue ZeroIdx = DAG.getVectorIdxConstant(0, DL); - Src = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NewVT, Src, ZeroIdx); + Src = DAG.getExtractLowSubvector(DL, NewVT, Src); // Freeze the source so we can increase its use count. Src = DAG.getFreeze(Src); SDValue Even = lowerVZIP(RISCVISD::RI_VUNZIP2A_VL, Src, DAG.getUNDEF(NewVT), DL, DAG, Subtarget); SDValue Odd = lowerVZIP(RISCVISD::RI_VUNZIP2B_VL, Src, DAG.getUNDEF(NewVT), DL, DAG, Subtarget); - Even = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, Even, ZeroIdx); - Odd = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, Odd, ZeroIdx); + Even = DAG.getExtractLowSubvector(DL, VT, Even); + Odd = DAG.getExtractLowSubvector(DL, VT, Odd); return DAG.getMergeValues({Even, Odd}, DL); } @@ -11601,13 +11567,11 @@ SDValue RISCVTargetLowering::lowerVECTOR_DEINTERLEAVE(SDValue Op, SDValue EvenSplat = DAG.getConstant(0b01010101, DL, MVT::nxv8i8); EvenSplat = DAG.getBitcast(MVT::nxv64i1, EvenSplat); - SDValue EvenMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MaskVT, - EvenSplat, DAG.getVectorIdxConstant(0, DL)); + SDValue EvenMask = DAG.getExtractLowSubvector(DL, MaskVT, EvenSplat); SDValue OddSplat = DAG.getConstant(0b10101010, DL, MVT::nxv8i8); OddSplat = DAG.getBitcast(MVT::nxv64i1, OddSplat); - SDValue OddMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MaskVT, OddSplat, - DAG.getVectorIdxConstant(0, DL)); + SDValue OddMask = DAG.getExtractLowSubvector(DL, MaskVT, OddSplat); // vcompress the even and odd elements into two separate vectors SDValue EvenWide = DAG.getNode(ISD::VECTOR_COMPRESS, DL, ConcatVT, Concat, @@ -11987,9 +11951,7 @@ SDValue RISCVTargetLowering::lowerVECTOR_REVERSE(SDValue Op, Hi = DAG.getNode(ISD::VECTOR_REVERSE, DL, HiVT, Hi); // Reassemble the low and high pieces reversed. // FIXME: This is a CONCAT_VECTORS. - SDValue Res = - DAG.getNode(ISD::INSERT_SUBVECTOR, DL, VecVT, DAG.getUNDEF(VecVT), Hi, - DAG.getVectorIdxConstant(0, DL)); + SDValue Res = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(VecVT), Hi); return DAG.getNode( ISD::INSERT_SUBVECTOR, DL, VecVT, Res, Lo, DAG.getVectorIdxConstant(LoVT.getVectorMinNumElements(), DL)); @@ -12138,8 +12100,7 @@ RISCVTargetLowering::lowerFixedLengthVectorStoreToRVV(SDValue Op, if (VT.getVectorElementType() == MVT::i1 && VT.getVectorNumElements() < 8) { VT = MVT::v8i1; StoreVal = - DAG.getNode(ISD::INSERT_SUBVECTOR, DL, VT, DAG.getConstant(0, DL, VT), - StoreVal, DAG.getVectorIdxConstant(0, DL)); + DAG.getInsertLowSubvector(DL, DAG.getConstant(0, DL, VT), StoreVal); } MVT ContainerVT = getContainerForFixedLengthVector(VT); @@ -14571,8 +14532,7 @@ static SDValue combineBinOpToReduce(SDNode *N, SelectionDAG &DAG, // If we looked through an INSERT_SUBVECTOR we need to restore it. if (ScalarVT != ScalarV.getValueType()) NewScalarV = - DAG.getNode(ISD::INSERT_SUBVECTOR, DL, ScalarVT, DAG.getUNDEF(ScalarVT), - NewScalarV, DAG.getVectorIdxConstant(0, DL)); + DAG.getInsertLowSubvector(DL, DAG.getUNDEF(ScalarVT), NewScalarV); SDValue Ops[] = {Reduce.getOperand(0), Reduce.getOperand(1), NewScalarV, Reduce.getOperand(3), @@ -19702,13 +19662,10 @@ SDValue RISCVTargetLowering::PerformDAGCombine(SDNode *N, // Use M1 or smaller to avoid over constraining register allocation const MVT M1VT = getLMUL1VT(VT); if (M1VT.bitsLT(VT)) { - SDValue M1Passthru = - DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, M1VT, Passthru, - DAG.getVectorIdxConstant(0, DL)); + SDValue M1Passthru = DAG.getExtractLowSubvector(DL, M1VT, Passthru); SDValue Result = DAG.getNode(N->getOpcode(), DL, M1VT, M1Passthru, Scalar, VL); - Result = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, VT, Passthru, Result, - DAG.getVectorIdxConstant(0, DL)); + Result = DAG.getInsertLowSubvector(DL, Passthru, Result); return Result; } @@ -19727,8 +19684,7 @@ SDValue RISCVTargetLowering::PerformDAGCombine(SDNode *N, MVT VecVT = N->getOperand(0).getSimpleValueType(); const MVT M1VT = getLMUL1VT(VecVT); if (M1VT.bitsLT(VecVT)) { - Vec = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, M1VT, Vec, - DAG.getVectorIdxConstant(0, DL)); + Vec = DAG.getExtractLowSubvector(DL, M1VT, Vec); return DAG.getNode(RISCVISD::VMV_X_S, DL, N->getSimpleValueType(0), Vec); } break; @@ -23360,15 +23316,11 @@ bool RISCVTargetLowering::splitValueIntoRegisterParts( assert(Count != 0 && "The number of element should not be zero."); EVT SameEltTypeVT = EVT::getVectorVT(Context, ValueEltVT, Count, /*IsScalable=*/true); - Val = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, SameEltTypeVT, - DAG.getUNDEF(SameEltTypeVT), Val, - DAG.getVectorIdxConstant(0, DL)); + Val = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(SameEltTypeVT), Val); } Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val); } else { - Val = - DAG.getNode(ISD::INSERT_SUBVECTOR, DL, PartVT, DAG.getUNDEF(PartVT), - Val, DAG.getVectorIdxConstant(0, DL)); + Val = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(PartVT), Val); } Parts[0] = Val; return true; @@ -23437,8 +23389,7 @@ SDValue RISCVTargetLowering::joinRegisterPartsIntoValue( EVT::getVectorVT(Context, ValueEltVT, Count, /*IsScalable=*/true); Val = DAG.getNode(ISD::BITCAST, DL, SameEltTypeVT, Val); } - Val = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, ValueVT, Val, - DAG.getVectorIdxConstant(0, DL)); + Val = DAG.getExtractLowSubvector(DL, ValueVT, Val); return Val; } } From 89e30dd46749b826dca047b7b3f52de6d8dbdb4c Mon Sep 17 00:00:00 2001 From: Philip Reames Date: Wed, 7 May 2025 14:58:34 -0700 Subject: [PATCH 2/3] Switch to unsigned index proposal --- llvm/include/llvm/CodeGen/SelectionDAG.h | 14 ++-- .../lib/CodeGen/SelectionDAG/SelectionDAG.cpp | 6 +- llvm/lib/Target/RISCV/RISCVISelLowering.cpp | 80 +++++++++---------- 3 files changed, 51 insertions(+), 49 deletions(-) diff --git a/llvm/include/llvm/CodeGen/SelectionDAG.h b/llvm/include/llvm/CodeGen/SelectionDAG.h index 2b0d928035851..9938f891b6d7d 100644 --- a/llvm/include/llvm/CodeGen/SelectionDAG.h +++ b/llvm/include/llvm/CodeGen/SelectionDAG.h @@ -924,16 +924,18 @@ class SelectionDAG { /// Example: shuffle A, B, <0,5,2,7> -> shuffle B, A, <4,1,6,3> SDValue getCommutedVectorShuffle(const ShuffleVectorSDNode &SV); - /// Insert SubVec into the lowest sub-vector of Vec. - SDValue getInsertLowSubvector(const SDLoc &DL, SDValue Vec, SDValue SubVec) { + /// Insert \p SubVec into the \p Idx sub-vector of \p Vec. + SDValue getInsertSubvector(const SDLoc &DL, SDValue Vec, SDValue SubVec, + unsigned Idx) { return getNode(ISD::INSERT_SUBVECTOR, DL, Vec.getValueType(), Vec, SubVec, - getVectorIdxConstant(0, DL)); + getVectorIdxConstant(Idx, DL)); } - /// Return the lowest VT typed sub-vector of Vec. - SDValue getExtractLowSubvector(const SDLoc &DL, EVT VT, SDValue Vec) { + /// Return the \p VT typed sub-vector of \p Vec at \p Idx + SDValue getExtractSubvector(const SDLoc &DL, EVT VT, SDValue Vec, + unsigned Idx) { return getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, Vec, - getVectorIdxConstant(0, DL)); + getVectorIdxConstant(Idx, DL)); } /// Convert Op, which must be of float type, to the diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp index f10ad5224346e..e9e649e99e3b6 100644 --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -12671,7 +12671,7 @@ SelectionDAG::matchBinOpReduction(SDNode *Extract, ISD::NodeType &BinOp, if (!TLI->isExtractSubvectorCheap(SubVT, OpVT, 0)) return SDValue(); BinOp = (ISD::NodeType)CandidateBinOp; - return getExtractLowSubvector(SDLoc(Op), SubVT, Op); + return getExtractSubvector(SDLoc(Op), SubVT, Op, 0); }; // At each stage, we're looking for something that looks like: @@ -13041,7 +13041,7 @@ SelectionDAG::SplitVector(const SDValue &N, const SDLoc &DL, const EVT &LoVT, N.getValueType().getVectorMinNumElements() && "More vector elements requested than available!"); SDValue Lo, Hi; - Lo = getExtractLowSubvector(DL, LoVT, N); + Lo = getExtractSubvector(DL, LoVT, N, 0); // For scalable vectors it is safe to use LoVT.getVectorMinNumElements() // (rather than having to use ElementCount), because EXTRACT_SUBVECTOR scales // IDX with the runtime scaling factor of the result vector type. For @@ -13073,7 +13073,7 @@ SDValue SelectionDAG::WidenVector(const SDValue &N, const SDLoc &DL) { EVT VT = N.getValueType(); EVT WideVT = EVT::getVectorVT(*getContext(), VT.getVectorElementType(), NextPowerOf2(VT.getVectorNumElements())); - return getInsertLowSubvector(DL, getUNDEF(WideVT), N); + return getInsertSubvector(DL, getUNDEF(WideVT), N, 0); } void SelectionDAG::ExtractVectorElements(SDValue Op, diff --git a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp index 17e2c3b6f82f3..b8ec7f5c78f77 100644 --- a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp +++ b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp @@ -2780,7 +2780,7 @@ static SDValue convertToScalableVector(EVT VT, SDValue V, SelectionDAG &DAG, assert(V.getValueType().isFixedLengthVector() && "Expected a fixed length vector operand!"); SDLoc DL(V); - return DAG.getInsertLowSubvector(DL, DAG.getUNDEF(VT), V); + return DAG.getInsertSubvector(DL, DAG.getUNDEF(VT), V, 0); } // Shrink V so it's just big enough to maintain a VT's worth of data. @@ -3624,9 +3624,9 @@ static SDValue matchSplatAsGather(SDValue SplatVal, MVT VT, const SDLoc &DL, // Put Vec in a VT sized vector if (SrcContainerVT.getVectorMinNumElements() < ContainerVT.getVectorMinNumElements()) - Src = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(ContainerVT), Src); + Src = DAG.getInsertSubvector(DL, DAG.getUNDEF(ContainerVT), Src, 0); else - Src = DAG.getExtractLowSubvector(DL, ContainerVT, Src); + Src = DAG.getExtractSubvector(DL, ContainerVT, Src, 0); // We checked that Idx fits inside VT earlier auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget); @@ -4551,8 +4551,8 @@ static SDValue lowerScalarInsert(SDValue Scalar, SDValue VL, MVT VT, ExtractedVal, DAG, Subtarget); } if (ExtractedContainerVT.bitsLE(VT)) - return DAG.getInsertLowSubvector(DL, Passthru, ExtractedVal); - return DAG.getExtractLowSubvector(DL, VT, ExtractedVal); + return DAG.getInsertSubvector(DL, Passthru, ExtractedVal, 0); + return DAG.getExtractSubvector(DL, VT, ExtractedVal, 0); } } @@ -4757,7 +4757,7 @@ static SDValue getDeinterleaveShiftAndTrunc(const SDLoc &DL, MVT VT, Res = DAG.getNode(ISD::TRUNCATE, DL, ResVT, Res); MVT CastVT = ResVT.changeVectorElementType(VT.getVectorElementType()); Res = DAG.getBitcast(CastVT, Res); - return DAG.getInsertLowSubvector(DL, DAG.getUNDEF(VT), Res); + return DAG.getInsertSubvector(DL, DAG.getUNDEF(VT), Res, 0); } /// Match a single source shuffle which is an identity except that some @@ -5217,7 +5217,7 @@ static SDValue lowerBitreverseShuffle(ShuffleVectorSDNode *SVN, // to insert it into the larger vector and then shift up the reversed bits // afterwards to get rid of the gap introduced. if (ViaEltSize > NumElts) - V = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(ViaBitVT), V); + V = DAG.getInsertSubvector(DL, DAG.getUNDEF(ViaBitVT), V, 0); SDValue Res = DAG.getNode(ISD::BITREVERSE, DL, ViaVT, DAG.getBitcast(ViaVT, V)); @@ -5231,7 +5231,7 @@ static SDValue lowerBitreverseShuffle(ShuffleVectorSDNode *SVN, Res = DAG.getBitcast(ViaBitVT, Res); if (ViaEltSize > NumElts) - Res = DAG.getExtractLowSubvector(DL, VT, Res); + Res = DAG.getExtractSubvector(DL, VT, Res, 0); return Res; } @@ -5751,7 +5751,7 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, return Concat; SDValue Vec = DAG.getUNDEF(VT); - return DAG.getInsertLowSubvector(DL, Vec, Concat); + return DAG.getInsertSubvector(DL, Vec, Concat, 0); } } } @@ -5800,8 +5800,8 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, // Prefer vzip2a if available. // TODO: Extend to matching zip2b if EvenSrc and OddSrc allow. if (Subtarget.hasVendorXRivosVizip()) { - EvenV = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(VT), EvenV); - OddV = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(VT), OddV); + EvenV = DAG.getInsertSubvector(DL, DAG.getUNDEF(VT), EvenV, 0); + OddV = DAG.getInsertSubvector(DL, DAG.getUNDEF(VT), OddV, 0); return lowerVZIP(RISCVISD::RI_VZIP2A_VL, EvenV, OddV, DL, DAG, Subtarget); } return getWideningInterleave(EvenV, OddV, DL, DAG, Subtarget); @@ -5936,7 +5936,7 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, if (isSpreadMask(Mask, Factor, Index)) { MVT NarrowVT = MVT::getVectorVT(VT.getVectorElementType(), NumElts / Factor); - SDValue Src = DAG.getExtractLowSubvector(DL, NarrowVT, V1); + SDValue Src = DAG.getExtractSubvector(DL, NarrowVT, V1, 0); return getWideningSpread(Src, Factor, Index, DL, DAG); } } @@ -5957,10 +5957,10 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, std::max((uint64_t)MinVLMAX, PowerOf2Ceil(MaxIdx + 1)); if (NewNumElts != NumElts) { MVT NewVT = MVT::getVectorVT(VT.getVectorElementType(), NewNumElts); - V1 = DAG.getExtractLowSubvector(DL, NewVT, V1); + V1 = DAG.getExtractSubvector(DL, NewVT, V1, 0); SDValue Res = DAG.getVectorShuffle(NewVT, DL, V1, DAG.getUNDEF(NewVT), Mask.take_front(NewNumElts)); - return DAG.getInsertLowSubvector(DL, DAG.getUNDEF(VT), Res); + return DAG.getInsertSubvector(DL, DAG.getUNDEF(VT), Res, 0); } } @@ -6040,7 +6040,7 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, // source register group. TODO: This generalizes to m2, and m4. const MVT M1VT = getLMUL1VT(ContainerVT); EVT SubIndexVT = M1VT.changeVectorElementType(IndexVT.getScalarType()); - SDValue SubIndex = DAG.getExtractLowSubvector(DL, SubIndexVT, LHSIndices); + SDValue SubIndex = DAG.getExtractSubvector(DL, SubIndexVT, LHSIndices, 0); auto [InnerTrueMask, InnerVL] = getDefaultScalableVLOps(M1VT, DL, DAG, Subtarget); int N = ContainerVT.getVectorMinNumElements() / @@ -6073,8 +6073,8 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, int N = ContainerVT.getVectorMinNumElements() / M1VT.getVectorMinNumElements(); assert(isPowerOf2_32(N) && N <= 8); - SDValue SubV1 = DAG.getExtractLowSubvector(DL, M1VT, V1); - SDValue SubIndex = DAG.getExtractLowSubvector(DL, SubIndexVT, LHSIndices); + SDValue SubV1 = DAG.getExtractSubvector(DL, M1VT, V1, 0); + SDValue SubIndex = DAG.getExtractSubvector(DL, SubIndexVT, LHSIndices, 0); SDValue SubVec = DAG.getNode(GatherVVOpc, DL, M1VT, SubV1, SubIndex, DAG.getUNDEF(M1VT), InnerTrueMask, InnerVL); Gather = DAG.getUNDEF(ContainerVT); @@ -6100,14 +6100,14 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, Gather = DAG.getUNDEF(ContainerVT); SDValue SlideAmt = DAG.getElementCount(DL, XLenVT, M1VT.getVectorElementCount()); - SDValue SubV1 = DAG.getExtractLowSubvector(DL, M1VT, V1); + SDValue SubV1 = DAG.getExtractSubvector(DL, M1VT, V1, 0); for (int i = 0; i < N; i++) { if (i != 0) LHSIndices = getVSlidedown(DAG, Subtarget, DL, IndexContainerVT, DAG.getUNDEF(IndexContainerVT), LHSIndices, SlideAmt, TrueMask, VL); SDValue SubIndex = - DAG.getExtractLowSubvector(DL, SubIndexVT, LHSIndices); + DAG.getExtractSubvector(DL, SubIndexVT, LHSIndices, 0); SDValue SubVec = DAG.getNode(GatherVVOpc, DL, M1VT, SubV1, SubIndex, DAG.getUNDEF(M1VT), InnerTrueMask, InnerVL); @@ -9875,7 +9875,7 @@ SDValue RISCVTargetLowering::lowerEXTRACT_VECTOR_ELT(SDValue Op, if (auto SmallerVT = getSmallestVTForIndex(ContainerVT, *MaxIdx, DL, DAG, Subtarget)) { ContainerVT = *SmallerVT; - Vec = DAG.getExtractLowSubvector(DL, ContainerVT, Vec); + Vec = DAG.getExtractSubvector(DL, ContainerVT, Vec, 0); } } @@ -10822,7 +10822,7 @@ static SDValue lowerReductionSeq(unsigned RVVOpcode, MVT ResVT, lowerScalarInsert(StartValue, InnerVL, InnerVT, DL, DAG, Subtarget); if (M1VT != InnerVT) InitialValue = - DAG.getInsertLowSubvector(DL, DAG.getUNDEF(M1VT), InitialValue); + DAG.getInsertSubvector(DL, DAG.getUNDEF(M1VT), InitialValue, 0); SDValue PassThru = NonZeroAVL ? DAG.getUNDEF(M1VT) : InitialValue; SDValue Policy = DAG.getTargetConstant(RISCVVType::TAIL_AGNOSTIC, DL, XLenVT); SDValue Ops[] = {PassThru, Vec, InitialValue, Mask, VL, Policy}; @@ -11072,7 +11072,7 @@ SDValue RISCVTargetLowering::lowerINSERT_SUBVECTOR(SDValue Op, Vec = convertToScalableVector(ContainerVT, Vec, DAG, Subtarget); } - SubVec = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(ContainerVT), SubVec); + SubVec = DAG.getInsertSubvector(DL, DAG.getUNDEF(ContainerVT), SubVec, 0); SDValue Mask = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget).first; @@ -11198,7 +11198,7 @@ SDValue RISCVTargetLowering::lowerINSERT_SUBVECTOR(SDValue Op, DAG.getVectorIdxConstant(AlignedIdx, DL)); } - SubVec = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(InterSubVT), SubVec); + SubVec = DAG.getInsertSubvector(DL, DAG.getUNDEF(InterSubVT), SubVec, 0); auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVecVT, DL, DAG, Subtarget); @@ -11312,7 +11312,7 @@ SDValue RISCVTargetLowering::lowerEXTRACT_SUBVECTOR(SDValue Op, if (auto ShrunkVT = getSmallestVTForIndex(ContainerVT, LastIdx, DL, DAG, Subtarget)) { ContainerVT = *ShrunkVT; - Vec = DAG.getExtractLowSubvector(DL, ContainerVT, Vec); + Vec = DAG.getExtractSubvector(DL, ContainerVT, Vec, 0); } SDValue Mask = @@ -11325,7 +11325,7 @@ SDValue RISCVTargetLowering::lowerEXTRACT_SUBVECTOR(SDValue Op, getVSlidedown(DAG, Subtarget, DL, ContainerVT, DAG.getUNDEF(ContainerVT), Vec, SlidedownAmt, Mask, VL); // Now we can use a cast-like subvector extract to get the result. - Slidedown = DAG.getExtractLowSubvector(DL, SubVecVT, Slidedown); + Slidedown = DAG.getExtractSubvector(DL, SubVecVT, Slidedown, 0); return DAG.getBitcast(Op.getValueType(), Slidedown); } @@ -11412,7 +11412,7 @@ SDValue RISCVTargetLowering::lowerEXTRACT_SUBVECTOR(SDValue Op, // Now the vector is in the right position, extract our final subvector. This // should resolve to a COPY. - Slidedown = DAG.getExtractLowSubvector(DL, SubVecVT, Slidedown); + Slidedown = DAG.getExtractSubvector(DL, SubVecVT, Slidedown, 0); // We might have bitcast from a mask type: cast back to the original type if // required. @@ -11515,15 +11515,15 @@ SDValue RISCVTargetLowering::lowerVECTOR_DEINTERLEAVE(SDValue Op, if (SDValue Src = foldConcatVector(V1, V2); Src && getLMUL1VT(VT).bitsGT(VT)) { EVT NewVT = VT.getDoubleNumVectorElementsVT(); - Src = DAG.getExtractLowSubvector(DL, NewVT, Src); + Src = DAG.getExtractSubvector(DL, NewVT, Src, 0); // Freeze the source so we can increase its use count. Src = DAG.getFreeze(Src); SDValue Even = lowerVZIP(RISCVISD::RI_VUNZIP2A_VL, Src, DAG.getUNDEF(NewVT), DL, DAG, Subtarget); SDValue Odd = lowerVZIP(RISCVISD::RI_VUNZIP2B_VL, Src, DAG.getUNDEF(NewVT), DL, DAG, Subtarget); - Even = DAG.getExtractLowSubvector(DL, VT, Even); - Odd = DAG.getExtractLowSubvector(DL, VT, Odd); + Even = DAG.getExtractSubvector(DL, VT, Even, 0); + Odd = DAG.getExtractSubvector(DL, VT, Odd, 0); return DAG.getMergeValues({Even, Odd}, DL); } @@ -11567,11 +11567,11 @@ SDValue RISCVTargetLowering::lowerVECTOR_DEINTERLEAVE(SDValue Op, SDValue EvenSplat = DAG.getConstant(0b01010101, DL, MVT::nxv8i8); EvenSplat = DAG.getBitcast(MVT::nxv64i1, EvenSplat); - SDValue EvenMask = DAG.getExtractLowSubvector(DL, MaskVT, EvenSplat); + SDValue EvenMask = DAG.getExtractSubvector(DL, MaskVT, EvenSplat, 0); SDValue OddSplat = DAG.getConstant(0b10101010, DL, MVT::nxv8i8); OddSplat = DAG.getBitcast(MVT::nxv64i1, OddSplat); - SDValue OddMask = DAG.getExtractLowSubvector(DL, MaskVT, OddSplat); + SDValue OddMask = DAG.getExtractSubvector(DL, MaskVT, OddSplat, 0); // vcompress the even and odd elements into two separate vectors SDValue EvenWide = DAG.getNode(ISD::VECTOR_COMPRESS, DL, ConcatVT, Concat, @@ -11951,7 +11951,7 @@ SDValue RISCVTargetLowering::lowerVECTOR_REVERSE(SDValue Op, Hi = DAG.getNode(ISD::VECTOR_REVERSE, DL, HiVT, Hi); // Reassemble the low and high pieces reversed. // FIXME: This is a CONCAT_VECTORS. - SDValue Res = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(VecVT), Hi); + SDValue Res = DAG.getInsertSubvector(DL, DAG.getUNDEF(VecVT), Hi, 0); return DAG.getNode( ISD::INSERT_SUBVECTOR, DL, VecVT, Res, Lo, DAG.getVectorIdxConstant(LoVT.getVectorMinNumElements(), DL)); @@ -12100,7 +12100,7 @@ RISCVTargetLowering::lowerFixedLengthVectorStoreToRVV(SDValue Op, if (VT.getVectorElementType() == MVT::i1 && VT.getVectorNumElements() < 8) { VT = MVT::v8i1; StoreVal = - DAG.getInsertLowSubvector(DL, DAG.getConstant(0, DL, VT), StoreVal); + DAG.getInsertSubvector(DL, DAG.getConstant(0, DL, VT), StoreVal, 0); } MVT ContainerVT = getContainerForFixedLengthVector(VT); @@ -14532,7 +14532,7 @@ static SDValue combineBinOpToReduce(SDNode *N, SelectionDAG &DAG, // If we looked through an INSERT_SUBVECTOR we need to restore it. if (ScalarVT != ScalarV.getValueType()) NewScalarV = - DAG.getInsertLowSubvector(DL, DAG.getUNDEF(ScalarVT), NewScalarV); + DAG.getInsertSubvector(DL, DAG.getUNDEF(ScalarVT), NewScalarV, 0); SDValue Ops[] = {Reduce.getOperand(0), Reduce.getOperand(1), NewScalarV, Reduce.getOperand(3), @@ -19662,10 +19662,10 @@ SDValue RISCVTargetLowering::PerformDAGCombine(SDNode *N, // Use M1 or smaller to avoid over constraining register allocation const MVT M1VT = getLMUL1VT(VT); if (M1VT.bitsLT(VT)) { - SDValue M1Passthru = DAG.getExtractLowSubvector(DL, M1VT, Passthru); + SDValue M1Passthru = DAG.getExtractSubvector(DL, M1VT, Passthru, 0); SDValue Result = DAG.getNode(N->getOpcode(), DL, M1VT, M1Passthru, Scalar, VL); - Result = DAG.getInsertLowSubvector(DL, Passthru, Result); + Result = DAG.getInsertSubvector(DL, Passthru, Result, 0); return Result; } @@ -19684,7 +19684,7 @@ SDValue RISCVTargetLowering::PerformDAGCombine(SDNode *N, MVT VecVT = N->getOperand(0).getSimpleValueType(); const MVT M1VT = getLMUL1VT(VecVT); if (M1VT.bitsLT(VecVT)) { - Vec = DAG.getExtractLowSubvector(DL, M1VT, Vec); + Vec = DAG.getExtractSubvector(DL, M1VT, Vec, 0); return DAG.getNode(RISCVISD::VMV_X_S, DL, N->getSimpleValueType(0), Vec); } break; @@ -23316,11 +23316,11 @@ bool RISCVTargetLowering::splitValueIntoRegisterParts( assert(Count != 0 && "The number of element should not be zero."); EVT SameEltTypeVT = EVT::getVectorVT(Context, ValueEltVT, Count, /*IsScalable=*/true); - Val = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(SameEltTypeVT), Val); + Val = DAG.getInsertSubvector(DL, DAG.getUNDEF(SameEltTypeVT), Val, 0); } Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val); } else { - Val = DAG.getInsertLowSubvector(DL, DAG.getUNDEF(PartVT), Val); + Val = DAG.getInsertSubvector(DL, DAG.getUNDEF(PartVT), Val, 0); } Parts[0] = Val; return true; @@ -23389,7 +23389,7 @@ SDValue RISCVTargetLowering::joinRegisterPartsIntoValue( EVT::getVectorVT(Context, ValueEltVT, Count, /*IsScalable=*/true); Val = DAG.getNode(ISD::BITCAST, DL, SameEltTypeVT, Val); } - Val = DAG.getExtractLowSubvector(DL, ValueVT, Val); + Val = DAG.getExtractSubvector(DL, ValueVT, Val, 0); return Val; } } From 83a78f759db6d75d1cfa7e6966031f9d4c3056bd Mon Sep 17 00:00:00 2001 From: Philip Reames Date: Wed, 7 May 2025 19:36:51 -0700 Subject: [PATCH 3/3] Update llvm/include/llvm/CodeGen/SelectionDAG.h Co-authored-by: Luke Lau --- llvm/include/llvm/CodeGen/SelectionDAG.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/include/llvm/CodeGen/SelectionDAG.h b/llvm/include/llvm/CodeGen/SelectionDAG.h index ecf343c2de287..1b990e29158fd 100644 --- a/llvm/include/llvm/CodeGen/SelectionDAG.h +++ b/llvm/include/llvm/CodeGen/SelectionDAG.h @@ -924,7 +924,7 @@ class SelectionDAG { /// Example: shuffle A, B, <0,5,2,7> -> shuffle B, A, <4,1,6,3> SDValue getCommutedVectorShuffle(const ShuffleVectorSDNode &SV); - /// Insert \p SubVec into the \p Idx sub-vector of \p Vec. + /// Insert \p SubVec at the \p Idx element of \p Vec. SDValue getInsertSubvector(const SDLoc &DL, SDValue Vec, SDValue SubVec, unsigned Idx) { return getNode(ISD::INSERT_SUBVECTOR, DL, Vec.getValueType(), Vec, SubVec,