Lines Matching defs:VL
2748 /// vector length VL. .
2749 static SDValue getAllOnesMask(MVT VecVT, SDValue VL, const SDLoc &DL,
2752 return DAG.getNode(RISCVISD::VMSET_VL, DL, MaskVT, VL);
2759 SDValue VL = DAG.getRegister(RISCV::X0, Subtarget.getXLenVT());
2760 SDValue Mask = getAllOnesMask(VecVT, VL, DL, DAG);
2761 return {Mask, VL};
2768 SDValue VL = DAG.getConstant(NumElts, DL, Subtarget.getXLenVT());
2769 SDValue Mask = getAllOnesMask(ContainerVT, VL, DL, DAG);
2770 return {Mask, VL};
2773 // Gets the two common "VL" operands: an all-ones mask and the vector length.
2973 auto [Mask, VL] = getDefaultVLOps(DstVT, DstContainerVT, DL, DAG, Subtarget);
2977 DAG.getUNDEF(Mask.getValueType()), Mask, VL});
2984 Src = DAG.getNode(RISCVISD::FP_EXTEND_VL, DL, InterVT, Src, Mask, VL);
2996 SDValue Res = DAG.getNode(RVVOpc, DL, CvtContainerVT, Src, Mask, VL);
3004 Res = DAG.getNode(ClipOpc, DL, CvtContainerVT, Res, Mask, VL);
3009 DAG.getConstant(0, DL, Subtarget.getXLenVT()), VL);
3011 Res, DAG.getUNDEF(DstContainerVT), VL);
3094 SDValue Mask, VL;
3100 VL = Op.getOperand(2);
3102 std::tie(Mask, VL) = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
3109 SDValue Abs = DAG.getNode(RISCVISD::FABS_VL, DL, ContainerVT, Src, Mask, VL);
3122 DAG.getUNDEF(ContainerVT), MaxValNode, VL);
3129 Mask, Mask, VL});
3153 DAG.getTargetConstant(FRM, DL, XLenVT), VL);
3158 Mask, VL);
3163 Mask, VL);
3170 Mask, VL);
3174 Src, Src, Mask, VL);
3199 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
3209 DAG.getUNDEF(MaskVT), Mask, VL});
3213 {Chain, Src, Src, Src, Unorder, VL});
3217 SDValue Abs = DAG.getNode(RISCVISD::FABS_VL, DL, ContainerVT, Src, Mask, VL);
3230 DAG.getUNDEF(ContainerVT), MaxValNode, VL);
3235 {Abs, MaxValSplat, DAG.getCondCode(ISD::SETOLT), Mask, Mask, VL});
3253 {Chain, Src, Mask, DAG.getTargetConstant(FRM, DL, XLenVT), VL});
3259 DAG.getVTList(IntVT, MVT::Other), Chain, Src, Mask, VL);
3264 Mask, VL);
3273 Truncated, Mask, VL);
3279 Src, Src, Mask, VL);
3329 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
3333 VL);
3344 SDValue Offset, SDValue Mask, SDValue VL,
3349 SDValue Ops[] = {Passthru, Op, Offset, Mask, VL, PolicyOp};
3356 SDValue VL,
3361 SDValue Ops[] = {Passthru, Op, Offset, Mask, VL, PolicyOp};
3565 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
3567 Idx, DAG.getUNDEF(ContainerVT), Mask, VL);
3589 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
3654 LastOp, Mask, VL);
3695 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
3702 SDValue VMClr = DAG.getNode(RISCVISD::VMCLR_VL, DL, ContainerVT, VL);
3707 SDValue VMSet = DAG.getNode(RISCVISD::VMSET_VL, DL, ContainerVT, VL);
3783 DAG.getNode(Opc, DL, ContainerVT, DAG.getUNDEF(ContainerVT), Splat, VL);
3820 SDValue VID = DAG.getNode(RISCVISD::VID_VL, DL, VIDContainerVT, Mask, VL);
3857 // If we can use the original VL with the modified element type, this
3858 // means we only have a VTYPE toggle, not a VL toggle. TODO: Should this
3911 // If we can use the original VL with the modified element type, this
3912 // means we only have a VTYPE toggle, not a VL toggle. TODO: Should this
3975 SDValue Res = DAG.getNode(RISCVISD::VSEXT_VL, DL, ContainerVT, Source, Mask, VL);
4111 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
4145 DAG.getNode(Opc, DL, ContainerVT, DAG.getUNDEF(ContainerVT), Splat, VL);
4183 // elements into the widest scalar type we can. This will force a VL/VTYPE
4232 // is linear in VL. However, at high lmuls vslide1down and vslidedown end up
4234 // lowering for every element ends up being VL*LMUL..
4302 Vec, Offset, Mask, VL, Policy);
4310 V, Mask, VL);
4315 Vec, Offset, Mask, VL, Policy);
4321 SDValue Lo, SDValue Hi, SDValue VL,
4331 return DAG.getNode(RISCVISD::VMV_V_X_VL, DL, VT, Passthru, Lo, VL);
4335 // vlmax vsetvli or vsetivli to change the VL.
4340 if (isAllOnesConstant(VL) ||
4341 (isa<RegisterSDNode>(VL) &&
4342 cast<RegisterSDNode>(VL)->getReg() == RISCV::X0))
4344 else if (isa<ConstantSDNode>(VL) && isUInt<4>(VL->getAsZExtVal()))
4345 NewVL = DAG.getNode(ISD::ADD, DL, VL.getValueType(), VL, VL);
4361 return DAG.getNode(RISCVISD::VMV_V_X_VL, DL, VT, Passthru, Lo, VL);
4366 return DAG.getNode(RISCVISD::VMV_V_X_VL, DL, VT, Passthru, Lo, VL);
4370 Hi, VL);
4377 SDValue Scalar, SDValue VL,
4382 return splatPartsI64WithVL(DL, VT, Passthru, Lo, Hi, VL, DAG);
4386 // length VL. It ensures the final sequence is type legal, which is useful when
4388 static SDValue lowerScalarSplat(SDValue Passthru, SDValue Scalar, SDValue VL,
4409 lowerScalarSplat(Passthru, Scalar, VL, IVT, DL, DAG, Subtarget);
4412 return DAG.getNode(RISCVISD::VFMV_V_F_VL, DL, VT, Passthru, Scalar, VL);
4424 return DAG.getNode(RISCVISD::VMV_V_X_VL, DL, VT, Passthru, Scalar, VL);
4430 if (isOneConstant(VL) && isNullConstant(Scalar))
4432 DAG.getConstant(0, DL, XLenVT), VL);
4435 return splatSplitI64WithVL(DL, VT, Passthru, Scalar, VL, DAG);
4439 // 0 of the vector regardless of the value of VL. The contents of the
4440 // remaining lanes of the result vector are unspecified. VL is assumed
4442 static SDValue lowerScalarInsert(SDValue Scalar, SDValue VL, MVT VT,
4475 DAG.getUNDEF(VT), Scalar, VL);
4492 VL);
4729 auto [TrueMask, VL] = getDefaultVLOps(SrcVT, ContainerVT, DL, DAG, Subtarget);
4733 DAG.getConstant(NewMask[0], DL, XLenVT), TrueMask, VL);
4771 // VL to the index + the number of elements being inserted.
4780 SDValue VL = DAG.getConstant(NumSubElts + Index, DL, XLenVT);
4787 VL);
4790 DAG.getConstant(Index, DL, XLenVT), TrueMask, VL, Policy);
4834 auto [TrueMask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
4848 IntVT, DAG.getUNDEF(IntVT), V2, Splat, TrueMask, VL);
4861 Splat, TrueMask, VL);
4962 auto [Mask, VL] = getDefaultVLOps(VecVT, VecContainerVT, DL, DAG, Subtarget);
4971 OffsetVec, Passthru, Mask, VL);
4973 Interleaved, EvenV, Passthru, Mask, VL);
4981 OddV, Passthru, Mask, VL);
4987 OddV, AllOnesVec, Passthru, Mask, VL);
4995 Interleaved, OddsMul, Passthru, Mask, VL);
5391 auto [TrueMask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
5428 VL};
5464 DAG.getNode(Opc, DL, SplatVT, DAG.getUNDEF(ContainerVT), V, VL);
5473 DAG.getUNDEF(ContainerVT), TrueMask, VL);
5520 // Even though we could use a smaller VL, don't to avoid a vsetivli
5523 DAG.getConstant(Rotation, DL, XLenVT), TrueMask, VL);
5527 DAG.getConstant(InvRotate, DL, XLenVT), TrueMask, VL,
5692 DAG.getUNDEF(ContainerVT), TrueMask, VL);
5782 SDValue Mask, VL;
5788 VL = Op.getOperand(2);
5812 Src, Mask, VL);
5813 Src = DAG.getNode(ISD::VP_AND, DL, VT, Src, Neg, Mask, VL);
5820 FloatVal = DAG.getNode(ISD::VP_UINT_TO_FP, DL, FloatVT, Src, Mask, VL);
5830 std::tie(Mask, VL) = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
5836 Src, Mask, RTZRM, VL);
5849 DAG.getConstant(ShiftAmt, DL, IntVT), Mask, VL);
5850 Exp = DAG.getVPZExtOrTrunc(DL, VT, Exp, Mask, VL);
5868 DAG.getConstant(ExponentBias, DL, VT), Mask, VL);
5876 Mask, VL);
5886 DAG.getConstant(EltSize, DL, VT), Mask, VL);
5921 // Convert -1 to VL.
6125 auto [Mask, VL] = getDefaultScalableVLOps(VT0, DL, DAG, Subtarget);
6128 VL = Op.getOperand(3);
6131 VL, Op->getFlags());
6145 auto [Mask, VL] = getDefaultVLOps(VT0, ContainerVT0, DL, DAG, Subtarget);
6151 VL = Op.getOperand(3);
6156 Mask, VL, Op->getFlags());
6159 DAG.getUNDEF(ContainerDstVT), TDCMaskV, VL);
6164 DAG.getUNDEF(ContainerVT), Mask, VL});
6168 TDCMaskV, DAG.getUNDEF(ContainerDstVT), Mask, VL);
6172 DAG.getUNDEF(ContainerDstVT), SplatZero, VL);
6176 DAG.getUNDEF(ContainerVT), Mask, VL});
6233 SDValue Mask, VL;
6239 VL = Op.getOperand(3);
6241 std::tie(Mask, VL) = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
6248 DAG.getUNDEF(ContainerVT), Mask, VL});
6250 DAG.getUNDEF(ContainerVT), VL);
6257 DAG.getUNDEF(ContainerVT), Mask, VL});
6259 DAG.getUNDEF(ContainerVT), VL);
6267 DAG.getUNDEF(ContainerVT), Mask, VL);
6356 /// Get a RISC-V target specified VL op for a given SDNode.
6367 llvm_unreachable("don't have RISC-V specified VL op for this SDNode");
6835 SDValue VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
6840 DAG.getUNDEF(ContainerVT), Scalar, VL);
6844 DAG.getUNDEF(ContainerVT), Scalar, VL);
7041 // For fixed-length vectors we lower to a custom "VL" node.
7077 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
7082 Op.getOperand(0), Src, Mask, VL);
7086 Src = DAG.getNode(RVVOpc, DL, ContainerVT, Src, Mask, VL);
8701 SDValue VL = getDefaultScalableVLOps(VT, DL, DAG, Subtarget).second;
8702 return DAG.getNode(RISCVISD::VMSET_VL, DL, VT, VL);
8705 SDValue VL = getDefaultScalableVLOps(VT, DL, DAG, Subtarget).second;
8706 return DAG.getNode(RISCVISD::VMCLR_VL, DL, VT, VL);
8735 auto VL = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget).second;
8738 splatPartsI64WithVL(DL, ContainerVT, SDValue(), Lo, Hi, VL, DAG);
8771 SDValue VL = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget).second;
8778 DAG.getUNDEF(ContainerVT), SplatZero, VL);
8780 DAG.getUNDEF(ContainerVT), SplatTrueVal, VL);
8783 SplatZero, DAG.getUNDEF(ContainerVT), VL);
8808 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
8810 SDValue Ext = DAG.getNode(ExtendOpc, DL, ContainerExtVT, Op1, Mask, VL);
8828 SDValue Mask, VL;
8831 VL = Op.getOperand(2);
8847 std::tie(Mask, VL) =
8855 DAG.getUNDEF(ContainerVT), SplatOne, VL);
8857 DAG.getUNDEF(ContainerVT), SplatZero, VL);
8861 DAG.getUNDEF(ContainerVT), Mask, VL);
8864 DAG.getUNDEF(MaskContainerVT), Mask, VL});
8898 SDValue Mask, VL;
8901 VL = Op.getOperand(2);
8914 std::tie(Mask, VL) =
8929 Result = DAG.getNode(NewOpc, DL, ResultVT, Result, Mask, VL);
8954 auto [Mask, VL] = getDefaultVLOps(SrcVT, ContainerVT, DL, DAG, Subtarget);
8969 Chain, Src, Mask, VL);
8977 Chain, Src, Mask, VL);
9017 SDValue Mask, VL;
9020 VL = Op.getOperand(2);
9034 std::tie(Mask, VL) =
9040 Src = DAG.getNode(ConvOpc, DL, ContainerVT, Src, Mask, VL);
9051 DAG.getNode(InterConvOpc, DL, InterVT, Src, Mask, VL);
9053 DAG.getNode(ConvOpc, DL, ContainerVT, IntermediateConv, Mask, VL);
9088 // original vector (with an undisturbed tail policy for elements >= VL), we
9090 // at VL-1, which is replaced with the desired value.
9176 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
9186 Vec = DAG.getNode(Opc, DL, ContainerVT, Vec, Val, VL);
9195 ValInVec = lowerScalarInsert(Val, VL, ContainerVT, DL, DAG, Subtarget);
9207 // Limit the active VL to two.
9286 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
9288 DAG.getNode(RISCVISD::VFIRST_VL, DL, XLenVT, Vec, Mask, VL);
9412 // Use a VL of 1 to avoid processing more elements than we need.
9413 auto [Mask, VL] = getDefaultVLOps(1, ContainerVT, DL, DAG, Subtarget);
9415 DAG.getUNDEF(ContainerVT), Vec, Idx, Mask, VL);
9511 // Double the VL since we halved SEW.
9541 SDValue VL = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, XLenVT, SETVL, AVL,
9544 DAG.getNode(ISD::SHL, DL, XLenVT, VL, DAG.getConstant(1, DL, XLenVT));
9595 SDValue VL = getVLOperand(Op);
9596 assert(VL.getValueType() == XLenVT);
9597 ScalarOp = splatSplitI64WithVL(DL, VT, SDValue(), ScalarOp, VL, DAG);
9657 auto [Mask, VL] = getDefaultVLOps(OpVT, ContainerVT, DL, DAG, Subtarget);
9658 SDValue Res = DAG.getNode(RISCVISD::VFIRST_VL, DL, XLenVT, Op0, Mask, VL);
9662 // Convert -1 to VL.
9665 VL = DAG.getElementCount(DL, XLenVT, OpVT.getVectorElementCount());
9666 return DAG.getSelect(DL, XLenVT, Setcc, VL, Res);
9862 SDValue VL = getVLOperand(Op);
9864 SDValue SplattedVal = splatSplitI64WithVL(DL, VT, SDValue(), Scalar, VL, DAG);
9869 DAG.getConstant(0, DL, MVT::i32), VL);
9872 SDValue Mask = getAllOnesMask(VT, VL, DL, DAG);
9873 SDValue VID = DAG.getNode(RISCVISD::VID_VL, DL, VT, Mask, VL);
9877 DAG.getUNDEF(MaskVT), Mask, VL});
9879 Vec, DAG.getUNDEF(VT), VL);
10043 SDValue VL = DAG.getConstant(VT.getVectorNumElements(), DL, XLenVT);
10053 VL,
10130 SDValue VL = DAG.getConstant(VT.getVectorNumElements(), DL, XLenVT);
10149 VL,
10249 SDValue Mask, VL;
10252 VL = Op.getOperand(3);
10254 std::tie(Mask, VL) =
10265 SDValue TrueMask = DAG.getNode(RISCVISD::VMSET_VL, DL, ContainerVT, VL);
10267 Vec = DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Vec, TrueMask, VL);
10270 Vec = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Vec, Mask, VL);
10277 Vec = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Vec, Mask, VL);
10284 Vec = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Vec, Mask, VL);
10319 SDValue VL, const SDLoc &DL, SelectionDAG &DAG,
10324 const bool NonZeroAVL = isNonZeroAVL(VL);
10329 // We reuse the VL of the reduction to reduce vsetvli toggles if we can
10332 auto InnerVL = NonZeroAVL ? VL : DAG.getConstant(1, DL, XLenVT);
10341 SDValue Ops[] = {PassThru, Vec, InitialValue, Mask, VL, Policy};
10379 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
10393 Mask, VL, DL, DAG, Subtarget);
10451 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
10453 VL, DL, DAG, Subtarget);
10465 DAG.getUNDEF(Mask.getValueType()), Mask, VL});
10467 SDValue CPop = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, IsNan, Mask, VL);
10497 SDValue VL = Op.getOperand(3);
10501 Vec, Mask, VL, DL, DAG, Subtarget);
10511 {Vec, Vec, DAG.getCondCode(ISD::SETNE), DAG.getUNDEF(PredVT), Mask, VL});
10512 SDValue VCPop = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, IsNaN, Mask, VL);
10597 SDValue VL = DAG.getConstant(EndIndex, DL, XLenVT);
10608 DAG.getNode(RISCVISD::VMV_V_V_VL, DL, ContainerVT, Vec, SubVec, VL);
10612 SlideupAmt, Mask, VL, Policy);
10697 // OFFSET<=i<VL set to the "subvector" and vl<=i<VLMAX set to the tail policy
10699 // where OFFSET is the insertion offset, and the VL is the OFFSET plus the
10720 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVecVT, DL, DAG, Subtarget);
10723 VL = DAG.getElementCount(DL, XLenVT, SubVecVT.getVectorElementCount());
10735 SubVec, VL);
10740 VL = DAG.getNode(ISD::ADD, DL, XLenVT, SlideupAmt, VL);
10743 SlideupAmt, Mask, VL, Policy);
10840 SDValue VL = DAG.getConstant(SubVecVT.getVectorNumElements(), DL, XLenVT);
10844 DAG.getUNDEF(ContainerVT), Vec, SlidedownAmt, Mask, VL);
10925 auto [Mask, VL] = getDefaultScalableVLOps(InterSubVT, DL, DAG, Subtarget);
10927 VL = DAG.getConstant(SubVecVT.getVectorNumElements(), DL, XLenVT);
10930 Vec, SlidedownAmt, Mask, VL);
11064 SDValue VL = DAG.getRegister(RISCV::X0, XLenVT);
11121 DAG.getNode(RISCVISD::ADD_VL, DL, IdxVT, Idx, VLMax, Idx, OddMask, VL);
11125 SDValue TrueMask = getAllOnesMask(IdxVT, VL, DL, DAG);
11127 Concat, Idx, DAG.getUNDEF(ConcatVT), TrueMask, VL);
11148 auto [Mask, VL] = getDefaultScalableVLOps(VT, DL, DAG, Subtarget);
11149 SDValue StepVec = DAG.getNode(RISCVISD::VID_VL, DL, VT, Mask, VL);
11155 DAG.getConstant(Log2_64(StepValImm), DL, XLenVT), VL);
11160 VL, VT, DL, DAG, Subtarget);
11192 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
11229 DAG.getUNDEF(ContainerVT), Concat, Offset, Mask, VL);
11298 SDValue VID = DAG.getNode(RISCVISD::VID_VL, DL, IntVT, Mask, VL);
11300 DAG.getUNDEF(IntVT), Mask, VL);
11303 DAG.getUNDEF(ContainerVT), Mask, VL);
11373 SDValue VL = DAG.getConstant(VT.getVectorNumElements(), DL, XLenVT);
11382 Ops.push_back(VL);
11432 SDValue VL = DAG.getConstant(VT.getVectorNumElements(), DL, XLenVT);
11439 {Store->getChain(), IntID, NewValue, Store->getBasePtr(), VL},
11454 SDValue Mask, PassThru, VL;
11459 VL = VPLoad->getVectorLength();
11481 if (!VL)
11482 VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
11486 ExpandingVL = VL;
11487 VL =
11489 getAllOnesMask(Mask.getSimpleValueType(), VL, DL, DAG), VL);
11502 Ops.push_back(VL);
11553 SDValue Val, Mask, VL;
11559 VL = VPStore->getVectorLength();
11584 if (!VL)
11585 VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
11590 DAG.getUNDEF(ContainerVT), Val, Mask, VL);
11591 VL =
11593 getAllOnesMask(Mask.getSimpleValueType(), VL, DL, DAG), VL);
11603 Ops.push_back(VL);
11627 SDValue VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
11631 Passthru, Val, Mask, VL);
11653 auto [Mask, VL] = getDefaultVLOps(VT.getVectorNumElements(), ContainerVT, DL,
11659 {Op1, Op2, Op.getOperand(2), DAG.getUNDEF(MaskVT), Mask, VL});
11714 auto [Mask, VL] = getDefaultVLOps(InVT, ContainerInVT, DL, DAG, Subtarget);
11722 SDValue True = getAllOnesMask(ContainerInVT, VL, DL, DAG);
11726 True, VL});
11730 True, VL});
11732 DAG.getNode(RISCVISD::VMAND_VL, DL, MaskVT, OrderMask1, OrderMask2, VL);
11737 {Chain, Op1, Op2, CC, Mask, Mask, VL});
11742 {Chain, Op1, Op2, CC, DAG.getUNDEF(MaskVT), Mask, VL});
11767 SDValue Mask, VL;
11773 VL = Op->getOperand(2);
11775 std::tie(Mask, VL) = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
11779 DAG.getConstant(0, DL, Subtarget.getXLenVT()), VL);
11781 DAG.getUNDEF(ContainerVT), Mask, VL);
11783 DAG.getUNDEF(ContainerVT), Mask, VL);
11803 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
11806 Sign, DAG.getUNDEF(ContainerVT), Mask, VL);
11827 SDValue VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
11830 Op2, DAG.getUNDEF(ContainerVT), VL);
11862 auto [Mask, VL] = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget);
11867 Ops.push_back(VL);
11923 // VFCVT_RM_X_F_VL requires a rounding mode to be injected before the VL.
11956 SDValue VL = Op.getOperand(2);
11968 DAG.getUNDEF(ContainerVT), Zero, VL);
11973 DAG.getUNDEF(ContainerVT), SplatValue, VL);
11976 ZeroSplat, DAG.getUNDEF(ContainerVT), VL);
11991 SDValue VL = Op.getOperand(4);
12001 SDValue AllOneMask = DAG.getNode(RISCVISD::VMSET_VL, DL, ContainerVT, VL);
12008 Result = DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Op1, Op2, VL);
12013 DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Op1, Op2, VL);
12015 DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Temp, AllOneMask, VL);
12023 DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Op1, AllOneMask, VL);
12024 Result = DAG.getNode(RISCVISD::VMAND_VL, DL, ContainerVT, Temp, Op2, VL);
12032 DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Op2, AllOneMask, VL);
12033 Result = DAG.getNode(RISCVISD::VMAND_VL, DL, ContainerVT, Op1, Temp, VL);
12041 DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Op1, AllOneMask, VL);
12042 Result = DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Temp, Op2, VL);
12050 DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Op2, AllOneMask, VL);
12051 Result = DAG.getNode(RISCVISD::VMXOR_VL, DL, ContainerVT, Temp, Op1, VL);
12068 SDValue VL = Op.getOperand(2);
12099 DAG.getUNDEF(IntVT), Zero, VL);
12103 DAG.getUNDEF(IntVT), One, VL);
12105 ZeroSplat, DAG.getUNDEF(IntVT), VL);
12110 Src = DAG.getNode(RISCVISDExtOpc, DL, IntVT, Src, Mask, VL);
12113 Result = DAG.getNode(RISCVISDOpc, DL, DstVT, Src, Mask, VL);
12124 DAG.getNode(RISCVISD::FP_EXTEND_VL, DL, InterimFVT, Src, Mask, VL);
12127 Result = DAG.getNode(RISCVISDOpc, DL, DstVT, Src, Mask, VL);
12142 Result = DAG.getNode(RISCVISDOpc, DL, InterimFVT, Src, Mask, VL);
12146 Result = DAG.getNode(RISCVISD::FP_ROUND_VL, DL, DstVT, Src, Mask, VL);
12160 Result = DAG.getNode(RISCVISDOpc, DL, InterimIVT, Src, Mask, VL);
12167 DAG.getUNDEF(InterimIVT), SplatZero, VL);
12170 DAG.getUNDEF(DstVT), Mask, VL});
12175 Result = DAG.getNode(RISCVISDOpc, DL, InterimIVT, Src, Mask, VL);
12183 Src, Mask, VL);
12204 SDValue VL = Op.getOperand(3);
12207 EVT EVLVecVT = EVT::getVectorVT(*DAG.getContext(), VL.getValueType(),
12233 SplatZero, DAG.getUNDEF(PromotedVT), VL);
12234 // Any element past VL uses FalseVal, so use VLMax
12240 TrueVal, FalseVal, FalseVal, VL);
12243 SDValue TrueMask = DAG.getNode(RISCVISD::VMSET_VL, DL, ContainerVT, VL);
12340 SDValue VL = Op.getOperand(2);
12351 lowerScalarSplat(SDValue(), Val, VL, ContainerVT, DL, DAG, Subtarget);
12412 // Slide the concatenated result by (VLMax - VL).
12488 SDValue VL = Op->getOperand(3);
12499 SDValue Val = DAG.getNode(getRISCVVLOp(Op), DL, ContainerVT, Op1, Op2, VL);
12606 SDValue Index, Mask, PassThru, VL;
12612 VL = VPGN->getVectorLength();
12653 if (!VL)
12654 VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
12672 Ops.push_back(VL);
12703 SDValue Index, Mask, Val, VL;
12709 VL = VPSN->getVectorLength();
12751 if (!VL)
12752 VL = getDefaultVLOps(VT, ContainerVT, DL, DAG, Subtarget).second;
12767 Ops.push_back(VL);
13381 // Use a VL of 1 to avoid processing more elements than we need.
13382 auto [Mask, VL] = getDefaultVLOps(1, ContainerVT, DL, DAG, Subtarget);
13388 DAG.getUNDEF(ContainerVT), Vec, Idx, Mask, VL);
13398 DAG.getConstant(32, DL, XLenVT), VL);
13401 DAG.getUNDEF(ContainerVT), Mask, VL);
13555 auto [Mask, VL] = getDefaultVLOps(1, VecVT, DL, DAG, Subtarget);
13559 DAG.getConstant(32, DL, XLenVT), VL);
13561 DAG.getUNDEF(VecVT), Mask, VL);
13795 // Make sure that ScalarV is a splat with VL=1.
15081 auto [Mask, VL] = getMaskAndVL(Root, DAG, Subtarget);
15088 return DAG.getNode(ExtOpc, DL, NarrowVT, Source, Mask, VL);
15093 DAG.getUNDEF(NarrowVT), Source.getOperand(1), VL);
15100 DAG.getUNDEF(NarrowVT), Source, VL);
15317 // that their passthru is undef, we can safely ignore their mask and VL.
15464 /// Helper function to get the Mask and VL from \p Root.
15553 SDValue Mask, VL, Passthru;
15554 std::tie(Mask, VL) =
15571 Passthru, Mask, VL);
16113 // VFCVT_..._VL node, as there are no specific VFWCVT/VFNCVT VL nodes. They
16128 auto [Mask, VL] =
16137 FpToInt = DAG.getNode(Opc, DL, ContainerVT, XVal, Mask, VL);
16142 DAG.getTargetConstant(FRM, DL, XLenVT), VL);
16378 // NOTE: Only supports RVV operations with VL.
16427 SDValue VL = N->getOperand(4 + Offset);
16429 auto invertIfNegative = [&Mask, &VL](SDValue &V) {
16431 V.getOperand(2) == VL) {
16451 {N->getOperand(0), A, B, C, Mask, VL});
16453 VL);
17402 /// in VL, so even if we cause some extract VTYPE/VL toggles, we still
17453 SDValue VL = N->getOperand(2);
17455 bool IsVLMAX = isAllOnesConstant(VL) ||
17456 (isa<RegisterSDNode>(VL) &&
17457 cast<RegisterSDNode>(VL)->getReg() == RISCV::X0);
17459 Mask.getOperand(0) != VL)
17464 V.getOperand(1) == Mask && V.getOperand(2) == VL;
17512 SDValue VL = N->getOperand(2);
17514 auto MatchMinMax = [&VL, &Mask](SDValue V, unsigned Opc, unsigned OpcVL,
17518 V.getOperand(3) == Mask && V.getOperand(4) == VL))
17536 Op.getOperand(2) == VL) {
17575 Mask, VL);
17606 Src.getOperand(1) == Mask && Src.getOperand(2) == VL &&
17624 Val = DAG.getNode(ClipOpc, DL, ValVT, Val, Mask, VL);
17669 auto [Mask, VL] = getDefaultVLOps(SrcMVT, ContainerVT, DL, DAG, Subtarget);
17672 SDValue Pop = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Src, Mask, VL);
18316 SDValue VL = N->getOperand(4);
18319 ShAmt.getOperand(1), VL);
18452 // Combine store of vmv.x.s/vfmv.f.s to vse with VL of 1.
18507 SDValue VL = N->getOperand(2);
18509 // If VL is 1, we can use vfmv.s.f.
18510 if (isOneConstant(VL))
18511 return DAG.getNode(RISCVISD::VFMV_S_F_VL, DL, VT, Passthru, Scalar, VL);
18518 SDValue VL = N->getOperand(2);
18528 // If VL is 1 and the scalar value won't benefit from immediate, we can
18531 if (isOneConstant(VL) &&
18534 return DAG.getNode(RISCVISD::VMV_S_X_VL, DL, VT, Passthru, Scalar, VL);
18561 SDValue VL = N->getOperand(2);
18574 DAG.getNode(N->getOpcode(), DL, M1VT, M1Passthru, Scalar, VL);
18586 return DAG.getNode(RISCVISD::VMV_V_X_VL, DL, VT, Passthru, Scalar, VL);
18614 SDValue VL = N->getOperand(2);
18617 VL = N->getOperand(3);
18618 if (!isNullConstant(VL))
18620 // If VL is 0, vcpop -> li 0, vfirst -> li -1.
22041 // broadcast. For everything else, prefer ELenVT to minimize VL and thus
22368 Value *VL = Builder.getInt32(VTy->getNumElements());
22373 {BasePtr, Stride, Mask, VL});
22380 Value *VL = ConstantInt::get(XLenTy, VTy->getNumElements());
22384 {LI->getPointerOperand(), VL});
22445 Value *VL = Builder.getInt32(VTy->getNumElements());
22450 {Data, BasePtr, Stride, Mask, VL});
22469 // This VL should be OK (should be executable in one vsseg instruction,
22472 Value *VL = ConstantInt::get(XLenTy, VTy->getNumElements());
22473 Ops.append({SI->getPointerOperand(), VL});
22501 Value *VL = ConstantInt::get(XLenTy, FVTy->getNumElements());
22505 {LI->getPointerOperand(), VL});
22521 Value *VL = Constant::getAllOnesValue(XLenTy);
22525 {PoisonValue::get(VecTupTy), LI->getPointerOperand(), VL,
22574 Value *VL = ConstantInt::get(XLenTy, FVTy->getNumElements());
22575 Ops.append({SI->getPointerOperand(), VL});
22596 Value *VL = Constant::getAllOnesValue(XLenTy);
22604 Builder.CreateCall(VssegNFunc, {StoredVal, SI->getPointerOperand(), VL,