Lines Matching defs:XLenVT
116 MVT XLenVT = Subtarget.getXLenVT();
119 addRegisterClass(XLenVT, &RISCV::GPRRegClass);
276 setLoadExtAction({ISD::EXTLOAD, ISD::SEXTLOAD, ISD::ZEXTLOAD}, XLenVT,
283 setOperationAction(ISD::DYNAMIC_STACKALLOC, XLenVT, Custom);
286 setOperationAction(ISD::BR_CC, XLenVT, Expand);
288 setOperationAction(ISD::SELECT_CC, XLenVT, Expand);
290 setCondCodeAction(ISD::SETGT, XLenVT, Custom);
291 setCondCodeAction(ISD::SETGE, XLenVT, Expand);
292 setCondCodeAction(ISD::SETUGT, XLenVT, Custom);
293 setCondCodeAction(ISD::SETUGE, XLenVT, Expand);
295 setCondCodeAction(ISD::SETULE, XLenVT, Expand);
296 setCondCodeAction(ISD::SETLE, XLenVT, Expand);
327 setOperationAction({ISD::MUL, ISD::MULHS, ISD::MULHU}, XLenVT, Expand);
336 setOperationAction({ISD::SDIV, ISD::UDIV, ISD::SREM, ISD::UREM}, XLenVT,
344 {ISD::SDIVREM, ISD::UDIVREM, ISD::SMUL_LOHI, ISD::UMUL_LOHI}, XLenVT,
347 setOperationAction({ISD::SHL_PARTS, ISD::SRL_PARTS, ISD::SRA_PARTS}, XLenVT,
356 setOperationAction({ISD::ROTL, ISD::ROTR}, XLenVT, Custom);
358 setOperationAction(ISD::ROTL, XLenVT, Expand);
360 setOperationAction({ISD::ROTL, ISD::ROTR}, XLenVT, Expand);
365 setOperationAction(ISD::BSWAP, XLenVT,
372 setOperationAction(ISD::BITREVERSE, XLenVT, Legal);
375 setOperationAction(ISD::BITREVERSE, XLenVT,
381 setOperationAction({ISD::SMIN, ISD::SMAX, ISD::UMIN, ISD::UMAX}, XLenVT,
390 setOperationAction({ISD::CTTZ, ISD::CTPOP}, XLenVT, Expand);
400 setOperationAction(ISD::CTLZ, XLenVT, Expand);
404 setOperationAction(ISD::ABS, XLenVT, Legal);
407 setOperationAction(ISD::ABS, XLenVT, Legal);
413 setOperationAction(ISD::SELECT, XLenVT, Legal);
415 setOperationAction(ISD::SELECT, XLenVT, Custom);
461 setOperationAction({ISD::FP_TO_SINT, ISD::FP_TO_UINT}, XLenVT, Custom);
462 setOperationAction({ISD::SINT_TO_FP, ISD::UINT_TO_FP}, XLenVT, Custom);
485 setOperationAction({ISD::FP_TO_SINT, ISD::FP_TO_UINT}, XLenVT, Custom);
486 setOperationAction({ISD::SINT_TO_FP, ISD::UINT_TO_FP}, XLenVT, Custom);
603 setOperationAction({ISD::FP_TO_UINT_SAT, ISD::FP_TO_SINT_SAT}, XLenVT,
607 setOperationAction({ISD::STRICT_FP_TO_UINT, ISD::STRICT_FP_TO_SINT}, XLenVT,
609 setOperationAction({ISD::STRICT_UINT_TO_FP, ISD::STRICT_SINT_TO_FP}, XLenVT,
612 setOperationAction(ISD::GET_ROUNDING, XLenVT, Custom);
618 XLenVT, Custom);
620 setOperationAction(ISD::GlobalTLSAddress, XLenVT, Custom);
670 setOperationAction(ISD::VSCALE, XLenVT, Custom);
1461 setOperationAction(ISD::ATOMIC_LOAD_SUB, XLenVT, Expand);
1470 XLenVT, LibCall);
3133 MVT XLenVT = Subtarget.getXLenVT();
3153 DAG.getTargetConstant(FRM, DL, XLenVT), VL);
3239 MVT XLenVT = Subtarget.getXLenVT();
3253 {Chain, Src, Mask, DAG.getTargetConstant(FRM, DL, XLenVT), VL});
3591 MVT XLenVT = Subtarget.getXLenVT();
3652 LastOp = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, LastOp);
3673 return DAG.getConstant(V == V1, DL, XLenVT);
3697 MVT XLenVT = Subtarget.getXLenVT();
3715 // is at most XLenVT, but may be shrunk to a smaller vector element type
3717 // XLenVT if we're producing a v8i1. This results in more consistent
3749 SDValue Elt = DAG.getSignedConstant(Bits, DL, XLenVT);
3766 DAG.getConstant(0, DL, XLenVT));
3781 Splat = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, Splat);
3882 DAG.getSignedConstant(SplatValue, DL, XLenVT),
3887 DAG.getConstant(0, DL, XLenVT));
3941 assert((ViaIntVT.bitsLE(XLenVT) ||
3944 if (ViaIntVT.bitsLE(XLenVT) || isInt<32>(SplatValue)) {
3946 DAG.getConstant(ViaVecVT.getVectorNumElements(), DL, XLenVT);
3952 DAG.getSignedConstant(SplatValue, DL, XLenVT), ViaVL);
3957 DAG.getConstant(0, DL, XLenVT));
4029 // scalars are XLenVT, possibly masked (see below).
4030 MVT XLenVT = Subtarget.getXLenVT();
4032 APInt::getLowBitsSet(XLenVT.getSizeInBits(), ElemSizeInBits), DL, XLenVT);
4043 ElemDL, XLenVT, A, B),
4046 A = DAG.getNode(ISD::AND, SDLoc(A), XLenVT, A, Mask);
4047 B = DAG.getNode(ISD::AND, SDLoc(B), XLenVT, B, Mask);
4048 SDValue ShtAmt = DAG.getConstant(ElemSizeInBits, ElemDL, XLenVT);
4049 return DAG.getNode(ISD::OR, ElemDL, XLenVT, A,
4050 DAG.getNode(ISD::SHL, ElemDL, XLenVT, B, ShtAmt),
4071 MVT XLenVT = Subtarget.getXLenVT();
4085 // Called by LegalizeDAG, we need to use XLenVT operations since we
4091 C->getValueAPF().bitcastToAPInt().sext(XLenVT.getSizeInBits());
4092 NewOps[I] = DAG.getConstant(V, DL, XLenVT);
4094 NewOps[I] = DAG.getNode(RISCVISD::FMV_X_ANYEXTH, DL, XLenVT, Elem);
4143 Splat = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, Splat);
4218 MaskVals.push_back(DAG.getConstant(SelectMaskVal, DL, XLenVT));
4396 MVT XLenVT = Subtarget.getXLenVT();
4403 Scalar = DAG.getNode(RISCVISD::FMV_X_ANYEXTH, DL, XLenVT, Scalar);
4415 // Simplest case is that the operand needs to be promoted to XLenVT.
4416 if (Scalar.getValueType().bitsLE(XLenVT)) {
4423 Scalar = DAG.getNode(ExtOpc, DL, XLenVT, Scalar);
4427 assert(XLenVT == MVT::i32 && Scalar.getValueType() == MVT::i64 &&
4432 DAG.getConstant(0, DL, XLenVT), VL);
4447 const MVT XLenVT = Subtarget.getXLenVT();
4479 if (!Scalar.getValueType().bitsLE(XLenVT))
4481 DAG.getConstant(1, DL, XLenVT),
4490 Scalar = DAG.getNode(ExtOpc, DL, XLenVT, Scalar);
4726 MVT XLenVT = Subtarget.getXLenVT();
4733 DAG.getConstant(NewMask[0], DL, XLenVT), TrueMask, VL);
4737 DAG.getConstant(0, DL, XLenVT));
4767 MVT XLenVT = Subtarget.getXLenVT();
4780 SDValue VL = DAG.getConstant(NumSubElts + Index, DL, XLenVT);
4790 DAG.getConstant(Index, DL, XLenVT), TrueMask, VL, Policy);
5283 MVT XLenVT = Subtarget.getXLenVT();
5307 SelectMaskVals.push_back(DAG.getUNDEF(XLenVT));
5309 SelectMaskVals.push_back(DAG.getConstant(Lane ? 0 : 1, DL, XLenVT));
5366 MVT XLenVT = Subtarget.getXLenVT();
5419 if (SVT.isInteger() && SVT.bitsGT(XLenVT)) {
5422 DAG.getTargetConstant(Intrinsic::riscv_vlse, DL, XLenVT);
5427 DAG.getRegister(RISCV::X0, XLenVT),
5455 V = DAG.getExtLoad(ISD::EXTLOAD, DL, XLenVT, Ld->getChain(), NewAddr,
5472 V1, DAG.getConstant(Lane, DL, XLenVT),
5523 DAG.getConstant(Rotation, DL, XLenVT), TrueMask, VL);
5527 DAG.getConstant(InvRotate, DL, XLenVT), TrueMask, VL,
5617 DAG.getConstant(false, DL, XLenVT));
5622 MaskVals[Idx] = DAG.getConstant(true, DL, XLenVT);
5662 // than XLenVT.
5663 if (IndexVT.getScalarType().bitsGT(XLenVT)) {
5685 ? DAG.getConstant(MaskIndex, DL, XLenVT)
5686 : DAG.getUNDEF(XLenVT));
5739 MaskVals.push_back(DAG.getConstant(SelectMaskVal, DL, XLenVT));
5893 MVT XLenVT = Subtarget.getXLenVT();
5916 SDValue Res = DAG.getNode(RISCVISD::VFIRST_VL, DL, XLenVT, Source, Mask, EVL);
5923 DAG.getSetCC(DL, XLenVT, Res, DAG.getConstant(0, DL, XLenVT), ISD::SETLT);
5924 Res = DAG.getSelect(DL, XLenVT, SetCC, EVL, Res);
6091 MVT XLenVT = Subtarget.getXLenVT();
6117 SDValue TDCMaskV = DAG.getConstant(TDCMask, DL, XLenVT);
6170 SDValue SplatZero = DAG.getConstant(0, DL, XLenVT);
6180 SDValue FCLASS = DAG.getNode(RISCVISD::FCLASS, DL, XLenVT, Op.getOperand(0));
6181 SDValue AND = DAG.getNode(ISD::AND, DL, XLenVT, FCLASS, TDCMaskV);
6182 SDValue Res = DAG.getSetCC(DL, XLenVT, AND, DAG.getConstant(0, DL, XLenVT),
6198 MVT XLenVT = Subtarget.getXLenVT();
6207 SDValue XIsNonNan = DAG.getSetCC(DL, XLenVT, X, X, ISD::SETOEQ);
6213 SDValue YIsNonNan = DAG.getSetCC(DL, XLenVT, Y, Y, ISD::SETOEQ);
6279 MVT XLenVT = Subtarget.getXLenVT();
6285 DAG.getNode(RISCVISD::FMV_X_ANYEXTH, DL, XLenVT, Op.getOperand(0));
6292 DAG.getNode(LogicOpc, DL, XLenVT, Fmv, DAG.getConstant(Mask, DL, XLenVT));
6300 MVT XLenVT = Subtarget.getXLenVT();
6313 SignAsInt = DAG.getNode(ISD::BITCAST, DL, XLenVT, Sign);
6315 SignAsInt = DAG.getNode(RISCVISD::FMV_X_ANYEXTH, DL, XLenVT, Sign);
6317 SignAsInt = DAG.getNode(RISCVISD::FMV_X_ANYEXTW_RV64, DL, XLenVT, Sign);
6319 assert(XLenVT == MVT::i32 && "Unexpected type");
6330 SignAsInt = DAG.getNode(ISD::SRL, DL, XLenVT, SignAsInt,
6331 DAG.getConstant(ShiftAmount, DL, XLenVT));
6333 SignAsInt = DAG.getNode(ISD::SHL, DL, XLenVT, SignAsInt,
6334 DAG.getConstant(-ShiftAmount, DL, XLenVT));
6340 APInt::getSignMask(16).sext(Subtarget.getXLen()), DL, XLenVT);
6341 SDValue SignBit = DAG.getNode(ISD::AND, DL, XLenVT, SignAsInt, SignMask);
6344 SDValue MagAsInt = DAG.getNode(RISCVISD::FMV_X_ANYEXTH, DL, XLenVT, Mag);
6346 APInt::getSignedMaxValue(16).sext(Subtarget.getXLen()), DL, XLenVT);
6348 DAG.getNode(ISD::AND, DL, XLenVT, MagAsInt, ClearSignMask);
6350 SDValue CopiedSign = DAG.getNode(ISD::OR, DL, XLenVT, ClearedSign, SignBit,
6717 MVT XLenVT = Subtarget.getXLenVT();
6721 SDValue NewOp0 = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, Op0);
6851 MVT XLenVT = Subtarget.getXLenVT();
6854 SDValue Res = DAG.getNode(RISCVISD::READ_VLENB, DL, XLenVT);
6867 Res = DAG.getNode(ISD::SRL, DL, XLenVT, Res,
6870 Res = DAG.getNode(ISD::SHL, DL, XLenVT, Res,
6871 DAG.getConstant(Log2 - 3, DL, XLenVT));
6875 Res = DAG.getNode(ISD::MUL, DL, XLenVT, Res,
6876 DAG.getConstant(Val / 8, DL, XLenVT));
6878 SDValue VScale = DAG.getNode(ISD::SRL, DL, XLenVT, Res,
6879 DAG.getConstant(3, DL, XLenVT));
6880 Res = DAG.getNode(ISD::MUL, DL, XLenVT, VScale,
6881 DAG.getConstant(Val, DL, XLenVT));
7333 MVT XLenVT = Subtarget.getXLenVT();
7343 SDValue VROffset = DAG.getNode(RISCVISD::READ_VLENB, DL, XLenVT);
7345 DAG.getNode(ISD::SHL, DL, XLenVT, VROffset,
7346 DAG.getConstant(std::max(Log2LMUL, 0), DL, XLenVT));
7357 BasePtr = DAG.getNode(ISD::ADD, DL, XLenVT, BasePtr, VROffset, Flag);
7376 MVT XLenVT = Subtarget.getXLenVT();
7387 SDValue VROffset = DAG.getNode(RISCVISD::READ_VLENB, DL, XLenVT);
7389 DAG.getNode(ISD::SHL, DL, XLenVT, VROffset,
7390 DAG.getConstant(std::max(Log2LMUL, 0), DL, XLenVT));
7402 BasePtr = DAG.getNode(ISD::ADD, DL, XLenVT, BasePtr, VROffset, Flag);
8049 MVT XLenVT = Subtarget.getXLenVT();
8068 SDValue TPReg = DAG.getRegister(RISCV::X4, XLenVT);
8084 SDValue TPReg = DAG.getRegister(RISCV::X4, XLenVT);
8337 MVT XLenVT = Subtarget.getXLenVT();
8432 SDValue XOR = DAG.getNode(ISD::XOR, DL, XLenVT, CondV,
8433 DAG.getConstant(1, DL, XLenVT));
8438 // If the condition is not an integer SETCC which operates on XLenVT, we need
8443 CondV.getOperand(0).getSimpleValueType() != XLenVT) {
8444 SDValue Zero = DAG.getConstant(0, DL, XLenVT);
8452 // If the CondV is the output of a SETCC node which operates on XLenVT inputs,
8512 MVT XLenVT = Subtarget.getXLenVT();
8515 CondV.getOperand(0).getValueType() == XLenVT) {
8528 CondV, DAG.getConstant(0, DL, XLenVT),
8577 MVT XLenVT = Subtarget.getXLenVT();
8597 Register Reg = MF.addLiveIn(RI.getRARegister(), getRegClassFor(XLenVT));
8598 return DAG.getCopyFromReg(DAG.getEntryNode(), DL, Reg, XLenVT);
8773 MVT XLenVT = Subtarget.getXLenVT();
8774 SDValue SplatZero = DAG.getConstant(0, DL, XLenVT);
8775 SDValue SplatTrueVal = DAG.getSignedConstant(ExtTrueVal, DL, XLenVT);
9095 MVT XLenVT = Subtarget.getXLenVT();
9116 DAG.getNode(RISCVISD::FMV_X_ANYEXTH, DL, XLenVT, Val), Idx);
9185 Val = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, Val);
9208 SDValue InsertI64VL = DAG.getConstant(2, DL, XLenVT);
9247 DAG.getNode(ISD::ADD, DL, XLenVT, Idx, DAG.getConstant(1, DL, XLenVT));
9276 MVT XLenVT = Subtarget.getXLenVT();
9288 DAG.getNode(RISCVISD::VFIRST_VL, DL, XLenVT, Vec, Mask, VL);
9289 SDValue Res = DAG.getSetCC(DL, XLenVT, Vfirst,
9290 DAG.getConstant(0, DL, XLenVT), ISD::SETEQ);
9302 std::min(MaxEEW, unsigned(XLenVT.getSizeInBits())));
9308 ExtractElementIdx = DAG.getConstant(0, DL, XLenVT);
9315 ISD::SRL, DL, XLenVT, Idx,
9316 DAG.getConstant(Log2_64(WideEltVT.getSizeInBits()), DL, XLenVT));
9319 ISD::AND, DL, XLenVT, Idx,
9320 DAG.getConstant(WideEltVT.getSizeInBits() - 1, DL, XLenVT));
9324 SDValue ExtractElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, XLenVT,
9328 DAG.getNode(ISD::SRL, DL, XLenVT, ExtractElt, ExtractBitIdx);
9329 SDValue Res = DAG.getNode(ISD::AND, DL, XLenVT, ShiftRight,
9330 DAG.getConstant(1, DL, XLenVT));
9346 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, XLenVT, IntVec, Idx);
9390 DAG.getConstant(0, DL, XLenVT));
9424 SDValue Elt0 = DAG.getNode(RISCVISD::VMV_X_S, DL, XLenVT, Vec);
9457 MVT XLenVT = Subtarget.getXLenVT();
9459 // If this isn't a scalar, or its type is XLenVT we're done.
9460 if (!OpVT.isScalarInteger() || OpVT == XLenVT)
9463 // Simplest case is that the operand needs to be promoted to XLenVT.
9464 if (OpVT.bitsLT(XLenVT)) {
9471 ScalarOp = DAG.getNode(ExtOpc, DL, XLenVT, ScalarOp);
9484 // The more complex case is when the scalar is larger than XLenVT.
9485 assert(XLenVT == MVT::i32 && OpVT == MVT::i64 &&
9522 I32VL = DAG.getConstant(2 * AVLInt, DL, XLenVT);
9525 I32VL = DAG.getRegister(RISCV::X0, XLenVT);
9534 SDValue LMUL = DAG.getConstant(Lmul, DL, XLenVT);
9536 SDValue SEW = DAG.getConstant(Sew, DL, XLenVT);
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));
9596 assert(VL.getValueType() == XLenVT);
9613 MVT XLenVT = Subtarget.getXLenVT();
9635 SDValue LMul = DAG.getTargetConstant(VLMUL, DL, XLenVT);
9636 SDValue Sew = DAG.getTargetConstant(VSEW, DL, XLenVT);
9638 SDValue AVL = DAG.getNode(ISD::ZERO_EXTEND, DL, XLenVT, N->getOperand(1));
9640 SDValue ID = DAG.getTargetConstant(Intrinsic::riscv_vsetvli, DL, XLenVT);
9642 DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, XLenVT, ID, AVL, Sew, LMul);
9655 MVT XLenVT = Subtarget.getXLenVT();
9658 SDValue Res = DAG.getNode(RISCVISD::VFIRST_VL, DL, XLenVT, Op0, Mask, VL);
9664 DAG.getSetCC(DL, XLenVT, Res, DAG.getConstant(0, DL, XLenVT), ISD::SETLT);
9665 VL = DAG.getElementCount(DL, XLenVT, OpVT.getVectorElementCount());
9666 return DAG.getSelect(DL, XLenVT, Setcc, VL, Res);
9690 MVT XLenVT = Subtarget.getXLenVT();
9693 // If this isn't a scalar, or its type is XLenVT we're done.
9694 if (!OpVT.isScalarInteger() || OpVT == XLenVT)
9698 if (OpVT.bitsLT(XLenVT)) {
9701 ScalarOp = DAG.getNode(ExtOpc, DL, XLenVT, ScalarOp);
9739 MVT XLenVT = Subtarget.getXLenVT();
9783 return DAG.getNode(Opc, DL, XLenVT, Op.getOperand(1));
9790 return DAG.getNode(Opc, DL, XLenVT, Op.getOperand(1), Op.getOperand(2),
9797 return DAG.getNode(Opc, DL, XLenVT, Op.getOperand(1));
9800 return DAG.getNode(RISCVISD::MOPR, DL, XLenVT, Op.getOperand(1),
9804 return DAG.getNode(RISCVISD::MOPRR, DL, XLenVT, Op.getOperand(1),
9808 return DAG.getNode(RISCVISD::CLMUL, DL, XLenVT, Op.getOperand(1),
9814 return DAG.getNode(Opc, DL, XLenVT, Op.getOperand(1), Op.getOperand(2));
9821 SDValue Res = DAG.getNode(RISCVISD::VMV_X_S, DL, XLenVT, Op.getOperand(1));
9837 if (Scalar.getValueType().bitsLE(XLenVT)) {
9838 Scalar = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, Scalar);
10036 MVT XLenVT = Subtarget.getXLenVT();
10043 SDValue VL = DAG.getConstant(VT.getVectorNumElements(), DL, XLenVT);
10044 SDValue IntID = DAG.getTargetConstant(VlsegInts[NF - 2], DL, XLenVT);
10054 DAG.getTargetConstant(Log2_64(VT.getScalarSizeInBits()), DL, XLenVT)};
10123 MVT XLenVT = Subtarget.getXLenVT();
10130 SDValue VL = DAG.getConstant(VT.getVectorNumElements(), DL, XLenVT);
10131 SDValue IntID = DAG.getTargetConstant(VssegInts[NF - 2], DL, XLenVT);
10150 DAG.getTargetConstant(Log2_64(VT.getScalarSizeInBits()), DL, XLenVT)};
10241 MVT XLenVT = Subtarget.getXLenVT();
10270 Vec = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Vec, Mask, VL);
10277 Vec = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Vec, Mask, VL);
10283 SDValue One = DAG.getConstant(1, DL, XLenVT);
10284 Vec = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Vec, Mask, VL);
10285 Vec = DAG.getNode(ISD::AND, DL, XLenVT, Vec, One);
10291 SDValue Zero = DAG.getConstant(0, DL, XLenVT);
10292 SDValue SetCC = DAG.getSetCC(DL, XLenVT, Vec, Zero, CC);
10323 const MVT XLenVT = Subtarget.getXLenVT();
10332 auto InnerVL = NonZeroAVL ? VL : DAG.getConstant(1, DL, XLenVT);
10340 SDValue Policy = DAG.getTargetConstant(RISCVII::TAIL_AGNOSTIC, DL, XLenVT);
10466 MVT XLenVT = Subtarget.getXLenVT();
10467 SDValue CPop = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, IsNan, Mask, VL);
10468 SDValue NoNaNs = DAG.getSetCC(DL, XLenVT, CPop,
10469 DAG.getConstant(0, DL, XLenVT), ISD::SETEQ);
10482 MVT XLenVT = Subtarget.getXLenVT();
10512 SDValue VCPop = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, IsNaN, Mask, VL);
10514 SDValue StartIsNaN = DAG.getSetCC(DL, XLenVT, Start, Start, ISD::SETUO);
10515 VCPop = DAG.getNode(ISD::OR, DL, XLenVT, VCPop, StartIsNaN);
10516 SDValue NoNaNs = DAG.getSetCC(DL, XLenVT, VCPop,
10517 DAG.getConstant(0, DL, XLenVT), ISD::SETEQ);
10532 MVT XLenVT = Subtarget.getXLenVT();
10597 SDValue VL = DAG.getConstant(EndIndex, DL, XLenVT);
10610 SDValue SlideupAmt = DAG.getConstant(OrigIdx, DL, XLenVT);
10688 DAG.getConstant(OrigIdx / Vscale, DL, XLenVT));
10723 VL = DAG.getElementCount(DL, XLenVT, SubVecVT.getVectorElementCount());
10737 SDValue SlideupAmt = DAG.getElementCount(DL, XLenVT, RemIdx);
10740 VL = DAG.getNode(ISD::ADD, DL, XLenVT, SlideupAmt, VL);
10767 MVT XLenVT = Subtarget.getXLenVT();
10840 SDValue VL = DAG.getConstant(SubVecVT.getVectorNumElements(), DL, XLenVT);
10841 SDValue SlidedownAmt = DAG.getConstant(OrigIdx, DL, XLenVT);
10891 DAG.getConstant(OrigIdx / Vscale, DL, XLenVT));
10919 DAG.getConstant(Idx, DL, XLenVT));
10924 SDValue SlidedownAmt = DAG.getElementCount(DL, XLenVT, RemIdx);
10927 VL = DAG.getConstant(SubVecVT.getVectorNumElements(), DL, XLenVT);
11063 MVT XLenVT = Subtarget.getXLenVT();
11064 SDValue VL = DAG.getRegister(RISCV::X0, XLenVT);
11105 SDValue Ones = DAG.getSplatVector(IdxVT, DL, DAG.getConstant(1, DL, XLenVT));
11111 DAG.getSplatVector(IdxVT, DL, DAG.getConstant(0, DL, XLenVT)),
11147 MVT XLenVT = Subtarget.getXLenVT();
11155 DAG.getConstant(Log2_64(StepValImm), DL, XLenVT), VL);
11191 MVT XLenVT = Subtarget.getXLenVT();
11224 ISD::SUB, DL, XLenVT,
11225 DAG.getElementCount(DL, XLenVT, ContainerVT.getVectorElementCount()),
11226 DAG.getElementCount(DL, XLenVT, VecVT.getVectorElementCount()));
11284 ISD::SUB, DL, XLenVT,
11285 DAG.getElementCount(DL, XLenVT, VecVT.getVectorElementCount()),
11286 DAG.getConstant(1, DL, XLenVT));
11296 VLMinus1, DAG.getRegister(RISCV::X0, XLenVT));
11314 MVT XLenVT = Subtarget.getXLenVT();
11324 DownOffset = DAG.getConstant(ImmValue, DL, XLenVT);
11325 UpOffset = DAG.getNode(ISD::SUB, DL, XLenVT, VLMax, DownOffset);
11329 UpOffset = DAG.getConstant(-ImmValue, DL, XLenVT);
11330 DownOffset = DAG.getNode(ISD::SUB, DL, XLenVT, VLMax, UpOffset);
11339 TrueMask, DAG.getRegister(RISCV::X0, XLenVT),
11355 MVT XLenVT = Subtarget.getXLenVT();
11373 SDValue VL = DAG.getConstant(VT.getVectorNumElements(), DL, XLenVT);
11377 IsMaskOp ? Intrinsic::riscv_vlm : Intrinsic::riscv_vle, DL, XLenVT);
11405 MVT XLenVT = Subtarget.getXLenVT();
11432 SDValue VL = DAG.getConstant(VT.getVectorNumElements(), DL, XLenVT);
11436 IsMaskOp ? Intrinsic::riscv_vsm : Intrinsic::riscv_vse, DL, XLenVT);
11469 MVT XLenVT = Subtarget.getXLenVT();
11488 DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Mask,
11494 SmallVector<SDValue, 8> Ops{Chain, DAG.getTargetConstant(IntID, DL, XLenVT)};
11504 Ops.push_back(DAG.getTargetConstant(RISCVII::TAIL_AGNOSTIC, DL, XLenVT));
11530 DAG.getConstant(Intrinsic::riscv_viota, DL, XLenVT),
11571 MVT XLenVT = Subtarget.getXLenVT();
11589 DAG.getConstant(Intrinsic::riscv_vcompress, DL, XLenVT),
11592 DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Mask,
11598 SmallVector<SDValue, 8> Ops{Chain, DAG.getTargetConstant(IntID, DL, XLenVT)};
11617 MVT XLenVT = Subtarget.getXLenVT();
11630 DAG.getConstant(Intrinsic::riscv_vcompress, DL, XLenVT),
11965 MVT XLenVT = Subtarget.getXLenVT();
11966 SDValue Zero = DAG.getConstant(0, DL, XLenVT);
11971 Op.getOpcode() == ISD::VP_ZERO_EXTEND ? 1 : -1, DL, XLenVT);
12096 MVT XLenVT = Subtarget.getXLenVT();
12097 SDValue Zero = DAG.getConstant(0, DL, XLenVT);
12101 RISCVISDExtOpc == RISCVISD::VZEXT_VL ? 1 : -1, DL, XLenVT);
12164 MVT XLenVT = Subtarget.getXLenVT();
12165 SDValue SplatZero = DAG.getConstant(0, DL, XLenVT);
12199 MVT XLenVT = Subtarget.getXLenVT();
12225 SDValue VLMax = DAG.getRegister(RISCV::X0, XLenVT);
12228 DAG.getConstant(1, DL, XLenVT), VLMax);
12231 DAG.getConstant(0, DL, XLenVT), VLMax);
12266 const MVT XLenVT = Subtarget.getXLenVT();
12284 DAG.getConstant(1, DL, XLenVT), EVL1);
12287 DAG.getConstant(0, DL, XLenVT), EVL1);
12293 DAG.getConstant(1, DL, XLenVT), EVL2);
12296 DAG.getConstant(0, DL, XLenVT), EVL2);
12306 DownOffset = DAG.getConstant(ImmValue, DL, XLenVT);
12307 UpOffset = DAG.getNode(ISD::SUB, DL, XLenVT, EVL1, DownOffset);
12311 UpOffset = DAG.getConstant(-ImmValue, DL, XLenVT);
12312 DownOffset = DAG.getNode(ISD::SUB, DL, XLenVT, EVL1, UpOffset);
12363 MVT XLenVT = Subtarget.getXLenVT();
12387 DAG.getConstant(1, DL, XLenVT), EVL);
12390 DAG.getConstant(0, DL, XLenVT), EVL);
12431 DAG.getVScale(DL, XLenVT, APInt(XLenVT.getSizeInBits(), MinElts));
12432 SDValue Diff = DAG.getNode(ISD::SUB, DL, XLenVT, VLMax, EVL);
12458 DAG.getNode(ISD::SUB, DL, XLenVT, EVL, DAG.getConstant(1, DL, XLenVT));
12508 MVT XLenVT = Subtarget.getXLenVT();
12523 DL, XLenVT);
12536 SDValue Policy = DAG.getTargetConstant(RISCVII::TAIL_AGNOSTIC, DL, XLenVT);
12554 MVT XLenVT = Subtarget.getXLenVT();
12571 DL, XLenVT);
12625 MVT XLenVT = Subtarget.getXLenVT();
12629 assert(BasePtr.getSimpleValueType() == XLenVT && "Unexpected pointer type");
12656 if (XLenVT == MVT::i32 && IndexVT.getVectorElementType().bitsGT(XLenVT)) {
12657 IndexVT = IndexVT.changeVectorElementType(XLenVT);
12663 SmallVector<SDValue, 8> Ops{Chain, DAG.getTargetConstant(IntID, DL, XLenVT)};
12674 Ops.push_back(DAG.getTargetConstant(RISCVII::TAIL_AGNOSTIC, DL, XLenVT));
12723 MVT XLenVT = Subtarget.getXLenVT();
12727 assert(BasePtr.getSimpleValueType() == XLenVT && "Unexpected pointer type");
12754 if (XLenVT == MVT::i32 && IndexVT.getVectorElementType().bitsGT(XLenVT)) {
12755 IndexVT = IndexVT.changeVectorElementType(XLenVT);
12761 SmallVector<SDValue, 8> Ops{Chain, DAG.getTargetConstant(IntID, DL, XLenVT)};
12775 const MVT XLenVT = Subtarget.getXLenVT();
12778 SDValue SysRegNo = DAG.getTargetConstant(RISCVSysReg::frm, DL, XLenVT);
12779 SDVTList VTs = DAG.getVTList(XLenVT, MVT::Other);
12794 DAG.getNode(ISD::SHL, DL, XLenVT, RM, DAG.getConstant(2, DL, XLenVT));
12795 SDValue Shifted = DAG.getNode(ISD::SRL, DL, XLenVT,
12796 DAG.getConstant(Table, DL, XLenVT), Shift);
12797 SDValue Masked = DAG.getNode(ISD::AND, DL, XLenVT, Shifted,
12798 DAG.getConstant(7, DL, XLenVT));
12805 const MVT XLenVT = Subtarget.getXLenVT();
12809 SDValue SysRegNo = DAG.getTargetConstant(RISCVSysReg::frm, DL, XLenVT);
12822 RMValue = DAG.getNode(ISD::ZERO_EXTEND, DL, XLenVT, RMValue);
12824 SDValue Shift = DAG.getNode(ISD::SHL, DL, XLenVT, RMValue,
12825 DAG.getConstant(2, DL, XLenVT));
12826 SDValue Shifted = DAG.getNode(ISD::SRL, DL, XLenVT,
12827 DAG.getConstant(Table, DL, XLenVT), Shift);
12828 RMValue = DAG.getNode(ISD::AND, DL, XLenVT, Shifted,
12829 DAG.getConstant(0x7, DL, XLenVT));
13010 MVT XLenVT = Subtarget.getXLenVT();
13012 LoCounter = DAG.getTargetConstant(RISCVSysReg::cycle, DL, XLenVT);
13013 HiCounter = DAG.getTargetConstant(RISCVSysReg::cycleh, DL, XLenVT);
13015 LoCounter = DAG.getTargetConstant(RISCVSysReg::time, DL, XLenVT);
13016 HiCounter = DAG.getTargetConstant(RISCVSysReg::timeh, DL, XLenVT);
13060 MVT XLenVT = Subtarget.getXLenVT();
13061 S = DAG.getNode(ISD::TRUNCATE, DL, XLenVT, S);
13062 U = DAG.getNode(ISD::TRUNCATE, DL, XLenVT, U);
13063 SDValue Lo = DAG.getNode(ISD::MUL, DL, XLenVT, S, U);
13064 SDValue Hi = DAG.getNode(RISCVISD::MULHSU, DL, XLenVT, S, U);
13301 MVT XLenVT = Subtarget.getXLenVT();
13305 SDValue FPConv = DAG.getNode(RISCVISD::FMV_X_ANYEXTH, DL, XLenVT, Op0);
13337 MVT XLenVT = Subtarget.getXLenVT();
13343 SDValue NewOp = DAG.getNode(ISD::ANY_EXTEND, DL, XLenVT, N->getOperand(0));
13344 SDValue NewRes = DAG.getNode(N->getOpcode(), DL, XLenVT, NewOp);
13379 MVT XLenVT = Subtarget.getXLenVT();
13392 SDValue EltLo = DAG.getNode(RISCVISD::VMV_X_S, DL, XLenVT, Vec);
13398 DAG.getConstant(32, DL, XLenVT), VL);
13403 SDValue EltHi = DAG.getNode(RISCVISD::VMV_X_S, DL, XLenVT, LShr32);
13534 MVT XLenVT = Subtarget.getXLenVT();
13535 if (VT.bitsLT(XLenVT)) {
13551 SDValue EltLo = DAG.getNode(RISCVISD::VMV_X_S, DL, XLenVT, Vec);
13559 DAG.getConstant(32, DL, XLenVT), VL);
13562 SDValue EltHi = DAG.getNode(RISCVISD::VMV_X_S, DL, XLenVT, LShr32);
15947 MVT XLenVT = Subtarget.getXLenVT();
15963 Opcode, SDLoc(LSNode1), DAG.getVTList({XLenVT, XLenVT, MVT::Other}),
15965 DAG.getConstant(Imm, SDLoc(LSNode1), XLenVT)},
15981 BasePtr, DAG.getConstant(Imm, SDLoc(LSNode1), XLenVT)},
16081 MVT XLenVT = Subtarget.getXLenVT();
16142 DAG.getTargetConstant(FRM, DL, XLenVT), VL);
16153 // eventually be legalized to XLenVT.
16154 if (VT != MVT::i32 && VT != XLenVT)
16158 if (VT == XLenVT)
16163 SDValue FpToInt = DAG.getNode(Opc, DL, XLenVT, Src.getOperand(0),
16164 DAG.getTargetConstant(FRM, DL, XLenVT));
16180 MVT XLenVT = Subtarget.getXLenVT();
16183 // legalized to XLenVT.
16185 if (DstVT != XLenVT)
16222 SDValue FpToInt = DAG.getNode(Opc, DL, XLenVT, Src,
16223 DAG.getTargetConstant(FRM, DL, XLenVT));
16237 // smaller than XLenVT.
16291 MVT XLenVT = Subtarget.getXLenVT();
16295 SDValue Temp1 = DAG.getNode(ISD::SUB, DL, XLenVT, NumElem,
16296 DAG.getConstant(1, DL, XLenVT));
16297 SDValue Temp2 = DAG.getNode(ISD::MUL, DL, XLenVT, Temp1,
16298 DAG.getConstant(ElemWidthByte, DL, XLenVT));
16299 SDValue Base = DAG.getNode(ISD::ADD, DL, XLenVT, VPLoad->getBasePtr(), Temp2);
16300 SDValue Stride = DAG.getConstant(-ElemWidthByte, DL, XLenVT);
16351 MVT XLenVT = Subtarget.getXLenVT();
16355 SDValue Temp1 = DAG.getNode(ISD::SUB, DL, XLenVT, NumElem,
16356 DAG.getConstant(1, DL, XLenVT));
16357 SDValue Temp2 = DAG.getNode(ISD::MUL, DL, XLenVT, Temp1,
16358 DAG.getConstant(ElemWidthByte, DL, XLenVT));
16360 DAG.getNode(ISD::ADD, DL, XLenVT, VPStore->getBasePtr(), Temp2);
16361 SDValue Stride = DAG.getConstant(-ElemWidthByte, DL, XLenVT);
17216 MVT XLenVT = Subtarget.getXLenVT();
17229 MaskVals.push_back(DAG.getConstant(SelectMaskVal, DL, XLenVT));
17343 const MVT XLenVT =
17353 if (IndexVT.getVectorElementType().bitsLT(XLenVT)) {
17354 // Any index legalization should first promote to XLenVT, so we don't lose
17359 IndexVT.changeVectorElementType(XLenVT), Index);
17671 MVT XLenVT = Subtarget.getXLenVT();
17672 SDValue Pop = DAG.getNode(RISCVISD::VCPOP_VL, DL, XLenVT, Src, Mask, VL);
17679 const MVT XLenVT = Subtarget.getXLenVT();
18146 // The sequence will be XLenVT, not the type of Index. Tell
18168 DAG.getSignedConstant(StepNumerator, DL, XLenVT), MGN->getMask(),
18181 MGN->getBasePtr(), DAG.getUNDEF(XLenVT),
18251 DAG.getUNDEF(XLenVT), MSN->getMask(),
20189 MVT XLenVT = Subtarget.getXLenVT();
20234 Offset = DAG.getNode(ISD::VSCALE, DL, XLenVT, Offset);
20288 SDValue ArgValue = DAG.getCopyFromReg(Chain, DL, Reg, XLenVT);
20396 MVT XLenVT = Subtarget.getXLenVT();
20440 SDValue SizeNode = DAG.getConstant(Size, DL, XLenVT);
20522 Offset = DAG.getNode(ISD::VSCALE, DL, XLenVT, Offset);
22071 MVT XLenVT = Subtarget.getXLenVT();
22074 auto [Lo, Hi] = DAG.SplitScalar(Val, DL, XLenVT, XLenVT);
22164 MVT XLenVT = Subtarget.getXLenVT();
22169 Val = DAG.getNode(RISCVISD::SplitGPRPair, DL, DAG.getVTList(XLenVT, XLenVT),
22881 MVT XLenVT = Subtarget.getXLenVT();
22892 SDValue SP = DAG.getCopyFromReg(Chain, dl, RISCV::X2, XLenVT);
22894 SP = DAG.getNode(ISD::SUB, dl, XLenVT, SP, Size);