Lines Matching defs:VecVT
2125 EVT VecVT = VecOp.getValueType();
2126 if (!isOperationLegalOrCustomOrPromote(Opc, VecVT))
2133 EVT ScalarVT = VecVT.getScalarType();
2492 // Attempt to decompose a subvector insert/extract between VecVT and
2499 MVT VecVT, MVT SubVecVT, unsigned InsertExtractIdx,
2505 unsigned VecRegClassID = getRegClassIDForVecVT(VecVT);
2508 // If VecVT is a vector tuple type, either it's the tuple type with same
2509 // RegClass with SubVecVT or SubVecVT is a actually a subvector of the VecVT.
2510 if (VecVT.isRISCVVectorTuple()) {
2516 assert(getLMUL(VecVT) == getLMUL(SubVecVT) &&
2519 return {getSubregIndexByMVT(VecVT, InsertExtractIdx), 0};
2532 VecVT = VecVT.getHalfNumVectorElementsVT();
2534 InsertExtractIdx >= VecVT.getVectorElementCount().getKnownMinValue();
2536 getSubregIndexByMVT(VecVT, IsHi));
2538 InsertExtractIdx -= VecVT.getVectorElementCount().getKnownMinValue();
2741 static MVT getMaskTypeFor(MVT VecVT) {
2742 assert(VecVT.isVector());
2743 ElementCount EC = VecVT.getVectorElementCount();
2749 static SDValue getAllOnesMask(MVT VecVT, SDValue VL, const SDLoc &DL,
2751 MVT MaskVT = getMaskTypeFor(VecVT);
2756 getDefaultScalableVLOps(MVT VecVT, const SDLoc &DL, SelectionDAG &DAG,
2758 assert(VecVT.isScalableVector() && "Expecting a scalable vector");
2760 SDValue Mask = getAllOnesMask(VecVT, VL, DL, DAG);
2774 // VecVT is a vector type, either fixed-length or scalable, and ContainerVT is
2776 // VecVT is scalable, then ContainerVT should be the same as VecVT.
2778 getDefaultVLOps(MVT VecVT, MVT ContainerVT, const SDLoc &DL, SelectionDAG &DAG,
2780 if (VecVT.isFixedLengthVector())
2781 return getDefaultVLOps(VecVT.getVectorNumElements(), ContainerVT, DL, DAG,
2787 SDValue RISCVTargetLowering::computeVLMax(MVT VecVT, const SDLoc &DL,
2789 assert(VecVT.isScalableVector() && "Expected scalable vector");
2791 VecVT.getVectorElementCount());
2795 RISCVTargetLowering::computeVLMAXBounds(MVT VecVT,
2797 assert(VecVT.isScalableVector() && "Expected scalable vector");
2799 unsigned EltSize = VecVT.getScalarSizeInBits();
2800 unsigned MinSize = VecVT.getSizeInBits().getKnownMinValue();
4935 MVT VecVT = EvenV.getSimpleValueType();
4936 MVT VecContainerVT = VecVT; // <vscale x n x ty>
4939 VecContainerVT = getContainerForFixedLengthVector(DAG, VecVT, Subtarget);
4944 assert(VecVT.getScalarSizeInBits() < Subtarget.getELen());
4951 MVT::getVectorVT(MVT::getIntegerVT(VecVT.getScalarSizeInBits() * 2),
4952 VecVT.getVectorElementCount());
4962 auto [Mask, VL] = getDefaultVLOps(VecVT, VecContainerVT, DL, DAG, Subtarget);
4967 // Interleaved = (OddV << VecVT.getScalarSizeInBits()) + EvenV.
4969 DAG.getConstant(VecVT.getScalarSizeInBits(), DL, VecContainerVT);
4983 // Then get OddV * by 2^(VecVT.getScalarSizeInBits() - 1)
4992 // = (OddV << VecVT.getScalarSizeInBits()) + EvenV
5000 VecVT.getVectorElementType(), // Make sure to use original type
5006 MVT::getVectorVT(VecVT.getVectorElementType(),
5007 VecVT.getVectorElementCount().multiplyCoefficientBy(2));
8723 MVT VecVT = Op.getSimpleValueType();
8724 assert(!Subtarget.is64Bit() && VecVT.getVectorElementType() == MVT::i64 &&
8731 MVT ContainerVT = VecVT;
8732 if (VecVT.isFixedLengthVector())
8733 ContainerVT = getContainerForFixedLengthVector(VecVT);
8735 auto VL = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget).second;
8740 if (VecVT.isFixedLengthVector())
8741 Res = convertFromScalableVector(VecVT, Res, DAG, Subtarget);
8753 MVT VecVT = Op.getSimpleValueType();
8759 if (VecVT.isScalableVector()) {
8760 SDValue SplatZero = DAG.getConstant(0, DL, VecVT);
8761 SDValue SplatTrueVal = DAG.getSignedConstant(ExtTrueVal, DL, VecVT);
8762 return DAG.getNode(ISD::VSELECT, DL, VecVT, Src, SplatTrueVal, SplatZero);
8765 MVT ContainerVT = getContainerForFixedLengthVector(VecVT);
8771 SDValue VL = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget).second;
8785 return convertFromScalableVector(VecVT, Select, DAG, Subtarget);
8827 MVT VecVT = Src.getSimpleValueType();
8834 MVT ContainerVT = VecVT;
8836 if (VecVT.isFixedLengthVector()) {
8837 ContainerVT = getContainerForFixedLengthVector(VecVT);
8848 getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
9065 getSmallestVTForIndex(MVT VecVT, unsigned MaxIdx, SDLoc DL, SelectionDAG &DAG,
9067 assert(VecVT.isScalableVector());
9068 const unsigned EltSize = VecVT.getScalarSizeInBits();
9073 SmallerVT = getLMUL1VT(VecVT);
9075 SmallerVT = getLMUL1VT(VecVT).getDoubleNumVectorElementsVT();
9077 SmallerVT = getLMUL1VT(VecVT)
9080 if (!SmallerVT.isValid() || !VecVT.bitsGT(SmallerVT))
9094 MVT VecVT = Op.getSimpleValueType();
9101 if (VecVT.getVectorElementType() == MVT::i1) {
9104 MVT WideVT = MVT::getVectorVT(MVT::i8, VecVT.getVectorElementCount());
9107 return DAG.getNode(ISD::TRUNCATE, DL, VecVT, Vec);
9113 MVT IntVT = VecVT.changeTypeToInteger();
9117 return DAG.getBitcast(VecVT, IntInsert);
9120 MVT ContainerVT = VecVT;
9122 if (VecVT.isFixedLengthVector()) {
9123 ContainerVT = getContainerForFixedLengthVector(VecVT);
9147 EVT ElemVT = VecVT.getVectorElementType();
9176 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
9182 VecVT.isFloatingPoint() ? RISCVISD::VFMV_S_F_VL : RISCVISD::VMV_S_X_VL;
9184 if (!VecVT.isFloatingPoint())
9191 if (!VecVT.isFixedLengthVector())
9193 return convertFromScalableVector(VecVT, Vec, DAG, Subtarget);
9227 if (!VecVT.isFixedLengthVector())
9229 return convertFromScalableVector(VecVT, ValInVec, DAG, Subtarget);
9251 if (VecVT.isFixedLengthVector() && isa<ConstantSDNode>(Idx) &&
9252 Idx->getAsZExtVal() + 1 == VecVT.getVectorNumElements())
9260 if (!VecVT.isFixedLengthVector())
9262 return convertFromScalableVector(VecVT, Slideup, DAG, Subtarget);
9275 MVT VecVT = Vec.getSimpleValueType();
9278 if (VecVT.getVectorElementType() == MVT::i1) {
9281 MVT ContainerVT = VecVT;
9282 if (VecVT.isFixedLengthVector()) {
9283 ContainerVT = getContainerForFixedLengthVector(VecVT);
9286 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
9293 if (VecVT.isFixedLengthVector()) {
9294 unsigned NumElts = VecVT.getVectorNumElements();
9335 MVT WideVT = MVT::getVectorVT(MVT::i8, VecVT.getVectorElementCount());
9343 MVT IntVT = VecVT.changeTypeToInteger();
9351 MVT ContainerVT = VecVT;
9352 if (VecVT.isFixedLengthVector()) {
9353 ContainerVT = getContainerForFixedLengthVector(VecVT);
9363 IdxC && VLen && VecVT.getSizeInBits().getKnownMinValue() > *VLen) {
9366 EVT ElemVT = VecVT.getVectorElementType();
9381 if (VecVT.isFixedLengthVector())
9382 MaxIdx = VecVT.getVectorNumElements() - 1;
9407 if (ContainerVT.bitsGT(LMUL2VT) && VecVT.isFixedLengthVector())
10232 MVT VecVT = Vec.getSimpleValueType();
10243 MVT ContainerVT = VecVT;
10244 if (VecVT.isFixedLengthVector()) {
10245 ContainerVT = getContainerForFixedLengthVector(VecVT);
10255 getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
10266 if (IsVP || VecVT.isFixedLengthVector())
10321 const MVT VecVT = Vec.getSimpleValueType();
10322 const MVT M1VT = getLMUL1VT(VecVT);
10328 auto InnerVT = VecVT.bitsLE(M1VT) ? VecVT : M1VT;
10369 MVT VecVT = VecEVT.getSimpleVT();
10370 MVT VecEltVT = VecVT.getVectorElementType();
10373 MVT ContainerVT = VecVT;
10374 if (VecVT.isFixedLengthVector()) {
10375 ContainerVT = getContainerForFixedLengthVector(VecVT);
10379 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
10442 MVT VecVT = VectorVal.getSimpleValueType();
10444 MVT ContainerVT = VecVT;
10445 if (VecVT.isFixedLengthVector()) {
10446 ContainerVT = getContainerForFixedLengthVector(VecVT);
10451 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
10489 MVT VecVT = VecEVT.getSimpleVT();
10492 if (VecVT.isFixedLengthVector()) {
10493 auto ContainerVT = getContainerForFixedLengthVector(VecVT);
10528 MVT VecVT = Vec.getSimpleValueType();
10545 if (VecVT.getVectorMinNumElements() >= 8 &&
10548 assert(VecVT.getVectorMinNumElements() % 8 == 0 &&
10555 VecVT = MVT::getVectorVT(MVT::i8, VecVT.getVectorMinNumElements() / 8,
10556 VecVT.isScalableVector());
10557 Vec = DAG.getBitcast(VecVT, Vec);
10564 MVT ExtVecVT = VecVT.changeVectorElementType(MVT::i8);
10571 return DAG.getSetCC(DL, VecVT, Vec, SplatZero, ISD::SETNE);
10582 MVT ContainerVT = VecVT;
10583 if (VecVT.isFixedLengthVector()) {
10584 ContainerVT = getContainerForFixedLengthVector(VecVT);
10593 getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget).first;
10601 if (VecVT.isFixedLengthVector() && EndIndex == VecVT.getVectorNumElements())
10615 if (VecVT.isFixedLengthVector())
10616 SubVec = convertFromScalableVector(VecVT, SubVec, DAG, Subtarget);
10620 MVT ContainerVecVT = VecVT;
10621 if (VecVT.isFixedLengthVector()) {
10622 ContainerVecVT = getContainerForFixedLengthVector(VecVT);
10689 if (VecVT.isFixedLengthVector())
10690 Insert = convertFromScalableVector(VecVT, Insert, DAG, Subtarget);
10720 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVecVT, DL, DAG, Subtarget);
10752 if (VecVT.isFixedLengthVector())
10753 SubVec = convertFromScalableVector(VecVT, SubVec, DAG, Subtarget);
10764 MVT VecVT = Vec.getSimpleValueType();
10782 if (VecVT.getVectorMinNumElements() >= 8 &&
10785 assert(VecVT.getVectorMinNumElements() % 8 == 0 &&
10792 VecVT = MVT::getVectorVT(MVT::i8, VecVT.getVectorMinNumElements() / 8,
10793 VecVT.isScalableVector());
10794 Vec = DAG.getBitcast(VecVT, Vec);
10803 MVT ExtVecVT = VecVT.changeVectorElementType(MVT::i8);
10821 MVT ContainerVT = VecVT;
10822 if (VecVT.isFixedLengthVector()) {
10823 ContainerVT = getContainerForFixedLengthVector(VecVT);
10837 getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget).first;
10851 if (VecVT.isFixedLengthVector()) {
10852 VecVT = getContainerForFixedLengthVector(VecVT);
10853 Vec = convertToScalableVector(VecVT, Vec, DAG, Subtarget);
10870 VecVT, ContainerSubVecVT, OrigIdx / Vscale, TRI);
10877 VecVT, ContainerSubVecVT, OrigIdx, TRI);
10905 MVT InterSubVT = VecVT;
10906 if (VecVT.bitsGT(getLMUL1VT(VecVT))) {
10907 // If VecVT has an LMUL > 1, then SubVecVT should have a smaller LMUL, and
10917 InterSubVT = getLMUL1VT(VecVT);
10975 MVT VecVT = Op.getSimpleValueType();
10977 assert(VecVT.isScalableVector() &&
10981 if (VecVT.getVectorElementType() == MVT::i1)
10985 if (VecVT.getSizeInBits().getKnownMinValue() ==
10996 SDValue Even = DAG.getNode(ISD::CONCAT_VECTORS, DL, VecVT,
10998 SDValue Odd = DAG.getNode(ISD::CONCAT_VECTORS, DL, VecVT, ResLo.getValue(1),
11005 MVT::getVectorVT(VecVT.getVectorElementType(),
11006 VecVT.getVectorElementCount().multiplyCoefficientBy(2));
11012 if (VecVT.getScalarSizeInBits() < Subtarget.getELen()) {
11013 SDValue Even = getDeinterleaveShiftAndTrunc(DL, VecVT, Concat, 2, 0, DAG);
11014 SDValue Odd = getDeinterleaveShiftAndTrunc(DL, VecVT, Concat, 2, 1, DAG);
11043 SDValue Even = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VecVT, EvenWide,
11045 SDValue Odd = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VecVT, OddWide,
11054 MVT VecVT = Op.getSimpleValueType();
11056 assert(VecVT.isScalableVector() &&
11060 if (VecVT.getVectorElementType() == MVT::i1)
11067 if (VecVT.getSizeInBits().getKnownMinValue() == (8 * RISCV::RVVBitsPerBlock)) {
11077 SDValue Lo = DAG.getNode(ISD::CONCAT_VECTORS, DL, VecVT,
11079 SDValue Hi = DAG.getNode(ISD::CONCAT_VECTORS, DL, VecVT,
11088 if (VecVT.getScalarSizeInBits() < Subtarget.getELen()) {
11094 MVT::getVectorVT(VecVT.getVectorElementType(),
11095 VecVT.getVectorElementCount().multiplyCoefficientBy(2));
11114 SDValue VLMax = DAG.getSplatVector(IdxVT, DL, computeVLMax(VecVT, DL, DAG));
11131 SDValue Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VecVT, Interleaved,
11134 ISD::EXTRACT_SUBVECTOR, DL, VecVT, Interleaved,
11135 DAG.getVectorIdxConstant(VecVT.getVectorMinNumElements(), DL));
11175 MVT VecVT = Op.getSimpleValueType();
11176 if (VecVT.getVectorElementType() == MVT::i1) {
11177 MVT WidenVT = MVT::getVectorVT(MVT::i8, VecVT.getVectorElementCount());
11180 return DAG.getSetCC(DL, VecVT, Op2,
11184 MVT ContainerVT = VecVT;
11186 if (VecVT.isFixedLengthVector()) {
11187 ContainerVT = getContainerForFixedLengthVector(VecVT);
11192 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
11222 if (VecVT.isFixedLengthVector()) {
11226 DAG.getElementCount(DL, XLenVT, VecVT.getVectorElementCount()));
11230 Concat = convertFromScalableVector(VecVT, Concat, DAG, Subtarget);
11239 VecVT.isFixedLengthVector()
11240 ? VecVT.getVectorNumElements()
11255 auto [LoVT, HiVT] = DAG.GetSplitDestVTs(VecVT);
11261 DAG.getNode(ISD::INSERT_SUBVECTOR, DL, VecVT, DAG.getUNDEF(VecVT), Hi,
11264 ISD::INSERT_SUBVECTOR, DL, VecVT, Res, Lo,
11285 DAG.getElementCount(DL, XLenVT, VecVT.getVectorElementCount()),
11304 if (VecVT.isFixedLengthVector())
11305 Gather = convertFromScalableVector(VecVT, Gather, DAG, Subtarget);
11315 MVT VecVT = Op.getSimpleValueType();
11317 SDValue VLMax = computeVLMax(VecVT, DL, DAG);
11333 SDValue TrueMask = getAllOnesMask(VecVT, VLMax, DL, DAG);
11336 getVSlidedown(DAG, Subtarget, DL, VecVT, DAG.getUNDEF(VecVT), V1,
11338 return getVSlideup(DAG, Subtarget, DL, VecVT, SlideDown, V2, UpOffset,
13366 MVT VecVT = Vec.getSimpleValueType();
13369 VecVT.getVectorElementType() == MVT::i64 &&
13373 MVT ContainerVT = VecVT;
13374 if (VecVT.isFixedLengthVector()) {
13375 ContainerVT = getContainerForFixedLengthVector(VecVT);
13548 MVT VecVT = Vec.getSimpleValueType();
13555 auto [Mask, VL] = getDefaultVLOps(1, VecVT, DL, DAG, Subtarget);
13558 DAG.getNode(RISCVISD::VMV_V_X_VL, DL, VecVT, DAG.getUNDEF(VecVT),
13560 SDValue LShr32 = DAG.getNode(RISCVISD::SRL_VL, DL, VecVT, Vec, ThirtyTwoV,
13561 DAG.getUNDEF(VecVT), Mask, VL);
18460 MVT VecVT = Src.getSimpleValueType();
18461 // VecVT should be scalable and memory VT should match the element type.
18462 if (!Store->isIndexed() && VecVT.isScalableVector() &&
18463 MemVT == VecVT.getVectorElementType()) {
18465 MVT MaskVT = getMaskTypeFor(VecVT);
18592 MVT VecVT = N->getOperand(0).getSimpleValueType();
18593 const MVT M1VT = getLMUL1VT(VecVT);
18594 if (M1VT.bitsLT(VecVT)) {