Lines Matching refs:VL
2761 /// vector length VL. .
2762 static SDValue getAllOnesMask(MVT VecVT, SDValue VL, const SDLoc &DL,
2765 return DAG.getNode(RISCVISD::VMSET_VL, DL, MaskVT, VL);
2770 // If we know the exact VLEN, and our VL is exactly equal to VLMAX,
2785 SDValue VL = DAG.getRegister(RISCV::X0, Subtarget.getXLenVT());
2786 SDValue Mask = getAllOnesMask(VecVT, VL, DL, DAG);
2787 return {Mask, VL};
2794 SDValue VL = getVLOp(NumElts, ContainerVT, DL, DAG, Subtarget);
2795 SDValue Mask = getAllOnesMask(ContainerVT, VL, DL, DAG);
2796 return {Mask, VL};
2799 // Gets the two common "VL" operands: an all-ones mask and the vector length.
2976 auto [Mask, VL] = getDefaultVLOps(DstVT, DstContainerVT, DL, DAG, Subtarget);
2980 DAG.getUNDEF(Mask.getValueType()), Mask, VL});
2987 Src = DAG.getNode(RISCVISD::FP_EXTEND_VL, DL, InterVT, Src, Mask, VL);
2992 SDValue Res = DAG.getNode(RVVOpc, DL, DstContainerVT, Src, Mask, VL);
2996 DAG.getConstant(0, DL, Subtarget.getXLenVT()), VL);
2998 Res, DAG.getUNDEF(DstContainerVT), VL);
3055 SDValue Mask, VL;
3061 VL = Op.getOperand(2);
3063 std::tie(Mask, VL) = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
3070 SDValue Abs = DAG.getNode(RISCVISD::FABS_VL, DL, ContainerVT, Src, Mask, VL);
3083 DAG.getUNDEF(ContainerVT), MaxValNode, VL);
3090 Mask, Mask, VL});
3112 DAG.getTargetConstant(FRM, DL, XLenVT), VL);
3117 Mask, VL);
3121 Truncated = DAG.getNode(RISCVISD::VFCVT_X_F_VL, DL, IntVT, Src, Mask, VL);
3126 Mask, VL);
3133 Mask, VL);
3137 Src, Src, Mask, VL);
3162 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
3172 DAG.getUNDEF(MaskVT), Mask, VL});
3176 {Chain, Src, Src, Src, Unorder, VL});
3180 SDValue Abs = DAG.getNode(RISCVISD::FABS_VL, DL, ContainerVT, Src, Mask, VL);
3193 DAG.getUNDEF(ContainerVT), MaxValNode, VL);
3198 {Abs, MaxValSplat, DAG.getCondCode(ISD::SETOLT), Mask, Mask, VL});
3216 {Chain, Src, Mask, DAG.getTargetConstant(FRM, DL, XLenVT), VL});
3222 DAG.getVTList(IntVT, MVT::Other), Chain, Src, Mask, VL);
3227 Mask, VL);
3236 Truncated, Mask, VL);
3242 Src, Src, Mask, VL);
3292 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
3294 DAG.getNode(RISCVISD::VFCVT_X_F_VL, DL, ContainerVT, Src, Mask, VL);
3305 SDValue Offset, SDValue Mask, SDValue VL,
3310 SDValue Ops[] = {Merge, Op, Offset, Mask, VL, PolicyOp};
3317 SDValue VL,
3322 SDValue Ops[] = {Merge, Op, Offset, Mask, VL, PolicyOp};
3493 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
3496 Idx, DAG.getUNDEF(ContainerVT), Mask, VL);
3521 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
3587 LastOp, Mask, VL);
3628 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
3635 SDValue VMClr = DAG.getNode(RISCVISD::VMCLR_VL, DL, ContainerVT, VL);
3640 SDValue VMSet = DAG.getNode(RISCVISD::VMSET_VL, DL, ContainerVT, VL);
3716 DAG.getNode(Opc, DL, ContainerVT, DAG.getUNDEF(ContainerVT), Splat, VL);
3753 SDValue VID = DAG.getNode(RISCVISD::VID_VL, DL, VIDContainerVT, Mask, VL);
3790 // If we can use the original VL with the modified element type, this
3791 // means we only have a VTYPE toggle, not a VL toggle. TODO: Should this
3843 // If we can use the original VL with the modified element type, this
3844 // means we only have a VTYPE toggle, not a VL toggle. TODO: Should this
3907 SDValue Res = DAG.getNode(RISCVISD::VSEXT_VL, DL, ContainerVT, Source, Mask, VL);
4027 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
4063 DAG.getNode(Opc, DL, ContainerVT, DAG.getUNDEF(ContainerVT), Splat, VL);
4101 // elements into the widest scalar type we can. This will force a VL/VTYPE
4150 // is linear in VL. However, at high lmuls vslide1down and vslidedown end up
4152 // lowering for every element ends up being VL*LMUL..
4220 Vec, Offset, Mask, VL, Policy);
4228 V, Mask, VL);
4233 Vec, Offset, Mask, VL, Policy);
4239 SDValue Lo, SDValue Hi, SDValue VL,
4249 return DAG.getNode(RISCVISD::VMV_V_X_VL, DL, VT, Passthru, Lo, VL);
4253 // vlmax vsetvli or vsetivli to change the VL.
4258 if (isAllOnesConstant(VL) ||
4259 (isa<RegisterSDNode>(VL) &&
4260 cast<RegisterSDNode>(VL)->getReg() == RISCV::X0))
4262 else if (isa<ConstantSDNode>(VL) && isUInt<4>(VL->getAsZExtVal()))
4263 NewVL = DAG.getNode(ISD::ADD, DL, VL.getValueType(), VL, VL);
4279 return DAG.getNode(RISCVISD::VMV_V_X_VL, DL, VT, Passthru, Lo, VL);
4284 return DAG.getNode(RISCVISD::VMV_V_X_VL, DL, VT, Passthru, Lo, VL);
4288 Hi, VL);
4295 SDValue Scalar, SDValue VL,
4300 return splatPartsI64WithVL(DL, VT, Passthru, Lo, Hi, VL, DAG);
4304 // length VL. It ensures the final sequence is type legal, which is useful when
4306 static SDValue lowerScalarSplat(SDValue Passthru, SDValue Scalar, SDValue VL,
4313 return DAG.getNode(RISCVISD::VFMV_V_F_VL, DL, VT, Passthru, Scalar, VL);
4326 return DAG.getNode(RISCVISD::VMV_V_X_VL, DL, VT, Passthru, Scalar, VL);
4332 if (isOneConstant(VL) && isNullConstant(Scalar))
4334 DAG.getConstant(0, DL, XLenVT), VL);
4337 return splatSplitI64WithVL(DL, VT, Passthru, Scalar, VL, DAG);
4341 // 0 of the vector regardless of the value of VL. The contents of the
4342 // remaining lanes of the result vector are unspecified. VL is assumed
4344 static SDValue lowerScalarInsert(SDValue Scalar, SDValue VL, MVT VT,
4377 DAG.getUNDEF(VT), Scalar, VL);
4394 DAG.getUNDEF(VT), Scalar, VL);
4577 auto [TrueMask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
4594 DAG.getConstant(Shift, DL, Subtarget.getXLenVT()), VL);
4597 DAG.getUNDEF(IntContainerVT), TrueMask, VL);
4672 auto [TrueMask, VL] = getDefaultVLOps(SrcVT, ContainerVT, DL, DAG, Subtarget);
4676 DAG.getConstant(NewMask[0], DL, XLenVT), TrueMask, VL);
4714 // VL to the index + the number of elements being inserted.
4723 SDValue VL = DAG.getConstant(NumSubElts + Index, DL, XLenVT);
4730 VL);
4733 DAG.getConstant(Index, DL, XLenVT), TrueMask, VL, Policy);
4777 auto [TrueMask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
4786 Splat, TrueMask, VL);
4823 auto [Mask, VL] = getDefaultVLOps(VecVT, VecContainerVT, DL, DAG, Subtarget);
4832 DAG.getNode(RISCVISD::VZEXT_VL, DL, WideContainerVT, EvenV, Mask, VL);
4838 OffsetVec, Passthru, Mask, VL);
4841 Interleaved, EvenV, Passthru, Mask, VL);
4844 DAG.getNode(RISCVISD::VZEXT_VL, DL, WideContainerVT, OddV, Mask, VL);
4849 Interleaved, OffsetVec, Passthru, Mask, VL);
4857 OddV, Passthru, Mask, VL);
4863 OddV, AllOnesVec, Passthru, Mask, VL);
4871 Interleaved, OddsMul, Passthru, Mask, VL);
5108 auto [TrueMask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
5145 VL};
5180 DAG.getNode(Opc, DL, SplatVT, DAG.getUNDEF(ContainerVT), V, VL);
5189 DAG.getUNDEF(ContainerVT), TrueMask, VL);
5236 // Even though we could use a smaller VL, don't to avoid a vsetivli
5239 DAG.getConstant(Rotation, DL, XLenVT), TrueMask, VL);
5243 DAG.getConstant(InvRotate, DL, XLenVT), TrueMask, VL,
5337 DAG.getUNDEF(ContainerVT), TrueMask, VL);
5411 SDValue Mask, VL;
5417 VL = Op.getOperand(2);
5441 Src, Mask, VL);
5442 Src = DAG.getNode(ISD::VP_AND, DL, VT, Src, Neg, Mask, VL);
5449 FloatVal = DAG.getNode(ISD::VP_UINT_TO_FP, DL, FloatVT, Src, Mask, VL);
5459 std::tie(Mask, VL) = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
5465 Src, Mask, RTZRM, VL);
5478 DAG.getConstant(ShiftAmt, DL, IntVT), Mask, VL);
5479 Exp = DAG.getVPZExtOrTrunc(DL, VT, Exp, Mask, VL);
5497 DAG.getConstant(ExponentBias, DL, VT), Mask, VL);
5505 Mask, VL);
5515 DAG.getConstant(EltSize, DL, VT), Mask, VL);
5550 // Convert -1 to VL.
5796 auto [Mask, VL] = getDefaultScalableVLOps(VT0, DL, DAG, Subtarget);
5799 VL = Op.getOperand(3);
5802 VL, Op->getFlags());
5816 auto [Mask, VL] = getDefaultVLOps(VT0, ContainerVT0, DL, DAG, Subtarget);
5822 VL = Op.getOperand(3);
5827 Mask, VL, Op->getFlags());
5830 DAG.getUNDEF(ContainerDstVT), TDCMaskV, VL);
5835 DAG.getUNDEF(ContainerVT), Mask, VL});
5839 TDCMaskV, DAG.getUNDEF(ContainerDstVT), Mask, VL);
5843 DAG.getUNDEF(ContainerDstVT), SplatZero, VL);
5847 DAG.getUNDEF(ContainerVT), Mask, VL});
5904 SDValue Mask, VL;
5910 VL = Op.getOperand(3);
5912 std::tie(Mask, VL) = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
5919 DAG.getUNDEF(ContainerVT), Mask, VL});
5921 DAG.getUNDEF(ContainerVT), VL);
5928 DAG.getUNDEF(ContainerVT), Mask, VL});
5930 DAG.getUNDEF(ContainerVT), VL);
5938 DAG.getUNDEF(ContainerVT), Mask, VL);
5944 /// Get a RISC-V target specified VL op for a given SDNode.
5955 llvm_unreachable("don't have RISC-V specified VL op for this SDNode");
6427 SDValue VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
6430 DAG.getUNDEF(ContainerVT), Scalar, VL);
6655 // For fixed-length vectors we lower to a custom "VL" node.
6691 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
6696 Op.getOperand(0), Src, Mask, VL);
6700 Src = DAG.getNode(RVVOpc, DL, ContainerVT, Src, Mask, VL);
8062 SDValue VL = getDefaultScalableVLOps(VT, DL, DAG, Subtarget).second;
8063 return DAG.getNode(RISCVISD::VMSET_VL, DL, VT, VL);
8066 SDValue VL = getDefaultScalableVLOps(VT, DL, DAG, Subtarget).second;
8067 return DAG.getNode(RISCVISD::VMCLR_VL, DL, VT, VL);
8096 auto VL = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget).second;
8099 splatPartsI64WithVL(DL, ContainerVT, SDValue(), Lo, Hi, VL, DAG);
8132 SDValue VL = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget).second;
8139 DAG.getUNDEF(ContainerVT), SplatZero, VL);
8141 DAG.getUNDEF(ContainerVT), SplatTrueVal, VL);
8144 SplatZero, DAG.getUNDEF(ContainerVT), VL);
8169 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
8171 SDValue Ext = DAG.getNode(ExtendOpc, DL, ContainerExtVT, Op1, Mask, VL);
8189 SDValue Mask, VL;
8192 VL = Op.getOperand(2);
8208 std::tie(Mask, VL) =
8216 DAG.getUNDEF(ContainerVT), SplatOne, VL);
8218 DAG.getUNDEF(ContainerVT), SplatZero, VL);
8222 DAG.getUNDEF(ContainerVT), Mask, VL);
8225 DAG.getUNDEF(MaskContainerVT), Mask, VL});
8258 SDValue Mask, VL;
8261 VL = Op.getOperand(2);
8274 std::tie(Mask, VL) =
8284 Mask, VL);
8309 auto [Mask, VL] = getDefaultVLOps(SrcVT, ContainerVT, DL, DAG, Subtarget);
8324 Chain, Src, Mask, VL);
8332 Chain, Src, Mask, VL);
8372 SDValue Mask, VL;
8375 VL = Op.getOperand(2);
8389 std::tie(Mask, VL) =
8395 Src = DAG.getNode(ConvOpc, DL, ContainerVT, Src, Mask, VL);
8406 DAG.getNode(InterConvOpc, DL, InterVT, Src, Mask, VL);
8408 DAG.getNode(ConvOpc, DL, ContainerVT, IntermediateConv, Mask, VL);
8443 // original vector (with an undisturbed tail policy for elements >= VL), we
8445 // at VL-1, which is replaced with the desired value.
8521 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
8531 Vec = DAG.getNode(Opc, DL, ContainerVT, Vec, Val, VL);
8540 ValInVec = lowerScalarInsert(Val, VL, ContainerVT, DL, DAG, Subtarget);
8552 // Limit the active VL to two.
8631 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
8633 DAG.getNode(RISCVISD::VFIRST_VL, DL, XLenVT, Vec, Mask, VL);
8747 // Use a VL of 1 to avoid processing more elements than we need.
8748 auto [Mask, VL] = getDefaultVLOps(1, ContainerVT, DL, DAG, Subtarget);
8750 DAG.getUNDEF(ContainerVT), Vec, Idx, Mask, VL);
8846 // Double the VL since we halved SEW.
8883 SDValue VL = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, XLenVT, SETVL, AVL,
8886 DAG.getNode(ISD::SHL, DL, XLenVT, VL, DAG.getConstant(1, DL, XLenVT));
8937 SDValue VL = getVLOperand(Op);
8938 assert(VL.getValueType() == XLenVT);
8939 ScalarOp = splatSplitI64WithVL(DL, VT, SDValue(), ScalarOp, VL, DAG);
8999 auto [Mask, VL] = getDefaultVLOps(OpVT, ContainerVT, DL, DAG, Subtarget);
9000 SDValue Res = DAG.getNode(RISCVISD::VFIRST_VL, DL, XLenVT, Op0, Mask, VL);
9004 // Convert -1 to VL.
9007 VL = DAG.getElementCount(DL, XLenVT, OpVT.getVectorElementCount());
9008 return DAG.getSelect(DL, XLenVT, Setcc, VL, Res);
9250 SDValue VL = getVLOperand(Op);
9252 SDValue SplattedVal = splatSplitI64WithVL(DL, VT, SDValue(), Scalar, VL, DAG);
9257 DAG.getConstant(0, DL, MVT::i32), VL);
9260 SDValue Mask = getAllOnesMask(VT, VL, DL, DAG);
9261 SDValue VID = DAG.getNode(RISCVISD::VID_VL, DL, VT, Mask, VL);
9265 DAG.getUNDEF(MaskVT), Mask, VL});
9267 Vec, DAG.getUNDEF(VT), VL);
9433 SDValue VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
9446 Result = lowerScalarSplat(SDValue(), ScalarLoad, VL, ContainerVT, DL, DAG,
9467 Ops.push_back(VL);
9503 SDValue VL = getVLOp(VT.getVectorNumElements(), ContainerVT, DL, DAG,
9513 Ops.push_back(VL);
9585 SDValue VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
9598 Ops.push_back(VL);
9624 SDValue VL = getVLOp(VT.getVectorNumElements(), ContainerVT, DL, DAG,
9634 Ops.append({Ptr, VL});
9733 SDValue Mask, VL;
9736 VL = Op.getOperand(3);
9738 std::tie(Mask, VL) =
9752 SDValue TrueMask = DAG.getNode(RISCVISD::VMSET_VL, DL, ContainerVT, VL);
9753 Vec = DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Vec, TrueMask, VL);
9754 Vec = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Vec, Mask, VL);
9762 Vec = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Vec, Mask, VL);
9770 Vec = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Vec, Mask, VL);
9804 SDValue VL, const SDLoc &DL, SelectionDAG &DAG,
9809 const bool NonZeroAVL = isNonZeroAVL(VL);
9814 // We reuse the VL of the reduction to reduce vsetvli toggles if we can
9817 auto InnerVL = NonZeroAVL ? VL : DAG.getConstant(1, DL, XLenVT);
9826 SDValue Ops[] = {PassThru, Vec, InitialValue, Mask, VL, Policy};
9864 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
9878 Mask, VL, DL, DAG, Subtarget);
9936 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
9938 VL, DL, DAG, Subtarget);
9950 DAG.getUNDEF(Mask.getValueType()), Mask, VL});
9952 SDValue CPop = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, IsNan, Mask, VL);
9983 SDValue VL = Op.getOperand(3);
9987 Vec, Mask, VL, DL, DAG, Subtarget);
9997 {Vec, Vec, DAG.getCondCode(ISD::SETNE), DAG.getUNDEF(PredVT), Mask, VL});
9998 SDValue VCPop = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, IsNaN, Mask, VL);
10091 SDValue VL = getVLOp(EndIndex, ContainerVT, DL, DAG, Subtarget);
10102 DAG.getNode(RISCVISD::VMV_V_V_VL, DL, ContainerVT, Vec, SubVec, VL);
10106 SlideupAmt, Mask, VL, Policy);
10187 // OFFSET<=i<VL set to the "subvector" and vl<=i<VLMAX set to the tail policy
10189 // where OFFSET is the insertion offset, and the VL is the OFFSET plus the
10208 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVecVT, DL, DAG, Subtarget);
10211 VL = DAG.getElementCount(DL, XLenVT, SubVecVT.getVectorElementCount());
10223 SubVec, VL);
10228 VL = DAG.getNode(ISD::ADD, DL, XLenVT, SlideupAmt, VL);
10231 SlideupAmt, Mask, VL, Policy);
10328 SDValue VL = getVLOp(SubVecVT.getVectorNumElements(), ContainerVT, DL, DAG,
10333 DAG.getUNDEF(ContainerVT), Vec, SlidedownAmt, Mask, VL);
10402 auto [Mask, VL] = getDefaultScalableVLOps(InterSubVT, DL, DAG, Subtarget);
10404 VL = getVLOp(SubVecVT.getVectorNumElements(), InterSubVT, DL, DAG,
10408 Vec, SlidedownAmt, Mask, VL);
10488 // We want to operate on all lanes, so get the mask and VL and mask for it
10489 auto [Mask, VL] = getDefaultScalableVLOps(ConcatVT, DL, DAG, Subtarget);
10513 Concat, EvenIdx, Passthru, Mask, VL);
10515 Concat, OddIdx, Passthru, Mask, VL);
10539 SDValue VL = DAG.getRegister(RISCV::X0, XLenVT);
10596 DAG.getNode(RISCVISD::ADD_VL, DL, IdxVT, Idx, VLMax, Idx, OddMask, VL);
10600 SDValue TrueMask = getAllOnesMask(IdxVT, VL, DL, DAG);
10602 Concat, Idx, DAG.getUNDEF(ConcatVT), TrueMask, VL);
10623 auto [Mask, VL] = getDefaultScalableVLOps(VT, DL, DAG, Subtarget);
10624 SDValue StepVec = DAG.getNode(RISCVISD::VID_VL, DL, VT, Mask, VL);
10630 DAG.getConstant(Log2_64(StepValImm), DL, XLenVT), VL);
10635 VL, VT, DL, DAG, Subtarget);
10696 auto [Mask, VL] = getDefaultScalableVLOps(VecVT, DL, DAG, Subtarget);
10713 SDValue VID = DAG.getNode(RISCVISD::VID_VL, DL, IntVT, Mask, VL);
10715 DAG.getUNDEF(IntVT), Mask, VL);
10718 DAG.getUNDEF(VecVT), Mask, VL);
10785 SDValue VL = getVLOp(VT.getVectorNumElements(), ContainerVT, DL, DAG, Subtarget);
10794 Ops.push_back(VL);
10845 SDValue VL = getVLOp(VT.getVectorNumElements(), ContainerVT, DL, DAG,
10853 {Store->getChain(), IntID, NewValue, Store->getBasePtr(), VL},
10868 SDValue Mask, PassThru, VL;
10872 VL = VPLoad->getVectorLength();
10893 if (!VL)
10894 VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
10906 Ops.push_back(VL);
10931 SDValue Val, Mask, VL;
10937 VL = VPStore->getVectorLength();
10962 if (!VL)
10963 VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
10968 DAG.getUNDEF(ContainerVT), Val, Mask, VL);
10969 VL =
10971 getAllOnesMask(Mask.getSimpleValueType(), VL, DL, DAG), VL);
10981 Ops.push_back(VL);
11001 auto [Mask, VL] = getDefaultVLOps(VT.getVectorNumElements(), ContainerVT, DL,
11007 {Op1, Op2, Op.getOperand(2), DAG.getUNDEF(MaskVT), Mask, VL});
11062 auto [Mask, VL] = getDefaultVLOps(InVT, ContainerInVT, DL, DAG, Subtarget);
11070 SDValue True = getAllOnesMask(ContainerInVT, VL, DL, DAG);
11074 True, VL});
11078 True, VL});
11080 DAG.getNode(RISCVISD::VMAND_VL, DL, MaskVT, OrderMask1, OrderMask2, VL);
11085 {Chain, Op1, Op2, CC, Mask, Mask, VL});
11090 {Chain, Op1, Op2, CC, DAG.getUNDEF(MaskVT), Mask, VL});
11115 SDValue Mask, VL;
11121 VL = Op->getOperand(2);
11123 std::tie(Mask, VL) = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
11127 DAG.getConstant(0, DL, Subtarget.getXLenVT()), VL);
11129 DAG.getUNDEF(ContainerVT), Mask, VL);
11131 DAG.getUNDEF(ContainerVT), Mask, VL);
11151 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
11154 Sign, DAG.getUNDEF(ContainerVT), Mask, VL);
11175 SDValue VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
11178 Op2, DAG.getUNDEF(ContainerVT), VL);
11210 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
11215 Ops.push_back(VL);
11299 SDValue VL = Op.getOperand(2);
11311 DAG.getUNDEF(ContainerVT), Zero, VL);
11316 DAG.getUNDEF(ContainerVT), SplatValue, VL);
11319 ZeroSplat, DAG.getUNDEF(ContainerVT), VL);
11334 SDValue VL = Op.getOperand(4);
11344 SDValue AllOneMask = DAG.getNode(RISCVISD::VMSET_VL, DL, ContainerVT, VL);
11351 Result = DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Op1, Op2, VL);
11356 DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Op1, Op2, VL);
11358 DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Temp, AllOneMask, VL);
11366 DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Op1, AllOneMask, VL);
11367 Result = DAG.getNode(RISCVISD::VMAND_VL, DL, ContainerVT, Temp, Op2, VL);
11375 DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Op2, AllOneMask, VL);
11376 Result = DAG.getNode(RISCVISD::VMAND_VL, DL, ContainerVT, Op1, Temp, VL);
11384 DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Op1, AllOneMask, VL);
11385 Result = DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Temp, Op2, VL);
11393 DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Op2, AllOneMask, VL);
11394 Result = DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Temp, Op1, VL);
11411 SDValue VL = Op.getOperand(2);
11442 DAG.getUNDEF(IntVT), Zero, VL);
11446 DAG.getUNDEF(IntVT), One, VL);
11448 ZeroSplat, DAG.getUNDEF(IntVT), VL);
11453 Src = DAG.getNode(RISCVISDExtOpc, DL, IntVT, Src, Mask, VL);
11456 Result = DAG.getNode(RISCVISDOpc, DL, DstVT, Src, Mask, VL);
11467 DAG.getNode(RISCVISD::FP_EXTEND_VL, DL, InterimFVT, Src, Mask, VL);
11470 Result = DAG.getNode(RISCVISDOpc, DL, DstVT, Src, Mask, VL);
11485 Result = DAG.getNode(RISCVISDOpc, DL, InterimFVT, Src, Mask, VL);
11489 Result = DAG.getNode(RISCVISD::FP_ROUND_VL, DL, DstVT, Src, Mask, VL);
11503 Result = DAG.getNode(RISCVISDOpc, DL, InterimIVT, Src, Mask, VL);
11510 DAG.getUNDEF(InterimIVT), SplatZero, VL);
11513 DAG.getUNDEF(DstVT), Mask, VL});
11518 Result = DAG.getNode(RISCVISDOpc, DL, InterimIVT, Src, Mask, VL);
11526 Src, Mask, VL);
11627 SDValue VL = Op.getOperand(2);
11638 lowerScalarSplat(SDValue(), Val, VL, ContainerVT, DL, DAG, Subtarget);
11699 // Slide the concatenated result by (VLMax - VL).
11775 SDValue VL = Op->getOperand(3);
11786 SDValue Val = DAG.getNode(getRISCVVLOp(Op), DL, ContainerVT, Op1, Op2, VL);
11893 SDValue Index, Mask, PassThru, VL;
11899 VL = VPGN->getVectorLength();
11940 if (!VL)
11941 VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
11959 Ops.push_back(VL);
11990 SDValue Index, Mask, Val, VL;
11996 VL = VPSN->getVectorLength();
12038 if (!VL)
12039 VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
12054 Ops.push_back(VL);
12690 // Use a VL of 1 to avoid processing more elements than we need.
12691 auto [Mask, VL] = getDefaultVLOps(1, ContainerVT, DL, DAG, Subtarget);
12697 DAG.getUNDEF(ContainerVT), Vec, Idx, Mask, VL);
12707 DAG.getConstant(32, DL, XLenVT), VL);
12710 DAG.getUNDEF(ContainerVT), Mask, VL);
12864 auto [Mask, VL] = getDefaultVLOps(1, VecVT, DL, DAG, Subtarget);
12868 DAG.getConstant(32, DL, XLenVT), VL);
12870 DAG.getUNDEF(VecVT), Mask, VL);
13105 // Make sure that ScalarV is a splat with VL=1.
14337 auto [Mask, VL] = getMaskAndVL(Root, DAG, Subtarget);
14344 return DAG.getNode(ExtOpc, DL, NarrowVT, Source, Mask, VL);
14349 DAG.getUNDEF(NarrowVT), Source.getOperand(1), VL);
14356 DAG.getUNDEF(NarrowVT), Source, VL);
14552 // that their passthru is undef, we can safely ignore their mask and VL.
14685 /// Helper function to get the Mask and VL from \p Root.
14770 SDValue Mask, VL, Merge;
14771 std::tie(Mask, VL) =
14788 Merge, Mask, VL);
15321 // VFCVT_..._VL node, as there are no specific VFWCVT/VFNCVT VL nodes. They
15336 auto [Mask, VL] =
15345 FpToInt = DAG.getNode(Opc, DL, ContainerVT, XVal, Mask, VL);
15349 FpToInt = DAG.getNode(Opc, DL, ContainerVT, XVal, Mask, VL);
15354 DAG.getTargetConstant(FRM, DL, XLenVT), VL);
15469 // NOTE: Only supports RVV operations with VL.
15516 SDValue VL = N->getOperand(4 + Offset);
15518 auto invertIfNegative = [&Mask, &VL](SDValue &V) {
15520 V.getOperand(2) == VL) {
15540 {N->getOperand(0), A, B, C, Mask, VL});
15542 VL);
15562 SDValue VL = N->getOperand(4);
15574 // Check the mask and VL are the same.
15575 if (Op0.getOperand(1) != Mask || Op0.getOperand(2) != VL ||
15576 Op1.getOperand(1) != Mask || Op1.getOperand(2) != VL)
15601 N->getOperand(2), Mask, VL);
16424 /// in VL, so even if we cause some extract VTYPE/VL toggles, we still
16475 SDValue VL = N->getOperand(2);
16477 bool IsVLMAX = isAllOnesConstant(VL) ||
16478 (isa<RegisterSDNode>(VL) &&
16479 cast<RegisterSDNode>(VL)->getReg() == RISCV::X0);
16481 Mask.getOperand(0) != VL)
16486 V.getOperand(1) == Mask && V.getOperand(2) == VL;
16534 SDValue VL = N->getOperand(2);
16536 auto MatchMinMax = [&VL, &Mask](SDValue V, unsigned Opc, unsigned OpcVL,
16540 V.getOperand(3) == Mask && V.getOperand(4) == VL))
16558 Op.getOperand(2) == VL) {
16597 Mask, VL);
16628 Src.getOperand(1) == Mask && Src.getOperand(2) == VL &&
16651 VL});
17258 SDValue VL = N->getOperand(4);
17261 ShAmt.getOperand(1), VL);
17398 // Combine store of vmv.x.s/vfmv.f.s to vse with VL of 1.
17449 SDValue VL = N->getOperand(2);
17451 // If VL is 1, we can use vfmv.s.f.
17452 if (isOneConstant(VL))
17453 return DAG.getNode(RISCVISD::VFMV_S_F_VL, DL, VT, Passthru, Scalar, VL);
17460 SDValue VL = N->getOperand(2);
17470 // If VL is 1 and the scalar value won't benefit from immediate, we can
17473 if (isOneConstant(VL) &&
17476 return DAG.getNode(RISCVISD::VMV_S_X_VL, DL, VT, Passthru, Scalar, VL);
17503 SDValue VL = N->getOperand(2);
17516 DAG.getNode(N->getOpcode(), DL, M1VT, M1Passthru, Scalar, VL);
17528 return DAG.getNode(RISCVISD::VMV_V_X_VL, DL, VT, Passthru, Scalar, VL);
17593 SDValue VL = N->getOperand(2);
17596 VL = N->getOperand(3);
17597 if (!isNullConstant(VL))
17599 // If VL is 0, vcpop -> li 0, vfirst -> li -1.
21460 // broadcast. For everything else, prefer ELenVT to minimize VL and thus
21712 Value *VL = ConstantInt::get(XLenTy, VTy->getNumElements());
21715 Builder.CreateCall(VlsegNFunc, {LI->getPointerOperand(), VL});
21775 // This VL should be OK (should be executable in one vsseg instruction,
21778 Value *VL = ConstantInt::get(XLenTy, VTy->getNumElements());
21779 Ops.append({SI->getPointerOperand(), VL});
21806 Value *VL;
21814 VL = ConstantInt::get(XLenTy, FVTy->getNumElements());
21824 VL = Constant::getAllOnesValue(XLenTy);
21828 Ops.append({LI->getPointerOperand(), VL});
21856 Value *VL;
21863 VL = ConstantInt::get(XLenTy, FVTy->getNumElements());
21873 VL = Constant::getAllOnesValue(XLenTy);
21877 SI->getPointerOperand(), VL});