Lines Matching defs:SrcVT
3346 bool X86TargetLowering::isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
3354 return Index == 0 || ((ResVT.getSizeInBits() == SrcVT.getSizeInBits()*2) &&
5166 EVT SrcVT = Op.getOperand(0).getValueType();
5167 unsigned NumSrcElts = SrcVT.getVectorNumElements();
6254 EVT SrcVT = SrcVec.getValueType();
6255 if (!SrcVT.getScalarType().isByteSized())
6258 unsigned SrcByte = SrcIdx * (SrcVT.getScalarSizeInBits() / 8);
6261 std::min<unsigned>(MinBitsPerElt, SrcVT.getScalarSizeInBits());
6352 EVT SrcVT = Src.getValueType();
6354 if (!SrcVT.isSimple() || (SrcVT.getSizeInBits() % 128) != 0 ||
6355 (SrcVT.getScalarSizeInBits() % 8) != 0)
6357 unsigned NumSrcElts = SrcVT.getVectorNumElements();
6358 unsigned NumBitsPerSrcElt = SrcVT.getScalarSizeInBits();
6454 EVT SrcVT = Src.getValueType();
6455 unsigned NumBitsPerSrcElt = SrcVT.getScalarSizeInBits();
6458 if (!SrcVT.isSimple() || (SrcVT.getSizeInBits() % 128) != 0 ||
6464 DemandedElts.zextOrTrunc(SrcVT.getVectorNumElements());
6480 EVT SrcVT = Src.getValueType();
6483 if (!SrcVT.isSimple() || (SrcVT.getSizeInBits() % 128) != 0 ||
6484 (SrcVT.getScalarSizeInBits() % 8) != 0)
6489 DecodeZeroExtendMask(SrcVT.getScalarSizeInBits(), NumBitsPerElt, NumElts,
6693 EVT SrcVT = Src.getValueType();
6694 if (SrcVT.isVector() && SrcVT.getVectorNumElements() == NumElems)
8732 EVT SrcVT = Idx.getValueType();
8733 unsigned NumDstBits = SrcVT.getScalarSizeInBits() / Scale;
8747 Idx = DAG.getNode(ISD::MUL, SDLoc(Idx), SrcVT, Idx,
8748 DAG.getConstant(IndexScale, SDLoc(Idx), SrcVT));
8749 Idx = DAG.getNode(ISD::ADD, SDLoc(Idx), SrcVT, Idx,
8750 DAG.getConstant(IndexOffset, SDLoc(Idx), SrcVT));
10319 static bool matchShuffleAsVTRUNC(MVT &SrcVT, MVT &DstVT, MVT VT,
10339 SrcVT = MVT::getIntegerVT(EltSizeInBits * Scale);
10340 SrcVT = MVT::getVectorVT(SrcVT, NumSrcElts);
10360 MVT SrcVT = Src.getSimpleValueType();
10363 unsigned NumSrcElts = SrcVT.getVectorNumElements();
10366 if (!DAG.getTargetLoweringInfo().isTypeLegal(SrcVT))
10388 if (!Subtarget.hasVLX() && !SrcVT.is512BitVector()) {
10446 MVT SrcVT = MVT::getVectorVT(SrcSVT, NumSrcElts);
10447 Src = DAG.getBitcast(SrcVT, Src);
10529 MVT SrcVT = MVT::getVectorVT(SrcSVT, NumSrcElts);
10530 Src = DAG.getBitcast(SrcVT, Src);
10536 X86ISD::VSRLI, DL, SrcVT, Src,
10622 static bool matchShuffleWithPACK(MVT VT, MVT &SrcVT, SDValue &V1, SDValue &V2,
10650 SrcVT = PackVT;
10663 SrcVT = PackVT;
10727 MVT SrcVT = MVT::getVectorVT(SrcSVT, NumSrcElts);
10729 Res = DAG.getNode(PackOpcode, DL, DstVT, DAG.getBitcast(SrcVT, V1),
10730 DAG.getBitcast(SrcVT, V2));
19410 MVT SrcVT = Src.getSimpleValueType();
19413 if (!Subtarget.hasDQI() || SrcVT != MVT::i64 || Subtarget.is64Bit() ||
19450 MVT SrcVT = Src.getSimpleValueType();
19453 if (SrcVT != MVT::i64 || Subtarget.is64Bit() || VT != MVT::f16)
19554 MVT SrcVT = X.getSimpleValueType();
19555 if (SrcVT != MVT::f32 && SrcVT != MVT::f64)
19564 unsigned SrcSize = SrcVT.getSizeInBits();
19567 MVT VecSrcVT = MVT::getVectorVT(SrcVT, 128 / SrcSize);
19724 MVT SrcVT = Src.getSimpleValueType();
19730 else if (isLegalConversion(SrcVT, true, Subtarget))
19733 if (Subtarget.isTargetWin64() && SrcVT == MVT::i128)
19742 if (SrcVT.isVector()) {
19743 if (SrcVT == MVT::v2i32 && VT == MVT::v2f64) {
19750 DAG.getUNDEF(SrcVT))});
19753 DAG.getUNDEF(SrcVT)));
19755 if (SrcVT == MVT::v2i64 || SrcVT == MVT::v4i64)
19761 assert(SrcVT <= MVT::i64 && SrcVT >= MVT::i16 &&
19768 if (SrcVT == MVT::i32 && UseSSEReg)
19770 if (SrcVT == MVT::i64 && UseSSEReg && Subtarget.is64Bit())
19779 if (SrcVT == MVT::i16 && (UseSSEReg || VT == MVT::f128)) {
19792 if (SrcVT == MVT::i64 && Subtarget.hasSSE2() && !Subtarget.is64Bit())
19798 unsigned Size = SrcVT.getStoreSize();
19808 BuildFILD(VT, SrcVT, dl, Chain, StackSlot, MPI, Alignment, DAG);
19817 EVT DstVT, EVT SrcVT, const SDLoc &DL, SDValue Chain, SDValue Pointer,
19829 DAG.getMemIntrinsicNode(X86ISD::FILD, DL, Tys, FILDOps, SrcVT, PtrInfo,
20201 MVT SrcVT = N0.getSimpleValueType();
20203 switch (SrcVT.SimpleTy) {
20224 MVT SrcVT = Src.getSimpleValueType();
20234 else if (isLegalConversion(SrcVT, false, Subtarget))
20240 if (Subtarget.isTargetWin64() && SrcVT == MVT::i128)
20247 (SrcVT == MVT::i32 || (SrcVT == MVT::i64 && Subtarget.is64Bit()))) {
20254 if (SrcVT == MVT::i32 && Subtarget.is64Bit()) {
20269 if (SrcVT == MVT::i64 && DstVT == MVT::f64 && Subtarget.hasSSE2() &&
20274 if (SrcVT == MVT::i32 && Subtarget.hasSSE2() && DstVT != MVT::f80 &&
20277 if (Subtarget.is64Bit() && SrcVT == MVT::i64 &&
20287 if (SrcVT == MVT::i32) {
20301 assert(SrcVT == MVT::i64 && "Unexpected type in UINT_TO_FP");
20691 EVT SrcVT = In.getValueType();
20694 if (SrcVT == DstVT)
20697 unsigned NumElems = SrcVT.getVectorNumElements();
20702 unsigned SrcSizeInBits = SrcVT.getSizeInBits();
20707 EVT PackedSVT = EVT::getIntegerVT(Ctx, SrcVT.getScalarSizeInBits() / 2);
20713 if (SrcVT.getScalarSizeInBits() > 16 &&
20750 if (SrcVT.is256BitVector() && DstVT.is128BitVector()) {
20759 if (SrcVT.is512BitVector() && Subtarget.hasInt256()) {
20813 EVT SrcVT = In.getValueType();
20814 In = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, SrcVT, In,
20831 EVT SrcVT = In.getValueType();
20833 EVT SrcSVT = SrcVT.getVectorElementType();
20848 if ((DstSVT == MVT::i32 && SrcVT.getSizeInBits() <= 128) ||
20849 (DstSVT == MVT::i16 && SrcVT.getSizeInBits() <= (64 * NumStages)) ||
20850 (DstVT == MVT::v2i8 && SrcVT == MVT::v2i64 && Subtarget.hasSSSE3()))
20855 if (SrcVT == MVT::v4i64 && DstVT == MVT::v4i32 &&
20904 return DAG.getNode(ISD::SRA, DL, SrcVT, In->ops());
20917 MVT SrcVT = In.getSimpleValueType();
20919 MVT SrcSVT = SrcVT.getVectorElementType();
20950 MVT SrcVT = In.getSimpleValueType();
20952 MVT SrcSVT = SrcVT.getVectorElementType();
21204 MVT SrcVT = Src.getSimpleValueType();
21213 DAG.getNode(ISD::FSUB, dl, SrcVT, Src,
21214 DAG.getConstantFP(2147483648.0f, dl, SrcVT)));
21244 MVT SrcVT = Src.getSimpleValueType();
21248 if (isSoftF16(SrcVT, Subtarget)) {
21256 } else if (isTypeLegal(SrcVT) && isLegalConversion(VT, IsSigned, Subtarget)) {
21261 if (VT == MVT::v2i1 && SrcVT == MVT::v2f64) {
21299 if (Subtarget.hasFP16() && SrcVT.getVectorElementType() == MVT::f16) {
21308 if (SrcVT != MVT::v8f16) {
21310 IsStrict ? DAG.getConstantFP(0.0, dl, SrcVT) : DAG.getUNDEF(SrcVT);
21311 SmallVector<SDValue, 4> Ops(SrcVT == MVT::v2f16 ? 4 : 2, Tmp);
21343 assert((SrcVT.getVectorElementType() == MVT::f32 ||
21344 SrcVT.getVectorElementType() == MVT::f64) &&
21366 if (VT == MVT::v8i32 && SrcVT == MVT::v8f64) {
21374 (SrcVT == MVT::v4f64 || SrcVT == MVT::v4f32 || SrcVT == MVT::v8f32) &&
21378 MVT WideVT = SrcVT == MVT::v4f64 ? MVT::v8f64 : MVT::v16f32;
21379 MVT ResVT = SrcVT == MVT::v4f64 ? MVT::v8i32 : MVT::v16i32;
21406 (SrcVT == MVT::v2f64 || SrcVT == MVT::v4f64 || SrcVT == MVT::v4f32) &&
21409 MVT WideVT = SrcVT == MVT::v4f32 ? MVT::v8f32 : MVT::v8f64;
21434 if (VT == MVT::v2i64 && SrcVT == MVT::v2f32) {
21466 if ((VT == MVT::v4i32 && SrcVT == MVT::v4f32) ||
21467 (VT == MVT::v4i32 && SrcVT == MVT::v4f64) ||
21468 (VT == MVT::v8i32 && SrcVT == MVT::v8f32)) {
21478 bool UseSSEReg = isScalarFPTypeInSSEReg(SrcVT);
21491 SDValue FloatOffset = DAG.getNode(ISD::UINT_TO_FP, dl, SrcVT,
21493 MVT SrcVecVT = MVT::getVectorVT(SrcVT, 128 / SrcVT.getScalarSizeInBits());
21504 DAG.getNode(ISD::FSUB, dl, SrcVT, Src, FloatOffset)));
21550 if (VT == MVT::i16 && (UseSSEReg || SrcVT == MVT::f128)) {
21570 if (SrcVT == MVT::f128) {
21573 LC = RTLIB::getFPTOSINT(SrcVT, VT);
21575 LC = RTLIB::getFPTOUINT(SrcVT, VT);
21601 MVT SrcVT = Src.getSimpleValueType();
21603 if (SrcVT.isVector())
21606 if (SrcVT == MVT::f16)
21610 if (isScalarFPTypeInSSEReg(SrcVT))
21620 EVT SrcVT = Src.getValueType();
21622 if (SrcVT != MVT::f32 && SrcVT != MVT::f64 && SrcVT != MVT::f80) {
21631 bool UseSSE = isScalarFPTypeInSSEReg(SrcVT);
21635 EVT OtherVT = UseSSE ? SrcVT : DstVT;
21647 Src = DAG.getMemIntrinsicNode(X86ISD::FLD, DL, Tys, Ops, SrcVT, MPI,
21671 // There are three types involved here: SrcVT is the source floating point
21675 EVT SrcVT = Src.getValueType();
21681 if (!isScalarFPTypeInSSEReg(SrcVT) || isSoftF16(SrcVT, Subtarget))
21720 const fltSemantics &Sem = SrcVT.getFltSemantics();
21731 SDValue MinFloatNode = DAG.getConstantFP(MinFloat, dl, SrcVT);
21732 SDValue MaxFloatNode = DAG.getConstantFP(MaxFloat, dl, SrcVT);
21740 X86ISD::FMAX, dl, SrcVT, MinFloatNode, Src);
21743 X86ISD::FMIN, dl, SrcVT, MaxFloatNode, MinClamped);
21754 X86ISD::FMAX, dl, SrcVT, Src, MinFloatNode);
21757 X86ISD::FMINC, dl, SrcVT, MinClamped, MaxFloatNode);
22698 EVT SrcVT = Src.getValueType();
22699 SDValue MaskValue = DAG.getConstant(Mask, DL, SrcVT);
22700 return DAG.getNode(ISD::AND, DL, SrcVT, Src, MaskValue);
26624 MVT SrcVT = Src.getSimpleValueType();
26625 MVT MaskVT = MVT::getVectorVT(MVT::i1, SrcVT.getVectorNumElements());
26667 MVT SrcVT = Src.getSimpleValueType();
26668 MVT MaskVT = MVT::getVectorVT(MVT::i1, SrcVT.getVectorNumElements());
31974 MVT SrcVT = Src.getSimpleValueType();
31979 if (SrcVT == MVT::i64 && DstVT == MVT::v64i1) {
31991 if ((SrcVT == MVT::v16i1 || SrcVT == MVT::v32i1) && DstVT.isScalarInteger()) {
31993 MVT SExtVT = SrcVT == MVT::v16i1 ? MVT::v16i8 : MVT::v32i8;
32000 assert((SrcVT == MVT::v2i32 || SrcVT == MVT::v4i16 || SrcVT == MVT::v8i8 ||
32001 SrcVT == MVT::i64) && "Unexpected VT!");
32004 if (!(DstVT == MVT::f64 && SrcVT == MVT::i64) &&
32005 !(DstVT == MVT::x86mmx && SrcVT.isVector()))
32010 if (SrcVT.isVector()) {
32013 MVT NewVT = MVT::getVectorVT(SrcVT.getVectorElementType(),
32014 SrcVT.getVectorNumElements() * 2);
32016 DAG.getUNDEF(SrcVT));
32018 assert(SrcVT == MVT::i64 && !Subtarget.is64Bit() &&
33782 EVT SrcVT = Src.getValueType();
33785 if (isSoftF16(SrcVT, Subtarget)) {
33805 SrcVT.getVectorElementType() == MVT::f16) {
33809 if (SrcVT != MVT::v8f16) {
33811 IsStrict ? DAG.getConstantFP(0.0, dl, SrcVT) : DAG.getUNDEF(SrcVT);
33812 SmallVector<SDValue, 4> Ops(SrcVT == MVT::v2f16 ? 4 : 2, Tmp);
33962 (SrcVT == MVT::f32 || SrcVT == MVT::f64)) ||
33963 (Subtarget.hasFP16() && SrcVT == MVT::f16)) {
33968 std::max(NumElts, 128U / (unsigned)SrcVT.getSizeInBits());
33970 MVT VecInVT = MVT::getVectorVT(SrcVT.getSimpleVT(), SrcElts);
34051 EVT SrcVT = Src.getValueType();
34052 if (Subtarget.hasDQI() && Subtarget.hasVLX() && SrcVT == MVT::v2i64) {
34066 if (SrcVT == MVT::v2i64 && !IsSigned && Subtarget.is64Bit() &&
34068 SDValue Zero = DAG.getConstant(0, dl, SrcVT);
34069 SDValue One = DAG.getConstant(1, dl, SrcVT);
34070 SDValue Sign = DAG.getNode(ISD::OR, dl, SrcVT,
34071 DAG.getNode(ISD::SRL, dl, SrcVT, Src, One),
34072 DAG.getNode(ISD::AND, dl, SrcVT, Src, One));
34074 SDValue SignSrc = DAG.getSelect(dl, SrcVT, IsNeg, Sign, Src);
34107 if (SrcVT != MVT::v2i32)
34153 EVT SrcVT = Src.getValueType();
34163 if (SrcVT.getVectorElementType() != MVT::f32)
34411 EVT SrcVT = N->getOperand(0).getValueType();
34415 if (SrcVT == MVT::v64i1 && DstVT == MVT::i64 && Subtarget.hasBWI()) {
34426 if (DstVT.isVector() && SrcVT == MVT::x86mmx) {
35187 EVT SrcVT = ExtVal.getOperand(0).getValueType();
35190 if (SrcVT.getScalarType() == MVT::i1)
35222 bool X86TargetLowering::isNarrowingProfitable(SDNode *N, EVT SrcVT,
35225 return !(SrcVT == MVT::i32 && DestVT == MVT::i16);
38252 EVT SrcVT = Src.getValueType();
38253 APInt DemandedElt = APInt::getOneBitSet(SrcVT.getVectorNumElements(),
38257 Known.Zero.setBitsFrom(SrcVT.getScalarSizeInBits());
38495 EVT SrcVT = Op.getOperand(0).getValueType();
38496 if (SrcVT.isVector()) {
38497 unsigned NumSrcElts = SrcVT.getVectorNumElements();
38510 EVT SrcVT = Op.getOperand(1).getValueType();
38511 if (SrcVT.isVector()) {
38512 unsigned NumSrcElts = SrcVT.getVectorNumElements();
38663 MVT SrcVT = Src.getSimpleValueType();
38664 unsigned NumSrcBits = SrcVT.getScalarSizeInBits();
38666 APInt DemandedSrc = DemandedElts.zextOrTrunc(SrcVT.getVectorNumElements());
38847 MVT &SrcVT, MVT &DstVT) {
38859 SrcVT = DstVT = MaskVT.changeVectorElementType(MVT::f16);
38861 SrcVT = DstVT = !Subtarget.hasSSE2() ? MVT::v4f32 : MaskVT;
38896 SrcVT = MVT::getVectorVT(ScalarTy, SrcSize / MaskEltSize);
38901 if (SrcVT.getVectorNumElements() != NumDstElts)
38918 SrcVT = DstVT = MaskVT.changeVectorElementType(MVT::f16);
38920 SrcVT = DstVT = !Subtarget.hasSSE2() ? MVT::v4f32 : MaskVT;
38930 SrcVT = DstVT = MVT::v2f64;
38935 SrcVT = DstVT = MVT::v4f32;
38940 SrcVT = DstVT = MVT::v4f32;
38949 SrcVT = DstVT = MVT::v4f64;
38955 SrcVT = DstVT = MVT::v8f32;
38961 SrcVT = DstVT = MVT::v8f32;
38972 SrcVT = DstVT = MVT::v8f64;
38979 SrcVT = DstVT = MVT::v16f32;
38986 SrcVT = DstVT = MVT::v16f32;
39150 unsigned &Shuffle, MVT &SrcVT, MVT &DstVT,
39162 SrcVT = DstVT = Subtarget.hasSSE2() ? MVT::v2f64 : MVT::v4f32;
39169 SrcVT = DstVT = Subtarget.hasSSE2() ? MVT::v2f64 : MVT::v4f32;
39176 SrcVT = DstVT = MVT::v2f64;
39182 SrcVT = DstVT = MVT::v4f32;
39189 SrcVT = DstVT = MVT::v8f16;
39198 if (matchShuffleWithPACK(MaskVT, SrcVT, V1, V2, Shuffle, Mask, DAG,
39213 SrcVT = MVT::v4i32;
39220 SrcVT = MVT::v8i16;
39227 SrcVT = MVT::v4i32;
39243 SrcVT = DstVT = MaskVT;
39245 SrcVT = DstVT = (32 == EltSizeInBits ? MVT::v8f32 : MVT::v4f64);
39288 SrcVT = DstVT = MaskVT.changeTypeToInteger();
39332 SrcVT = DstVT = MaskVT.changeTypeToInteger();
40449 MVT SrcVT = BC0.getOperand(0).getSimpleValueType();
40479 SDValue LHS = DAG.getNode(Opcode0, DL, SrcVT, M0, M1);
40480 SDValue RHS = DAG.getNode(Opcode0, DL, SrcVT, M2, M3);
40509 LHS = DAG.getBitcast(SrcVT, LHS);
40510 RHS = DAG.getBitcast(SrcVT, RHS ? RHS : LHS);
40586 SDValue Undef = DAG.getUNDEF(SrcVT);
40587 SDValue Zero = getZeroVector(SrcVT, Subtarget, DAG, DL);
40607 unsigned Idx0 = (M0 & 2) ? (SrcVT.getVectorNumElements() / 2) : 0;
40608 unsigned Idx1 = (M1 & 2) ? (SrcVT.getVectorNumElements() / 2) : 0;
41804 EVT SrcVT = Src.getValueType();
41822 DAG.getBitcast(SrcVT, Res));
41828 SrcVT.getScalarSizeInBits() == BCVT.getScalarSizeInBits() &&
41853 if (SrcVT.getSizeInBits() > 128)
41883 if (!SrcVT.isVector() && (Src.hasOneUse() || VT.isFloatingPoint()) &&
41898 SDValue Scl = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, SrcVT, BcastLd,
41907 if (SrcVT == MVT::i16 && Src.getOpcode() == ISD::TRUNCATE &&
41995 if ((SrcVT == MVT::v2f64 || SrcVT == MVT::v4f32 || SrcVT == MVT::v2i64 ||
41996 SrcVT == MVT::v4i32) &&
42004 X86ISD::VBROADCAST_LOAD, DL, Tys, Ops, SrcVT.getScalarType(),
42122 MVT SrcVT = N0.getOperand(0).getSimpleValueType();
42123 unsigned SrcBits = SrcVT.getScalarSizeInBits();
42125 unsigned NewSize = SrcVT.getVectorNumElements();
42129 VT, DAG.getNode(X86ISD::BLENDI, DL, SrcVT, N0.getOperand(0),
42215 EVT SrcVT = Src.getValueType();
42216 SDValue Res = DAG.getNode(X86ISD::VPERMI, DL, SrcVT, Src, N1);
42255 EVT SrcVT = LHS.getOperand(0).getValueType();
42256 if (RHS.isUndef() || SrcVT == RHS.getOperand(0).getValueType()) {
42257 return DAG.getBitcast(VT, DAG.getNode(X86ISD::VPERM2X128, DL, SrcVT,
42258 DAG.getBitcast(SrcVT, LHS),
42259 DAG.getBitcast(SrcVT, RHS),
43301 EVT SrcVT = Src.getValueType();
43303 APInt SrcElts = DemandedElts.zextOrTrunc(SrcVT.getVectorNumElements());
43385 MVT SrcVT = Src.getSimpleValueType();
43386 APInt DemandedSrc = DemandedElts.zextOrTrunc(SrcVT.getVectorNumElements());
43450 MVT SrcVT = Src.getSimpleValueType();
43453 if (!SrcVT.isVector())
43460 if (!SrcVT.isVector())
43463 APInt SrcElts = APInt::getOneBitSet(SrcVT.getVectorNumElements(), 0);
43620 MVT SrcVT = SrcOp.getSimpleValueType();
43622 std::max<unsigned>(SrcVT.getSizeInBits() / Scale, 128);
43674 EVT SrcVT = SrcOp.getValueType();
43675 assert((!SrcVT.isVector() || SrcVT.getSizeInBits() == SizeInBits) &&
43677 Ops.push_back(SrcVT.isVector() ? extractSubVector(SrcOp, 0, TLO.DAG, DL,
43797 MVT SrcVT = Src.getSimpleValueType();
43800 APInt TruncMask = OriginalDemandedBits.zext(SrcVT.getScalarSizeInBits());
43801 APInt DemandedElts = OriginalDemandedElts.trunc(SrcVT.getVectorNumElements());
44145 MVT SrcVT = Src.getSimpleValueType();
44147 SrcVT.isVector() ? SrcVT.getVectorNumElements() : 1, 0);
44154 if ((BitWidth == 64) && SrcVT.isScalarInteger() && !Subtarget.hasAVX512() &&
44176 MVT SrcVT = Src.getSimpleValueType();
44177 unsigned SrcBits = SrcVT.getScalarSizeInBits();
44178 unsigned NumElts = SrcVT.getVectorNumElements();
44185 if (SrcVT.is256BitVector() &&
44593 EVT SrcVT = Src.getValueType();
44594 if (SrcVT != MVT::v4i1)
44659 EVT SrcVT = Src.getValueType();
44660 if (!SrcVT.isSimple() || SrcVT.getScalarType() != MVT::i1)
44729 switch (SrcVT.getSimpleVT().SimpleTy) {
44799 EVT::getIntegerVT(*DAG.getContext(), SrcVT.getVectorNumElements());
44806 EVT SrcVT = Op.getValueType();
44807 assert(SrcVT.getVectorElementType() == MVT::i1 &&
44812 APInt Imm(SrcVT.getVectorNumElements(), 0);
44836 EVT SrcVT = Op.getValueType();
44848 if (!(SrcVT.isVector() && SrcVT.getVectorElementType() == MVT::i1 &&
44851 SrcVT.isScalarInteger()))
44971 EVT SrcVT = Src.getValueType();
44972 if (SrcVT.isVector() || SrcVT.isFloatingPoint())
45052 EVT SrcVT = N0.getValueType();
45068 if ((VT == MVT::v4i1 || VT == MVT::v2i1) && SrcVT.isScalarInteger() &&
45078 if ((SrcVT == MVT::v4i1 || SrcVT == MVT::v2i1) && VT.isScalarInteger() &&
45090 SrcVT = LastOp.getValueType();
45091 unsigned NumConcats = 8 / SrcVT.getVectorNumElements();
45093 Ops.resize(NumConcats, DAG.getConstant(0, dl, SrcVT));
45100 unsigned NumConcats = 8 / SrcVT.getVectorNumElements();
45101 SmallVector<SDValue, 4> Ops(NumConcats, DAG.getUNDEF(SrcVT));
45111 SrcVT.isScalarInteger() && TLI.isTypeLegal(VT)) {
45123 if (VT == MVT::i8 && SrcVT == MVT::v8i1 && Subtarget.hasAVX512() &&
45134 VT.isFloatingPoint() != SrcVT.isFloatingPoint() && VT.isVector()) {
45136 unsigned SrcVTSize = SrcVT.getScalarSizeInBits();
45144 LoadVT = MVT::getVectorVT(LoadVT, SrcVT.getVectorNumElements());
45179 (SrcVT == MVT::v2i32 || SrcVT == MVT::v4i16 || SrcVT == MVT::v8i8) &&
45180 N0.getOperand(0).getValueType() == SrcVT.getScalarType()) {
45182 for (unsigned i = 1, e = SrcVT.getVectorNumElements(); i != e; ++i) {
45200 (SrcVT == MVT::v2f32 || SrcVT == MVT::v2i32 || SrcVT == MVT::v4i16 ||
45201 SrcVT == MVT::v8i8))
45215 if (SrcVT == MVT::v2i32 && N0.getOpcode() == ISD::FP_TO_SINT) {
45227 SrcVT.isVector() && SrcVT.getVectorElementType() == MVT::i1 &&
45232 if (Subtarget.hasAVX512() && SrcVT.isScalarInteger() && VT.isVector() &&
45245 if (Subtarget.hasAVX512() && SrcVT.isScalarInteger() &&
45482 EVT SrcVT = Src.getValueType();
45483 EVT SrcSVT = SrcVT.getScalarType();
45484 if (SrcSVT != ExtractVT || (SrcVT.getSizeInBits() % 128) != 0)
45491 while (SrcVT.getSizeInBits() > 128) {
45494 SrcVT = Lo.getValueType();
45495 MinPos = DAG.getNode(BinOp, DL, SrcVT, Lo, Hi);
45497 assert(((SrcVT == MVT::v8i16 && ExtractVT == MVT::i16) ||
45498 (SrcVT == MVT::v16i8 && ExtractVT == MVT::i8)) &&
45506 Mask = DAG.getConstant(APInt::getSignedMaxValue(MaskEltsBits), DL, SrcVT);
45508 Mask = DAG.getConstant(APInt::getSignedMinValue(MaskEltsBits), DL, SrcVT);
45510 Mask = DAG.getAllOnesConstant(DL, SrcVT);
45513 MinPos = DAG.getNode(ISD::XOR, DL, SrcVT, Mask, MinPos);
45521 SrcVT, DL, MinPos, DAG.getConstant(0, DL, MVT::v16i8),
45523 MinPos = DAG.getNode(ISD::UMIN, DL, SrcVT, MinPos, Upper);
45529 MinPos = DAG.getBitcast(SrcVT, MinPos);
45532 MinPos = DAG.getNode(ISD::XOR, DL, SrcVT, Mask, MinPos);
45880 EVT SrcVT = Src.getValueType();
45881 EVT SrcSVT = SrcVT.getVectorElementType();
45883 unsigned NumSrcElts = SrcVT.getVectorNumElements();
45905 SrcOp = DAG.getZExtOrTrunc(SrcOp, dl, SrcVT.getScalarType());
45938 unsigned Offset = IdxC.getZExtValue() * SrcVT.getScalarSizeInBits();
45945 Scl = DAG.getZExtOrTrunc(Scl, dl, SrcVT.getScalarType());
45955 (SrcVT.getSizeInBits() % 128) == 0) {
46001 if (llvm::any_of(Ops, [SrcVT](SDValue Op) {
46002 return SrcVT.getSizeInBits() != Op.getValueSizeInBits();
46035 ExtractVT = SrcVT;
46038 if ((Mask.size() % NumSrcElts) != 0 || SrcVT.isFloatingPoint())
46046 assert(SrcVT.getSizeInBits() == ExtractVT.getSizeInBits() &&
46063 if (N->getOpcode() == ISD::EXTRACT_VECTOR_ELT && ExtractVT == SrcVT)
46065 N, SrcVT, peekThroughBitcasts(SrcOp), ExtractIdx, dl, DAG, DCI))
46380 EVT SrcVT = InputVector.getValueType();
46384 unsigned NumSrcElts = SrcVT.getVectorNumElements();
46395 unsigned VecEltBitWidth = SrcVT.getScalarSizeInBits();
46429 assert(SrcVT == InputVector.getOperand(0).getValueType() &&
46432 Scl = DAG.getNode(ISD::TRUNCATE, dl, SrcVT.getScalarType(), Scl);
46443 if (VT == MVT::i64 && SrcVT == MVT::v1i64 &&
46450 if (VT == MVT::i32 && SrcVT == MVT::v2i32 &&
46497 if (SrcVT.getScalarType() == MVT::i1) {
47336 EVT SrcVT = SelectableLHS ? LHS.getOperand(0).getValueType()
47338 EVT SrcCondVT = SrcVT.changeVectorElementType(MVT::i1);
47339 LHS = insertSubVector(DAG.getUNDEF(SrcVT), LHS, 0, DAG, DL,
47341 RHS = insertSubVector(DAG.getUNDEF(SrcVT), RHS, 0, DAG, DL,
47346 SDValue Res = DAG.getSelect(DL, SrcVT, Cond, LHS, RHS);
47777 MVT SrcVT = Src.getSimpleValueType();
47778 APInt BitMask = APInt::getSignMask(SrcVT.getScalarSizeInBits());
47789 SDValue Mask = DAG.getNode(ISD::AND, DL, SrcVT, Src,
47790 DAG.getConstant(BitMask, DL, SrcVT));
47793 DAG.getConstant(0, DL, SrcVT));
49534 EVT SrcVT = N0.getValueType();
49546 if (VT.is128BitVector() && SrcVT.getScalarSizeInBits() <= 32) {
49561 Lo = DAG.getBitcast(SrcVT, Lo);
49562 Hi = DAG.getBitcast(SrcVT, Hi);
49573 if (VT.is128BitVector() && SrcVT.getScalarSizeInBits() <= 32) {
49618 LHS = DAG.getBitcast(SrcVT, LHS);
49619 RHS = DAG.getBitcast(SrcVT, RHS ? RHS : LHS);
49657 SDValue Res = DAG.getNode(Opcode, DL, VT, DAG.getBitcast(SrcVT, Op00),
49658 DAG.getBitcast(SrcVT, Op01));
49755 MVT SrcVT = N0.getSimpleValueType();
49757 DAG.getNode(X86ISD::PACKSS, DL, VT, DAG.getBitcast(SrcVT, Not0),
49758 DAG.getBitcast(SrcVT, Not1));
50569 MVT SrcVT = N0.getOperand(0).getSimpleValueType();
50570 unsigned NumSrcBits = SrcVT.getScalarSizeInBits();
50579 SDValue LHS = DAG.getNode(Opc, DL, SrcVT, N0.getOperand(0), N1.getOperand(0));
50580 SDValue RHS = DAG.getNode(Opc, DL, SrcVT, N0.getOperand(1), N1.getOperand(1));
50810 EVT SrcVT = Src.getValueType();
50813 if (!SrcVT.isVector() || SrcVT.getVectorElementType() != MVT::i1 ||
50814 !TLI.isTypeLegal(SrcVT))
50854 SDValue Concat = DAG.getNode(ISD::CONCAT_VECTORS, dl, SrcVT,
50856 EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), SrcVT.getSizeInBits());
52977 MVT SrcVT = Src.getSimpleValueType();
52978 unsigned NumSrcElts = SrcVT.getVectorNumElements();
52982 TLI.isTruncStoreLegal(SrcVT, TruncVT)) {
53553 EVT SrcVT = Src.getValueType();
53557 SrcVT != MVT::v2f32)
53562 DAG.getUNDEF(SrcVT)));
53579 EVT SrcVT = Src.getValueType();
53622 if (SrcVT.getScalarType() == MVT::i64 &&
53624 !TLI.isOperationLegal(SrcOpcode, SrcVT))
54389 EVT SrcVT = Src.getValueType();
54390 if (SrcVT.isVector() && SrcVT.getScalarType() == MVT::i1 &&
54392 DAG.getTargetLoweringInfo().isTypeLegal(SrcVT)) &&
54394 unsigned NumElts = SrcVT.getVectorNumElements();
54399 DAG.getVectorShuffle(SrcVT, SDLoc(N), Src, Src, ReverseMask);
54748 EVT SrcVT = Src.getValueType();
54749 if (Src.getOpcode() == ISD::SETCC && SrcVT.getScalarType() == MVT::i1 &&
54750 TLI.isTypeLegal(SrcVT) && N0.hasOneUse() && Src.hasOneUse())
54751 return DAG.getSelect(DL, VT, DAG.getNOT(DL, Src, SrcVT), N1,
55551 EVT SrcVT = LHS.getOperand(0).getValueType();
55552 APInt UpperBits = APInt::getBitsSetFrom(SrcVT.getScalarSizeInBits(),
55558 DAG.getZExtOrTrunc(RHS, DL, SrcVT), CC);
55779 MVT SrcVT = Src.getSimpleValueType();
55782 unsigned NumElts = SrcVT.getVectorNumElements();
55783 unsigned NumBitsPerElt = SrcVT.getScalarSizeInBits();
55801 unsigned EltWidth = SrcVT.getScalarSizeInBits();
55811 NotSrc = DAG.getBitcast(SrcVT, NotSrc);
55841 MVT ShiftVT = SrcVT;
55854 ShiftLHS = DAG.getBitcast(SrcVT, ShiftLHS);
55855 ShiftRHS = DAG.getBitcast(SrcVT, ShiftRHS);
55856 SDValue Res = DAG.getNode(ISD::XOR, DL, SrcVT, ShiftLHS, ShiftRHS);
55857 return DAG.getNode(X86ISD::MOVMSK, DL, VT, DAG.getNOT(DL, Res, SrcVT));
55875 SDValue NewSrc = DAG.getBitcast(SrcVT, SrcBC.getOperand(0));
56165 EVT SrcVT = ExtElt.getValueType();
56167 unsigned SrcWidth = SrcVT.getSizeInBits();
56375 EVT SrcVT = N->getOperand(0).getValueType();
56379 if (SrcVT == MVT::v2f32 && DstVT == MVT::v2i64) {
56380 SDValue V2F32Value = DAG.getUNDEF(SrcVT);
56532 EVT SrcVT = Src.getValueType();
56533 if (SrcVT.getScalarSizeInBits() >= 8 && TLI.isTypeLegal(SrcVT))
56535 DAG.getConstant(0, dl, SrcVT));
57649 MVT SrcVT = Op0.getOperand(0).getSimpleValueType();
57650 SrcVT = MVT::getVectorVT(SrcVT.getScalarType(),
57651 NumOps * SrcVT.getVectorNumElements());
57653 ConcatSubOperand(SrcVT, Ops, 0),
57654 ConcatSubOperand(SrcVT, Ops, 1));
57758 EVT SrcVT = Ops[0].getOperand(0).getValueType();
57759 if (SrcVT.is256BitVector() && SrcVT.isSimple() &&
57760 SrcVT == Ops[1].getOperand(0).getValueType() &&
57763 (SrcVT.getScalarSizeInBits() > 16 || Subtarget.useBWIRegs())) {
57764 EVT NewSrcVT = SrcVT.getDoubleNumVectorElementsVT(Ctx);
57778 EVT SrcVT = Ops[0].getOperand(0).getValueType();
57779 if (SrcVT.isSimple() && SrcVT.is128BitVector() &&
57780 SrcVT == Ops[1].getOperand(0).getValueType()) {
57781 EVT NewSrcVT = SrcVT.getDoubleNumVectorElementsVT(Ctx);
57962 MVT SrcVT = Op0.getOperand(0).getSimpleValueType();
57963 SrcVT = MVT::getVectorVT(SrcVT.getScalarType(),
57964 NumOps * SrcVT.getVectorNumElements());
57966 ConcatSubOperand(SrcVT, Ops, 0),
57967 ConcatSubOperand(SrcVT, Ops, 1));
58114 EVT SrcVT = N->getOperand(0).getValueType();
58120 unsigned SubSizeInBits = SrcVT.getSizeInBits();
58137 if (Subtarget.hasAVX() && TLI.isTypeLegal(VT) && TLI.isTypeLegal(SrcVT)) {
58958 EVT SrcVT = Src.getValueType();
58959 if (TLI.isTypeLegal(SrcVT) && Amt < SrcVT.getVectorNumElements()) {
58960 SDValue Shift = DAG.getNode(X86ISD::KSHIFTR, DL, SrcVT, Src,
59006 EVT SrcVT = Src.getValueType();
59009 if (SrcVT.getScalarType() == MVT::bf16) {
59014 if (!SrcVT.isVector())
59024 EVT NVT = SrcVT.changeVectorElementType(MVT::i32);
59025 Src = DAG.getBitcast(SrcVT.changeTypeToInteger(), Src);
59037 if (!SrcVT.isVector() || SrcVT.getVectorElementType() != MVT::f16)
59049 EVT IntVT = SrcVT.changeVectorElementTypeToInteger();
59141 EVT SrcVT = Src.getValueType();
59144 SrcVT.getVectorElementType() != MVT::f32)
59195 DAG.getConstantFP(0.0, dl, SrcVT));