Lines Matching refs:XLenVT
118 MVT XLenVT = Subtarget.getXLenVT();
121 addRegisterClass(XLenVT, &RISCV::GPRRegClass);
235 setLoadExtAction({ISD::EXTLOAD, ISD::SEXTLOAD, ISD::ZEXTLOAD}, XLenVT,
242 setOperationAction(ISD::DYNAMIC_STACKALLOC, XLenVT, Expand);
245 setOperationAction(ISD::BR_CC, XLenVT, Expand);
249 setOperationAction(ISD::SELECT_CC, XLenVT, Expand);
254 setCondCodeAction(ISD::SETLE, XLenVT, Expand);
255 setCondCodeAction(ISD::SETGT, XLenVT, Custom);
256 setCondCodeAction(ISD::SETGE, XLenVT, Expand);
258 setCondCodeAction(ISD::SETULE, XLenVT, Expand);
259 setCondCodeAction(ISD::SETUGT, XLenVT, Custom);
260 setCondCodeAction(ISD::SETUGE, XLenVT, Expand);
300 setOperationAction({ISD::MUL, ISD::MULHS, ISD::MULHU}, XLenVT, Expand);
315 XLenVT, Expand);
333 {ISD::SDIVREM, ISD::UDIVREM, ISD::SMUL_LOHI, ISD::UMUL_LOHI}, XLenVT,
336 setOperationAction({ISD::SHL_PARTS, ISD::SRL_PARTS, ISD::SRA_PARTS}, XLenVT,
345 setOperationAction({ISD::ROTL, ISD::ROTR}, XLenVT, Custom);
347 setOperationAction(ISD::ROTL, XLenVT, Expand);
349 setOperationAction({ISD::ROTL, ISD::ROTR}, XLenVT, Expand);
356 setOperationAction(ISD::BSWAP, XLenVT,
370 setOperationAction(ISD::BITREVERSE, XLenVT, Legal);
373 setOperationAction(ISD::BITREVERSE, XLenVT,
378 setOperationAction({ISD::SMIN, ISD::SMAX, ISD::UMIN, ISD::UMAX}, XLenVT,
391 setOperationAction({ISD::CTTZ, ISD::CTPOP}, XLenVT, Expand);
410 setOperationAction(ISD::CTLZ, XLenVT, Expand);
421 setOperationAction(ISD::ABS, XLenVT, Legal);
424 setOperationAction(ISD::SELECT, XLenVT, Custom);
604 setOperationAction({ISD::FP_TO_UINT_SAT, ISD::FP_TO_SINT_SAT}, XLenVT,
609 XLenVT, Legal);
616 setOperationAction(ISD::GET_ROUNDING, XLenVT, Custom);
622 XLenVT, Custom);
624 setOperationAction(ISD::GlobalTLSAddress, XLenVT, Custom);
669 setOperationAction(ISD::VSCALE, XLenVT, Custom);
1412 setOperationAction(ISD::ATOMIC_LOAD_SUB, XLenVT, Expand);
1424 XLenVT, LibCall);
1454 setOperationAction(ISD::ABS, XLenVT, Legal);
1455 setOperationAction(ISD::SMIN, XLenVT, Legal);
1456 setOperationAction(ISD::UMIN, XLenVT, Legal);
1457 setOperationAction(ISD::SMAX, XLenVT, Legal);
1458 setOperationAction(ISD::UMAX, XLenVT, Legal);
3094 MVT XLenVT = Subtarget.getXLenVT();
3112 DAG.getTargetConstant(FRM, DL, XLenVT), VL);
3202 MVT XLenVT = Subtarget.getXLenVT();
3216 {Chain, Src, Mask, DAG.getTargetConstant(FRM, DL, XLenVT), VL});
3523 MVT XLenVT = Subtarget.getXLenVT();
3585 LastOp = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, LastOp);
3606 return DAG.getConstant(V == V1, DL, XLenVT);
3630 MVT XLenVT = Subtarget.getXLenVT();
3648 // is at most XLenVT, but may be shrunk to a smaller vector element type
3650 // XLenVT if we're producing a v8i1. This results in more consistent
3682 SDValue Elt = DAG.getConstant(Bits, DL, XLenVT);
3699 DAG.getConstant(0, DL, XLenVT));
3714 Splat = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, Splat);
3814 DAG.getConstant(SplatValue, DL, XLenVT),
3819 DAG.getConstant(0, DL, XLenVT));
3872 assert((ViaIntVT.bitsLE(XLenVT) ||
3875 if (ViaIntVT.bitsLE(XLenVT) || isInt<32>(SplatValue)) {
3877 DAG.getConstant(ViaVecVT.getVectorNumElements(), DL, XLenVT);
3883 DAG.getConstant(SplatValue, DL, XLenVT), ViaVL);
3888 DAG.getConstant(0, DL, XLenVT));
3962 // scalars are XLenVT, possibly masked (see below).
3963 MVT XLenVT = Subtarget.getXLenVT();
3965 APInt::getLowBitsSet(XLenVT.getSizeInBits(), ElemSizeInBits), DL, XLenVT);
3976 ElemDL, XLenVT, A, B),
3979 A = DAG.getNode(ISD::AND, SDLoc(A), XLenVT, A, Mask);
3980 B = DAG.getNode(ISD::AND, SDLoc(B), XLenVT, B, Mask);
3981 SDValue ShtAmt = DAG.getConstant(ElemSizeInBits, ElemDL, XLenVT);
3984 return DAG.getNode(ISD::OR, ElemDL, XLenVT, A,
3985 DAG.getNode(ISD::SHL, ElemDL, XLenVT, B, ShtAmt), Flags);
4029 MVT XLenVT = Subtarget.getXLenVT();
4061 Splat = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, Splat);
4136 MaskVals.push_back(DAG.getConstant(SelectMaskVal, DL, XLenVT));
4315 MVT XLenVT = Subtarget.getXLenVT();
4317 // Simplest case is that the operand needs to be promoted to XLenVT.
4318 if (Scalar.getValueType().bitsLE(XLenVT)) {
4325 Scalar = DAG.getNode(ExtOpc, DL, XLenVT, Scalar);
4329 assert(XLenVT == MVT::i32 && Scalar.getValueType() == MVT::i64 &&
4334 DAG.getConstant(0, DL, XLenVT), VL);
4349 const MVT XLenVT = Subtarget.getXLenVT();
4381 if (!Scalar.getValueType().bitsLE(XLenVT))
4383 DAG.getConstant(1, DL, XLenVT),
4392 Scalar = DAG.getNode(ExtOpc, DL, XLenVT, Scalar);
4669 MVT XLenVT = Subtarget.getXLenVT();
4676 DAG.getConstant(NewMask[0], DL, XLenVT), TrueMask, VL);
4680 DAG.getConstant(0, DL, XLenVT));
4710 MVT XLenVT = Subtarget.getXLenVT();
4723 SDValue VL = DAG.getConstant(NumSubElts + Index, DL, XLenVT);
4733 DAG.getConstant(Index, DL, XLenVT), TrueMask, VL, Policy);
5083 MVT XLenVT = Subtarget.getXLenVT();
5136 if (SVT.isInteger() && SVT.bitsGT(XLenVT)) {
5139 DAG.getTargetConstant(Intrinsic::riscv_vlse, DL, XLenVT);
5144 DAG.getRegister(RISCV::X0, XLenVT),
5171 V = DAG.getExtLoad(ISD::EXTLOAD, DL, XLenVT, Ld->getChain(), NewAddr,
5188 V1, DAG.getConstant(Lane, DL, XLenVT),
5239 DAG.getConstant(Rotation, DL, XLenVT), TrueMask, VL);
5243 DAG.getConstant(InvRotate, DL, XLenVT), TrueMask, VL,
5307 // than XLenVT.
5308 if (IndexVT.getScalarType().bitsGT(XLenVT)) {
5330 ? DAG.getConstant(MaskIndex, DL, XLenVT)
5331 : DAG.getUNDEF(XLenVT));
5368 MaskVals.push_back(DAG.getConstant(SelectMaskVal, DL, XLenVT));
5522 MVT XLenVT = Subtarget.getXLenVT();
5545 SDValue Res = DAG.getNode(RISCVISD::VFIRST_VL, DL, XLenVT, Source, Mask, EVL);
5552 DAG.getSetCC(DL, XLenVT, Res, DAG.getConstant(0, DL, XLenVT), ISD::SETLT);
5553 Res = DAG.getSelect(DL, XLenVT, SetCC, EVL, Res);
5762 MVT XLenVT = Subtarget.getXLenVT();
5788 SDValue TDCMaskV = DAG.getConstant(TDCMask, DL, XLenVT);
5841 SDValue SplatZero = DAG.getConstant(0, DL, XLenVT);
5851 SDValue FCLASS = DAG.getNode(RISCVISD::FCLASS, DL, XLenVT, Op.getOperand(0));
5852 SDValue AND = DAG.getNode(ISD::AND, DL, XLenVT, FCLASS, TDCMaskV);
5853 SDValue Res = DAG.getSetCC(DL, XLenVT, AND, DAG.getConstant(0, DL, XLenVT),
5869 MVT XLenVT = Subtarget.getXLenVT();
5878 SDValue XIsNonNan = DAG.getSetCC(DL, XLenVT, X, X, ISD::SETOEQ);
5884 SDValue YIsNonNan = DAG.getSetCC(DL, XLenVT, Y, Y, ISD::SETOEQ);
6301 MVT XLenVT = Subtarget.getXLenVT();
6304 SDValue NewOp0 = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, Op0);
6310 SDValue NewOp0 = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, Op0);
6436 MVT XLenVT = Subtarget.getXLenVT();
6439 SDValue Res = DAG.getNode(RISCVISD::READ_VLENB, DL, XLenVT);
6452 Res = DAG.getNode(ISD::SRL, DL, XLenVT, Res,
6455 Res = DAG.getNode(ISD::SHL, DL, XLenVT, Res,
6456 DAG.getConstant(Log2 - 3, DL, XLenVT));
6460 Res = DAG.getNode(ISD::MUL, DL, XLenVT, Res,
6461 DAG.getConstant(Val / 8, DL, XLenVT));
6463 SDValue VScale = DAG.getNode(ISD::SRL, DL, XLenVT, Res,
6464 DAG.getConstant(3, DL, XLenVT));
6465 Res = DAG.getNode(ISD::MUL, DL, XLenVT, VScale,
6466 DAG.getConstant(Val, DL, XLenVT));
7411 MVT XLenVT = Subtarget.getXLenVT();
7430 SDValue TPReg = DAG.getRegister(RISCV::X4, XLenVT);
7446 SDValue TPReg = DAG.getRegister(RISCV::X4, XLenVT);
7699 MVT XLenVT = Subtarget.getXLenVT();
7794 SDValue XOR = DAG.getNode(ISD::XOR, DL, XLenVT, CondV,
7795 DAG.getConstant(1, DL, XLenVT));
7800 // If the condition is not an integer SETCC which operates on XLenVT, we need
7805 CondV.getOperand(0).getSimpleValueType() != XLenVT) {
7806 SDValue Zero = DAG.getConstant(0, DL, XLenVT);
7814 // If the CondV is the output of a SETCC node which operates on XLenVT inputs,
7874 MVT XLenVT = Subtarget.getXLenVT();
7877 CondV.getOperand(0).getValueType() == XLenVT) {
7890 CondV, DAG.getConstant(0, DL, XLenVT),
7938 MVT XLenVT = Subtarget.getXLenVT();
7958 Register Reg = MF.addLiveIn(RI.getRARegister(), getRegClassFor(XLenVT));
7959 return DAG.getCopyFromReg(DAG.getEntryNode(), DL, Reg, XLenVT);
8134 MVT XLenVT = Subtarget.getXLenVT();
8135 SDValue SplatZero = DAG.getConstant(0, DL, XLenVT);
8136 SDValue SplatTrueVal = DAG.getConstant(ExtTrueVal, DL, XLenVT);
8506 MVT XLenVT = Subtarget.getXLenVT();
8530 Val = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, Val);
8553 SDValue InsertI64VL = DAG.getConstant(2, DL, XLenVT);
8592 DAG.getNode(ISD::ADD, DL, XLenVT, Idx, DAG.getConstant(1, DL, XLenVT));
8621 MVT XLenVT = Subtarget.getXLenVT();
8633 DAG.getNode(RISCVISD::VFIRST_VL, DL, XLenVT, Vec, Mask, VL);
8634 SDValue Res = DAG.getSetCC(DL, XLenVT, Vfirst,
8635 DAG.getConstant(0, DL, XLenVT), ISD::SETEQ);
8647 std::min(MaxEEW, unsigned(XLenVT.getSizeInBits())));
8653 ExtractElementIdx = DAG.getConstant(0, DL, XLenVT);
8660 ISD::SRL, DL, XLenVT, Idx,
8661 DAG.getConstant(Log2_64(WideEltVT.getSizeInBits()), DL, XLenVT));
8664 ISD::AND, DL, XLenVT, Idx,
8665 DAG.getConstant(WideEltVT.getSizeInBits() - 1, DL, XLenVT));
8669 SDValue ExtractElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, XLenVT,
8673 DAG.getNode(ISD::SRL, DL, XLenVT, ExtractElt, ExtractBitIdx);
8674 SDValue Res = DAG.getNode(ISD::AND, DL, XLenVT, ShiftRight,
8675 DAG.getConstant(1, DL, XLenVT));
8725 DAG.getConstant(0, DL, XLenVT));
8759 SDValue Elt0 = DAG.getNode(RISCVISD::VMV_X_S, DL, XLenVT, Vec);
8792 MVT XLenVT = Subtarget.getXLenVT();
8794 // If this isn't a scalar, or its type is XLenVT we're done.
8795 if (!OpVT.isScalarInteger() || OpVT == XLenVT)
8798 // Simplest case is that the operand needs to be promoted to XLenVT.
8799 if (OpVT.bitsLT(XLenVT)) {
8806 ScalarOp = DAG.getNode(ExtOpc, DL, XLenVT, ScalarOp);
8819 // The more complex case is when the scalar is larger than XLenVT.
8820 assert(XLenVT == MVT::i32 && OpVT == MVT::i64 &&
8857 I32VL = DAG.getConstant(2 * AVLInt, DL, XLenVT);
8861 SDValue LMUL = DAG.getConstant(Lmul, DL, XLenVT);
8863 SDValue SEW = DAG.getConstant(Sew, DL, XLenVT);
8866 I32VL = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, XLenVT, SETVLMAX, SEW,
8876 SDValue LMUL = DAG.getConstant(Lmul, DL, XLenVT);
8878 SDValue SEW = DAG.getConstant(Sew, DL, XLenVT);
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));
8938 assert(VL.getValueType() == XLenVT);
8955 MVT XLenVT = Subtarget.getXLenVT();
8977 SDValue LMul = DAG.getTargetConstant(VLMUL, DL, XLenVT);
8978 SDValue Sew = DAG.getTargetConstant(VSEW, DL, XLenVT);
8980 SDValue AVL = DAG.getNode(ISD::ZERO_EXTEND, DL, XLenVT, N->getOperand(1));
8982 SDValue ID = DAG.getTargetConstant(Intrinsic::riscv_vsetvli, DL, XLenVT);
8984 DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, XLenVT, ID, AVL, Sew, LMul);
8997 MVT XLenVT = Subtarget.getXLenVT();
9000 SDValue Res = DAG.getNode(RISCVISD::VFIRST_VL, DL, XLenVT, Op0, Mask, VL);
9006 DAG.getSetCC(DL, XLenVT, Res, DAG.getConstant(0, DL, XLenVT), ISD::SETLT);
9007 VL = DAG.getElementCount(DL, XLenVT, OpVT.getVectorElementCount());
9008 return DAG.getSelect(DL, XLenVT, Setcc, VL, Res);
9032 MVT XLenVT = Subtarget.getXLenVT();
9035 // If this isn't a scalar, or its type is XLenVT we're done.
9036 if (!OpVT.isScalarInteger() || OpVT == XLenVT)
9040 if (OpVT.bitsLT(XLenVT)) {
9043 ScalarOp = DAG.getNode(ExtOpc, DL, XLenVT, ScalarOp);
9083 MVT XLenVT = Subtarget.getXLenVT();
9119 return DAG.getNode(Opc, DL, XLenVT, Op.getOperand(1));
9136 return DAG.getNode(Opc, DL, XLenVT, Op.getOperand(1), Op.getOperand(2),
9143 return DAG.getNode(Opc, DL, XLenVT, Op.getOperand(1));
9154 return DAG.getNode(RISCVISD::MOPR, DL, XLenVT, Op.getOperand(1),
9169 return DAG.getNode(RISCVISD::MOPRR, DL, XLenVT, Op.getOperand(1),
9181 return DAG.getNode(RISCVISD::CLMUL, DL, XLenVT, Op.getOperand(1),
9202 return DAG.getNode(Opc, DL, XLenVT, Op.getOperand(1), Op.getOperand(2));
9209 SDValue Res = DAG.getNode(RISCVISD::VMV_X_S, DL, XLenVT, Op.getOperand(1));
9225 if (Scalar.getValueType().bitsLE(XLenVT)) {
9226 Scalar = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, Scalar);
9411 MVT XLenVT = Subtarget.getXLenVT();
9443 DAG.getExtLoad(ISD::EXTLOAD, DL, XLenVT, Load->getChain(), Ptr,
9456 XLenVT);
9470 DAG.getTargetConstant(RISCVII::TAIL_AGNOSTIC, DL, XLenVT);
9499 MVT XLenVT = Subtarget.getXLenVT();
9505 SDValue IntID = DAG.getTargetConstant(VlsegInts[NF - 2], DL, XLenVT);
9565 MVT XLenVT = Subtarget.getXLenVT();
9589 XLenVT);
9620 MVT XLenVT = Subtarget.getXLenVT();
9626 SDValue IntID = DAG.getTargetConstant(VssegInts[NF - 2], DL, XLenVT);
9725 MVT XLenVT = Subtarget.getXLenVT();
9744 SDValue Zero = DAG.getConstant(0, DL, XLenVT);
9754 Vec = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Vec, Mask, VL);
9762 Vec = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Vec, Mask, VL);
9769 SDValue One = DAG.getConstant(1, DL, XLenVT);
9770 Vec = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Vec, Mask, VL);
9771 Vec = DAG.getNode(ISD::AND, DL, XLenVT, Vec, One);
9778 SDValue SetCC = DAG.getSetCC(DL, XLenVT, Vec, Zero, CC);
9808 const MVT XLenVT = Subtarget.getXLenVT();
9817 auto InnerVL = NonZeroAVL ? VL : DAG.getConstant(1, DL, XLenVT);
9825 SDValue Policy = DAG.getTargetConstant(RISCVII::TAIL_AGNOSTIC, DL, XLenVT);
9951 MVT XLenVT = Subtarget.getXLenVT();
9952 SDValue CPop = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, IsNan, Mask, VL);
9953 SDValue NoNaNs = DAG.getSetCC(DL, XLenVT, CPop,
9954 DAG.getConstant(0, DL, XLenVT), ISD::SETEQ);
9968 MVT XLenVT = Subtarget.getXLenVT();
9998 SDValue VCPop = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, IsNaN, Mask, VL);
10000 SDValue StartIsNaN = DAG.getSetCC(DL, XLenVT, Start, Start, ISD::SETUO);
10001 VCPop = DAG.getNode(ISD::OR, DL, XLenVT, VCPop, StartIsNaN);
10002 SDValue NoNaNs = DAG.getSetCC(DL, XLenVT, VCPop,
10003 DAG.getConstant(0, DL, XLenVT), ISD::SETEQ);
10019 MVT XLenVT = Subtarget.getXLenVT();
10104 SDValue SlideupAmt = DAG.getConstant(OrigIdx, DL, XLenVT);
10211 VL = DAG.getElementCount(DL, XLenVT, SubVecVT.getVectorElementCount());
10225 SDValue SlideupAmt = DAG.getElementCount(DL, XLenVT, RemIdx);
10228 VL = DAG.getNode(ISD::ADD, DL, XLenVT, SlideupAmt, VL);
10255 MVT XLenVT = Subtarget.getXLenVT();
10330 SDValue SlidedownAmt = DAG.getConstant(OrigIdx, DL, XLenVT);
10401 SDValue SlidedownAmt = DAG.getElementCount(DL, XLenVT, RemIdx);
10538 MVT XLenVT = Subtarget.getXLenVT();
10539 SDValue VL = DAG.getRegister(RISCV::X0, XLenVT);
10580 SDValue Ones = DAG.getSplatVector(IdxVT, DL, DAG.getConstant(1, DL, XLenVT));
10586 DAG.getSplatVector(IdxVT, DL, DAG.getConstant(0, DL, XLenVT)),
10622 MVT XLenVT = Subtarget.getXLenVT();
10630 DAG.getConstant(Log2_64(StepValImm), DL, XLenVT), VL);
10695 MVT XLenVT = Subtarget.getXLenVT();
10699 SDValue VLMinus1 = DAG.getNode(ISD::SUB, DL, XLenVT,
10701 DAG.getConstant(1, DL, XLenVT));
10711 VLMinus1, DAG.getRegister(RISCV::X0, XLenVT));
10726 MVT XLenVT = Subtarget.getXLenVT();
10736 DownOffset = DAG.getConstant(ImmValue, DL, XLenVT);
10737 UpOffset = DAG.getNode(ISD::SUB, DL, XLenVT, VLMax, DownOffset);
10741 UpOffset = DAG.getConstant(-ImmValue, DL, XLenVT);
10742 DownOffset = DAG.getNode(ISD::SUB, DL, XLenVT, VLMax, UpOffset);
10751 TrueMask, DAG.getRegister(RISCV::X0, XLenVT),
10767 MVT XLenVT = Subtarget.getXLenVT();
10789 IsMaskOp ? Intrinsic::riscv_vlm : Intrinsic::riscv_vle, DL, XLenVT);
10817 MVT XLenVT = Subtarget.getXLenVT();
10850 IsMaskOp ? Intrinsic::riscv_vsm : Intrinsic::riscv_vse, DL, XLenVT);
10881 MVT XLenVT = Subtarget.getXLenVT();
10898 SmallVector<SDValue, 8> Ops{Chain, DAG.getTargetConstant(IntID, DL, XLenVT)};
10908 Ops.push_back(DAG.getTargetConstant(RISCVII::TAIL_AGNOSTIC, DL, XLenVT));
10949 MVT XLenVT = Subtarget.getXLenVT();
10967 DAG.getConstant(Intrinsic::riscv_vcompress, DL, XLenVT),
10970 DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Mask,
10976 SmallVector<SDValue, 8> Ops{Chain, DAG.getTargetConstant(IntID, DL, XLenVT)};
11308 MVT XLenVT = Subtarget.getXLenVT();
11309 SDValue Zero = DAG.getConstant(0, DL, XLenVT);
11314 Op.getOpcode() == ISD::VP_ZERO_EXTEND ? 1 : -1, DL, XLenVT);
11439 MVT XLenVT = Subtarget.getXLenVT();
11440 SDValue Zero = DAG.getConstant(0, DL, XLenVT);
11444 RISCVISDExtOpc == RISCVISD::VZEXT_VL ? 1 : -1, DL, XLenVT);
11507 MVT XLenVT = Subtarget.getXLenVT();
11508 SDValue SplatZero = DAG.getConstant(0, DL, XLenVT);
11550 const MVT XLenVT = Subtarget.getXLenVT();
11561 // EVL1 may need to be extended to XLenVT with RV64LegalI32.
11562 EVL1 = DAG.getNode(ISD::ZERO_EXTEND, DL, XLenVT, EVL1);
11571 DAG.getConstant(1, DL, XLenVT), EVL1);
11574 DAG.getConstant(0, DL, XLenVT), EVL1);
11580 DAG.getConstant(1, DL, XLenVT), EVL2);
11583 DAG.getConstant(0, DL, XLenVT), EVL2);
11593 DownOffset = DAG.getConstant(ImmValue, DL, XLenVT);
11594 UpOffset = DAG.getNode(ISD::SUB, DL, XLenVT, EVL1, DownOffset);
11598 UpOffset = DAG.getConstant(-ImmValue, DL, XLenVT);
11599 DownOffset = DAG.getNode(ISD::SUB, DL, XLenVT, EVL1, UpOffset);
11650 MVT XLenVT = Subtarget.getXLenVT();
11674 DAG.getConstant(1, DL, XLenVT), EVL);
11677 DAG.getConstant(0, DL, XLenVT), EVL);
11718 DAG.getVScale(DL, XLenVT, APInt(XLenVT.getSizeInBits(), MinElts));
11719 SDValue Diff = DAG.getNode(ISD::SUB, DL, XLenVT, VLMax, EVL);
11745 DAG.getNode(ISD::SUB, DL, XLenVT, EVL, DAG.getConstant(1, DL, XLenVT));
11795 MVT XLenVT = Subtarget.getXLenVT();
11810 DL, XLenVT);
11823 SDValue Policy = DAG.getTargetConstant(RISCVII::TAIL_AGNOSTIC, DL, XLenVT);
11841 MVT XLenVT = Subtarget.getXLenVT();
11858 DL, XLenVT);
11912 MVT XLenVT = Subtarget.getXLenVT();
11916 assert(BasePtr.getSimpleValueType() == XLenVT && "Unexpected pointer type");
11943 if (XLenVT == MVT::i32 && IndexVT.getVectorElementType().bitsGT(XLenVT)) {
11944 IndexVT = IndexVT.changeVectorElementType(XLenVT);
11950 SmallVector<SDValue, 8> Ops{Chain, DAG.getTargetConstant(IntID, DL, XLenVT)};
11961 Ops.push_back(DAG.getTargetConstant(RISCVII::TAIL_AGNOSTIC, DL, XLenVT));
12010 MVT XLenVT = Subtarget.getXLenVT();
12014 assert(BasePtr.getSimpleValueType() == XLenVT && "Unexpected pointer type");
12041 if (XLenVT == MVT::i32 && IndexVT.getVectorElementType().bitsGT(XLenVT)) {
12042 IndexVT = IndexVT.changeVectorElementType(XLenVT);
12048 SmallVector<SDValue, 8> Ops{Chain, DAG.getTargetConstant(IntID, DL, XLenVT)};
12062 const MVT XLenVT = Subtarget.getXLenVT();
12066 RISCVSysReg::lookupSysRegByName("FRM")->Encoding, DL, XLenVT);
12067 SDVTList VTs = DAG.getVTList(XLenVT, MVT::Other);
12082 DAG.getNode(ISD::SHL, DL, XLenVT, RM, DAG.getConstant(2, DL, XLenVT));
12083 SDValue Shifted = DAG.getNode(ISD::SRL, DL, XLenVT,
12084 DAG.getConstant(Table, DL, XLenVT), Shift);
12085 SDValue Masked = DAG.getNode(ISD::AND, DL, XLenVT, Shifted,
12086 DAG.getConstant(7, DL, XLenVT));
12093 const MVT XLenVT = Subtarget.getXLenVT();
12098 RISCVSysReg::lookupSysRegByName("FRM")->Encoding, DL, XLenVT);
12111 RMValue = DAG.getNode(ISD::ZERO_EXTEND, DL, XLenVT, RMValue);
12113 SDValue Shift = DAG.getNode(ISD::SHL, DL, XLenVT, RMValue,
12114 DAG.getConstant(2, DL, XLenVT));
12115 SDValue Shifted = DAG.getNode(ISD::SRL, DL, XLenVT,
12116 DAG.getConstant(Table, DL, XLenVT), Shift);
12117 RMValue = DAG.getNode(ISD::AND, DL, XLenVT, Shifted,
12118 DAG.getConstant(0x7, DL, XLenVT));
12299 MVT XLenVT = Subtarget.getXLenVT();
12302 RISCVSysReg::lookupSysRegByName("CYCLE")->Encoding, DL, XLenVT);
12304 RISCVSysReg::lookupSysRegByName("CYCLEH")->Encoding, DL, XLenVT);
12307 RISCVSysReg::lookupSysRegByName("TIME")->Encoding, DL, XLenVT);
12309 RISCVSysReg::lookupSysRegByName("TIMEH")->Encoding, DL, XLenVT);
12353 MVT XLenVT = Subtarget.getXLenVT();
12354 S = DAG.getNode(ISD::TRUNCATE, DL, XLenVT, S);
12355 U = DAG.getNode(ISD::TRUNCATE, DL, XLenVT, U);
12356 SDValue Lo = DAG.getNode(ISD::MUL, DL, XLenVT, S, U);
12357 SDValue Hi = DAG.getNode(RISCVISD::MULHSU, DL, XLenVT, S, U);
12607 MVT XLenVT = Subtarget.getXLenVT();
12610 SDValue FPConv = DAG.getNode(RISCVISD::FMV_X_ANYEXTH, DL, XLenVT, Op0);
12614 SDValue FPConv = DAG.getNode(RISCVISD::FMV_X_ANYEXTH, DL, XLenVT, Op0);
12646 MVT XLenVT = Subtarget.getXLenVT();
12652 SDValue NewOp = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, N->getOperand(0));
12653 SDValue NewRes = DAG.getNode(N->getOpcode(), DL, XLenVT, NewOp);
12688 MVT XLenVT = Subtarget.getXLenVT();
12701 SDValue EltLo = DAG.getNode(RISCVISD::VMV_X_S, DL, XLenVT, Vec);
12707 DAG.getConstant(32, DL, XLenVT), VL);
12712 SDValue EltHi = DAG.getNode(RISCVISD::VMV_X_S, DL, XLenVT, LShr32);
12843 MVT XLenVT = Subtarget.getXLenVT();
12844 if (VT.bitsLT(XLenVT)) {
12860 SDValue EltLo = DAG.getNode(RISCVISD::VMV_X_S, DL, XLenVT, Vec);
12868 DAG.getConstant(32, DL, XLenVT), VL);
12871 SDValue EltHi = DAG.getNode(RISCVISD::VMV_X_S, DL, XLenVT, LShr32);
15153 MVT XLenVT = Subtarget.getXLenVT();
15169 Opcode, SDLoc(LSNode1), DAG.getVTList({XLenVT, XLenVT, MVT::Other}),
15171 DAG.getConstant(Imm, SDLoc(LSNode1), XLenVT)},
15187 BasePtr, DAG.getConstant(Imm, SDLoc(LSNode1), XLenVT)},
15289 MVT XLenVT = Subtarget.getXLenVT();
15354 DAG.getTargetConstant(FRM, DL, XLenVT), VL);
15365 // eventually be legalized to XLenVT.
15366 if (VT != MVT::i32 && VT != XLenVT)
15370 if (VT == XLenVT)
15375 SDValue FpToInt = DAG.getNode(Opc, DL, XLenVT, Src.getOperand(0),
15376 DAG.getTargetConstant(FRM, DL, XLenVT));
15392 MVT XLenVT = Subtarget.getXLenVT();
15395 // legalized to XLenVT.
15397 if (DstVT != XLenVT)
15434 SDValue FpToInt = DAG.getNode(Opc, DL, XLenVT, Src,
15435 DAG.getTargetConstant(FRM, DL, XLenVT));
15449 // smaller than XLenVT.
16365 const MVT XLenVT =
16375 if (IndexVT.getVectorElementType().bitsLT(XLenVT)) {
16376 // Any index legalization should first promote to XLenVT, so we don't lose
16381 IndexVT.changeVectorElementType(XLenVT), Index);
16660 const MVT XLenVT = Subtarget.getXLenVT();
17088 // The sequence will be XLenVT, not the type of Index. Tell
17110 DAG.getConstant(StepNumerator, DL, XLenVT),
17123 MGN->getBasePtr(), DAG.getUNDEF(XLenVT),
17193 DAG.getUNDEF(XLenVT), MSN->getMask(),
17566 DAG.getUNDEF(XLenVT), Mask, PassThru,
17584 DAG.getUNDEF(XLenVT), Mask,
19001 MVT XLenVT = XLen == 32 ? MVT::i32 : MVT::i64;
19055 LocVT = XLenVT;
19129 LocVT = XLenVT;
19177 LocVT = XLenVT;
19180 LocVT = XLenVT;
19216 assert((!UseGPRForF16_F32 || !UseGPRForF64 || LocVT == XLenVT ||
19218 "Expected an XLenVT or vector types at this stage");
19699 MVT XLenVT = Subtarget.getXLenVT();
19744 Offset = DAG.getNode(ISD::VSCALE, DL, XLenVT, Offset);
19798 SDValue ArgValue = DAG.getCopyFromReg(Chain, DL, Reg, XLenVT);
19906 MVT XLenVT = Subtarget.getXLenVT();
19950 SDValue SizeNode = DAG.getConstant(Size, DL, XLenVT);
20031 Offset = DAG.getNode(ISD::VSCALE, DL, XLenVT, Offset);