Lines Matching defs:SrcVT
3195 bool X86TargetLowering::isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
3203 return Index == 0 || ((ResVT.getSizeInBits() == SrcVT.getSizeInBits()*2) &&
5002 EVT SrcVT = Op.getOperand(0).getValueType();
5003 unsigned NumSrcElts = SrcVT.getVectorNumElements();
6055 EVT SrcVT = SrcVec.getValueType();
6056 if (!SrcVT.getScalarType().isByteSized())
6059 unsigned SrcByte = SrcIdx * (SrcVT.getScalarSizeInBits() / 8);
6062 std::min<unsigned>(MinBitsPerElt, SrcVT.getScalarSizeInBits());
6153 EVT SrcVT = Src.getValueType();
6155 if (!SrcVT.isSimple() || (SrcVT.getSizeInBits() % 128) != 0 ||
6156 (SrcVT.getScalarSizeInBits() % 8) != 0)
6158 unsigned NumSrcElts = SrcVT.getVectorNumElements();
6159 unsigned NumBitsPerSrcElt = SrcVT.getScalarSizeInBits();
6231 EVT SrcVT = Src.getValueType();
6232 unsigned NumBitsPerSrcElt = SrcVT.getScalarSizeInBits();
6235 if (!SrcVT.isSimple() || (SrcVT.getSizeInBits() % 128) != 0 ||
6241 DemandedElts.zextOrTrunc(SrcVT.getVectorNumElements());
6257 EVT SrcVT = Src.getValueType();
6260 if (!SrcVT.isSimple() || (SrcVT.getSizeInBits() % 128) != 0 ||
6261 (SrcVT.getScalarSizeInBits() % 8) != 0)
6266 DecodeZeroExtendMask(SrcVT.getScalarSizeInBits(), NumBitsPerElt, NumElts,
6470 EVT SrcVT = Src.getValueType();
6471 if (SrcVT.isVector() && SrcVT.getVectorNumElements() == NumElems)
8508 EVT SrcVT = Idx.getValueType();
8509 unsigned NumDstBits = SrcVT.getScalarSizeInBits() / Scale;
8523 Idx = DAG.getNode(ISD::MUL, SDLoc(Idx), SrcVT, Idx,
8524 DAG.getConstant(IndexScale, SDLoc(Idx), SrcVT));
8525 Idx = DAG.getNode(ISD::ADD, SDLoc(Idx), SrcVT, Idx,
8526 DAG.getConstant(IndexOffset, SDLoc(Idx), SrcVT));
10059 static bool matchShuffleAsVTRUNC(MVT &SrcVT, MVT &DstVT, MVT VT,
10079 SrcVT = MVT::getIntegerVT(EltSizeInBits * Scale);
10080 SrcVT = MVT::getVectorVT(SrcVT, NumSrcElts);
10100 MVT SrcVT = Src.getSimpleValueType();
10103 unsigned NumSrcElts = SrcVT.getVectorNumElements();
10106 if (!DAG.getTargetLoweringInfo().isTypeLegal(SrcVT))
10128 if (!Subtarget.hasVLX() && !SrcVT.is512BitVector()) {
10186 MVT SrcVT = MVT::getVectorVT(SrcSVT, NumSrcElts);
10187 Src = DAG.getBitcast(SrcVT, Src);
10269 MVT SrcVT = MVT::getVectorVT(SrcSVT, NumSrcElts);
10270 Src = DAG.getBitcast(SrcVT, Src);
10276 X86ISD::VSRLI, DL, SrcVT, Src,
10362 static bool matchShuffleWithPACK(MVT VT, MVT &SrcVT, SDValue &V1, SDValue &V2,
10390 SrcVT = PackVT;
10403 SrcVT = PackVT;
10466 MVT SrcVT = MVT::getVectorVT(SrcSVT, NumSrcElts);
10468 Res = DAG.getNode(PackOpcode, DL, DstVT, DAG.getBitcast(SrcVT, V1),
10469 DAG.getBitcast(SrcVT, V2));
19030 MVT SrcVT = Src.getSimpleValueType();
19033 if (!Subtarget.hasDQI() || SrcVT != MVT::i64 || Subtarget.is64Bit() ||
19070 MVT SrcVT = Src.getSimpleValueType();
19073 if (SrcVT != MVT::i64 || Subtarget.is64Bit() || VT != MVT::f16)
19174 MVT SrcVT = X.getSimpleValueType();
19175 if (SrcVT != MVT::f32 && SrcVT != MVT::f64)
19184 unsigned SrcSize = SrcVT.getSizeInBits();
19187 MVT VecSrcVT = MVT::getVectorVT(SrcVT, 128 / SrcSize);
19344 MVT SrcVT = Src.getSimpleValueType();
19350 else if (isLegalConversion(SrcVT, true, Subtarget))
19353 if (Subtarget.isTargetWin64() && SrcVT == MVT::i128)
19362 if (SrcVT.isVector()) {
19363 if (SrcVT == MVT::v2i32 && VT == MVT::v2f64) {
19370 DAG.getUNDEF(SrcVT))});
19373 DAG.getUNDEF(SrcVT)));
19375 if (SrcVT == MVT::v2i64 || SrcVT == MVT::v4i64)
19381 assert(SrcVT <= MVT::i64 && SrcVT >= MVT::i16 &&
19388 if (SrcVT == MVT::i32 && UseSSEReg)
19390 if (SrcVT == MVT::i64 && UseSSEReg && Subtarget.is64Bit())
19399 if (SrcVT == MVT::i16 && (UseSSEReg || VT == MVT::f128)) {
19412 if (SrcVT == MVT::i64 && Subtarget.hasSSE2() && !Subtarget.is64Bit())
19418 unsigned Size = SrcVT.getStoreSize();
19428 BuildFILD(VT, SrcVT, dl, Chain, StackSlot, MPI, Alignment, DAG);
19437 EVT DstVT, EVT SrcVT, const SDLoc &DL, SDValue Chain, SDValue Pointer,
19449 DAG.getMemIntrinsicNode(X86ISD::FILD, DL, Tys, FILDOps, SrcVT, PtrInfo,
19821 MVT SrcVT = N0.getSimpleValueType();
19823 switch (SrcVT.SimpleTy) {
19844 MVT SrcVT = Src.getSimpleValueType();
19854 else if (isLegalConversion(SrcVT, false, Subtarget))
19860 if (Subtarget.isTargetWin64() && SrcVT == MVT::i128)
19867 (SrcVT == MVT::i32 || (SrcVT == MVT::i64 && Subtarget.is64Bit()))) {
19874 if (SrcVT == MVT::i32 && Subtarget.is64Bit()) {
19889 if (SrcVT == MVT::i64 && DstVT == MVT::f64 && Subtarget.hasSSE2() &&
19894 if (SrcVT == MVT::i32 && Subtarget.hasSSE2() && DstVT != MVT::f80 &&
19897 if (Subtarget.is64Bit() && SrcVT == MVT::i64 &&
19907 if (SrcVT == MVT::i32) {
19921 assert(SrcVT == MVT::i64 && "Unexpected type in UINT_TO_FP");
20311 EVT SrcVT = In.getValueType();
20314 if (SrcVT == DstVT)
20317 unsigned NumElems = SrcVT.getVectorNumElements();
20322 unsigned SrcSizeInBits = SrcVT.getSizeInBits();
20327 EVT PackedSVT = EVT::getIntegerVT(Ctx, SrcVT.getScalarSizeInBits() / 2);
20333 if (SrcVT.getScalarSizeInBits() > 16 &&
20370 if (SrcVT.is256BitVector() && DstVT.is128BitVector()) {
20379 if (SrcVT.is512BitVector() && Subtarget.hasInt256()) {
20433 EVT SrcVT = In.getValueType();
20434 In = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, SrcVT, In,
20450 EVT SrcVT = In.getValueType();
20452 EVT SrcSVT = SrcVT.getVectorElementType();
20467 if ((DstSVT == MVT::i32 && SrcVT.getSizeInBits() <= 128) ||
20468 (DstSVT == MVT::i16 && SrcVT.getSizeInBits() <= (64 * NumStages)) ||
20469 (DstVT == MVT::v2i8 && SrcVT == MVT::v2i64 && Subtarget.hasSSSE3()))
20474 if (SrcVT == MVT::v4i64 && DstVT == MVT::v4i32 &&
20522 return DAG.getNode(ISD::SRA, DL, SrcVT, In->ops());
20536 MVT SrcVT = In.getSimpleValueType();
20538 MVT SrcSVT = SrcVT.getVectorElementType();
20569 MVT SrcVT = In.getSimpleValueType();
20571 MVT SrcSVT = SrcVT.getVectorElementType();
20823 MVT SrcVT = Src.getSimpleValueType();
20832 DAG.getNode(ISD::FSUB, dl, SrcVT, Src,
20833 DAG.getConstantFP(2147483648.0f, dl, SrcVT)));
20863 MVT SrcVT = Src.getSimpleValueType();
20867 if (isSoftF16(SrcVT, Subtarget)) {
20875 } else if (isTypeLegal(SrcVT) && isLegalConversion(VT, IsSigned, Subtarget)) {
20880 if (VT == MVT::v2i1 && SrcVT == MVT::v2f64) {
20918 if (Subtarget.hasFP16() && SrcVT.getVectorElementType() == MVT::f16) {
20927 if (SrcVT != MVT::v8f16) {
20929 IsStrict ? DAG.getConstantFP(0.0, dl, SrcVT) : DAG.getUNDEF(SrcVT);
20930 SmallVector<SDValue, 4> Ops(SrcVT == MVT::v2f16 ? 4 : 2, Tmp);
20962 assert((SrcVT.getVectorElementType() == MVT::f32 ||
20963 SrcVT.getVectorElementType() == MVT::f64) &&
20985 if (VT == MVT::v8i32 && SrcVT == MVT::v8f64) {
20993 (SrcVT == MVT::v4f64 || SrcVT == MVT::v4f32 || SrcVT == MVT::v8f32) &&
20997 MVT WideVT = SrcVT == MVT::v4f64 ? MVT::v8f64 : MVT::v16f32;
20998 MVT ResVT = SrcVT == MVT::v4f64 ? MVT::v8i32 : MVT::v16i32;
21025 (SrcVT == MVT::v2f64 || SrcVT == MVT::v4f64 || SrcVT == MVT::v4f32) &&
21028 MVT WideVT = SrcVT == MVT::v4f32 ? MVT::v8f32 : MVT::v8f64;
21053 if (VT == MVT::v2i64 && SrcVT == MVT::v2f32) {
21085 if ((VT == MVT::v4i32 && SrcVT == MVT::v4f32) ||
21086 (VT == MVT::v4i32 && SrcVT == MVT::v4f64) ||
21087 (VT == MVT::v8i32 && SrcVT == MVT::v8f32)) {
21097 bool UseSSEReg = isScalarFPTypeInSSEReg(SrcVT);
21110 SDValue FloatOffset = DAG.getNode(ISD::UINT_TO_FP, dl, SrcVT,
21112 MVT SrcVecVT = MVT::getVectorVT(SrcVT, 128 / SrcVT.getScalarSizeInBits());
21123 DAG.getNode(ISD::FSUB, dl, SrcVT, Src, FloatOffset)));
21169 if (VT == MVT::i16 && (UseSSEReg || SrcVT == MVT::f128)) {
21189 if (SrcVT == MVT::f128) {
21192 LC = RTLIB::getFPTOSINT(SrcVT, VT);
21194 LC = RTLIB::getFPTOUINT(SrcVT, VT);
21220 MVT SrcVT = Src.getSimpleValueType();
21222 if (SrcVT.isVector())
21225 if (SrcVT == MVT::f16)
21229 if (isScalarFPTypeInSSEReg(SrcVT))
21239 EVT SrcVT = Src.getValueType();
21241 if (SrcVT != MVT::f32 && SrcVT != MVT::f64 && SrcVT != MVT::f80) {
21250 bool UseSSE = isScalarFPTypeInSSEReg(SrcVT);
21254 EVT OtherVT = UseSSE ? SrcVT : DstVT;
21266 Src = DAG.getMemIntrinsicNode(X86ISD::FLD, DL, Tys, Ops, SrcVT, MPI,
21290 // There are three types involved here: SrcVT is the source floating point
21294 EVT SrcVT = Src.getValueType();
21300 if (!isScalarFPTypeInSSEReg(SrcVT) || isSoftF16(SrcVT, Subtarget))
21339 APFloat MinFloat(DAG.EVTToAPFloatSemantics(SrcVT));
21340 APFloat MaxFloat(DAG.EVTToAPFloatSemantics(SrcVT));
21349 SDValue MinFloatNode = DAG.getConstantFP(MinFloat, dl, SrcVT);
21350 SDValue MaxFloatNode = DAG.getConstantFP(MaxFloat, dl, SrcVT);
21358 X86ISD::FMAX, dl, SrcVT, MinFloatNode, Src);
21361 X86ISD::FMIN, dl, SrcVT, MaxFloatNode, MinClamped);
21372 X86ISD::FMAX, dl, SrcVT, Src, MinFloatNode);
21375 X86ISD::FMINC, dl, SrcVT, MinClamped, MaxFloatNode);
22315 EVT SrcVT = Src.getValueType();
22316 SDValue MaskValue = DAG.getConstant(Mask, DL, SrcVT);
22317 return DAG.getNode(ISD::AND, DL, SrcVT, Src, MaskValue);
26110 MVT SrcVT = Src.getSimpleValueType();
26111 MVT MaskVT = MVT::getVectorVT(MVT::i1, SrcVT.getVectorNumElements());
26138 MVT SrcVT = Src.getSimpleValueType();
26139 MVT MaskVT = MVT::getVectorVT(MVT::i1, SrcVT.getVectorNumElements());
31143 MVT SrcVT = Src.getSimpleValueType();
31148 if (SrcVT == MVT::i64 && DstVT == MVT::v64i1) {
31160 if ((SrcVT == MVT::v16i1 || SrcVT == MVT::v32i1) && DstVT.isScalarInteger()) {
31162 MVT SExtVT = SrcVT == MVT::v16i1 ? MVT::v16i8 : MVT::v32i8;
31169 assert((SrcVT == MVT::v2i32 || SrcVT == MVT::v4i16 || SrcVT == MVT::v8i8 ||
31170 SrcVT == MVT::i64) && "Unexpected VT!");
31173 if (!(DstVT == MVT::f64 && SrcVT == MVT::i64) &&
31174 !(DstVT == MVT::x86mmx && SrcVT.isVector()))
31179 if (SrcVT.isVector()) {
31182 MVT NewVT = MVT::getVectorVT(SrcVT.getVectorElementType(),
31183 SrcVT.getVectorNumElements() * 2);
31185 DAG.getUNDEF(SrcVT));
31187 assert(SrcVT == MVT::i64 && !Subtarget.is64Bit() &&
32899 EVT SrcVT = Src.getValueType();
32902 if (isSoftF16(SrcVT, Subtarget)) {
32922 SrcVT.getVectorElementType() == MVT::f16) {
32926 if (SrcVT != MVT::v8f16) {
32928 IsStrict ? DAG.getConstantFP(0.0, dl, SrcVT) : DAG.getUNDEF(SrcVT);
32929 SmallVector<SDValue, 4> Ops(SrcVT == MVT::v2f16 ? 4 : 2, Tmp);
33081 (SrcVT == MVT::f32 || SrcVT == MVT::f64)) ||
33082 (Subtarget.hasFP16() && SrcVT == MVT::f16)) {
33087 std::max(NumElts, 128U / (unsigned)SrcVT.getSizeInBits());
33089 MVT VecInVT = MVT::getVectorVT(SrcVT.getSimpleVT(), SrcElts);
33172 EVT SrcVT = Src.getValueType();
33173 if (Subtarget.hasDQI() && Subtarget.hasVLX() && SrcVT == MVT::v2i64) {
33187 if (SrcVT == MVT::v2i64 && !IsSigned && Subtarget.is64Bit() &&
33189 SDValue Zero = DAG.getConstant(0, dl, SrcVT);
33190 SDValue One = DAG.getConstant(1, dl, SrcVT);
33191 SDValue Sign = DAG.getNode(ISD::OR, dl, SrcVT,
33192 DAG.getNode(ISD::SRL, dl, SrcVT, Src, One),
33193 DAG.getNode(ISD::AND, dl, SrcVT, Src, One));
33195 SDValue SignSrc = DAG.getSelect(dl, SrcVT, IsNeg, Sign, Src);
33228 if (SrcVT != MVT::v2i32)
33274 EVT SrcVT = Src.getValueType();
33284 if (SrcVT.getVectorElementType() != MVT::f32)
33532 EVT SrcVT = N->getOperand(0).getValueType();
33536 if (SrcVT == MVT::v64i1 && DstVT == MVT::i64 && Subtarget.hasBWI()) {
33547 if (DstVT.isVector() && SrcVT == MVT::x86mmx) {
34330 EVT SrcVT = ExtVal.getOperand(0).getValueType();
34333 if (SrcVT.getScalarType() == MVT::i1)
34362 bool X86TargetLowering::isNarrowingProfitable(EVT SrcVT, EVT DestVT) const {
34364 return !(SrcVT == MVT::i32 && DestVT == MVT::i16);
37234 EVT SrcVT = Src.getValueType();
37235 APInt DemandedElt = APInt::getOneBitSet(SrcVT.getVectorNumElements(),
37239 Known.Zero.setBitsFrom(SrcVT.getScalarSizeInBits());
37475 EVT SrcVT = Op.getOperand(0).getValueType();
37476 if (SrcVT.isVector()) {
37477 unsigned NumSrcElts = SrcVT.getVectorNumElements();
37490 EVT SrcVT = Op.getOperand(1).getValueType();
37491 if (SrcVT.isVector()) {
37492 unsigned NumSrcElts = SrcVT.getVectorNumElements();
37643 MVT SrcVT = Src.getSimpleValueType();
37644 unsigned NumSrcBits = SrcVT.getScalarSizeInBits();
37646 APInt DemandedSrc = DemandedElts.zextOrTrunc(SrcVT.getVectorNumElements());
37827 MVT &SrcVT, MVT &DstVT) {
37839 SrcVT = DstVT = MaskVT.changeVectorElementType(MVT::f16);
37841 SrcVT = DstVT = !Subtarget.hasSSE2() ? MVT::v4f32 : MaskVT;
37876 SrcVT = MVT::getVectorVT(ScalarTy, SrcSize / MaskEltSize);
37881 if (SrcVT.getVectorNumElements() != NumDstElts)
37898 SrcVT = DstVT = MaskVT.changeVectorElementType(MVT::f16);
37900 SrcVT = DstVT = !Subtarget.hasSSE2() ? MVT::v4f32 : MaskVT;
37910 SrcVT = DstVT = MVT::v2f64;
37915 SrcVT = DstVT = MVT::v4f32;
37920 SrcVT = DstVT = MVT::v4f32;
37929 SrcVT = DstVT = MVT::v4f64;
37935 SrcVT = DstVT = MVT::v8f32;
37941 SrcVT = DstVT = MVT::v8f32;
37952 SrcVT = DstVT = MVT::v8f64;
37959 SrcVT = DstVT = MVT::v16f32;
37966 SrcVT = DstVT = MVT::v16f32;
38130 unsigned &Shuffle, MVT &SrcVT, MVT &DstVT,
38142 SrcVT = DstVT = Subtarget.hasSSE2() ? MVT::v2f64 : MVT::v4f32;
38149 SrcVT = DstVT = Subtarget.hasSSE2() ? MVT::v2f64 : MVT::v4f32;
38156 SrcVT = DstVT = MVT::v2f64;
38162 SrcVT = DstVT = MVT::v4f32;
38169 SrcVT = DstVT = MVT::v8f16;
38178 if (matchShuffleWithPACK(MaskVT, SrcVT, V1, V2, Shuffle, Mask, DAG,
38193 SrcVT = MVT::v4i32;
38200 SrcVT = MVT::v8i16;
38207 SrcVT = MVT::v4i32;
38223 SrcVT = DstVT = MaskVT;
38225 SrcVT = DstVT = (32 == EltSizeInBits ? MVT::v8f32 : MVT::v4f64);
38268 SrcVT = DstVT = MaskVT.changeTypeToInteger();
38312 SrcVT = DstVT = MaskVT.changeTypeToInteger();
39404 MVT SrcVT = BC0.getOperand(0).getSimpleValueType();
39434 SDValue LHS = DAG.getNode(Opcode0, DL, SrcVT, M0, M1);
39435 SDValue RHS = DAG.getNode(Opcode0, DL, SrcVT, M2, M3);
39464 LHS = DAG.getBitcast(SrcVT, LHS);
39465 RHS = DAG.getBitcast(SrcVT, RHS ? RHS : LHS);
39541 SDValue Undef = DAG.getUNDEF(SrcVT);
39542 SDValue Zero = getZeroVector(SrcVT, Subtarget, DAG, DL);
39562 unsigned Idx0 = (M0 & 2) ? (SrcVT.getVectorNumElements() / 2) : 0;
39563 unsigned Idx1 = (M1 & 2) ? (SrcVT.getVectorNumElements() / 2) : 0;
40726 EVT SrcVT = Src.getValueType();
40744 DAG.getBitcast(SrcVT, Res));
40750 SrcVT.getScalarSizeInBits() == BCVT.getScalarSizeInBits() &&
40775 if (SrcVT.getSizeInBits() > 128)
40805 if (!SrcVT.isVector() && (Src.hasOneUse() || VT.isFloatingPoint()) &&
40820 SDValue Scl = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, SrcVT, BcastLd,
40829 if (SrcVT == MVT::i16 && Src.getOpcode() == ISD::TRUNCATE &&
40917 if ((SrcVT == MVT::v2f64 || SrcVT == MVT::v4f32 || SrcVT == MVT::v2i64 ||
40918 SrcVT == MVT::v4i32) &&
40926 X86ISD::VBROADCAST_LOAD, DL, Tys, Ops, SrcVT.getScalarType(),
41045 MVT SrcVT = N0.getOperand(0).getSimpleValueType();
41046 unsigned SrcBits = SrcVT.getScalarSizeInBits();
41049 unsigned NewSize = SrcVT.getVectorNumElements();
41053 VT, DAG.getNode(X86ISD::BLENDI, DL, SrcVT, N0.getOperand(0),
41139 EVT SrcVT = Src.getValueType();
41140 SDValue Res = DAG.getNode(X86ISD::VPERMI, DL, SrcVT, Src, N1);
41179 EVT SrcVT = LHS.getOperand(0).getValueType();
41180 if (RHS.isUndef() || SrcVT == RHS.getOperand(0).getValueType()) {
41181 return DAG.getBitcast(VT, DAG.getNode(X86ISD::VPERM2X128, DL, SrcVT,
41182 DAG.getBitcast(SrcVT, LHS),
41183 DAG.getBitcast(SrcVT, RHS),
42190 EVT SrcVT = Src.getValueType();
42192 APInt SrcElts = DemandedElts.zextOrTrunc(SrcVT.getVectorNumElements());
42274 MVT SrcVT = Src.getSimpleValueType();
42275 APInt DemandedSrc = DemandedElts.zextOrTrunc(SrcVT.getVectorNumElements());
42339 MVT SrcVT = Src.getSimpleValueType();
42340 if (!SrcVT.isVector())
42350 APInt SrcElts = APInt::getOneBitSet(SrcVT.getVectorNumElements(), 0);
42537 EVT SrcVT = SrcOp.getValueType();
42538 assert((!SrcVT.isVector() || SrcVT.getSizeInBits() == SizeInBits) &&
42540 Ops.push_back(SrcVT.isVector() ? extractSubVector(SrcOp, 0, TLO.DAG, DL,
42660 MVT SrcVT = Src.getSimpleValueType();
42663 APInt TruncMask = OriginalDemandedBits.zext(SrcVT.getScalarSizeInBits());
42664 APInt DemandedElts = OriginalDemandedElts.trunc(SrcVT.getVectorNumElements());
42975 MVT SrcVT = Src.getSimpleValueType();
42977 SrcVT.isVector() ? SrcVT.getVectorNumElements() : 1, 0);
42984 if ((BitWidth == 64) && SrcVT.isScalarInteger() && !Subtarget.hasAVX512() &&
43006 MVT SrcVT = Src.getSimpleValueType();
43007 unsigned SrcBits = SrcVT.getScalarSizeInBits();
43008 unsigned NumElts = SrcVT.getVectorNumElements();
43015 if (SrcVT.is256BitVector() &&
43407 EVT SrcVT = Src.getValueType();
43408 if (SrcVT != MVT::v4i1)
43473 EVT SrcVT = Src.getValueType();
43474 if (!SrcVT.isSimple() || SrcVT.getScalarType() != MVT::i1)
43543 switch (SrcVT.getSimpleVT().SimpleTy) {
43613 EVT::getIntegerVT(*DAG.getContext(), SrcVT.getVectorNumElements());
43620 EVT SrcVT = Op.getValueType();
43621 assert(SrcVT.getVectorElementType() == MVT::i1 &&
43626 APInt Imm(SrcVT.getVectorNumElements(), 0);
43650 EVT SrcVT = Op.getValueType();
43662 if (!(SrcVT.isVector() && SrcVT.getVectorElementType() == MVT::i1 &&
43665 SrcVT.isScalarInteger()))
43785 EVT SrcVT = Src.getValueType();
43786 if (SrcVT.isVector() || SrcVT.isFloatingPoint())
43866 EVT SrcVT = N0.getValueType();
43882 if ((VT == MVT::v4i1 || VT == MVT::v2i1) && SrcVT.isScalarInteger() &&
43892 if ((SrcVT == MVT::v4i1 || SrcVT == MVT::v2i1) && VT.isScalarInteger() &&
43904 SrcVT = LastOp.getValueType();
43905 unsigned NumConcats = 8 / SrcVT.getVectorNumElements();
43907 Ops.resize(NumConcats, DAG.getConstant(0, dl, SrcVT));
43914 unsigned NumConcats = 8 / SrcVT.getVectorNumElements();
43915 SmallVector<SDValue, 4> Ops(NumConcats, DAG.getUNDEF(SrcVT));
43925 SrcVT.isScalarInteger() && TLI.isTypeLegal(VT)) {
43937 if (VT == MVT::i8 && SrcVT == MVT::v8i1 && Subtarget.hasAVX512() &&
43948 VT.isFloatingPoint() != SrcVT.isFloatingPoint() && VT.isVector()) {
43950 unsigned SrcVTSize = SrcVT.getScalarSizeInBits();
43958 LoadVT = MVT::getVectorVT(LoadVT, SrcVT.getVectorNumElements());
43993 (SrcVT == MVT::v2i32 || SrcVT == MVT::v4i16 || SrcVT == MVT::v8i8) &&
43994 N0.getOperand(0).getValueType() == SrcVT.getScalarType()) {
43996 for (unsigned i = 1, e = SrcVT.getVectorNumElements(); i != e; ++i) {
44014 (SrcVT == MVT::v2f32 || SrcVT == MVT::v2i32 || SrcVT == MVT::v4i16 ||
44015 SrcVT == MVT::v8i8))
44029 if (SrcVT == MVT::v2i32 && N0.getOpcode() == ISD::FP_TO_SINT) {
44041 SrcVT.isVector() && SrcVT.getVectorElementType() == MVT::i1 &&
44046 if (Subtarget.hasAVX512() && SrcVT.isScalarInteger() && VT.isVector() &&
44059 if (Subtarget.hasAVX512() && SrcVT.isScalarInteger() &&
44296 EVT SrcVT = Src.getValueType();
44297 EVT SrcSVT = SrcVT.getScalarType();
44298 if (SrcSVT != ExtractVT || (SrcVT.getSizeInBits() % 128) != 0)
44305 while (SrcVT.getSizeInBits() > 128) {
44308 SrcVT = Lo.getValueType();
44309 MinPos = DAG.getNode(BinOp, DL, SrcVT, Lo, Hi);
44311 assert(((SrcVT == MVT::v8i16 && ExtractVT == MVT::i16) ||
44312 (SrcVT == MVT::v16i8 && ExtractVT == MVT::i8)) &&
44320 Mask = DAG.getConstant(APInt::getSignedMaxValue(MaskEltsBits), DL, SrcVT);
44322 Mask = DAG.getConstant(APInt::getSignedMinValue(MaskEltsBits), DL, SrcVT);
44324 Mask = DAG.getAllOnesConstant(DL, SrcVT);
44327 MinPos = DAG.getNode(ISD::XOR, DL, SrcVT, Mask, MinPos);
44335 SrcVT, DL, MinPos, DAG.getConstant(0, DL, MVT::v16i8),
44337 MinPos = DAG.getNode(ISD::UMIN, DL, SrcVT, MinPos, Upper);
44343 MinPos = DAG.getBitcast(SrcVT, MinPos);
44346 MinPos = DAG.getNode(ISD::XOR, DL, SrcVT, Mask, MinPos);
44694 EVT SrcVT = Src.getValueType();
44695 EVT SrcSVT = SrcVT.getVectorElementType();
44697 unsigned NumSrcElts = SrcVT.getVectorNumElements();
44719 SrcOp = DAG.getZExtOrTrunc(SrcOp, dl, SrcVT.getScalarType());
44752 unsigned Offset = IdxC.getZExtValue() * SrcVT.getScalarSizeInBits();
44759 Scl = DAG.getZExtOrTrunc(Scl, dl, SrcVT.getScalarType());
44769 (SrcVT.getSizeInBits() % 128) == 0) {
44815 if (llvm::any_of(Ops, [SrcVT](SDValue Op) {
44816 return SrcVT.getSizeInBits() != Op.getValueSizeInBits();
44849 ExtractVT = SrcVT;
44852 if ((Mask.size() % NumSrcElts) != 0 || SrcVT.isFloatingPoint())
44860 assert(SrcVT.getSizeInBits() == ExtractVT.getSizeInBits() &&
44877 if (N->getOpcode() == ISD::EXTRACT_VECTOR_ELT && ExtractVT == SrcVT)
44879 N, SrcVT, peekThroughBitcasts(SrcOp), ExtractIdx, dl, DAG, DCI))
45191 EVT SrcVT = InputVector.getValueType();
45195 unsigned NumSrcElts = SrcVT.getVectorNumElements();
45206 unsigned VecEltBitWidth = SrcVT.getScalarSizeInBits();
45239 assert(SrcVT == InputVector.getOperand(0).getValueType() &&
45242 Scl = DAG.getNode(ISD::TRUNCATE, dl, SrcVT.getScalarType(), Scl);
45253 if (VT == MVT::i64 && SrcVT == MVT::v1i64 &&
45260 if (VT == MVT::i32 && SrcVT == MVT::v2i32 &&
45307 if (SrcVT.getScalarType() == MVT::i1) {
46137 EVT SrcVT = SelectableLHS ? LHS.getOperand(0).getValueType()
46139 EVT SrcCondVT = SrcVT.changeVectorElementType(MVT::i1);
46140 LHS = insertSubVector(DAG.getUNDEF(SrcVT), LHS, 0, DAG, DL,
46142 RHS = insertSubVector(DAG.getUNDEF(SrcVT), RHS, 0, DAG, DL,
46147 SDValue Res = DAG.getSelect(DL, SrcVT, Cond, LHS, RHS);
46565 MVT SrcVT = Src.getSimpleValueType();
46566 APInt BitMask = APInt::getSignMask(SrcVT.getScalarSizeInBits());
46577 SDValue Mask = DAG.getNode(ISD::AND, DL, SrcVT, Src,
46578 DAG.getConstant(BitMask, DL, SrcVT));
46581 DAG.getConstant(0, DL, SrcVT));
48322 EVT SrcVT = N0.getValueType();
48334 if (VT.is128BitVector() && SrcVT.getScalarSizeInBits() <= 32) {
48349 Lo = DAG.getBitcast(SrcVT, Lo);
48350 Hi = DAG.getBitcast(SrcVT, Hi);
48361 if (VT.is128BitVector() && SrcVT.getScalarSizeInBits() <= 32) {
48406 LHS = DAG.getBitcast(SrcVT, LHS);
48407 RHS = DAG.getBitcast(SrcVT, RHS ? RHS : LHS);
48445 SDValue Res = DAG.getNode(Opcode, DL, VT, DAG.getBitcast(SrcVT, Op00),
48446 DAG.getBitcast(SrcVT, Op01));
48543 MVT SrcVT = N0.getSimpleValueType();
48545 DAG.getNode(X86ISD::PACKSS, DL, VT, DAG.getBitcast(SrcVT, Not0),
48546 DAG.getBitcast(SrcVT, Not1));
49369 MVT SrcVT = N0.getOperand(0).getSimpleValueType();
49370 unsigned NumSrcBits = SrcVT.getScalarSizeInBits();
49380 SDValue LHS = DAG.getNode(Opc, DL, SrcVT, N0.getOperand(0), N1.getOperand(0));
49381 SDValue RHS = DAG.getNode(Opc, DL, SrcVT, N0.getOperand(1), N1.getOperand(1));
49595 EVT SrcVT = Src.getValueType();
49598 if (!SrcVT.isVector() || SrcVT.getVectorElementType() != MVT::i1 ||
49599 !TLI.isTypeLegal(SrcVT))
49639 SDValue Concat = DAG.getNode(ISD::CONCAT_VECTORS, dl, SrcVT,
49641 EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), SrcVT.getSizeInBits());
51762 MVT SrcVT = Src.getSimpleValueType();
51763 unsigned NumSrcElts = SrcVT.getVectorNumElements();
51767 TLI.isTruncStoreLegal(SrcVT, TruncVT)) {
52300 EVT SrcVT = Src.getValueType();
52304 SrcVT != MVT::v2f32)
52309 DAG.getUNDEF(SrcVT)));
52326 EVT SrcVT = Src.getValueType();
52369 if (SrcVT.getScalarType() == MVT::i64 &&
52371 !TLI.isOperationLegal(SrcOpcode, SrcVT))
53140 EVT SrcVT = Src.getValueType();
53141 if (SrcVT.isVector() && SrcVT.getScalarType() == MVT::i1 &&
53143 DAG.getTargetLoweringInfo().isTypeLegal(SrcVT)) &&
53145 unsigned NumElts = SrcVT.getVectorNumElements();
53150 DAG.getVectorShuffle(SrcVT, SDLoc(N), Src, Src, ReverseMask);
54269 EVT SrcVT = LHS.getOperand(0).getValueType();
54270 APInt UpperBits = APInt::getBitsSetFrom(SrcVT.getScalarSizeInBits(),
54276 DAG.getZExtOrTrunc(RHS, DL, SrcVT), CC);
54497 MVT SrcVT = Src.getSimpleValueType();
54500 unsigned NumElts = SrcVT.getVectorNumElements();
54501 unsigned NumBitsPerElt = SrcVT.getScalarSizeInBits();
54519 unsigned EltWidth = SrcVT.getScalarSizeInBits();
54529 NotSrc = DAG.getBitcast(SrcVT, NotSrc);
54559 MVT ShiftVT = SrcVT;
54572 ShiftLHS = DAG.getBitcast(SrcVT, ShiftLHS);
54573 ShiftRHS = DAG.getBitcast(SrcVT, ShiftRHS);
54574 SDValue Res = DAG.getNode(ISD::XOR, DL, SrcVT, ShiftLHS, ShiftRHS);
54575 return DAG.getNode(X86ISD::MOVMSK, DL, VT, DAG.getNOT(DL, Res, SrcVT));
54593 SDValue NewSrc = DAG.getBitcast(SrcVT, SrcBC.getOperand(0));
54883 EVT SrcVT = ExtElt.getValueType();
54885 unsigned SrcWidth = SrcVT.getSizeInBits();
55223 EVT SrcVT = Src.getValueType();
55224 if (SrcVT.getScalarSizeInBits() >= 8 && TLI.isTypeLegal(SrcVT))
55226 DAG.getConstant(0, dl, SrcVT));
56300 MVT SrcVT = Op0.getOperand(0).getSimpleValueType();
56301 SrcVT = MVT::getVectorVT(SrcVT.getScalarType(),
56302 NumOps * SrcVT.getVectorNumElements());
56304 ConcatSubOperand(SrcVT, Ops, 0),
56305 ConcatSubOperand(SrcVT, Ops, 1));
56405 EVT SrcVT = Ops[0].getOperand(0).getValueType();
56406 if (SrcVT.is256BitVector() && SrcVT.isSimple() &&
56407 SrcVT == Ops[1].getOperand(0).getValueType() &&
56410 (SrcVT.getScalarSizeInBits() > 16 || Subtarget.useBWIRegs())) {
56411 EVT NewSrcVT = SrcVT.getDoubleNumVectorElementsVT(Ctx);
56592 MVT SrcVT = Op0.getOperand(0).getSimpleValueType();
56593 SrcVT = MVT::getVectorVT(SrcVT.getScalarType(),
56594 NumOps * SrcVT.getVectorNumElements());
56596 ConcatSubOperand(SrcVT, Ops, 0),
56597 ConcatSubOperand(SrcVT, Ops, 1));
56744 EVT SrcVT = N->getOperand(0).getValueType();
56750 unsigned SubSizeInBits = SrcVT.getSizeInBits();
56767 if (Subtarget.hasAVX() && TLI.isTypeLegal(VT) && TLI.isTypeLegal(SrcVT)) {
57496 EVT SrcVT = Src.getValueType();
57499 if (SrcVT.getScalarType() == MVT::bf16) {
57504 if (!SrcVT.isVector())
57514 EVT NVT = SrcVT.changeVectorElementType(MVT::i32);
57515 Src = DAG.getBitcast(SrcVT.changeTypeToInteger(), Src);
57527 if (!SrcVT.isVector() || SrcVT.getVectorElementType() != MVT::f16)
57539 EVT IntVT = SrcVT.changeVectorElementTypeToInteger();
57631 EVT SrcVT = Src.getValueType();
57634 SrcVT.getVectorElementType() != MVT::f32)
57685 DAG.getConstantFP(0.0, dl, SrcVT));