Lines Matching defs:NumElts
3211 unsigned NumElts = std::min(DataVT.getVectorNumElements(),
3213 Info.memVT = MVT::getVectorVT(DataVT.getVectorElementType(), NumElts);
3223 unsigned NumElts = std::min(DataVT.getVectorNumElements(),
3225 Info.memVT = MVT::getVectorVT(DataVT.getVectorElementType(), NumElts);
3713 unsigned NumElts = Mask.size();
3714 return isUndefInRange(Mask, 0, NumElts / 2);
3719 unsigned NumElts = Mask.size();
3720 return isUndefInRange(Mask, NumElts / 2, NumElts / 2);
3768 unsigned NumElts = Mask.size();
3770 if (!isUndefOrEqual(M, I) && !isUndefOrEqual(M, I + NumElts))
3808 unsigned NumElts = Mask.size();
3809 APInt DemandedElts = APInt::getZero(NumElts);
3811 if (isInRange(M, 0, NumElts))
3946 unsigned NumElts = VT.getVectorNumElements();
3949 ConstVecVT = MVT::getVectorVT(MVT::i32, NumElts * 2);
3954 for (unsigned i = 0; i < NumElts; ++i) {
3977 unsigned NumElts = VT.getVectorNumElements();
3980 ConstVecVT = MVT::getVectorVT(MVT::i32, NumElts * 2);
4057 unsigned NumElts = LHS.getValueType().getVectorNumElements();
4059 RHS.getConstantOperandAPInt(1) == NumElts) ||
4061 LHS.getConstantOperandAPInt(1) == NumElts))
4197 unsigned NumElts = VT.getVectorNumElements();
4198 if ((!Subtarget.hasDQI() && NumElts == 8) || NumElts < 8)
4672 unsigned NumElts = VT.getSizeInBits() / 32;
4673 SDValue Vec = DAG.getAllOnesConstant(dl, MVT::getVectorVT(MVT::i32, NumElts));
4715 int NumElts = VT.getVectorNumElements();
4717 for (int i = 0; i < NumElts; ++i) {
4720 Pos += (Unary ? 0 : NumElts * (i % 2));
4733 int NumElts = VT.getVectorNumElements();
4734 for (int i = 0; i < NumElts; ++i) {
4736 Pos += (Lo ? 0 : NumElts / 2);
4747 for (int I = 0, NumElts = Mask.size(); I != NumElts; ++I) {
4751 SDValue V = (M < NumElts) ? V1 : V2;
4754 Ops[I] = V.getOperand(M % NumElts);
4798 int NumElts = VT.getVectorNumElements();
4799 for (int I = 0; I != NumElts; I += 4) {
4802 PackMask.push_back(I + Offset + NumElts);
4803 PackMask.push_back(I + Offset + NumElts + 2);
4908 unsigned NumElts = SizeInBits / EltSizeInBits;
4923 if (NumSrcElts == NumElts) {
4941 UndefElts = APInt(NumElts, 0);
4942 EltBits.resize(NumElts, APInt(EltSizeInBits, 0));
4944 for (unsigned i = 0; i != NumElts; ++i) {
5006 APInt UndefSrcElts = APInt::getAllOnes(NumElts);
5007 SmallVector<APInt, 64> SrcEltBits(NumElts, APInt(EltSizeInBits, 0));
5192 if (isAnyInRange(Mask, 0, NumElts) &&
5197 if (isAnyInRange(Mask, NumElts, 2 * NumElts) &&
5203 UndefElts = APInt::getZero(NumElts);
5204 for (int i = 0; i != (int)NumElts; ++i) {
5209 } else if (M < (int)NumElts) {
5214 if (UndefElts1[M - NumElts])
5216 EltBits.push_back(EltBits1[M - NumElts]);
5366 unsigned NumElts = VT.getVectorNumElements();
5369 unsigned Offset = Unary ? 0 : NumElts;
5388 int NumElts = DemandedElts.getBitWidth();
5389 int NumInnerElts = NumElts / 2;
5390 int NumEltsPerLane = NumElts / NumLanes;
5936 unsigned NumElts = Mask.size();
5937 assert(KnownUndef.getBitWidth() == NumElts &&
5938 KnownZero.getBitWidth() == NumElts && "Shuffle mask size mismatch");
5940 for (unsigned i = 0; i != NumElts; ++i) {
5952 unsigned NumElts = Mask.size();
5953 KnownUndef = KnownZero = APInt::getZero(NumElts);
5955 for (unsigned i = 0; i != NumElts; ++i) {
5969 unsigned NumElts = CondVT.getVectorNumElements();
5978 Mask.resize(NumElts, SM_SentinelUndef);
5980 for (int i = 0; i != (int)NumElts; ++i) {
5987 Mask[i] += NumElts;
6013 unsigned NumElts = VT.getVectorNumElements();
6018 assert(NumElts == DemandedElts.getBitWidth() && "Unexpected vector size");
6027 if (isUndefOrInRange(ShuffleMask, 0, 2 * NumElts)) {
6115 unsigned MaxElts = std::max(NumElts, NumSubSrcBCElts);
6116 assert((MaxElts % NumElts) == 0 && (MaxElts % NumSubSrcBCElts) == 0 &&
6118 InsertIdx *= (MaxElts / NumElts);
6120 NumSubElts *= (MaxElts / NumElts);
6134 if (Depth > 0 && InsertIdx == NumSubElts && NumElts == (2 * NumSubElts) &&
6143 Mask.push_back(i + NumElts);
6179 NumElts *= Scale;
6186 Mask.append(NumElts, SM_SentinelZero);
6188 for (int i = 0; i != (int)NumElts; ++i)
6194 M = (NumElts * (1 + InputIdx)) + (M % NumSubElts);
6212 N.getConstantOperandAPInt(2).uge(NumElts))
6219 for (unsigned i = 0; i != NumElts; ++i)
6286 assert(N0.getValueType().getVectorNumElements() == (NumElts / 2) &&
6287 N1.getValueType().getVectorNumElements() == (NumElts / 2) &&
6334 if ((Offset0 && isInRange(M, 0, NumElts)) ||
6335 (Offset1 && isInRange(M, NumElts, 2 * NumElts)))
6363 Mask.append(NumElts - NumSrcElts, SM_SentinelZero);
6396 Mask.append(NumElts, SM_SentinelZero);
6430 for (int i = 0; i != (int)NumElts; ++i) {
6449 Mask.append(NumElts, 0);
6470 for (unsigned I = 0; I != NumElts; ++I)
6489 DecodeZeroExtendMask(SrcVT.getScalarSizeInBits(), NumBitsPerElt, NumElts,
6588 unsigned NumElts = Op.getValueType().getVectorNumElements();
6589 APInt DemandedElts = APInt::getAllOnes(NumElts);
6727 unsigned NumElts = VT.getVectorNumElements();
6735 for (unsigned i = 0; i < NumElts; ++i) {
7513 unsigned NumElts = VT.getVectorNumElements();
7523 assert((NumElts % Sequence.size()) == 0 && "Sequence doesn't fit.");
7552 MVT BcstVT = MVT::getVectorVT(EltType, NumElts / SeqLen);
7555 BcstVT = MVT::getVectorVT(EltType, Scale * (NumElts / SeqLen));
7566 if (!Ld || (NumElts - NumUndefElts) <= 1) {
7621 if (!Ld || NumElts - NumUndefElts != 1)
7699 if (!Ld->hasNUsesOfValue(NumElts - NumUndefElts, 0))
7993 unsigned NumElts = LastIdx - BaseIdx;
7998 for (unsigned i = 0, e = NumElts; i != e && CanFold; ++i) {
8004 if (i * 2 == NumElts)
8031 if (i * 2 < NumElts) {
8043 if (i * 2 == NumElts)
8047 SDValue Expected = (i * 2 < NumElts) ? V0 : V1;
8102 unsigned NumElts = VT.getVectorNumElements();
8104 SDValue V0_HI = extract128BitVector(V0, NumElts/2, DAG, DL);
8106 SDValue V1_HI = extract128BitVector(V1, NumElts/2, DAG, DL);
8145 unsigned NumElts = VT.getVectorNumElements();
8156 for (unsigned i = 0, e = NumElts; i != e; ++i) {
8341 unsigned NumElts = VT.getVectorNumElements();
8344 unsigned NumEltsIn128Bits = NumElts / Num128BitChunks;
8437 unsigned NumElts = VT.getVectorNumElements();
8438 APInt DemandedElts = APInt::getAllOnes(NumElts);
8439 for (unsigned i = 0; i != NumElts; ++i)
8444 unsigned HalfNumElts = NumElts / 2;
8485 unsigned NumElts = VT.getVectorNumElements();
8486 unsigned Half = NumElts / 2;
8493 for (unsigned i = Half, e = NumElts; i != e; ++i)
8504 isHorizontalBinOpPart(BV, ISD::ADD, DL, DAG, Half, NumElts, InVec2,
8511 isHorizontalBinOpPart(BV, ISD::SUB, DL, DAG, Half, NumElts, InVec2,
8541 if (isHorizontalBinOpPart(BV, ISD::ADD, DL, DAG, 0, NumElts, InVec0,
8544 else if (isHorizontalBinOpPart(BV, ISD::SUB, DL, DAG, 0, NumElts, InVec0,
8547 else if (isHorizontalBinOpPart(BV, ISD::FADD, DL, DAG, 0, NumElts, InVec0,
8550 else if (isHorizontalBinOpPart(BV, ISD::FSUB, DL, DAG, 0, NumElts, InVec0,
8688 unsigned NumElts = VT.getVectorNumElements();
8692 assert(IndicesVec.getValueType().getVectorNumElements() >= NumElts &&
8694 if (IndicesVec.getValueType().getVectorNumElements() > NumElts) {
8698 NumElts * VT.getScalarSizeInBits());
8703 if (IndicesVec.getValueType().getVectorNumElements() > NumElts)
8714 VT = MVT::getVectorVT(VT.getScalarType(), Scale * NumElts);
9175 unsigned NumElts = VT.getVectorNumElements();
9176 for (unsigned i = 0; i != NumElts; ++i)
9177 ShuffleMask.push_back(i == InsertC ? NumElts : i);
9658 int NumElts = Mask.size();
9660 int NumLanes = NumElts / NumEltsPerLane;
9668 int Lane = (M % NumElts) / NumEltsPerLane;
9813 // TODO: Handle MaskSize != NumElts?
9817 int NumElts = VT.getVectorNumElements();
9818 if (MaskSize == NumElts) {
9820 int NumEltsPerLane = NumElts / NumLanes;
10167 unsigned NumElts = VT.getVectorNumElements();
10168 assert((NumElts == 4 || NumElts == 8 || NumElts == 16) &&
10170 SDValue VMask = getMaskNode(MaskNode, MVT::getVectorVT(MVT::i1, NumElts),
10182 int NumElts = VT.getVectorNumElements();
10185 for (int i = 0; i != NumElts; i += 2) {
10220 isSequentialOrUndefOrZeroInRange(TargetMask, 0, NumElts, 0))
10224 for (int i = 0; (i != NumElts) && (MatchLo || MatchHi); ++i) {
10325 unsigned NumElts = Mask.size();
10333 unsigned NumSrcElts = NumElts / Scale;
10336 unsigned UpperElts = NumElts - NumSrcElts;
10427 unsigned NumElts = VT.getVectorNumElements();
10432 unsigned NumSrcElts = NumElts / Scale;
10433 unsigned UpperElts = NumElts - NumSrcElts;
10478 unsigned NumElts = VT.getVectorNumElements();
10489 unsigned NumHalfSrcElts = NumElts / Scale;
10497 unsigned UpperElts = NumElts - NumSrcElts;
10525 MVT ConcatVT = MVT::getVectorVT(VT.getScalarType(), NumElts * 2);
10627 unsigned NumElts = VT.getVectorNumElements();
10673 MVT PackVT = MVT::getVectorVT(PackSVT, NumElts >> NumStages);
10834 int NumElts = Mask.size();
10836 int NumEltsPerLane = NumElts / NumLanes;
10837 assert((NumLanes * NumEltsPerLane) == NumElts && "Value type mismatch");
10856 if (M == Elt || (0 <= M && M < NumElts &&
10857 IsElementEquivalent(NumElts, V1, V1, M, Elt))) {
10862 if (M == (Elt + NumElts) ||
10863 (NumElts <= M &&
10864 IsElementEquivalent(NumElts, V2, V2, M - NumElts, Elt))) {
10866 Mask[Elt] = Elt + NumElts;
10880 Mask[Elt] = Elt + NumElts;
10923 unsigned NumElts = VT.getVectorNumElements();
10983 MVT IntegerType = MVT::getIntegerVT(std::max<unsigned>(NumElts, 8));
11052 MVT IntegerType = MVT::getIntegerVT(std::max<unsigned>(NumElts, 8));
11109 int NumElts = Mask.size();
11111 int NumLaneElts = NumElts / NumLanes;
11118 for (int Elt = 0; Elt != NumElts; ++Elt) {
11126 if (M < NumElts && (Op.isUndef() || Op == V1))
11128 else if (NumElts <= M && (Op.isUndef() || Op == V2)) {
11130 NormM -= NumElts;
11135 for (int Lane = 0; Lane != NumElts; Lane += NumLaneElts) {
11155 SmallVector<int, 32> PermuteMask(NumElts, -1);
11156 for (int Elt = 0; Elt != NumElts; ++Elt) {
11161 if (NumElts <= M)
11162 NormM -= NumElts;
11163 bool IsFirstOp = M < NumElts;
11313 int NumElts = VT.getVectorNumElements();
11314 int NumEltsPerLane = NumElts / NumLanes;
11321 for (int Lane = 0; Lane != NumElts; Lane += NumEltsPerLane) {
11326 if (M < NumElts) {
11333 M -= NumElts;
11360 SmallVector<int, 64> PermMask(NumElts, SM_SentinelUndef);
11361 for (int Lane = 0; Lane != NumElts; Lane += NumEltsPerLane) {
11366 if (M < NumElts)
11379 return RotateAndPermute(V2, V1, Range2.first, NumElts);
11419 int NumElts = Mask.size();
11421 int NumEltsPerLane = NumElts / NumLanes;
11427 SmallVector<int, 32> V1Mask(NumElts, -1);
11428 SmallVector<int, 32> V2Mask(NumElts, -1);
11429 SmallVector<int, 32> FinalMask(NumElts, -1);
11430 for (int i = 0; i < NumElts; ++i) {
11432 if (M >= 0 && M < NumElts) {
11437 } else if (M >= NumElts) {
11438 V2Mask[i] = M - NumElts;
11439 FinalMask[i] = i + NumElts;
11516 V1Mask.assign(NumElts, -1);
11517 V2Mask.assign(NumElts, -1);
11518 FinalMask.assign(NumElts, -1);
11519 for (int i = 0; i != NumElts; i += NumEltsPerLane)
11522 if (M >= 0 && M < NumElts) {
11525 } else if (M >= NumElts) {
11526 V2Mask[i + (j / 2)] = M - NumElts;
11527 FinalMask[i + j] = i + (j / 2) + NumElts;
11550 unsigned NumElts = Mask.size();
11552 RotateVT = MVT::getVectorVT(RotateSVT, NumElts / NumSubElts);
11603 int NumElts = Mask.size();
11614 for (int i = 0; i < NumElts; ++i) {
11616 assert((M == SM_SentinelUndef || (0 <= M && M < (2*NumElts))) &&
11622 int StartIdx = i - (M % NumElts);
11630 int CandidateRotation = StartIdx < 0 ? -StartIdx : NumElts - StartIdx;
11639 SDValue MaskV = M < NumElts ? V1 : V2;
11703 int NumElts = RepeatedMask.size();
11704 int Scale = 16 / NumElts;
11787 unsigned NumElts = Mask.size();
11790 assert((ZeroLo + ZeroHi) < NumElts && "Zeroable shuffle detected");
11795 SDValue Src = Mask[ZeroLo] < (int)NumElts ? V1 : V2;
11796 int Low = Mask[ZeroLo] < (int)NumElts ? 0 : NumElts;
11797 if (isSequentialOrUndefInRange(Mask, ZeroLo, NumElts - ZeroLo, Low))
11800 DAG.getTargetConstant(NumElts - ZeroLo, DL, MVT::i8));
11804 SDValue Src = Mask[0] < (int)NumElts ? V1 : V2;
11805 int Low = Mask[0] < (int)NumElts ? 0 : NumElts;
11806 if (isSequentialOrUndefInRange(Mask, 0, NumElts - ZeroHi, Low + ZeroHi))
11831 unsigned NumElts = Mask.size();
11832 unsigned Len = NumElts - (ZeroLo + ZeroHi);
11838 if (!isUndefOrInRange(StubMask, 0, NumElts) &&
11839 !isUndefOrInRange(StubMask, NumElts, 2 * NumElts))
11842 SDValue Res = Mask[ZeroLo] < (int)NumElts ? V1 : V2;
11851 unsigned Shift = (NumElts - 1) - (Mask[ZeroLo + Len - 1] % NumElts);
11857 unsigned Shift = Mask[ZeroLo] % NumElts;
11866 unsigned Shift = (NumElts - 1) - (Mask[ZeroLo + Len - 1] % NumElts);
11869 Shift += Mask[ZeroLo] % NumElts;
12486 unsigned NumElts = VT.getVectorNumElements();
12535 SmallVector<APInt> Bits(NumElts, APInt::getAllOnes(EltBits));
12587 if (VT.isFloatingPoint() || NumElts <= 4) {
12717 unsigned NumElts = VT.getVectorNumElements();
12721 if (ExtIndex1 == 0 && ExtIndex0 == NumElts)
12723 else if (ExtIndex0 != 0 || ExtIndex1 != NumElts)
12729 if (NumElts == 4 &&
12734 NewMask.append(NumElts, -1);
14401 int NumElts = VT.getVectorNumElements();
14405 if (NumElts <= M)
14406 M += (Scale - 1) * NumElts;
15047 int NumElts = VT.getVectorNumElements();
15049 int NumEltsPerLane = NumElts / NumLanes;
15059 int NumEltsPerSublane = NumElts / NumSublanes;
15062 SmallVector<int, 16> InLaneMask(NumElts, SM_SentinelUndef);
15065 APInt DemandedCrossLane = APInt::getZero(NumElts);
15067 for (int i = 0; i != NumElts; ++i) {
15125 for (int i = 0; i != NumElts; ++i)
15362 int NumElts = Mask.size();
15391 InLaneMask[i] = (M % NumLaneElts) + Src * NumElts;
15456 if (RepeatMask[i] < NumElts) {
15461 if (RepeatMask[i] != ((M % NumLaneElts) + NumElts))
15471 SmallVector<int, 16> NewMask(NumElts, -1);
15506 for (int i = 0; i != NumElts; ++i) {
15736 int NumElts = VT.getVectorNumElements();
15738 int NumLaneElts = NumElts / NumLanes;
15752 for (int i = 0; i != NumElts; i += NumBroadcastElts)
15758 if (0 != ((M % NumElts) / NumLaneElts))
15767 SmallVector<int, 8> RepeatMask((unsigned)NumElts, -1);
15775 SmallVector<int, 8> BroadcastMask((unsigned)NumElts, -1);
15776 for (int i = 0; i != NumElts; i += NumBroadcastElts)
15822 int Lane = (M % NumElts) / NumLaneElts;
15826 int LocalM = (M % NumLaneElts) + (M < NumElts ? 0 : NumElts);
15876 SmallVector<int, 8> RepeatedMask((unsigned)NumElts, -1);
15890 SmallVector<int, 8> SubLaneMask((unsigned)NumElts, -1);
15891 for (int i = 0; i != NumElts; i += NumSubLaneElts) {
15936 int NumElts = VT.getVectorNumElements();
15938 (NumElts == 2 || NumElts == 4 || NumElts == 8) &&
15940 assert(isUndefOrZeroOrInRange(Mask, 0, 2 * NumElts) &&
15944 for (int i = 0; i < NumElts; ++i)
15951 SmallVector<int, 8> SHUFPDMask(NumElts, -1);
15952 for (int i = 0; i < NumElts; ++i) {
15957 int Val = (i & 6) + NumElts * (i & 1);
15958 int CommutVal = (i & 0xe) + NumElts * ((i & 1) ^ 1);
16073 int NumElts = VT.getVectorNumElements();
16074 size_t FirstQtr = NumElts / 2;
16075 size_t ThirdQtr = NumElts + NumElts / 2;
16076 bool IsFirstHalf = IsInterleavingPattern(Mask, 0, NumElts);
16095 if (IsInterleavingPattern(SVN1->getMask(), 0, NumElts) &&
16100 IsInterleavingPattern(SVN2->getMask(), 0, NumElts)) {
16874 int NumElts = VT.getVectorNumElements();
16875 int NumV2Elements = count_if(Mask, [NumElts](int M) { return M >= NumElts; });
16877 if (NumV2Elements == 1 && Mask[0] >= NumElts)
16960 unsigned NumElts = ((Zeroable & 0x0c) == 0x0c) ? 2 : 4;
16961 MVT SubVT = MVT::getVectorVT(VT.getVectorElementType(), NumElts);
17516 int NumElts = Mask.size();
17517 int NumV2Elements = count_if(Mask, [NumElts](int M) { return M >= NumElts; });
17519 if (NumV2Elements == 1 && Mask[0] >= NumElts)
17589 int NumElts = Mask.size();
17590 for (int i = 0; i != NumElts; ++i) {
17592 assert((M == SM_SentinelUndef || (0 <= M && M < NumElts)) &&
17663 int NumElts = Mask.size();
17664 int NumV2Elements = count_if(Mask, [NumElts](int M) { return M >= NumElts; });
17669 for (int i = 0; i != NumElts; ++i) {
17674 Src = Mask[i] / NumElts;
17675 if (Src != (Mask[i] / NumElts) || (Mask[i] % NumElts) != i)
17681 assert(SubvecElts != NumElts && "Identity shuffle?");
17688 if ((int)Zeroable.countl_one() >= (NumElts - SubvecElts)) {
17718 DAG.getTargetConstant(WideElts - NumElts, DL, MVT::i8));
17720 ShiftAmt += WideElts - NumElts;
17728 Offset += NumElts; // Increment for next iteration.
18184 unsigned NumElts = VT.getVectorNumElements();
18195 MVT MaskVT = MVT::getVectorVT(MVT::i1, NumElts);
18210 MVT NewCondVT = MVT::getVectorVT(NewCondSVT, NumElts);
18249 MVT CastVT = MVT::getVectorVT(MVT::i8, NumElts * 2);
18325 unsigned NumElts = VecVT.getVectorNumElements();
18328 if (NumElts == 1) {
18333 MVT ExtEltVT = (NumElts <= 8) ? MVT::getIntegerVT(128 / NumElts) : MVT::i8;
18334 MVT ExtVecVT = MVT::getVectorVT(ExtEltVT, NumElts);
18358 unsigned NumElts = VT.getVectorNumElements();
18359 APInt DemandedElts = APInt::getZero(NumElts);
18378 DemandedElts |= APIntOps::ScaleBitMask(DemandedSrcElts, NumElts);
18557 unsigned NumElts = VecVT.getVectorNumElements();
18558 MVT ExtEltVT = (NumElts <= 8) ? MVT::getIntegerVT(128 / NumElts) : MVT::i8;
18559 MVT ExtVecVT = MVT::getVectorVT(ExtEltVT, NumElts);
18575 unsigned NumElts = VT.getVectorNumElements();
18605 MVT IdxVT = MVT::getVectorVT(IdxSVT, NumElts);
18614 for (unsigned I = 0; I != NumElts; ++I)
18623 if (N2C->getAPIntValue().uge(NumElts))
18638 SmallVector<SDValue, 8> CstVectorElts(NumElts, ZeroCst);
18648 for (unsigned i = 0; i != NumElts; ++i)
18649 BlendMask.push_back(i == IdxVal ? i + NumElts : i);
18686 for (unsigned i = 0; i != NumElts; ++i)
18687 BlendMask.push_back(i == IdxVal ? i + NumElts : i);
19420 unsigned NumElts = Subtarget.hasVLX() ? 4 : 8;
19421 MVT VecInVT = MVT::getVectorVT(MVT::i64, NumElts);
19422 MVT VecVT = MVT::getVectorVT(VT, NumElts);
20613 unsigned NumElts = VT.getVectorNumElements();
20627 if (NumElts == 16 && !Subtarget.canExtendTo512DQ())
20630 ExtVT = MVT::getVectorVT(MVT::i32, NumElts);
20636 NumElts *= 512 / ExtVT.getSizeInBits();
20637 InVT = MVT::getVectorVT(MVT::i1, NumElts);
20640 WideVT = MVT::getVectorVT(ExtVT.getVectorElementType(), NumElts);
20650 WideVT = MVT::getVectorVT(MVT::i8, NumElts);
21026 unsigned NumElts = InVT.getVectorNumElements();
21027 assert((NumElts == 8 || NumElts == 16) && "Unexpected number of elements");
21037 if (NumElts == 16 && !Subtarget.canExtendTo512DQ()) {
21059 MVT EltVT = Subtarget.hasVLX() ? MVT::i32 : MVT::getIntegerVT(512/NumElts);
21060 MVT ExtVT = MVT::getVectorVT(EltVT, NumElts);
22643 unsigned NumElts = VT.getVectorNumElements();
22644 APInt EltCount = APInt::getZero(NumElts);
23545 unsigned NumElts = VT.getVectorNumElements();
23548 for (unsigned i = 0; i < NumElts; ++i) {
24857 unsigned NumElts = VT.getVectorNumElements();
24863 if (NumElts == 16 && !Subtarget.canExtendTo512DQ())
24866 ExtVT = MVT::getVectorVT(MVT::i32, NumElts);
24872 NumElts *= 512 / ExtVT.getSizeInBits();
24873 InVT = MVT::getVectorVT(MVT::i1, NumElts);
24876 WideVT = MVT::getVectorVT(ExtVT.getVectorElementType(), NumElts);
24892 WideVT = MVT::getVectorVT(VTElt, NumElts);
24943 unsigned NumElts = VT.getVectorNumElements();
24950 int InSize = InSVT.getSizeInBits() * NumElts;
24961 if (InVT.getVectorNumElements() != NumElts)
24996 APInt DemandedElts = APInt::getLowBitsSet(InNumElts, NumElts);
24998 unsigned Scale = InNumElts / NumElts;
25000 for (unsigned I = 0; I != NumElts; ++I)
25174 unsigned NumElts = StoredVal.getValueType().getVectorNumElements();
25175 assert(NumElts <= 8 && "Unexpected VT");
25187 if (NumElts < 8)
25189 StoredVal, dl, EVT::getIntegerVT(*DAG.getContext(), NumElts));
28583 int NumElts = VT.getVectorNumElements();
28584 int NumBytes = NumElts * (VT.getScalarSizeInBits() / 8);
29152 unsigned NumElts = VT.getVectorNumElements();
29154 unsigned NumEltsPerLane = NumElts / NumLanes;
29166 MVT ExVT = MVT::getVectorVT(MVT::i16, NumElts / 2);
29207 for (unsigned i = 0; i != NumElts; i += 16) {
29311 unsigned NumElts = VT.getVectorNumElements();
29325 MVT ExVT = MVT::getVectorVT(MVT::i16, NumElts / 2);
29341 for (unsigned i = 0; i != NumElts; i += 16) {
29390 unsigned NumElts = VT.getVectorNumElements();
29422 DAG.getVectorShuffle(VT, dl, A, A, ArrayRef(&Mask[0], NumElts));
29425 DAG.getVectorShuffle(VT, dl, B, B, ArrayRef(&Mask[0], NumElts));
29429 MVT MulVT = MVT::getVectorVT(MVT::i64, NumElts / 2);
29444 SmallVector<int, 16> ShufMask(NumElts);
29445 for (int i = 0; i != (int)NumElts; ++i)
29446 ShufMask[i] = (i / 2) * 2 + ((i % 2) * NumElts) + 1;
29479 MVT ExVT = MVT::getVectorVT(MVT::i16, NumElts);
29539 unsigned NumElts = VT.getVectorNumElements();
29540 MVT ExVT = MVT::getVectorVT(MVT::i16, NumElts);
29916 unsigned NumElts = VT.getVectorNumElements();
29917 MVT ShiftVT = MVT::getVectorVT(MVT::i16, NumElts / 2);
30004 unsigned NumElts = VT.getVectorNumElements();
30005 MVT ExtVT = MVT::getVectorVT(MVT::i16, NumElts / 2);
30020 SmallVector<int, 64>(NumElts, 0));
30109 unsigned NumElts = VT.getVectorNumElements();
30169 for (unsigned I = 0; I != NumElts; ++I) {
30178 UniqueCstAmt[CstAmt] = APInt::getOneBitSet(NumElts, I);
30200 SmallVector<int, 8> ShuffleMask(NumElts, SM_SentinelUndef);
30201 for (unsigned I = 0; I != NumElts; ++I) {
30205 ShuffleMask[I] = I + NumElts;
30310 if (Profitable && WideNumElts != NumElts) {
30483 unsigned NumEltsPerLane = NumElts / NumLanes;
30487 APInt EltMask = APInt::getBitsSet(NumElts, LoElt, LoElt + NumEltsPerLane);
30502 if (LUT.size() == NumElts) {
30503 APInt Undefs = APInt::getSplat(NumElts, APInt(16, 0xFF00));
30521 MVT ExtVT = MVT::getVectorVT(EvtSVT, NumElts);
30535 MVT VT16 = MVT::getVectorVT(MVT::i16, NumElts / 2);
30540 MVT ExVT = MVT::getVectorVT(MVT::i16, NumElts);
30556 for (unsigned i = 0; i != NumElts; i += 16) {
30580 MVT ExtVT = MVT::getVectorVT(MVT::i16, NumElts / 2);
30587 MVT MaskVT = MVT::getVectorVT(MVT::i1, NumElts);
30714 MVT ExtVT = MVT::getVectorVT(MVT::i8, NumElts * 2);
30794 unsigned NumElts = VT.getVectorNumElements();
30824 MVT WideVT = MVT::getVectorVT(MVT::i16, NumElts / 2);
30865 MVT ExtVT = MVT::getVectorVT(ExtSVT, NumElts / 2);
30898 MVT WideVT = MVT::getVectorVT(WideSVT, NumElts);
30990 int NumElts = VT.getVectorNumElements();
31094 MVT ExtVT = MVT::getVectorVT(ExtSVT, NumElts / 2);
31144 MVT::getVectorVT(Subtarget.hasBWI() ? MVT::i16 : MVT::i32, NumElts);
32108 int NumElts = VT.getVectorNumElements();
32128 for (int i = 0; i < NumElts; ++i)
32298 int NumElts = VT.getVectorNumElements();
32313 for (int i = 0; i != NumElts; ++i) {
32376 unsigned NumElts = VT.getVectorNumElements();
32404 for (unsigned i = 0; i < NumElts; ++i) {
32833 unsigned NumElts = VT.getVectorNumElements() * Factor;
32835 VT = MVT::getVectorVT(VT.getVectorElementType(), NumElts);
32836 IndexVT = MVT::getVectorVT(IndexVT.getVectorElementType(), NumElts);
32837 MVT MaskVT = MVT::getVectorVT(MVT::i1, NumElts);
32986 unsigned NumElts = VT.getVectorNumElements() * Factor;
32988 VT = MVT::getVectorVT(VT.getVectorElementType(), NumElts);
32989 IndexVT = MVT::getVectorVT(IndexVT.getVectorElementType(), NumElts);
32990 MVT MaskVT = MVT::getVectorVT(MVT::i1, NumElts);
33739 unsigned NumElts = InVT.getVectorNumElements();
33740 unsigned HalfNumElts = NumElts / 2;
33741 SmallVector<int, 16> ShufMask(NumElts, SM_SentinelUndef);
33965 unsigned NumElts = Subtarget.hasVLX() ? 2 : 8;
33968 std::max(NumElts, 128U / (unsigned)SrcVT.getSizeInBits());
33969 MVT VecVT = MVT::getVectorVT(MVT::i64, NumElts);
33971 if (NumElts != SrcElts) {
38193 unsigned NumElts = DemandedElts.getBitWidth();
38498 if (NumElts > NumSrcElts && DemandedElts.countr_zero() >= NumSrcElts)
38513 if (NumElts > NumSrcElts && DemandedElts.countr_zero() >= NumSrcElts)
38520 if (DemandedElts.countr_zero() >= (NumElts / 2))
38532 for (unsigned I = 0; I != NumElts; ++I) {
38607 unsigned NumElts = VT.getVectorNumElements();
38608 if (Mask.size() == NumElts) {
38609 SmallVector<APInt, 2> DemandedOps(NumOps, APInt(NumElts, 0));
38611 for (unsigned i = 0; i != NumElts; ++i) {
38625 assert(0 <= M && (unsigned)M < (NumOps * NumElts) &&
38628 unsigned OpIdx = (unsigned)M / NumElts;
38629 unsigned EltIdx = (unsigned)M % NumElts;
38776 unsigned NumElts = VT.getVectorNumElements();
38777 if (Mask.size() == NumElts) {
38778 SmallVector<APInt, 2> DemandedOps(NumOps, APInt(NumElts, 0));
38779 for (unsigned i = 0; i != NumElts; ++i) {
38791 assert(0 <= M && (unsigned)M < (NumOps * NumElts) &&
38794 unsigned OpIdx = (unsigned)M / NumElts;
38795 unsigned EltIdx = (unsigned)M % NumElts;
39296 unsigned NumElts = V.getValueType().getVectorNumElements();
39297 KnownBits Known(NumElts);
39298 for (unsigned EltIdx = 0; EltIdx != NumElts; ++EltIdx) {
39299 APInt Mask = APInt::getOneBitSet(NumElts, EltIdx);
39597 unsigned NumElts = VT1.getVectorNumElements();
39598 if (Mask.size() <= NumElts &&
39599 scaleShuffleElements(Mask, NumElts, ScaledMask)) {
39600 for (unsigned i = 0; i != NumElts; ++i)
40445 int NumElts = VT0.getVectorNumElements();
40447 int NumEltsPerLane = NumElts / NumLanes;
40547 if (M < NumElts) // BC0 element or UNDEF/Zero sentinel.
40550 M -= NumElts + (SubLane * NumHalfEltsPerLane);
40558 for (int i = 0; i != NumElts; ++i) {
40562 if (M < NumElts && BC0.getOperand(0) == BC0.getOperand(1) &&
40565 if (NumElts <= M && BC1.getOperand(0) == BC1.getOperand(1) &&
40817 unsigned NumElts = VT.getVectorNumElements();
40819 OpMask.assign(NumElts, SM_SentinelUndef);
40821 OpZero = OpUndef = APInt::getZero(NumElts);
41428 unsigned NumElts = VT.getVectorNumElements();
41439 !scaleShuffleElements(Mask0, NumElts, ScaledMask0) ||
41440 !scaleShuffleElements(Mask1, NumElts, ScaledMask1))
41446 if (!getShuffleDemandedElts(NumElts, BlendMask, DemandedElts, Demanded0,
41449 !getShuffleDemandedElts(NumElts, ScaledMask0, Demanded0, DemandedLHS0,
41451 !getShuffleDemandedElts(NumElts, ScaledMask1, Demanded1, DemandedLHS1,
41463 SmallVector<int, 32> NewBlendMask(NumElts, SM_SentinelUndef);
41464 SmallVector<int, 32> NewPermuteMask(NumElts, SM_SentinelUndef);
41465 for (unsigned I = 0; I != NumElts; ++I) {
41477 assert(isUndefOrEqual(NewBlendMask[M], M + NumElts) &&
41479 NewBlendMask[M] = M + NumElts;
41485 assert(isUndefOrInRange(NewPermuteMask, 0, NumElts) && "Bad permute");
41774 unsigned NumElts = VT.getVectorNumElements();
42060 MVT VecVT = MVT::getVectorVT(MVT::i32, NumElts * 2);
42076 SmallVector<Constant *, 32> ConstantVec(NumElts, Zero);
42126 APInt BlendMask = N.getConstantOperandAPInt(2).zextOrTrunc(NumElts);
42277 unsigned NumElts = Src.getValueType().getVectorNumElements();
42280 Src.getConstantOperandAPInt(2) == (NumElts / 2)) {
42485 assert(Mask.size() == NumElts && "Unexpected shuffle mask size");
42509 M = (M < (int)NumElts ? M : (M - (NumElts / 2)));
42552 MVT DVT = MVT::getVectorVT(MVT::i32, NumElts / 2);
42819 int NumElts = VT.getVectorNumElements();
42823 Mask.push_back(Elt < NumElts ? Elt : (Elt - NumElts / 2));
42930 unsigned NumElts = DemandedElts.getBitWidth();
42963 if (NumCstElts != NumElts && NumCstElts != (NumElts * 2))
42965 unsigned Scale = NumCstElts / NumElts;
42996 int NumElts = DemandedElts.getBitWidth();
43024 APInt DemandedSrcElts = APIntOps::ScaleBitMask(DemandedElts, 2 * NumElts);
43160 assert(Amt->getAPIntValue().ult(NumElts) && "Out of range shift amount");
43170 if (!DemandedElts.intersects(APInt::getLowBitsSet(NumElts, ShiftAmt))) {
43199 assert(Amt->getAPIntValue().ult(NumElts) && "Out of range shift amount");
43209 if (!DemandedElts.intersects(APInt::getHighBitsSet(NumElts, ShiftAmt))) {
43243 int NumElts = VT.getVectorNumElements();
43251 for (int I = 0; I != NumElts; ++I) {
43391 KnownZero = SrcZero.zextOrTrunc(NumElts);
43392 KnownUndef = SrcUndef.zextOrTrunc(NumElts);
43397 DecodeBLENDMask(NumElts, Op.getConstantOperandVal(2), BlendMask);
43498 DemandedElts.lshr(NumElts / 2) == 0) {
43503 if (VT.is512BitVector() && DemandedElts.lshr(NumElts / 4) == 0)
43585 DecodeVPERMMask(NumElts, Op.getConstantOperandVal(1), Mask);
43603 unsigned EltIdx = (LoMask & 0x1) * (NumElts / 2);
43708 if (OpMask.size() != (unsigned)NumElts ||
43720 for (int i = 0; i != NumElts; ++i)
43724 if (isUndefInRange(OpMask, 0, NumElts)) {
43728 if (isUndefOrZeroInRange(OpMask, 0, NumElts)) {
43734 if (isSequentialOrUndefInRange(OpMask, 0, NumElts, Src * NumElts))
43743 int Lo = Src * NumElts;
43744 APInt SrcElts = APInt::getZero(NumElts);
43745 for (int i = 0; i != NumElts; ++i)
43748 if (0 <= M && M < NumElts)
43769 SmallVector<int, 64> DemandedMask(NumElts, SM_SentinelUndef);
43770 for (int i = 0; i != NumElts; ++i)
44178 unsigned NumElts = SrcVT.getVectorNumElements();
44181 if (OriginalDemandedBits.countr_zero() >= NumElts)
44186 OriginalDemandedBits.getActiveBits() <= (NumElts / 2)) {
44193 APInt DemandedElts = OriginalDemandedBits.zextOrTrunc(NumElts);
44199 Known.Zero.setHighBits(BitWidth - NumElts);
44209 Known.One.setLowBits(NumElts);
44211 Known.Zero.setLowBits(NumElts);
44336 int NumElts = DemandedElts.getBitWidth();
44415 if (ShuffleMask.size() == (unsigned)NumElts &&
44427 for (int i = 0; i != NumElts; ++i) {
44431 int OpIdx = M / NumElts;
44432 int EltIdx = M % NumElts;
44456 unsigned NumElts = DemandedElts.getBitWidth();
44466 APInt::getZero(NumElts));
44472 assert(0 <= M.value() && M.value() < (int)(Ops.size() * NumElts) &&
44474 DemandedSrcElts[M.value() / NumElts].setBit(M.value() % NumElts);
44533 unsigned NumElts = DemandedElts.getBitWidth();
44539 UndefElts = APInt::getZero(NumElts);
44881 unsigned NumElts = BV->getNumOperands();
44915 if (NumElts == 8)
44923 unsigned ShufMask = (NumElts > 2 ? 0 : 0x44);
44930 Ops.append(NumElts, Splat);
44932 for (unsigned i = 0; i != NumElts; ++i)
45248 unsigned NumElts = VT.getVectorNumElements();
45262 if (MovMskElts <= NumElts &&
45275 unsigned NumConcats = NumElts / MovMskElts;
45567 unsigned NumElts = MatchVT.getVectorNumElements();
45574 if (NumElts > 64 || !isPowerOf2_32(NumElts))
45594 EVT MovmskVT = EVT::getIntegerVT(Ctx, NumElts);
45598 while (NumElts > MaxElts) {
45602 NumElts /= 2;
45604 EVT MovmskVT = EVT::getIntegerVT(Ctx, NumElts);
45609 Movmsk = DAG.getZExtOrTrunc(Movmsk, DL, NumElts > 32 ? MVT::i64 : MVT::i32);
45645 NumElts = MaskSrcVT.getVectorNumElements();
45647 assert((NumElts <= 32 || NumElts == 64) &&
45650 MVT CmpVT = NumElts == 64 ? MVT::i64 : MVT::i32;
45664 // all_of -> MOVMSK == ((1 << NumElts) - 1)
45665 CmpC = DAG.getConstant(APInt::getLowBitsSet(CmpVT.getSizeInBits(), NumElts),
46201 unsigned NumElts = VecVT.getVectorNumElements();
46224 if (VT != MVT::i8 || NumElts < 4 || !isPowerOf2_32(NumElts))
46227 EVT WideVT = EVT::getVectorVT(*DAG.getContext(), MVT::i16, NumElts / 2);
46242 if (NumElts >= 8)
46266 if ((VecVT.getSizeInBits() % 128) != 0 || !isPowerOf2_32(NumElts))
46293 if (Opc == ISD::ADD && NumElts >= 4 && EltSizeInBits >= 16 &&
46326 if (NumElts > 8) {
46348 unsigned NumElts = VecVT.getVectorNumElements();
46349 SDValue Hi = extract128BitVector(Rdx, NumElts / 2, DAG, DL);
46579 unsigned NumElts = VT.getVectorNumElements();
46580 assert(NumElts == SclVT.getSizeInBits() && "Unexpected bool vector size");
46583 if (NumElts > EltSizeInBits) {
46588 assert((NumElts % EltSizeInBits) == 0 && "Unexpected integer scale");
46589 unsigned Scale = NumElts / EltSizeInBits;
46603 } else if (Subtarget.hasAVX2() && NumElts < EltSizeInBits &&
46609 assert((EltSizeInBits % NumElts) == 0 && "Unexpected integer scale");
46611 (NumElts * EltSizeInBits) / NumElts);
46622 for (unsigned i = 0; i != NumElts; ++i) {
46631 EVT CCVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, NumElts);
47098 int NumElts = VT.getVectorNumElements();
47099 for (int i = 0; i != NumElts; ++i) {
47102 if (CondMask[i] < NumElts) {
48238 unsigned NumElts = VecVT.getVectorNumElements();
48243 NumElts <= CmpBits && CmpVal.isMask(NumElts);
48261 if (Vec.getOpcode() == ISD::BITCAST && NumElts <= CmpBits) {
48281 if (VecVT.is256BitVector() && NumElts <= CmpBits && IsOneUse) {
48287 APInt CmpMask = APInt::getLowBitsSet(32, IsAnyOf ? 0 : NumElts / 2);
48306 if (BC.getValueType().getVectorNumElements() <= NumElts) {
48362 Result.getValueType().getVectorNumElements() <= NumElts) {
48400 if (NumElts <= CmpBits &&
48405 canScaleShuffleElements(ShuffleMask, NumElts)) {
48419 if (NumElts <= CmpBits && Subtarget.hasAVX() &&
48424 MVT FloatVT = MVT::getVectorVT(FloatSVT, NumElts);
48796 unsigned NumElts = VT.getVectorNumElements();
48797 if ((NumElts % 2) != 0)
48800 EVT ReducedVT = EVT::getVectorVT(*DAG.getContext(), MVT::i16, NumElts);
48814 EVT ResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32, NumElts / 2);
48824 SmallVector<int, 16> ShuffleMask(NumElts);
48825 for (unsigned i = 0, e = NumElts / 2; i < e; i++) {
48827 ShuffleMask[2 * i + 1] = i + NumElts;
48833 for (unsigned i = 0, e = NumElts / 2; i < e; i++) {
48834 ShuffleMask[2 * i] = i + NumElts / 2;
48835 ShuffleMask[2 * i + 1] = i + NumElts * 3 / 2;
48949 unsigned NumElts = VT.getVectorNumElements();
48950 if (NumElts == 1 || !isPowerOf2_32(NumElts))
48954 if (32 <= (2 * NumElts) && Subtarget.hasAVX512() && !Subtarget.hasBWI())
50462 unsigned NumElts = 128 / N00Type.getSizeInBits();
50463 EVT VecVT = EVT::getVectorVT(*DAG.getContext(), N00Type, NumElts);
50464 EVT BoolVecVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, NumElts);
51102 unsigned NumElts = SrcOps[0].getValueType().getVectorNumElements();
51103 EVT MaskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
51108 assert(SrcPartials[0].getBitWidth() == NumElts &&
51247 int NumElts = VT.getVectorNumElements();
51250 APInt DemandedElts = APInt::getAllOnes(NumElts);
51255 for (int I = 0; I != NumElts; ++I) {
51306 unsigned NumElts = SrcVecVT.getVectorNumElements();
51311 SmallVector<int, 16> ShuffleMask(NumElts * Scale, SM_SentinelUndef);
51910 unsigned NumElts = SrcOps[0].getValueType().getVectorNumElements();
51911 EVT MaskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
51916 assert(SrcPartials[0].getBitWidth() == NumElts &&
51984 unsigned NumElts = VT.getVectorNumElements();
51985 unsigned HalfElts = NumElts / 2;
51986 APInt UpperElts = APInt::getHighBitsSet(NumElts, HalfElts);
51987 if (NumElts >= 16 && N1.getOpcode() == X86ISD::KSHIFTL &&
51995 if (NumElts >= 16 && N0.getOpcode() == X86ISD::KSHIFTL &&
52016 int NumElts = VT.getVectorNumElements();
52021 APInt DemandedElts = APInt::getZero(NumElts);
52022 for (int I = 0; I != NumElts; ++I)
52454 unsigned NumElts = RegVT.getVectorNumElements();
52455 EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
52525 unsigned NumElts = BV->getValueType(0).getVectorNumElements();
52526 for (unsigned i = 0; i < NumElts; ++i) {
52630 unsigned NumElts = VT.getVectorNumElements();
52633 bool LoadLastElt = !isNullConstant(MaskBV->getOperand(NumElts - 1));
53183 unsigned NumElts = VT.getVectorNumElements();
53203 scaleShuffleElements(SrcMask, NumElts, ScaledMask)) {
53209 scaleShuffleElements(SrcMask, 2 * NumElts, ScaledMask)) {
53211 ArrayRef<int> Mask = ArrayRef<int>(ScaledMask).slice(0, NumElts);
53239 for (unsigned i = 0; i != NumElts; ++i)
53245 for (unsigned i = 0; i != NumElts; ++i)
53250 if (isUndefOrInRange(LMask, 0, NumElts))
53252 else if (isUndefOrInRange(LMask, NumElts, NumElts * 2))
53255 if (isUndefOrInRange(RMask, 0, NumElts))
53257 else if (isUndefOrInRange(RMask, NumElts, NumElts * 2))
53271 PostShuffleMask.append(NumElts, SM_SentinelUndef);
53280 unsigned NumEltsPer128BitChunk = NumElts / Num128BitChunks;
53284 for (unsigned j = 0; j != NumElts; j += NumEltsPer128BitChunk) {
53289 (!A.getNode() && (LIdx < (int)NumElts || RIdx < (int)NumElts)) ||
53290 (!B.getNode() && (LIdx >= (int)NumElts || RIdx >= (int)NumElts)))
53303 ((Base % NumElts) & ~(NumEltsPer128BitChunk - 1));
53308 if ((B && Base >= (int)NumElts) || (!B && i >= NumEltsPer64BitChunk))
53318 isSequentialOrUndefInRange(PostShuffleMask, 0, NumElts, 0);
54394 unsigned NumElts = SrcVT.getVectorNumElements();
54395 SmallVector<int, 32> ReverseMask(NumElts);
54396 for (unsigned I = 0; I != NumElts; ++I)
54397 ReverseMask[I] = (NumElts - 1) - I;
54717 int NumElts = VT.getVectorNumElements();
54765 for (int I = 0; I != NumElts; ++I)
54796 APInt DemandedElts = APInt::getAllOnes(NumElts);
54801 for (int I = 0; I != NumElts; ++I) {
55782 unsigned NumElts = SrcVT.getVectorNumElements();
55784 assert(VT == MVT::i32 && NumElts <= NumBits && "Unexpected MOVMSK types");
55793 for (unsigned Idx = 0; Idx != NumElts; ++Idx)
55810 APInt NotMask = APInt::getLowBitsSet(NumBits, NumElts);
55822 APInt NotMask = APInt::getLowBitsSet(NumBits, NumElts);
55846 ShiftVT = MVT::getVectorVT(MVT::i16, NumElts / 2);
55870 for (unsigned Idx = 0; Idx != NumElts; ++Idx) {
56174 unsigned NumElts = VecWidth / DestWidth;
56175 EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), TruncVT, NumElts);
56966 unsigned NumElts = VT.getVectorNumElements();
56969 APInt DemandedHiElts = APInt::getSplat(2 * NumElts, APInt(2, 2));
56985 for (int i = 0; i != (int)NumElts; ++i) {
56987 Mask.push_back(2 * (i + NumElts));
57330 unsigned NumElts = VT.getVectorNumElements();
57347 SmallVector<APInt> Results(NumElts);
57348 for (unsigned I = 0; I != NumElts; ++I) {
58921 unsigned NumElts = VT.getVectorNumElements();
58924 SmallVector<SDValue> Elts(Scale * NumElts, DAG.getConstant(0, DL, EltVT));
58925 for (unsigned I = 0; I != NumElts; ++I)
59044 unsigned NumElts = VT.getVectorNumElements();
59045 if (NumElts == 1 || !isPowerOf2_32(NumElts))
59053 if (NumElts < 8) {
59054 unsigned NumConcats = 8 / NumElts;
59055 SDValue Fill = NumElts == 4 ? DAG.getUNDEF(IntVT)
59064 std::max(4U, NumElts));
59074 if (NumElts < 4) {
59075 assert(NumElts == 2 && "Unexpected size");
59150 unsigned NumElts = VT.getVectorNumElements();
59156 if (NumElts == 8 && Src.getOpcode() == ISD::CONCAT_VECTORS &&
59189 if (NumElts == 1 || !isPowerOf2_32(NumElts))
59193 if (NumElts < 4)
59199 EVT::getVectorVT(*DAG.getContext(), MVT::i16, std::max(8U, NumElts));
59210 if (NumElts < 8) {