Lines Matching refs:NumElts
2062 handleMaskRegisterForCallingConv(unsigned NumElts, CallingConv::ID CC,
2066 if (NumElts == 2)
2068 if (NumElts == 4)
2070 if (NumElts == 8 && CC != CallingConv::X86_RegCall &&
2073 if (NumElts == 16 && CC != CallingConv::X86_RegCall &&
2078 if (NumElts == 32 && (!Subtarget.hasBWI() || CC != CallingConv::X86_RegCall))
2081 if (NumElts == 64 && Subtarget.hasBWI() && CC != CallingConv::X86_RegCall) {
2088 if (!isPowerOf2_32(NumElts) || (NumElts == 64 && !Subtarget.hasBWI()) ||
2089 NumElts > 64)
2090 return {MVT::i8, NumElts};
2100 unsigned NumElts = VT.getVectorNumElements();
2105 handleMaskRegisterForCallingConv(NumElts, CC, Subtarget);
2118 unsigned NumElts = VT.getVectorNumElements();
2123 handleMaskRegisterForCallingConv(NumElts, CC, Subtarget);
2166 const unsigned NumElts = VT.getVectorNumElements();
2175 return EVT::getVectorVT(Context, MVT::i1, NumElts);
2183 return EVT::getVectorVT(Context, MVT::i1, NumElts);
5059 unsigned NumElts = std::min(DataVT.getVectorNumElements(),
5061 Info.memVT = MVT::getVectorVT(DataVT.getVectorElementType(), NumElts);
5071 unsigned NumElts = std::min(DataVT.getVectorNumElements(),
5073 Info.memVT = MVT::getVectorVT(DataVT.getVectorElementType(), NumElts);
5431 unsigned NumElts = Mask.size();
5432 return isUndefInRange(Mask, 0, NumElts / 2);
5437 unsigned NumElts = Mask.size();
5438 return isUndefInRange(Mask, NumElts / 2, NumElts / 2);
5647 unsigned NumElts = VT.getVectorNumElements();
5650 ConstVecVT = MVT::getVectorVT(MVT::i32, NumElts * 2);
5655 for (unsigned i = 0; i < NumElts; ++i) {
5678 unsigned NumElts = VT.getVectorNumElements();
5681 ConstVecVT = MVT::getVectorVT(MVT::i32, NumElts * 2);
6182 unsigned NumElts = VT.getSizeInBits() / 32;
6183 SDValue Vec = DAG.getConstant(Ones, dl, MVT::getVectorVT(MVT::i32, NumElts));
6259 int NumElts = VT.getVectorNumElements();
6261 for (int i = 0; i < NumElts; ++i) {
6264 Pos += (Unary ? 0 : NumElts * (i % 2));
6277 int NumElts = VT.getVectorNumElements();
6278 for (int i = 0; i < NumElts; ++i) {
6280 Pos += (Lo ? 0 : NumElts / 2);
6362 unsigned NumElts = SizeInBits / EltSizeInBits;
6377 if (NumSrcElts == NumElts) {
6395 UndefElts = APInt(NumElts, 0);
6396 EltBits.resize(NumElts, APInt(EltSizeInBits, 0));
6398 for (unsigned i = 0; i != NumElts; ++i) {
6442 APInt UndefSrcElts = APInt::getAllOnesValue(NumElts);
6443 SmallVector<APInt, 64> SrcEltBits(NumElts, APInt(EltSizeInBits, 0));
6546 UndefElts = APInt::getSplat(NumElts, UndefElts);
6547 while (EltBits.size() < NumElts)
6625 if (isAnyInRange(Mask, 0, NumElts) &&
6630 if (isAnyInRange(Mask, NumElts, 2 * NumElts) &&
6636 UndefElts = APInt::getNullValue(NumElts);
6637 for (int i = 0; i != (int)NumElts; ++i) {
6642 } else if (M < (int)NumElts) {
6647 if (UndefElts1[M - NumElts])
6649 EltBits.push_back(EltBits1[M - NumElts]);
6711 unsigned NumElts = VT.getVectorNumElements();
6714 unsigned Offset = Unary ? 0 : NumElts;
6733 int NumElts = DemandedElts.getBitWidth();
6734 int NumInnerElts = NumElts / 2;
6735 int NumEltsPerLane = NumElts / NumLanes;
6758 int NumElts = DemandedElts.getBitWidth();
6759 int NumEltsPerLane = NumElts / NumLanes;
6762 DemandedLHS = APInt::getNullValue(NumElts);
6763 DemandedRHS = APInt::getNullValue(NumElts);
6766 for (int Idx = 0; Idx != NumElts; ++Idx) {
7284 unsigned NumElts = Mask.size();
7285 assert(KnownUndef.getBitWidth() == NumElts &&
7286 KnownZero.getBitWidth() == NumElts && "Shuffle mask size mismatch");
7288 for (unsigned i = 0; i != NumElts; ++i) {
7300 unsigned NumElts = Mask.size();
7301 KnownUndef = KnownZero = APInt::getNullValue(NumElts);
7303 for (unsigned i = 0; i != NumElts; ++i) {
7331 unsigned NumElts = VT.getVectorNumElements();
7336 assert(NumElts == DemandedElts.getBitWidth() && "Unexpected vector size");
7345 if (isUndefOrInRange(ShuffleMask, 0, 2 * NumElts)) {
7468 for (int i = 0; i != (int)NumElts; ++i)
7471 Mask[InsertIdx + i] = NumElts + ExtractIdx + i;
7500 NumElts *= Scale;
7506 for (int i = 0; i != (int)NumElts; ++i)
7512 M = (NumElts * (1 + InputIdx)) + (M % NumSubElts);
7530 N.getConstantOperandAPInt(2).uge(NumElts))
7537 for (unsigned i = 0; i != NumElts; ++i)
7601 assert(N0.getValueType().getVectorNumElements() == (NumElts / 2) &&
7602 N1.getValueType().getVectorNumElements() == (NumElts / 2) &&
7647 Mask.append(NumElts - NumSrcElts, SM_SentinelZero);
7656 Mask.append(NumElts, SM_SentinelZero);
7690 for (int i = 0; i != (int)NumElts; ++i) {
7703 Mask.append(NumElts, 0);
7720 DecodeZeroExtendMask(SrcVT.getScalarSizeInBits(), NumBitsPerElt, NumElts,
7807 unsigned NumElts = Op.getValueType().getVectorNumElements();
7808 APInt DemandedElts = APInt::getAllOnesValue(NumElts);
7924 unsigned NumElts = VT.getVectorNumElements();
7933 for (unsigned i = 0; i < NumElts; ++i) {
8633 unsigned NumElts = Op->getNumOperands();
8634 unsigned Delta = NumElts;
8636 for (unsigned i = 1; i < NumElts; i++) {
8647 for (unsigned i = Delta; i < NumElts; i++) {
8658 NumElt = NumElts / Delta;
8695 unsigned NumElts = VT.getVectorNumElements();
8697 SDValue ZeroExtended = isSplatZeroExtended(BVOp, NumElts, EltType);
8710 MVT::getVectorVT(EltType, NumElts), BOperand);
8716 unsigned NumElts = VT.getVectorNumElements();
8718 if (!Ld || (NumElts - NumUndefElts) <= 1) {
8779 if (!Ld || NumElts - NumUndefElts != 1)
8854 if (!Ld->hasNUsesOfValue(NumElts - NumUndefElts, 0))
9121 unsigned NumElts = LastIdx - BaseIdx;
9126 for (unsigned i = 0, e = NumElts; i != e && CanFold; ++i) {
9132 if (i * 2 == NumElts)
9159 if (i * 2 < NumElts) {
9171 if (i * 2 == NumElts)
9175 SDValue Expected = (i * 2 < NumElts) ? V0 : V1;
9230 unsigned NumElts = VT.getVectorNumElements();
9232 SDValue V0_HI = extract128BitVector(V0, NumElts/2, DAG, DL);
9234 SDValue V1_HI = extract128BitVector(V1, NumElts/2, DAG, DL);
9273 unsigned NumElts = VT.getVectorNumElements();
9284 for (unsigned i = 0, e = NumElts; i != e; ++i) {
9464 unsigned NumElts = VT.getVectorNumElements();
9467 unsigned NumEltsIn128Bits = NumElts / Num128BitChunks;
9558 unsigned NumElts = VT.getVectorNumElements();
9559 APInt DemandedElts = APInt::getAllOnesValue(NumElts);
9560 for (unsigned i = 0; i != NumElts; ++i)
9565 unsigned HalfNumElts = NumElts / 2;
9606 unsigned NumElts = VT.getVectorNumElements();
9607 unsigned Half = NumElts / 2;
9614 for (unsigned i = Half, e = NumElts; i != e; ++i)
9626 isHorizontalBinOpPart(BV, ISD::ADD, DAG, Half, NumElts, InVec2,
9633 isHorizontalBinOpPart(BV, ISD::SUB, DAG, Half, NumElts, InVec2,
9663 if (isHorizontalBinOpPart(BV, ISD::ADD, DAG, 0, NumElts, InVec0, InVec1))
9665 else if (isHorizontalBinOpPart(BV, ISD::SUB, DAG, 0, NumElts, InVec0,
9668 else if (isHorizontalBinOpPart(BV, ISD::FADD, DAG, 0, NumElts, InVec0,
9671 else if (isHorizontalBinOpPart(BV, ISD::FSUB, DAG, 0, NumElts, InVec0,
9810 unsigned NumElts = VT.getVectorNumElements();
9814 assert(IndicesVec.getValueType().getVectorNumElements() >= NumElts &&
9816 if (IndicesVec.getValueType().getVectorNumElements() > NumElts)
9818 NumElts * VT.getScalarSizeInBits());
9826 VT = MVT::getVectorVT(VT.getScalarType(), Scale * NumElts);
10216 unsigned NumElts = VT.getVectorNumElements();
10217 for (unsigned i = 0; i != NumElts; ++i)
10218 ShuffleMask.push_back(i == InsertC ? NumElts : i);
11068 unsigned NumElts = VT.getVectorNumElements();
11069 assert((NumElts == 4 || NumElts == 8 || NumElts == 16) &&
11071 SDValue VMask = getMaskNode(MaskNode, MVT::getVectorVT(MVT::i1, NumElts),
11083 int NumElts = VT.getVectorNumElements();
11086 for (int i = 0; i != NumElts; i += 2) {
11119 isSequentialOrUndefOrZeroInRange(TargetMask, 0, NumElts, 0))
11123 for (int i = 0; (i != NumElts) && (MatchLo || MatchHi); ++i) {
11225 unsigned NumElts = Mask.size();
11233 unsigned NumSrcElts = NumElts / Scale;
11236 unsigned UpperElts = NumElts - NumSrcElts;
11423 unsigned NumElts = VT.getVectorNumElements();
11458 MVT PackVT = MVT::getVectorVT(PackSVT, NumElts >> NumStages);
11870 int NumElts = Mask.size();
11872 int NumLaneElts = NumElts / NumLanes;
11879 for (int Lane = 0; Lane != NumElts; Lane += NumLaneElts) {
11886 if (M < NumElts && (Op.isUndef() || Op == V1))
11888 else if (NumElts <= M && (Op.isUndef() || Op == V2))
11895 isUndefOrInRange(M, NumElts + Lo, NumElts + Mid);
11897 isUndefOrInRange(M, NumElts + Mid, NumElts + Hi);
11907 SmallVector<int, 32> PermuteMask(NumElts, -1);
11908 for (int Lane = 0; Lane != NumElts; Lane += NumLaneElts) {
11943 int NumElts = VT.getVectorNumElements();
11944 int NumEltsPerLane = NumElts / NumLanes;
11951 for (int Lane = 0; Lane != NumElts; Lane += NumEltsPerLane) {
11956 if (M < NumElts) {
11963 M -= NumElts;
11990 SmallVector<int, 64> PermMask(NumElts, SM_SentinelUndef);
11991 for (int Lane = 0; Lane != NumElts; Lane += NumEltsPerLane) {
11996 if (M < NumElts)
12009 return RotateAndPermute(V2, V1, Range2.first, NumElts);
12069 int NumElts = Mask.size();
12070 assert((NumElts % NumSubElts) == 0 && "Illegal shuffle mask");
12073 for (int i = 0; i != NumElts; i += NumSubElts) {
12103 int NumElts = Mask.size();
12105 RotateVT = MVT::getVectorVT(RotateSVT, NumElts / NumSubElts);
12159 int NumElts = Mask.size();
12170 for (int i = 0; i < NumElts; ++i) {
12172 assert((M == SM_SentinelUndef || (0 <= M && M < (2*NumElts))) &&
12178 int StartIdx = i - (M % NumElts);
12186 int CandidateRotation = StartIdx < 0 ? -StartIdx : NumElts - StartIdx;
12195 SDValue MaskV = M < NumElts ? V1 : V2;
12259 int NumElts = RepeatedMask.size();
12260 int Scale = 16 / NumElts;
12357 unsigned NumElts = Mask.size();
12358 unsigned Len = NumElts - (ZeroLo + ZeroHi);
12364 if (!isUndefOrInRange(StubMask, 0, NumElts) &&
12365 !isUndefOrInRange(StubMask, NumElts, 2 * NumElts))
12368 SDValue Res = Mask[ZeroLo] < (int)NumElts ? V1 : V2;
12377 unsigned Shift = (NumElts - 1) - (Mask[ZeroLo + Len - 1] % NumElts);
12383 unsigned Shift = Mask[ZeroLo] % NumElts;
12392 unsigned Shift = (NumElts - 1) - (Mask[ZeroLo + Len - 1] % NumElts);
12395 Shift += Mask[ZeroLo] % NumElts;
13188 unsigned NumElts = VT.getVectorNumElements();
13192 if (ExtIndex1 == 0 && ExtIndex0 == NumElts)
13194 else if (ExtIndex0 != 0 || ExtIndex1 != NumElts)
13200 if (NumElts == 4 &&
13205 NewMask.append(NumElts, -1);
15404 int NumElts = VT.getVectorNumElements();
15406 int NumEltsPerLane = NumElts / NumLanes;
15409 SmallVector<int, 16> PermMask(NumElts, SM_SentinelUndef);
15411 for (int i = 0; i != NumElts; ++i) {
15427 SmallVector<int, 16> LaneMask(NumElts, SM_SentinelUndef);
15637 int NumElts = Mask.size();
15666 InLaneMask[i] = (M % NumLaneElts) + Src * NumElts;
15731 if (RepeatMask[i] < NumElts) {
15736 if (RepeatMask[i] != ((M % NumLaneElts) + NumElts))
15746 SmallVector<int, 16> NewMask(NumElts, -1);
15781 for (int i = 0; i != NumElts; ++i) {
16018 int NumElts = VT.getVectorNumElements();
16020 int NumLaneElts = NumElts / NumLanes;
16034 for (int i = 0; i != NumElts; i += NumBroadcastElts)
16040 if (0 != ((M % NumElts) / NumLaneElts))
16049 SmallVector<int, 8> RepeatMask((unsigned)NumElts, -1);
16057 SmallVector<int, 8> BroadcastMask((unsigned)NumElts, -1);
16058 for (int i = 0; i != NumElts; i += NumBroadcastElts)
16099 int Lane = (M % NumElts) / NumLaneElts;
16103 int LocalM = (M % NumLaneElts) + (M < NumElts ? 0 : NumElts);
16153 SmallVector<int, 8> RepeatedMask((unsigned)NumElts, -1);
16168 SmallVector<int, 8> SubLaneMask((unsigned)NumElts, -1);
16169 for (int i = 0; i != NumElts; i += NumSubLaneElts) {
16185 int NumElts = VT.getVectorNumElements();
16187 (NumElts == 2 || NumElts == 4 || NumElts == 8) &&
16189 assert(isUndefOrZeroOrInRange(Mask, 0, 2 * NumElts) &&
16193 for (int i = 0; i < NumElts; ++i)
16201 for (int i = 0; i < NumElts; ++i) {
16206 int Val = (i & 6) + NumElts * (i & 1);
16207 int CommutVal = (i & 0xe) + NumElts * ((i & 1) ^ 1);
16949 int NumElts = VT.getVectorNumElements();
16950 int NumV2Elements = count_if(Mask, [NumElts](int M) { return M >= NumElts; });
16952 if (NumV2Elements == 1 && Mask[0] >= NumElts)
17028 unsigned NumElts = ((Zeroable & 0x0c) == 0x0c) ? 2 : 4;
17029 MVT SubVT = MVT::getVectorVT(VT.getVectorElementType(), NumElts);
17522 int NumElts = Mask.size();
17523 int NumV2Elements = count_if(Mask, [NumElts](int M) { return M >= NumElts; });
17525 if (NumV2Elements == 1 && Mask[0] >= NumElts)
17584 int NumElts = Mask.size();
17585 for (int i = 0; i != NumElts; ++i) {
17587 assert((M == SM_SentinelUndef || (0 <= M && M < NumElts)) &&
17607 if ((!Subtarget.hasDQI() && NumElts == 8) || NumElts < 8)
17663 int NumElts = Mask.size();
17668 for (int i = 0; i != NumElts; ++i) {
17673 Src = Mask[i] / NumElts;
17674 if (Src != (Mask[i] / NumElts) || (Mask[i] % NumElts) != i)
17680 assert(SubvecElts != NumElts && "Identity shuffle?");
17687 if ((int)Zeroable.countLeadingOnes() >= (NumElts - SubvecElts)) {
17710 if ((!Subtarget.hasDQI() && NumElts == 8) || NumElts < 8)
17720 DAG.getTargetConstant(WideElts - NumElts, DL, MVT::i8));
17722 ShiftAmt += WideElts - NumElts;
17730 Offset += NumElts; // Increment for next iteration.
18032 unsigned NumElts = VT.getVectorNumElements();
18043 MVT MaskVT = MVT::getVectorVT(MVT::i1, NumElts);
18058 MVT NewCondVT = MVT::getVectorVT(NewCondSVT, NumElts);
18081 MVT CastVT = MVT::getVectorVT(MVT::i8, NumElts * 2);
18155 unsigned NumElts = VecVT.getVectorNumElements();
18158 MVT ExtEltVT = (NumElts <= 8) ? MVT::getIntegerVT(128 / NumElts) : MVT::i8;
18159 MVT ExtVecVT = MVT::getVectorVT(ExtEltVT, NumElts);
18344 unsigned NumElts = VecVT.getVectorNumElements();
18345 MVT ExtEltVT = (NumElts <= 8) ? MVT::getIntegerVT(128 / NumElts) : MVT::i8;
18346 MVT ExtVecVT = MVT::getVectorVT(ExtEltVT, NumElts);
18362 unsigned NumElts = VT.getVectorNumElements();
18373 if (!N2C || N2C->getAPIntValue().uge(NumElts))
18386 for (unsigned i = 0; i != NumElts; ++i)
18387 BlendMask.push_back(i == IdxVal ? i + NumElts : i);
19190 unsigned NumElts = Subtarget.hasVLX() ? 4 : 8;
19191 MVT VecInVT = MVT::getVectorVT(MVT::i64, NumElts);
19192 MVT VecVT = MVT::getVectorVT(VT, NumElts);
20281 unsigned NumElts = VT.getVectorNumElements();
20295 if (NumElts == 16 && !Subtarget.canExtendTo512DQ())
20298 ExtVT = MVT::getVectorVT(MVT::i32, NumElts);
20304 NumElts *= 512 / ExtVT.getSizeInBits();
20305 InVT = MVT::getVectorVT(MVT::i1, NumElts);
20309 NumElts);
20319 WideVT = MVT::getVectorVT(MVT::i8, NumElts);
20482 unsigned NumElts = InVT.getVectorNumElements();
20483 assert((NumElts == 8 || NumElts == 16) && "Unexpected number of elements");
20493 if (NumElts == 16 && !Subtarget.canExtendTo512DQ()) {
20515 MVT EltVT = Subtarget.hasVLX() ? MVT::i32 : MVT::getIntegerVT(512/NumElts);
20516 MVT ExtVT = MVT::getVectorVT(EltVT, NumElts);
21409 unsigned NumElts = VT.getVectorNumElements();
21410 APInt EltCount = APInt::getNullValue(NumElts);
22150 unsigned NumElts = VT.getVectorNumElements();
22153 for (unsigned i = 0; i < NumElts; ++i) {
23249 unsigned NumElts = VT.getVectorNumElements();
23255 if (NumElts == 16 && !Subtarget.canExtendTo512DQ())
23258 ExtVT = MVT::getVectorVT(MVT::i32, NumElts);
23264 NumElts *= 512 / ExtVT.getSizeInBits();
23265 InVT = MVT::getVectorVT(MVT::i1, NumElts);
23268 WideVT = MVT::getVectorVT(ExtVT.getVectorElementType(), NumElts);
23284 WideVT = MVT::getVectorVT(VTElt, NumElts);
23334 unsigned NumElts = VT.getVectorNumElements();
23341 int InSize = InSVT.getSizeInBits() * NumElts;
23352 if (InVT.getVectorNumElements() != NumElts)
24071 unsigned NumElts = SrcOp->getNumOperands();
24076 for (unsigned i = 0; i != NumElts; ++i) {
24089 for (unsigned i = 0; i != NumElts; ++i) {
24102 for (unsigned i = 0; i != NumElts; ++i) {
26244 int NumElts = VT.getVectorNumElements();
26245 int NumBytes = NumElts * (VT.getScalarSizeInBits() / 8);
26574 unsigned NumElts = VT.getVectorNumElements();
26586 MVT ExVT = MVT::getVectorVT(MVT::i16, NumElts / 2);
26600 for (unsigned i = 0; i != NumElts; i += 16) {
26706 unsigned NumElts = VT.getVectorNumElements();
26738 makeArrayRef(&Mask[0], NumElts));
26741 makeArrayRef(&Mask[0], NumElts));
26745 MVT MulVT = MVT::getVectorVT(MVT::i64, NumElts / 2);
26760 SmallVector<int, 16> ShufMask(NumElts);
26761 for (int i = 0; i != (int)NumElts; ++i)
26762 ShufMask[i] = (i / 2) * 2 + ((i % 2) * NumElts) + 1;
26796 MVT ExVT = MVT::getVectorVT(MVT::i16, NumElts);
26808 MVT ExVT = MVT::getVectorVT(MVT::i16, NumElts / 2);
26843 for (unsigned i = 0; i != NumElts; i += 16) {
27067 unsigned NumElts = VT.getVectorNumElements();
27068 MVT ShiftVT = MVT::getVectorVT(MVT::i16, NumElts / 2);
27149 unsigned NumElts = VT.getVectorNumElements();
27150 MVT ExtVT = MVT::getVectorVT(MVT::i16, NumElts / 2);
27166 SmallVector<int, 64>(NumElts, 0));
27349 unsigned NumElts = VT.getVectorNumElements();
27351 for (unsigned i = 0; i != NumElts; ++i) {
27363 ShuffleMask.push_back(i + NumElts);
27371 if (ShuffleMask.size() == NumElts && Amt1 && Amt2 &&
27515 int NumElts = VT.getVectorNumElements();
27520 MVT ExVT = MVT::getVectorVT(MVT::i16, NumElts);
27536 for (int i = 0; i != NumElts; i += 16) {
27543 MVT VT16 = MVT::getVectorVT(MVT::i16, NumElts / 2);
27769 int NumElts = VT.getVectorNumElements();
27836 MVT ExtVT = MVT::getVectorVT(MVT::i16, NumElts / 2);
28405 int NumElts = VT.getVectorNumElements();
28425 for (int i = 0; i < NumElts; ++i)
28513 int NumElts = VT.getVectorNumElements();
28528 for (int i = 0; i != NumElts; ++i) {
28559 unsigned NumElts = VT.getVectorNumElements();
28586 for (unsigned i = 0; i < NumElts; ++i) {
28950 unsigned NumElts = VT.getVectorNumElements() * Factor;
28952 VT = MVT::getVectorVT(VT.getVectorElementType(), NumElts);
28953 IndexVT = MVT::getVectorVT(IndexVT.getVectorElementType(), NumElts);
28954 MVT MaskVT = MVT::getVectorVT(MVT::i1, NumElts);
29103 unsigned NumElts = VT.getVectorNumElements() * Factor;
29105 VT = MVT::getVectorVT(VT.getVectorElementType(), NumElts);
29106 IndexVT = MVT::getVectorVT(IndexVT.getVectorElementType(), NumElts);
29107 MVT MaskVT = MVT::getVectorVT(MVT::i1, NumElts);
29682 unsigned NumElts = InVT.getVectorNumElements();
29683 unsigned HalfNumElts = NumElts / 2;
29684 SmallVector<int, 16> ShufMask(NumElts, SM_SentinelUndef);
29811 unsigned NumElts = Subtarget.hasVLX() ? 2 : 8;
29814 std::max(NumElts, 128U / (unsigned)SrcVT.getSizeInBits());
29815 MVT VecVT = MVT::getVectorVT(MVT::i64, NumElts);
29818 if (NumElts != SrcElts) {
33541 unsigned NumElts = DemandedElts.getBitWidth();
33705 if (NumElts > NumSrcElts &&
33721 if (NumElts > NumSrcElts &&
33729 if (DemandedElts.countTrailingZeros() >= (NumElts / 2))
33744 unsigned NumElts = VT.getVectorNumElements();
33745 if (Mask.size() == NumElts) {
33746 SmallVector<APInt, 2> DemandedOps(NumOps, APInt(NumElts, 0));
33748 for (unsigned i = 0; i != NumElts; ++i) {
33761 assert(0 <= M && (unsigned)M < (NumOps * NumElts) &&
33764 unsigned OpIdx = (unsigned)M / NumElts;
33765 unsigned EltIdx = (unsigned)M % NumElts;
33883 unsigned NumElts = VT.getVectorNumElements();
33884 if (Mask.size() == NumElts) {
33885 SmallVector<APInt, 2> DemandedOps(NumOps, APInt(NumElts, 0));
33886 for (unsigned i = 0; i != NumElts; ++i) {
33898 assert(0 <= M && (unsigned)M < (NumOps * NumElts) &&
33901 unsigned OpIdx = (unsigned)M / NumElts;
33902 unsigned EltIdx = (unsigned)M % NumElts;
36229 unsigned NumElts = VT.getVectorNumElements();
36231 SmallVector<Constant *, 32> ConstantVec(NumElts, Zero);
36740 int NumElts = VT.getVectorNumElements();
36744 Mask.push_back(Elt < NumElts ? Elt : (Elt - NumElts / 2));
36958 unsigned NumElts = DemandedElts.getBitWidth();
36991 if (NumCstElts != NumElts && NumCstElts != (NumElts * 2))
36993 unsigned Scale = NumCstElts / NumElts;
37024 int NumElts = DemandedElts.getBitWidth();
37085 assert(Amt->getAPIntValue().ult(NumElts) && "Out of range shift amount");
37095 if (!DemandedElts.intersects(APInt::getLowBitsSet(NumElts, ShiftAmt))) {
37124 assert(Amt->getAPIntValue().ult(NumElts) && "Out of range shift amount");
37134 if (!DemandedElts.intersects(APInt::getHighBitsSet(NumElts, ShiftAmt))) {
37230 KnownZero = SrcZero.zextOrTrunc(NumElts);
37231 KnownUndef = SrcUndef.zextOrTrunc(NumElts);
37312 DemandedElts.lshr(NumElts / 2) == 0) {
37317 if (VT.is512BitVector() && DemandedElts.lshr(NumElts / 4) == 0)
37362 DecodeVPERMMask(NumElts, Op.getConstantOperandVal(1), Mask);
37427 if (OpMask.size() != (unsigned)NumElts ||
37439 for (int i = 0; i != NumElts; ++i)
37443 if (isUndefInRange(OpMask, 0, NumElts)) {
37447 if (isUndefOrZeroInRange(OpMask, 0, NumElts)) {
37453 if (isSequentialOrUndefInRange(OpMask, 0, NumElts, Src * NumElts))
37462 int Lo = Src * NumElts;
37463 APInt SrcElts = APInt::getNullValue(NumElts);
37464 for (int i = 0; i != NumElts; ++i)
37467 if (0 <= M && M < NumElts)
37483 SmallVector<int, 64> DemandedMask(NumElts, SM_SentinelUndef);
37484 for (int i = 0; i != NumElts; ++i)
37773 unsigned NumElts = SrcVT.getVectorNumElements();
37776 if (OriginalDemandedBits.countTrailingZeros() >= NumElts)
37781 APInt DemandedElts = OriginalDemandedBits.zextOrTrunc(NumElts);
37787 Known.Zero.setHighBits(BitWidth - NumElts);
37797 Known.One.setLowBits(NumElts);
37799 Known.Zero.setLowBits(NumElts);
37845 int NumElts = DemandedElts.getBitWidth();
37896 if (ShuffleMask.size() == (unsigned)NumElts &&
37908 for (int i = 0; i != NumElts; ++i) {
37912 int OpIdx = M / NumElts;
37913 int EltIdx = M % NumElts;
38222 unsigned NumElts = BV->getNumOperands();
38254 if (NumElts == 8)
38261 unsigned ShufMask = (NumElts > 2 ? 0 : 0x44);
38267 Ops.append(NumElts, Splat);
38269 for (unsigned i = 0; i != NumElts; ++i)
38557 unsigned NumElts = VT.getVectorNumElements();
38571 if (MovMskElts <= NumElts &&
38584 unsigned NumConcats = NumElts / MovMskElts;
38792 unsigned NumElts = MatchVT.getVectorNumElements();
38798 if (NumElts > 64 || !isPowerOf2_32(NumElts))
38802 EVT MovmskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
38814 (2 * NumElts) <= MaxElts) {
38815 NumElts *= 2;
38816 EVT CmpVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32, NumElts);
38817 MatchVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, NumElts);
38825 while (NumElts > MaxElts) {
38829 NumElts /= 2;
38831 EVT MovmskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
38836 Movmsk = DAG.getZExtOrTrunc(Movmsk, DL, NumElts > 32 ? MVT::i64 : MVT::i32);
38872 NumElts = MaskSrcVT.getVectorNumElements();
38874 assert((NumElts <= 32 || NumElts == 64) &&
38877 MVT CmpVT = NumElts == 64 ? MVT::i64 : MVT::i32;
38893 // all_of -> MOVMSK == ((1 << NumElts) - 1)
38894 CmpC = DAG.getConstant(APInt::getLowBitsSet(CmpVT.getSizeInBits(), NumElts),
39344 unsigned NumElts = VecVT.getVectorNumElements();
39345 SDValue Hi = extract128BitVector(Rdx, NumElts / 2, DAG, DL);
40882 unsigned NumElts = VecVT.getVectorNumElements();
40886 bool IsAllOf = CmpOpcode == X86ISD::SUB && NumElts <= CmpBits &&
40887 CmpVal.isMask(NumElts);
40972 if (NumElts == CmpBits &&
41331 unsigned NumElts = VT.getVectorNumElements();
41332 if ((NumElts % 2) != 0)
41335 EVT ReducedVT = EVT::getVectorVT(*DAG.getContext(), MVT::i16, NumElts);
41349 EVT ResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32, NumElts / 2);
41359 SmallVector<int, 16> ShuffleMask(NumElts);
41360 for (unsigned i = 0, e = NumElts / 2; i < e; i++) {
41362 ShuffleMask[2 * i + 1] = i + NumElts;
41368 for (unsigned i = 0, e = NumElts / 2; i < e; i++) {
41369 ShuffleMask[2 * i] = i + NumElts / 2;
41370 ShuffleMask[2 * i + 1] = i + NumElts * 3 / 2;
42910 unsigned NumElts = SrcOps[0].getValueType().getVectorNumElements();
42911 EVT MaskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
42916 assert(SrcPartials[0].getBitWidth() == NumElts &&
42973 unsigned NumElts = SrcVecVT.getVectorNumElements();
42978 SmallVector<int, 16> ShuffleMask(NumElts * Scale, SM_SentinelUndef);
43276 unsigned NumElts = SrcOps[0].getValueType().getVectorNumElements();
43277 EVT MaskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
43282 assert(SrcPartials[0].getBitWidth() == NumElts &&
43315 unsigned NumElts = VT.getVectorNumElements();
43316 unsigned HalfElts = NumElts / 2;
43317 APInt UpperElts = APInt::getHighBitsSet(NumElts, HalfElts);
43318 if (NumElts >= 16 && N1.getOpcode() == X86ISD::KSHIFTL &&
43327 if (NumElts >= 16 && N0.getOpcode() == X86ISD::KSHIFTL &&
43823 unsigned NumElts = RegVT.getVectorNumElements();
43824 EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
43868 unsigned NumElts = BV->getValueType(0).getVectorNumElements();
43869 for (unsigned i = 0; i < NumElts; ++i) {
43956 unsigned NumElts = VT.getVectorNumElements();
43959 bool LoadLastElt = !isNullConstant(MaskBV->getOperand(NumElts - 1));
44408 unsigned NumElts = VT.getVectorNumElements();
44436 if (!UseSubVector && SrcShuffleMask.size() == NumElts &&
44442 if (UseSubVector && (SrcShuffleMask.size() == (NumElts * 2)) &&
44445 N1 = extract128BitVector(SrcOps[0], NumElts, DAG, SDLoc(Op));
44446 ArrayRef<int> Mask = ArrayRef<int>(SrcShuffleMask).slice(0, NumElts);
44474 for (unsigned i = 0; i != NumElts; ++i)
44480 for (unsigned i = 0; i != NumElts; ++i)
44501 PostShuffleMask.append(NumElts, SM_SentinelUndef);
44510 unsigned NumEltsPer128BitChunk = NumElts / Num128BitChunks;
44514 for (unsigned j = 0; j != NumElts; j += NumEltsPer128BitChunk) {
44519 (!A.getNode() && (LIdx < (int)NumElts || RIdx < (int)NumElts)) ||
44520 (!B.getNode() && (LIdx >= (int)NumElts || RIdx >= (int)NumElts)))
44533 ((Base % NumElts) & ~(NumEltsPer128BitChunk - 1));
44538 if ((B && Base >= (int)NumElts) || (!B && i >= NumEltsPer64BitChunk))
44548 isSequentialOrUndefInRange(PostShuffleMask, 0, NumElts, 0);
46016 unsigned NumElts = VT.getVectorNumElements();
46017 assert(NumElts == SclVT.getSizeInBits() && "Unexpected bool vector size");
46020 if (NumElts > EltSizeInBits) {
46025 assert((NumElts % EltSizeInBits) == 0 && "Unexpected integer scale");
46026 unsigned Scale = NumElts / EltSizeInBits;
46035 } else if (Subtarget.hasAVX2() && NumElts < EltSizeInBits &&
46041 assert((EltSizeInBits % NumElts) == 0 && "Unexpected integer scale");
46042 unsigned Scale = EltSizeInBits / NumElts;
46044 EVT::getVectorVT(*DAG.getContext(), SclVT, NumElts * Scale);
46046 ShuffleMask.append(NumElts * Scale, 0);
46055 ShuffleMask.append(NumElts, 0);
46061 for (unsigned i = 0; i != NumElts; ++i) {
46070 EVT CCVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, NumElts);
46604 unsigned NumElts = SrcVT.getVectorNumElements();
46628 APInt NotMask = APInt::getLowBitsSet(NumBits, NumElts);
46704 unsigned NumElts = Index.getValueType().getVectorNumElements();
46705 EVT NewVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32, NumElts);
46719 unsigned NumElts = Index.getValueType().getVectorNumElements();
46720 EVT NewVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32, NumElts);
46869 unsigned NumElts = VecWidth / DestWidth;
46870 EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), TruncVT, NumElts);
48706 unsigned NumElts = VT.getVectorNumElements();
48707 if (NumElts == 1 || !isPowerOf2_32(NumElts))
48717 if (NumElts < 8) {
48718 unsigned NumConcats = 8 / NumElts;
48719 SDValue Fill = NumElts == 4 ? DAG.getUNDEF(IntVT)
48728 std::max(4U, NumElts));
48738 if (NumElts < 4) {
48739 assert(NumElts == 2 && "Unexpected size");
48806 unsigned NumElts = VT.getVectorNumElements();
48807 if (NumElts == 1 || !isPowerOf2_32(NumElts))
48813 if (NumElts < 4)
48819 std::max(8U, NumElts));
48824 if (NumElts < 8) {