Lines Matching refs:VecVT
2199 EVT VecVT = VecOp.getValueType();
2200 if (!isOperationLegalOrCustomOrPromote(Opc, VecVT))
2207 EVT ScalarVT = VecVT.getScalarType();
2522 // Attempt to decompose a subvector insert/extract between VecVT and
2529 MVT VecVT, MVT SubVecVT, unsigned InsertExtractIdx,
2535 unsigned VecRegClassID = getRegClassIDForVecVT(VecVT);
2547 VecVT = VecVT.getHalfNumVectorElementsVT();
2549 InsertExtractIdx >= VecVT.getVectorElementCount().getKnownMinValue();
2551 getSubregIndexByMVT(VecVT, IsHi));
2553 InsertExtractIdx -= VecVT.getVectorElementCount().getKnownMinValue();
2754 static MVT getMaskTypeFor(MVT VecVT) {
2755 assert(VecVT.isVector());
2756 ElementCount EC = VecVT.getVectorElementCount();
2762 static SDValue getAllOnesMask(MVT VecVT, SDValue VL, const SDLoc &DL,
2764 MVT MaskVT = getMaskTypeFor(VecVT);
2782 getDefaultScalableVLOps(MVT VecVT, const SDLoc &DL, SelectionDAG &DAG,
2784 assert(VecVT.isScalableVector() && "Expecting a scalable vector");
2786 SDValue Mask = getAllOnesMask(VecVT, VL, DL, DAG);
2800 // VecVT is a vector type, either fixed-length or scalable, and ContainerVT is
2802 // VecVT is scalable, then ContainerVT should be the same as VecVT.
2804 getDefaultVLOps(MVT VecVT, MVT ContainerVT, const SDLoc &DL, SelectionDAG &DAG,
2806 if (VecVT.isFixedLengthVector())
2807 return getDefaultVLOps(VecVT.getVectorNumElements(), ContainerVT, DL, DAG,
2813 SDValue RISCVTargetLowering::computeVLMax(MVT VecVT, const SDLoc &DL,
2815 assert(VecVT.isScalableVector() && "Expected scalable vector");
2817 VecVT.getVectorElementCount());
2821 RISCVTargetLowering::computeVLMAXBounds(MVT VecVT,
2823 assert(VecVT.isScalableVector() && "Expected scalable vector");
2825 unsigned EltSize = VecVT.getScalarSizeInBits();
2826 unsigned MinSize = VecVT.getSizeInBits().getKnownMinValue();
4796 MVT VecVT = EvenV.getSimpleValueType();
4797 MVT VecContainerVT = VecVT; // <vscale x n x ty>
4800 VecContainerVT = getContainerForFixedLengthVector(DAG, VecVT, Subtarget);
4805 assert(VecVT.getScalarSizeInBits() < Subtarget.getELen());
4812 MVT::getVectorVT(MVT::getIntegerVT(VecVT.getScalarSizeInBits() * 2),
4813 VecVT.getVectorElementCount());
4823 auto [Mask, VL] = getDefaultVLOps(VecVT, VecContainerVT, DL, DAG, Subtarget);
4834 // Interleaved = (OddV << VecVT.getScalarSizeInBits()) + EvenV.
4836 DAG.getConstant(VecVT.getScalarSizeInBits(), DL, VecContainerVT);
4847 DAG.getConstant(VecVT.getScalarSizeInBits(), DL, WideContainerVT);
4859 // Then get OddV * by 2^(VecVT.getScalarSizeInBits() - 1)
4868 // = (OddV << VecVT.getScalarSizeInBits()) + EvenV
4876 VecVT.getVectorElementType(), // Make sure to use original type
4882 MVT::getVectorVT(VecVT.getVectorElementType(),
4883 VecVT.getVectorElementCount().multiplyCoefficientBy(2));
8084 MVT VecVT = Op.getSimpleValueType();
8085 assert(!Subtarget.is64Bit() && VecVT.getVectorElementType() == MVT::i64 &&
8092 MVT ContainerVT = VecVT;
8093 if (VecVT.isFixedLengthVector())
8094 ContainerVT = getContainerForFixedLengthVector(VecVT);
8096 auto VL = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget).second;
8101 if (VecVT.isFixedLengthVector())
8102 Res = convertFromScalableVector(VecVT, Res, DAG, Subtarget);
8114 MVT VecVT = Op.getSimpleValueType();
8120 if (VecVT.isScalableVector()) {
8121 SDValue SplatZero = DAG.getConstant(0, DL, VecVT);
8122 SDValue SplatTrueVal = DAG.getConstant(ExtTrueVal, DL, VecVT);
8123 return DAG.getNode(ISD::VSELECT, DL, VecVT, Src, SplatTrueVal, SplatZero);
8126 MVT ContainerVT = getContainerForFixedLengthVector(VecVT);
8132 SDValue VL = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget).second;
8146 return convertFromScalableVector(VecVT, Select, DAG, Subtarget);
8188 MVT VecVT = Src.getSimpleValueType();
8195 MVT ContainerVT = VecVT;
8197 if (VecVT.isFixedLengthVector()) {
8198 ContainerVT = getContainerForFixedLengthVector(VecVT);
8209 getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
8420 getSmallestVTForIndex(MVT VecVT, unsigned MaxIdx, SDLoc DL, SelectionDAG &DAG,
8422 assert(VecVT.isScalableVector());
8423 const unsigned EltSize = VecVT.getScalarSizeInBits();
8428 SmallerVT = getLMUL1VT(VecVT);
8430 SmallerVT = getLMUL1VT(VecVT).getDoubleNumVectorElementsVT();
8432 SmallerVT = getLMUL1VT(VecVT)
8435 if (!SmallerVT.isValid() || !VecVT.bitsGT(SmallerVT))
8449 MVT VecVT = Op.getSimpleValueType();
8454 if (VecVT.getVectorElementType() == MVT::i1) {
8457 MVT WideVT = MVT::getVectorVT(MVT::i8, VecVT.getVectorElementCount());
8460 return DAG.getNode(ISD::TRUNCATE, DL, VecVT, Vec);
8463 MVT ContainerVT = VecVT;
8465 if (VecVT.isFixedLengthVector()) {
8466 ContainerVT = getContainerForFixedLengthVector(VecVT);
8490 EVT ElemVT = VecVT.getVectorElementType();
8521 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
8527 VecVT.isFloatingPoint() ? RISCVISD::VFMV_S_F_VL : RISCVISD::VMV_S_X_VL;
8529 if (!VecVT.isFloatingPoint())
8536 if (!VecVT.isFixedLengthVector())
8538 return convertFromScalableVector(VecVT, Vec, DAG, Subtarget);
8572 if (!VecVT.isFixedLengthVector())
8574 return convertFromScalableVector(VecVT, ValInVec, DAG, Subtarget);
8596 if (VecVT.isFixedLengthVector() && isa<ConstantSDNode>(Idx) &&
8597 Idx->getAsZExtVal() + 1 == VecVT.getVectorNumElements())
8605 if (!VecVT.isFixedLengthVector())
8607 return convertFromScalableVector(VecVT, Slideup, DAG, Subtarget);
8620 MVT VecVT = Vec.getSimpleValueType();
8623 if (VecVT.getVectorElementType() == MVT::i1) {
8626 MVT ContainerVT = VecVT;
8627 if (VecVT.isFixedLengthVector()) {
8628 ContainerVT = getContainerForFixedLengthVector(VecVT);
8631 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
8638 if (VecVT.isFixedLengthVector()) {
8639 unsigned NumElts = VecVT.getVectorNumElements();
8680 MVT WideVT = MVT::getVectorVT(MVT::i8, VecVT.getVectorElementCount());
8686 MVT ContainerVT = VecVT;
8687 if (VecVT.isFixedLengthVector()) {
8688 ContainerVT = getContainerForFixedLengthVector(VecVT);
8698 IdxC && VLen && VecVT.getSizeInBits().getKnownMinValue() > *VLen) {
8701 EVT ElemVT = VecVT.getVectorElementType();
8716 if (VecVT.isFixedLengthVector())
8717 MaxIdx = VecVT.getVectorNumElements() - 1;
8742 if (ContainerVT.bitsGT(LMUL2VT) && VecVT.isFixedLengthVector())
9716 MVT VecVT = Vec.getSimpleValueType();
9727 MVT ContainerVT = VecVT;
9728 if (VecVT.isFixedLengthVector()) {
9729 ContainerVT = getContainerForFixedLengthVector(VecVT);
9739 getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
9806 const MVT VecVT = Vec.getSimpleValueType();
9807 const MVT M1VT = getLMUL1VT(VecVT);
9813 auto InnerVT = VecVT.bitsLE(M1VT) ? VecVT : M1VT;
9854 MVT VecVT = VecEVT.getSimpleVT();
9855 MVT VecEltVT = VecVT.getVectorElementType();
9858 MVT ContainerVT = VecVT;
9859 if (VecVT.isFixedLengthVector()) {
9860 ContainerVT = getContainerForFixedLengthVector(VecVT);
9864 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
9927 MVT VecVT = VectorVal.getSimpleValueType();
9929 MVT ContainerVT = VecVT;
9930 if (VecVT.isFixedLengthVector()) {
9931 ContainerVT = getContainerForFixedLengthVector(VecVT);
9936 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget);
9975 MVT VecVT = VecEVT.getSimpleVT();
9978 if (VecVT.isFixedLengthVector()) {
9979 auto ContainerVT = getContainerForFixedLengthVector(VecVT);
10015 MVT VecVT = Vec.getSimpleValueType();
10030 if (VecVT.getVectorMinNumElements() >= 8 &&
10033 assert(VecVT.getVectorMinNumElements() % 8 == 0 &&
10040 VecVT = MVT::getVectorVT(MVT::i8, VecVT.getVectorMinNumElements() / 8,
10041 VecVT.isScalableVector());
10042 Vec = DAG.getBitcast(VecVT, Vec);
10049 MVT ExtVecVT = VecVT.changeVectorElementType(MVT::i8);
10056 return DAG.getSetCC(DL, VecVT, Vec, SplatZero, ISD::SETNE);
10067 if (OrigIdx == 0 && Vec.isUndef() && !VecVT.isFixedLengthVector())
10069 MVT ContainerVT = VecVT;
10070 if (VecVT.isFixedLengthVector()) {
10071 ContainerVT = getContainerForFixedLengthVector(VecVT);
10075 if (OrigIdx == 0 && Vec.isUndef() && VecVT.isFixedLengthVector()) {
10079 SubVec = convertFromScalableVector(VecVT, SubVec, DAG, Subtarget);
10087 getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget).first;
10095 if (VecVT.isFixedLengthVector() && EndIndex == VecVT.getVectorNumElements())
10109 if (VecVT.isFixedLengthVector())
10110 SubVec = convertFromScalableVector(VecVT, SubVec, DAG, Subtarget);
10114 MVT ContainerVecVT = VecVT;
10115 if (VecVT.isFixedLengthVector()) {
10116 ContainerVecVT = getContainerForFixedLengthVector(VecVT);
10179 if (VecVT.isFixedLengthVector())
10180 Insert = convertFromScalableVector(VecVT, Insert, DAG, Subtarget);
10208 auto [Mask, VL] = getDefaultVLOps(VecVT, ContainerVecVT, DL, DAG, Subtarget);
10240 if (VecVT.isFixedLengthVector())
10241 SubVec = convertFromScalableVector(VecVT, SubVec, DAG, Subtarget);
10252 MVT VecVT = Vec.getSimpleValueType();
10265 if (VecVT.getVectorMinNumElements() >= 8 &&
10268 assert(VecVT.getVectorMinNumElements() % 8 == 0 &&
10275 VecVT = MVT::getVectorVT(MVT::i8, VecVT.getVectorMinNumElements() / 8,
10276 VecVT.isScalableVector());
10277 Vec = DAG.getBitcast(VecVT, Vec);
10286 MVT ExtVecVT = VecVT.changeVectorElementType(MVT::i8);
10309 MVT ContainerVT = VecVT;
10310 if (VecVT.isFixedLengthVector()) {
10311 ContainerVT = getContainerForFixedLengthVector(VecVT);
10325 getDefaultVLOps(VecVT, ContainerVT, DL, DAG, Subtarget).first;
10340 if (VecVT.isFixedLengthVector()) {
10341 VecVT = getContainerForFixedLengthVector(VecVT);
10342 Vec = convertToScalableVector(VecVT, Vec, DAG, Subtarget);
10359 VecVT, ContainerSubVecVT, OrigIdx / Vscale, TRI);
10366 VecVT, ContainerSubVecVT, OrigIdx, TRI);
10390 MVT InterSubVT = VecVT;
10391 if (VecVT.bitsGT(getLMUL1VT(VecVT))) {
10392 // If VecVT has an LMUL > 1, then SubVecVT should have a smaller LMUL, and
10395 InterSubVT = getLMUL1VT(VecVT);
10453 MVT VecVT = Op.getSimpleValueType();
10455 assert(VecVT.isScalableVector() &&
10459 if (VecVT.getVectorElementType() == MVT::i1)
10463 if (VecVT.getSizeInBits().getKnownMinValue() ==
10474 SDValue Even = DAG.getNode(ISD::CONCAT_VECTORS, DL, VecVT,
10476 SDValue Odd = DAG.getNode(ISD::CONCAT_VECTORS, DL, VecVT, ResLo.getValue(1),
10483 MVT::getVectorVT(VecVT.getVectorElementType(),
10484 VecVT.getVectorElementCount().multiplyCoefficientBy(2));
10494 if (VecVT.getScalarSizeInBits() < Subtarget.getELen()) {
10496 getDeinterleaveViaVNSRL(DL, VecVT, Concat, true, Subtarget, DAG);
10498 getDeinterleaveViaVNSRL(DL, VecVT, Concat, false, Subtarget, DAG);
10518 SDValue Even = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VecVT, EvenWide,
10520 SDValue Odd = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VecVT, OddWide,
10529 MVT VecVT = Op.getSimpleValueType();
10531 assert(VecVT.isScalableVector() &&
10535 if (VecVT.getVectorElementType() == MVT::i1)
10542 if (VecVT.getSizeInBits().getKnownMinValue() == (8 * RISCV::RVVBitsPerBlock)) {
10552 SDValue Lo = DAG.getNode(ISD::CONCAT_VECTORS, DL, VecVT,
10554 SDValue Hi = DAG.getNode(ISD::CONCAT_VECTORS, DL, VecVT,
10563 if (VecVT.getScalarSizeInBits() < Subtarget.getELen()) {
10569 MVT::getVectorVT(VecVT.getVectorElementType(),
10570 VecVT.getVectorElementCount().multiplyCoefficientBy(2));
10589 SDValue VLMax = DAG.getSplatVector(IdxVT, DL, computeVLMax(VecVT, DL, DAG));
10606 SDValue Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VecVT, Interleaved,
10609 ISD::EXTRACT_SUBVECTOR, DL, VecVT, Interleaved,
10610 DAG.getVectorIdxConstant(VecVT.getVectorMinNumElements(), DL));
10650 MVT VecVT = Op.getSimpleValueType();
10651 if (VecVT.getVectorElementType() == MVT::i1) {
10652 MVT WidenVT = MVT::getVectorVT(MVT::i8, VecVT.getVectorElementCount());
10655 return DAG.getNode(ISD::TRUNCATE, DL, VecVT, Op2);
10657 unsigned EltSize = VecVT.getScalarSizeInBits();
10658 unsigned MinSize = VecVT.getSizeInBits().getKnownMinValue();
10664 MVT IntVT = VecVT.changeVectorElementTypeToInteger();
10677 auto [LoVT, HiVT] = DAG.GetSplitDestVTs(VecVT);
10683 DAG.getNode(ISD::INSERT_SUBVECTOR, DL, VecVT, DAG.getUNDEF(VecVT), Hi,
10686 ISD::INSERT_SUBVECTOR, DL, VecVT, Res, Lo,
10691 IntVT = MVT::getVectorVT(MVT::i16, VecVT.getVectorElementCount());
10696 auto [Mask, VL] = getDefaultScalableVLOps(VecVT, DL, DAG, Subtarget);
10700 computeVLMax(VecVT, DL, DAG),
10717 return DAG.getNode(GatherOpc, DL, VecVT, Op.getOperand(0), Indices,
10718 DAG.getUNDEF(VecVT), Mask, VL);
10727 MVT VecVT = Op.getSimpleValueType();
10729 SDValue VLMax = computeVLMax(VecVT, DL, DAG);
10745 SDValue TrueMask = getAllOnesMask(VecVT, VLMax, DL, DAG);
10748 getVSlidedown(DAG, Subtarget, DL, VecVT, DAG.getUNDEF(VecVT), V1,
10750 return getVSlideup(DAG, Subtarget, DL, VecVT, SlideDown, V2, UpOffset,
12675 MVT VecVT = Vec.getSimpleValueType();
12678 VecVT.getVectorElementType() == MVT::i64 &&
12682 MVT ContainerVT = VecVT;
12683 if (VecVT.isFixedLengthVector()) {
12684 ContainerVT = getContainerForFixedLengthVector(VecVT);
12857 MVT VecVT = Vec.getSimpleValueType();
12864 auto [Mask, VL] = getDefaultVLOps(1, VecVT, DL, DAG, Subtarget);
12867 DAG.getNode(RISCVISD::VMV_V_X_VL, DL, VecVT, DAG.getUNDEF(VecVT),
12869 SDValue LShr32 = DAG.getNode(RISCVISD::SRL_VL, DL, VecVT, Vec, ThirtyTwoV,
12870 DAG.getUNDEF(VecVT), Mask, VL);
17406 MVT VecVT = Src.getSimpleValueType();
17407 // VecVT should be scalable and memory VT should match the element type.
17408 if (!Store->isIndexed() && VecVT.isScalableVector() &&
17409 MemVT == VecVT.getVectorElementType()) {
17411 MVT MaskVT = getMaskTypeFor(VecVT);
17534 MVT VecVT = N->getOperand(0).getSimpleValueType();
17535 const MVT M1VT = getLMUL1VT(VecVT);
17536 if (M1VT.bitsLT(VecVT)) {