Lines Matching defs:NumElems
181 unsigned NumElems, SelectionDAG &DAG,
184 return Insert128BitVector(V, V2, NumElems/2, DAG, dl);
188 unsigned NumElems, SelectionDAG &DAG,
191 return Insert256BitVector(V, V2, NumElems/2, DAG, dl);
3834 unsigned NumElems) {
3835 for (unsigned i = 0; i != NumElems; ++i) {
3839 else if (idx < (int)NumElems)
3840 Mask[i] = idx + NumElems;
3842 Mask[i] = idx - NumElems;
3852 unsigned NumElems = VT.getVectorNumElements();
3854 unsigned NumLaneElems = NumElems/NumLanes;
3884 for (unsigned l = 0; l != NumElems; l += NumLaneElems) {
3887 unsigned RngStart = l + ((Commuted == (i<HalfLaneElems)) ? NumElems : 0);
3913 unsigned NumElems = VT.getVectorNumElements();
3915 if (NumElems != 4)
3932 unsigned NumElems = VT.getVectorNumElements();
3934 if (NumElems != 4)
3949 unsigned NumElems = VT.getVectorNumElements();
3951 if (NumElems != 2 && NumElems != 4)
3954 for (unsigned i = 0, e = NumElems/2; i != e; ++i)
3955 if (!isUndefOrEqual(Mask[i], i + NumElems))
3958 for (unsigned i = NumElems/2, e = NumElems; i != e; ++i)
3971 unsigned NumElems = VT.getVectorNumElements();
3973 if (NumElems != 2 && NumElems != 4)
3976 for (unsigned i = 0, e = NumElems/2; i != e; ++i)
3980 for (unsigned i = 0, e = NumElems/2; i != e; ++i)
3981 if (!isUndefOrEqual(Mask[i + e], i + NumElems))
4446 unsigned NumElems = VT.getVectorNumElements();
4448 if ((VT.is128BitVector() && NumElems != 4) ||
4449 (VT.is256BitVector() && NumElems != 8) ||
4450 (VT.is512BitVector() && NumElems != 16))
4454 for (unsigned i = 0; i != NumElems; i += 2)
4470 unsigned NumElems = VT.getVectorNumElements();
4472 if ((VT.is128BitVector() && NumElems != 4) ||
4473 (VT.is256BitVector() && NumElems != 8) ||
4474 (VT.is512BitVector() && NumElems != 16))
4478 for (unsigned i = 0; i != NumElems; i += 2)
4759 unsigned NumElems = VT.getVectorNumElements();
4762 for (unsigned i = 0; i != NumElems; ++i) {
4765 if (Idx < (int)NumElems)
4766 Idx += NumElems;
4768 Idx -= NumElems;
4848 unsigned NumElems = VT.getVectorNumElements();
4850 if (NumElems != 2 && NumElems != 4)
4852 for (unsigned i = 0, e = NumElems/2; i != e; ++i)
4855 for (unsigned i = NumElems/2, e = NumElems; i != e; ++i)
4856 if (!isUndefOrEqual(Mask[i], i+NumElems))
4867 unsigned NumElems = N->getValueType(0).getVectorNumElements();
4868 for (unsigned i = 0; i != NumElems; ++i) {
4870 if (Idx >= (int)NumElems) {
4875 !X86::isZeroNode(V2.getOperand(Idx-NumElems)))
4962 static void NormalizeMask(SmallVectorImpl<int> &Mask, unsigned NumElems) {
4963 for (unsigned i = 0; i != NumElems; ++i) {
4964 if (Mask[i] > (int)NumElems) {
4965 Mask[i] = NumElems;
4974 unsigned NumElems = VT.getVectorNumElements();
4976 Mask.push_back(NumElems);
4977 for (unsigned i = 1; i != NumElems; ++i)
4985 unsigned NumElems = VT.getVectorNumElements();
4987 for (unsigned i = 0, e = NumElems/2; i != e; ++i) {
4989 Mask.push_back(i + NumElems);
4997 unsigned NumElems = VT.getVectorNumElements();
4999 for (unsigned i = 0, Half = NumElems/2; i != Half; ++i) {
5001 Mask.push_back(i + NumElems + Half);
5012 int NumElems = VT.getVectorNumElements();
5015 while (NumElems > 4) {
5016 if (EltNo < NumElems/2) {
5020 EltNo -= NumElems/2;
5022 NumElems >>= 1;
5060 int NumElems = SrcVT.getVectorNumElements();
5063 assert(((SrcVT.is128BitVector() && NumElems > 4) || Is256BitVec) &&
5070 if (EltNo >= NumElems/2)
5071 EltNo -= NumElems/2;
5103 unsigned NumElems = VT.getVectorNumElements();
5105 for (unsigned i = 0; i != NumElems; ++i)
5107 MaskVec.push_back(i == Idx ? NumElems : i);
5116 unsigned NumElems = VT.getVectorNumElements();
5132 DecodeMOVHLPSMask(NumElems, Mask);
5135 DecodeMOVLHPSMask(NumElems, Mask);
5167 Mask.push_back(NumElems);
5168 for (unsigned i = 1; i != NumElems; ++i) {
5210 unsigned NumElems = VT.getVectorNumElements();
5211 SDValue NewV = (Elt < (int)NumElems) ? SV->getOperand(0)
5213 return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG, Depth+1);
5219 unsigned NumElems = ShufVT.getVectorNumElements();
5230 SDValue NewV = (Elt < (int)NumElems) ? N->getOperand(0)
5232 return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG,
5240 unsigned NumElems = VT.getVectorNumElements();
5242 if (!SrcVT.isVector() || SrcVT.getVectorNumElements() != NumElems)
5261 unsigned NumElems, bool ZerosFromLeft,
5265 for (unsigned i = 0; i != NumElems; ++i) {
5266 unsigned Index = ZerosFromLeft ? i : NumElems - i - 1;
5288 unsigned NumElems, unsigned &OpNum) {
5298 if (Idx < (int)NumElems)
5304 if ((Idx % NumElems != OpIdx) || (SeenV1 && SeenV2))
5316 unsigned NumElems =
5319 SVOp, NumElems, false /* check zeros from right */, DAG,
5335 NumElems-NumZeros, // Mask End Index(exclusive)
5337 NumElems, // Number of elements in vector
5351 unsigned NumElems =
5354 SVOp, NumElems, true /* check zeros from left */, DAG,
5355 NumElems - SVOp->getMaskElt(NumElems - 1) - 1);
5370 NumElems, // Mask End Index(exclusive)
5372 NumElems, // Number of elements in vector
5479 static SDValue LowerBuildVectorv4x32(SDValue Op, unsigned NumElems,
5508 for (unsigned Idx = FirstNonZeroIdx + 1; Idx < NumElems; ++Idx) {
5623 unsigned NumElems = VT.getVectorNumElements();
5625 EVT NVT = EVT::getVectorVT(*DAG.getContext(), PVT, NumElems);
5631 for (unsigned i = 0; i != NumElems; ++i)
5653 unsigned NumElems = Elts.size();
5661 for (unsigned i = 0; i < NumElems; ++i) {
5686 if (LastLoadedElt == NumElems - 1) {
5715 if (NumElems == 4 && LastLoadedElt == 1 &&
5928 unsigned NumElems = Op.getNumOperands();
5933 SmallVector<int, 8> Mask(NumElems, -1);
5935 for (unsigned i = 0; i != NumElems; ++i) {
5974 Mask[i] = Idx + NumElems;
6504 unsigned NumElems = Op.getNumOperands();
6542 for (unsigned i = 0; i < NumElems; ++i) {
6636 if (NumElems == 2 && Idx == 1 &&
6660 for (unsigned i = 0; i != NumElems; ++i)
6690 for (unsigned i = 0; i != NumElems; ++i)
6693 EVT HVT = EVT::getVectorVT(*DAG.getContext(), ExtVT, NumElems/2);
6697 makeArrayRef(&V[0], NumElems/2));
6699 makeArrayRef(&V[NumElems / 2], NumElems/2));
6703 return Concat128BitVectors(Lower, Upper, VT, NumElems, DAG, dl);
6704 return Concat256BitVectors(Lower, Upper, VT, NumElems, DAG, dl);
6720 if (EVTBits == 8 && NumElems == 16) {
6726 if (EVTBits == 16 && NumElems == 8) {
6733 if (EVTBits == 32 && NumElems == 4) {
6734 SDValue V = LowerBuildVectorv4x32(Op, NumElems, NonZeros, NumNonZero,
6741 SmallVector<SDValue, 8> V(NumElems);
6742 if (NumElems == 4 && NumZero > 0) {
6774 static_cast<int>(Reverse2 ? NumElems+1 : NumElems),
6775 static_cast<int>(Reverse2 ? NumElems : NumElems+1)
6782 for (unsigned i = 0; i < NumElems; ++i)
6803 for (unsigned i = 1; i < NumElems; ++i) {
6814 for (unsigned i = 0; i < NumElems; ++i) {
6825 unsigned EltStride = NumElems >> 1;
6834 EltStride == NumElems/2)
6857 unsigned NumElems = ResVT.getVectorNumElements();
6859 return Concat128BitVectors(V1, V2, ResVT, NumElems, DAG, dl);
6866 return Concat256BitVectors(Concat128BitVectors(V1, V2, HalfVT, NumElems/2, DAG, dl),
6867 Concat128BitVectors(V3, V4, HalfVT, NumElems/2, DAG, dl), ResVT, NumElems, DAG, dl);
6869 return Concat256BitVectors(V1, V2, ResVT, NumElems, DAG, dl);
8029 unsigned NumElems = VT.getVectorNumElements();
8030 // There are 2 lanes if (NumElems > 8), and 1 lane otherwise.
8031 unsigned NumLanes = (NumElems - 1) / 8 + 1;
8032 unsigned NumElemsInLane = NumElems / NumLanes;
8044 if (((unsigned)EltIdx == (i + NumElems)) &&
8046 (unsigned)SndLaneEltIdx == i + NumElems + NumElemsInLane))
8073 unsigned NumElems = VT.getVectorNumElements();
8080 NumElems);
8572 unsigned NumElems = VT.getVectorNumElements();
8589 for (unsigned i = 0; i != NumElems; i += Scale) {
8654 unsigned NumElems = VT.getVectorNumElements();
8655 unsigned NumLaneElems = NumElems / 2;
8721 int Input = Idx / NumElems;
8724 Idx -= Input * NumElems;
8963 unsigned NumElems = VT.getVectorNumElements();
8985 if (HasSSE2 && NumElems == 2)
8988 if (NumElems == 4)
9003 if (NumElems == 2 || !isMOVLMask(SVOp->getMask(), VT))
9122 unsigned NumElems = VT.getVectorNumElements();
9132 while ((1U << Shift) < NumElems) {
9143 for (unsigned i = 0; i != NumElems; ++i) {
9153 MVT NVT = MVT::getVectorVT(NeVT, NumElems >> Shift);
9255 unsigned NumElems = VT.getVectorNumElements();
9415 CommuteVectorShuffleMask(M, NumElems);
9442 NormalizeMask(NewMask, NumElems);
9452 CommuteVectorShuffleMask(M, NumElems);
9522 Idx*(NumElems/2), DAG, dl);
9536 if ((V2IsUndef && HasInt256 && VT.is256BitVector() && NumElems == 8) ||
9539 MVT MaskVectorVT = MVT::getVectorVT(MaskEltVT, NumElems);
9541 for (unsigned i = 0; i != NumElems; ++i) {
9587 if (NumElems == 4 && VT.is128BitVector())
9603 unsigned NumElems = BuildVector->getNumOperands();
9604 // There are 2 lanes if (NumElems > 8), and 1 lane otherwise.
9605 unsigned NumLanes = (NumElems - 1) / 8 + 1;
9606 unsigned NumElemsInLane = NumElems / NumLanes;
9643 unsigned NumElems = VT.getVectorNumElements();
9667 NumElems);
9838 //if (IdxVal >= NumElems/2)
9839 // IdxVal -= NumElems/2;
11306 unsigned NumElems = VT.getVectorNumElements();
11307 MVT NVT = MVT::getVectorVT(VT.getVectorElementType(), NumElems * 2);
11309 SmallVector<int, 16> MaskVec(NumElems * 2, -1);
11311 for (unsigned i = 0; i != NumElems; ++i)
12070 unsigned NumElems = VT.getVectorNumElements();
12077 SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
12082 SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, dl);
12086 MVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
12782 unsigned NumElems = InVT.getVectorNumElements();
12785 SmallVector<int,8> ShufMask1(NumElems, -1);
12786 for (unsigned i = 0; i != NumElems/2; ++i)
12791 SmallVector<int,8> ShufMask2(NumElems, -1);
12792 for (unsigned i = 0; i != NumElems/2; ++i)
12793 ShufMask2[i] = i + NumElems/2;
14991 unsigned NumElems = VT.getVectorNumElements();
14997 SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
15002 SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, dl);
15005 MVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
15567 unsigned NumElems = VT.getVectorNumElements();
15569 for (unsigned i=0; i !=NumElems; ++i) {
15730 unsigned NumElems = VT.getVectorNumElements();
15732 EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
15736 SDValue V2 = Extract128BitVector(R, NumElems/2, DAG, dl);
15744 for (unsigned i = 0; i != NumElems/2; ++i)
15746 for (unsigned i = NumElems/2; i != NumElems; ++i)
15754 Amt2 = Extract128BitVector(Amt, NumElems/2, DAG, dl);
15863 unsigned NumElems = VT.getVectorNumElements();
15868 SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
15871 EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
18301 unsigned NumElems = VT.getVectorNumElements();
18304 for (unsigned i = 0, j = NumElems/2; i != NumElems/2; ++i, ++j)
18317 unsigned NumElems = VT.getVectorNumElements();
18320 for (unsigned i = NumElems/2, j = 0; i != NumElems; ++i, ++j)
18337 unsigned NumElems = VT.getVectorNumElements();
18362 for (unsigned i = 0; i != NumElems/2; ++i)
18364 !isUndefOrEqual(SVOp->getMaskElt(i+NumElems/2), NumElems))
18408 SDValue V = Extract128BitVector(V1, NumElems/2, DAG, dl);
18416 SDValue InsV = Insert128BitVector(DAG.getUNDEF(VT), V, NumElems/2, DAG, dl);
18940 unsigned NumElems = VT.getVectorNumElements();
18942 int Idx = (Elt > (int)NumElems) ? -1 : ShuffleMask[Elt];
18943 SDValue LdNode = (Idx < (int)NumElems) ? InVec.getOperand(0)
19180 unsigned NumElems = VT.getVectorNumElements();
19197 SmallVector<int, 8> ShuffleMask(NumElems, -1);
19198 for (unsigned i = 0; i < NumElems; ++i) {
19203 ShuffleMask[i] = i + NumElems * ((MaskValue >> i) & 1);
19577 unsigned NumElems = VT.getVectorNumElements();
19580 SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, DL);
19584 SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, DL);
19649 unsigned NumElems = Cond.getNumOperands();
19658 for (unsigned i = 1, e = NumElems; i != e && CanFold; ++i)
19666 for (unsigned i = 1, e = NumElems; i != e && CanFold; ++i)
20841 unsigned NumElems = RegVT.getVectorNumElements();
20842 if (NumElems < 2)
20849 NumElems/2);
20865 NewVec = Insert128BitVector(NewVec, Load2, NumElems/2, DAG, dl);
20881 unsigned NumElems = RegVT.getVectorNumElements();
20889 if (!isPowerOf2_32(RegSz * MemSz * NumElems))
20981 SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1);
20982 for (unsigned i = 0; i != NumElems; ++i)
21001 SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1);
21002 for (unsigned i = 0; i != NumElems; ++i)
21037 unsigned NumElems = VT.getVectorNumElements();
21038 if (NumElems < 2)
21042 SDValue Value1 = Extract128BitVector(StoredVal, NumElems/2, DAG, dl);
21063 unsigned NumElems = VT.getVectorNumElements();
21069 if (!isPowerOf2_32(NumElems * FromSz * ToSz)) return SDValue();
21072 if (0 != (NumElems * FromSz) % ToSz) return SDValue();
21076 assert(SizeRatio * NumElems * ToSz == VT.getSizeInBits());
21080 StVT.getScalarType(), NumElems*SizeRatio);
21085 SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1);
21086 for (unsigned i = 0; i != NumElems; ++i)
21104 if (TLI.isTypeLegal(Tp) && Tp.getSizeInBits() <= NumElems * ToSz)
21110 (64 <= NumElems * ToSz))
21124 for (unsigned i=0, e=(ToSz*NumElems)/StoreType.getSizeInBits(); i!=e; ++i) {
