Lines Matching defs:MaskVT
7548 MVT MaskVT = BOperand.getSimpleValueType();
7550 if ((EltType == MVT::i64 && MaskVT == MVT::v8i1) || // for broadcastmb2q
7551 (EltType == MVT::i32 && MaskVT == MVT::v16i1)) { // for broadcastmw2d
10149 static SDValue getMaskNode(SDValue Mask, MVT MaskVT,
10748 MVT MaskVT = VT;
10754 MaskVT = MVT::getVectorVT(EltVT, Mask.size());
10786 SDValue VMask = DAG.getBuildVector(MaskVT, DL, VMaskOps);
14392 MVT MaskVT = VT.changeTypeToInteger();
14407 MaskNode = getConstVector(AdjustedMask, MaskVT, DAG, DL, true);
14410 MaskNode = getConstVector(Mask, MaskVT, DAG, DL, true);
18195 MVT MaskVT = MVT::getVectorVT(MVT::i1, NumElts);
18196 SDValue Mask = DAG.getSetCC(dl, MaskVT, Cond,
22807 MVT MaskVT = ScalarSize >= 32 ? MVT::v4i32 : MVT::v16i8;
22808 LHS = DAG.getBitcast(MaskVT, MaskBits(LHS));
22809 RHS = DAG.getBitcast(MaskVT, MaskBits(RHS));
22810 SDValue V = DAG.getNode(X86ISD::PCMPEQ, DL, MaskVT, LHS, RHS);
22811 V = DAG.getNOT(DL, V, MaskVT);
25819 /// for \p Mask according to \p MaskVT when lowering masking intrinsics
25820 static SDValue getMaskNode(SDValue Mask, MVT MaskVT,
25825 return DAG.getConstant(1, dl, MaskVT);
25827 return DAG.getConstant(0, dl, MaskVT);
25829 assert(MaskVT.bitsLE(Mask.getSimpleValueType()) && "Unexpected mask size!");
25832 assert(MaskVT == MVT::v64i1 && "Expected v64i1 mask!");
25843 // In case when MaskVT equals v2i1 or v4i1, low 2 or 4 elements
25845 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
25859 MVT MaskVT = MVT::getVectorVT(MVT::i1, VT.getVectorNumElements());
25866 SDValue VMask = getMaskNode(Mask, MaskVT, Subtarget, DAG, dl);
26316 EVT MaskVT = Src3.getValueType().changeVectorElementTypeToInteger();
26317 Src3 = DAG.getBitcast(MaskVT, Src3);
26382 MVT MaskVT = Op.getSimpleValueType();
26391 return DAG.getNode(IntrData->Opc1, dl, MaskVT, Op.getOperand(1),
26397 return DAG.getNode(IntrData->Opc0, dl, MaskVT,
26625 MVT MaskVT = MVT::getVectorVT(MVT::i1, SrcVT.getVectorNumElements());
26626 Mask = getMaskNode(Mask, MaskVT, Subtarget, DAG, dl);
26640 MVT MaskVT = MVT::getVectorVT(MVT::i1, Src2VT.getVectorNumElements());
26641 Mask = getMaskNode(Mask, MaskVT, Subtarget, DAG, dl);
26668 MVT MaskVT = MVT::getVectorVT(MVT::i1, SrcVT.getVectorNumElements());
26669 Mask = getMaskNode(Mask, MaskVT, Subtarget, DAG, dl);
26932 MVT MaskVT = Op.getSimpleValueType();
26942 MaskVT, Operation);
26944 MaskVT, Operation);
27036 EVT MaskVT = Mask.getValueType().changeVectorElementTypeToInteger();
27045 Mask = DAG.getBitcast(MaskVT, Mask);
27071 MVT MaskVT = MVT::getVectorVT(MVT::i1, MinElts);
27075 if (Mask.getValueType() != MaskVT)
27076 Mask = getMaskNode(Mask, MaskVT, Subtarget, DAG, dl);
27108 MVT MaskVT = MVT::getVectorVT(MVT::i1, MinElts);
27112 if (Mask.getValueType() != MaskVT)
27113 Mask = getMaskNode(Mask, MaskVT, Subtarget, DAG, dl);
27139 MVT MaskVT =
27141 SDValue VMask = getMaskNode(Mask, MaskVT, Subtarget, DAG, dl);
27843 MVT MaskVT = MVT::getVectorVT(MVT::i1, MemVT.getVectorNumElements());
27844 SDValue VMask = getMaskNode(Mask, MaskVT, Subtarget, DAG, dl);
27858 MVT MaskVT = MVT::getVectorVT(MVT::i1, MemVT.getVectorNumElements());
27859 SDValue VMask = getMaskNode(Mask, MaskVT, Subtarget, DAG, dl);
28611 MVT MaskVT = MVT::getVectorVT(MVT::i1, CurrVT.getVectorNumElements());
28612 HiZ = DAG.getSetCC(DL, MaskVT, Hi, Zero, ISD::SETEQ);
28637 MVT MaskVT = MVT::getVectorVT(MVT::i1, CurrVT.getVectorNumElements());
28638 HiZ = DAG.getSetCC(DL, MaskVT, DAG.getBitcast(CurrVT, Op0),
30587 MVT MaskVT = MVT::getVectorVT(MVT::i1, NumElts);
30591 Sel = DAG.getSetCC(dl, MaskVT, DAG.getConstant(0, dl, VT), Sel,
32837 MVT MaskVT = MVT::getVectorVT(MVT::i1, NumElts);
32841 Mask = ExtendToType(Mask, MaskVT, DAG, true);
32857 MVT MaskVT = Mask.getSimpleValueType();
32862 if (MaskVT.getVectorElementType() != MVT::i1) {
32990 MVT MaskVT = MVT::getVectorVT(MVT::i1, NumElts);
32994 Mask = ExtendToType(Mask, MaskVT, DAG, true);
38843 static bool matchUnaryShuffle(MVT MaskVT, ArrayRef<int> Mask,
38849 unsigned MaskEltSize = MaskVT.getScalarSizeInBits();
38859 SrcVT = DstVT = MaskVT.changeVectorElementType(MVT::f16);
38861 SrcVT = DstVT = !Subtarget.hasSSE2() ? MVT::v4f32 : MaskVT;
38868 if (AllowIntDomain && ((MaskVT.is128BitVector() && Subtarget.hasSSE41()) ||
38869 (MaskVT.is256BitVector() && Subtarget.hasInt256()))) {
38894 MVT ScalarTy = MaskVT.isInteger() ? MaskVT.getScalarType()
38918 SrcVT = DstVT = MaskVT.changeVectorElementType(MVT::f16);
38920 SrcVT = DstVT = !Subtarget.hasSSE2() ? MVT::v4f32 : MaskVT;
38927 if (MaskVT.is128BitVector() && Subtarget.hasSSE3() && AllowFloatDomain) {
38928 if (isTargetShuffleEquivalent(MaskVT, Mask, {0, 0}, DAG, V1)) {
38933 if (isTargetShuffleEquivalent(MaskVT, Mask, {0, 0, 2, 2}, DAG, V1)) {
38938 if (isTargetShuffleEquivalent(MaskVT, Mask, {1, 1, 3, 3}, DAG, V1)) {
38945 if (MaskVT.is256BitVector() && AllowFloatDomain) {
38947 if (isTargetShuffleEquivalent(MaskVT, Mask, {0, 0, 2, 2}, DAG, V1)) {
38952 if (isTargetShuffleEquivalent(MaskVT, Mask, {0, 0, 2, 2, 4, 4, 6, 6}, DAG,
38958 if (isTargetShuffleEquivalent(MaskVT, Mask, {1, 1, 3, 3, 5, 5, 7, 7}, DAG,
38966 if (MaskVT.is512BitVector() && AllowFloatDomain) {
38969 if (isTargetShuffleEquivalent(MaskVT, Mask, {0, 0, 2, 2, 4, 4, 6, 6}, DAG,
38976 MaskVT, Mask,
38983 MaskVT, Mask,
38997 static bool matchUnaryPermuteShuffle(MVT MaskVT, ArrayRef<int> Mask,
39005 unsigned InputSizeInBits = MaskVT.getSizeInBits();
39015 if (Subtarget.hasAVX2() && MaskVT.is256BitVector()) {
39021 if (Subtarget.hasAVX512() && MaskVT.is512BitVector()) {
39072 ((MaskVT.is128BitVector() && Subtarget.hasSSE2()) ||
39073 (MaskVT.is256BitVector() && Subtarget.hasAVX2()) ||
39074 (MaskVT.is512BitVector() && Subtarget.hasBWI()))) {
39107 ((MaskVT.is128BitVector() && Subtarget.hasXOP()) ||
39120 ((MaskVT.is128BitVector() && Subtarget.hasSSE2()) ||
39121 (MaskVT.is256BitVector() && Subtarget.hasAVX2()) ||
39122 (MaskVT.is512BitVector() && Subtarget.hasAVX512()))) {
39146 static bool matchBinaryShuffle(MVT MaskVT, ArrayRef<int> Mask,
39153 unsigned EltSizeInBits = MaskVT.getScalarSizeInBits();
39154 unsigned SizeInBits = MaskVT.getSizeInBits();
39156 if (MaskVT.is128BitVector()) {
39157 if (isTargetShuffleEquivalent(MaskVT, Mask, {0, 0}, DAG) &&
39165 if (isTargetShuffleEquivalent(MaskVT, Mask, {1, 1}, DAG) &&
39172 if (isTargetShuffleEquivalent(MaskVT, Mask, {0, 3}, DAG) &&
39179 if (isTargetShuffleEquivalent(MaskVT, Mask, {4, 1, 2, 3}, DAG) &&
39185 if (isTargetShuffleEquivalent(MaskVT, Mask, {8, 1, 2, 3, 4, 5, 6, 7},
39195 if (((MaskVT == MVT::v8i16 || MaskVT == MVT::v16i8) && Subtarget.hasSSE2()) ||
39196 ((MaskVT == MVT::v16i16 || MaskVT == MVT::v32i8) && Subtarget.hasInt256()) ||
39197 ((MaskVT == MVT::v32i16 || MaskVT == MVT::v64i8) && Subtarget.hasBWI())) {
39198 if (matchShuffleWithPACK(MaskVT, SrcVT, V1, V2, Shuffle, Mask, DAG,
39200 DstVT = MaskVT;
39205 if (MaskVT == MVT::v4i32 && Subtarget.hasSSE2() &&
39206 isTargetShuffleEquivalent(MaskVT, Mask, {0, 2, 4, 6}, DAG) &&
39235 if ((MaskVT == MVT::v4f32 && Subtarget.hasSSE1()) ||
39236 (MaskVT.is128BitVector() && Subtarget.hasSSE2()) ||
39237 (MaskVT.is256BitVector() && 32 <= EltSizeInBits && Subtarget.hasAVX()) ||
39238 (MaskVT.is256BitVector() && Subtarget.hasAVX2()) ||
39239 (MaskVT.is512BitVector() && Subtarget.hasAVX512() &&
39241 if (matchShuffleWithUNPCK(MaskVT, V1, V2, Shuffle, IsUnary, Mask, DL, DAG,
39243 SrcVT = DstVT = MaskVT;
39244 if (MaskVT.is256BitVector() && !Subtarget.hasAVX2())
39288 SrcVT = DstVT = MaskVT.changeTypeToInteger();
39332 SrcVT = DstVT = MaskVT.changeTypeToInteger();
39343 MVT MaskVT, ArrayRef<int> Mask, const APInt &Zeroable,
39348 unsigned EltSizeInBits = MaskVT.getScalarSizeInBits();
39352 ((MaskVT.is128BitVector() && Subtarget.hasVLX()) ||
39353 (MaskVT.is256BitVector() && Subtarget.hasVLX()) ||
39354 (MaskVT.is512BitVector() && Subtarget.hasAVX512()))) {
39360 ShuffleVT = MVT::getVectorVT(MVT::i64, MaskVT.getSizeInBits() / 64);
39362 ShuffleVT = MVT::getVectorVT(MVT::i32, MaskVT.getSizeInBits() / 32);
39370 if (AllowIntDomain && ((MaskVT.is128BitVector() && Subtarget.hasSSSE3()) ||
39371 (MaskVT.is256BitVector() && Subtarget.hasAVX2()) ||
39372 (MaskVT.is512BitVector() && Subtarget.hasBWI()))) {
39373 int ByteRotation = matchShuffleAsByteRotate(MaskVT, V1, V2, Mask);
39376 ShuffleVT = MVT::getVectorVT(MVT::i8, MaskVT.getSizeInBits() / 8);
39383 if ((NumMaskElts <= 8 && ((Subtarget.hasSSE41() && MaskVT.is128BitVector()) ||
39384 (Subtarget.hasAVX() && MaskVT.is256BitVector()))) ||
39385 (MaskVT == MVT::v16i16 && Subtarget.hasAVX2())) {
39389 if (matchShuffleAsBlend(MaskVT, V1, V2, TargetMask, Zeroable, ForceV1Zero,
39391 if (MaskVT == MVT::v16i16) {
39394 if (isRepeatedTargetShuffleMask(128, MaskVT, TargetMask,
39402 V1 = ForceV1Zero ? getZeroVector(MaskVT, Subtarget, DAG, DL) : V1;
39403 V2 = ForceV2Zero ? getZeroVector(MaskVT, Subtarget, DAG, DL) : V2;
39405 ShuffleVT = MaskVT;
39409 V1 = ForceV1Zero ? getZeroVector(MaskVT, Subtarget, DAG, DL) : V1;
39410 V2 = ForceV2Zero ? getZeroVector(MaskVT, Subtarget, DAG, DL) : V2;
39413 ShuffleVT = MaskVT;
39422 MaskVT.is128BitVector() && isAnyZero(Mask) &&
39431 ((MaskVT.is128BitVector() && Subtarget.hasSSE2()) ||
39432 (MaskVT.is256BitVector() && Subtarget.hasAVX()) ||
39433 (MaskVT.is512BitVector() && Subtarget.hasAVX512()))) {
39435 if (matchShuffleWithSHUFPD(MaskVT, V1, V2, ForceV1Zero, ForceV2Zero,
39437 V1 = ForceV1Zero ? getZeroVector(MaskVT, Subtarget, DAG, DL) : V1;
39438 V2 = ForceV2Zero ? getZeroVector(MaskVT, Subtarget, DAG, DL) : V2;
39440 ShuffleVT = MVT::getVectorVT(MVT::f64, MaskVT.getSizeInBits() / 64);
39447 ((MaskVT.is128BitVector() && Subtarget.hasSSE1()) ||
39448 (MaskVT.is256BitVector() && Subtarget.hasAVX()) ||
39449 (MaskVT.is512BitVector() && Subtarget.hasAVX512()))) {
39451 if (isRepeatedTargetShuffleMask(128, MaskVT, Mask, RepeatedMask)) {
39459 return DAG.getUNDEF(MaskVT);
39463 return getZeroVector(MaskVT, Subtarget, DAG, DL);
39485 ShuffleVT = MVT::getVectorVT(MVT::f32, MaskVT.getSizeInBits() / 32);
39494 MaskVT.is128BitVector() &&
39774 MVT MaskVT = FloatDomain ? MVT::getFloatingPointVT(MaskEltSizeInBits)
39776 MaskVT = MVT::getVectorVT(MaskVT, NumMaskElts);
39779 if (!TLI.isTypeLegal(MaskVT))
39791 (!MaskVT.is256BitVector() || Subtarget.hasAVX2());
39805 if (V1.getValueType() == MaskVT &&
39811 Res = DAG.getNode(X86ISD::VBROADCAST, DL, MaskVT, Res);
39817 Res = CanonicalizeShuffleInput(MaskVT, V1);
39818 Res = DAG.getNode(X86ISD::VBROADCAST, DL, MaskVT, Res);
39824 if (matchUnaryShuffle(MaskVT, Mask, AllowFloatDomain, AllowIntDomain, V1,
39835 if (matchUnaryPermuteShuffle(MaskVT, Mask, Zeroable, AllowFloatDomain,
39854 !isTargetShuffleEquivalent(MaskVT, Mask, {4, 1, 2, 3}, DAG)) {
39870 isTargetShuffleEquivalent(MaskVT, Mask, {0, 2}, DAG) &&
39886 if (matchBinaryShuffle(MaskVT, Mask, AllowFloatDomain, AllowIntDomain, NewV1,
39900 if (matchBinaryPermuteShuffle(MaskVT, Mask, Zeroable, AllowFloatDomain,
39913 // Typically from here on, we need an integer version of MaskVT.
40010 if (is128BitLaneCrossingShuffleMask(MaskVT, Mask)) {
40014 (MaskVT == MVT::v8f32 || MaskVT == MVT::v8i32)) {
40016 Res = CanonicalizeShuffleInput(MaskVT, V1);
40017 Res = DAG.getNode(X86ISD::VPERMV, DL, MaskVT, VPermMask, Res);
40022 (MaskVT == MVT::v8f64 || MaskVT == MVT::v8i64 ||
40023 MaskVT == MVT::v16f32 || MaskVT == MVT::v16i32)) ||
40025 (MaskVT == MVT::v16i16 || MaskVT == MVT::v32i16)) ||
40027 (MaskVT == MVT::v32i8 || MaskVT == MVT::v64i8))) {
40028 V1 = CanonicalizeShuffleInput(MaskVT, V1);
40029 V2 = DAG.getUNDEF(MaskVT);
40030 Res = lowerShuffleWithPERMV(DL, MaskVT, Mask, V1, V2, Subtarget, DAG);
40039 (MaskVT == MVT::v8f64 || MaskVT == MVT::v8i64 ||
40040 MaskVT == MVT::v4f64 || MaskVT == MVT::v4i64 ||
40041 MaskVT == MVT::v8f32 || MaskVT == MVT::v8i32 ||
40042 MaskVT == MVT::v16f32 || MaskVT == MVT::v16i32)) ||
40044 (MaskVT == MVT::v16i16 || MaskVT == MVT::v32i16)) ||
40046 (MaskVT == MVT::v32i8 || MaskVT == MVT::v64i8)))) {
40051 V1 = CanonicalizeShuffleInput(MaskVT, V1);
40052 V2 = getZeroVector(MaskVT, Subtarget, DAG, DL);
40053 Res = lowerShuffleWithPERMV(DL, MaskVT, Mask, V1, V2, Subtarget, DAG);
40069 (MaskVT == MVT::v8f64 || MaskVT == MVT::v8i64 ||
40070 MaskVT == MVT::v4f64 || MaskVT == MVT::v4i64 ||
40071 MaskVT == MVT::v16f32 || MaskVT == MVT::v16i32 ||
40072 MaskVT == MVT::v8f32 || MaskVT == MVT::v8i32)) ||
40074 (MaskVT == MVT::v16i16 || MaskVT == MVT::v32i16)) ||
40076 (MaskVT == MVT::v32i8 || MaskVT == MVT::v64i8)))) {
40077 V1 = CanonicalizeShuffleInput(MaskVT, V1);
40078 V2 = CanonicalizeShuffleInput(MaskVT, V2);
40079 Res = lowerShuffleWithPERMV(DL, MaskVT, Mask, V1, V2, Subtarget, DAG);
40089 TLI.isTypeLegal(MaskVT)) {
40104 SDValue BitMask = getConstVector(EltBits, UndefElts, MaskVT, DAG, DL);
40105 Res = CanonicalizeShuffleInput(MaskVT, V1);
40107 MaskVT.isFloatingPoint() ? unsigned(X86ISD::FAND) : unsigned(ISD::AND);
40108 Res = DAG.getNode(AndOpcode, DL, MaskVT, Res, BitMask);
40116 ((MaskVT == MVT::v8f32 && Subtarget.hasAVX()) ||
40117 (MaskVT == MVT::v16f32 && Subtarget.hasAVX512()))) {
40125 Res = CanonicalizeShuffleInput(MaskVT, V1);
40126 Res = DAG.getNode(X86ISD::VPERMILPV, DL, MaskVT, Res, VPermMask);
40133 (MaskVT == MVT::v2f64 || MaskVT == MVT::v4f64 || MaskVT == MVT::v4f32 ||
40134 MaskVT == MVT::v8f32)) {
40139 unsigned NumLanes = MaskVT.getSizeInBits() / 128;
40154 Index = (MaskVT.getScalarSizeInBits() == 64 ? Index << 1 : Index);
40157 V1 = CanonicalizeShuffleInput(MaskVT, V1);
40158 V2 = CanonicalizeShuffleInput(MaskVT, V2);
40160 Res = DAG.getNode(X86ISD::VPERMIL2, DL, MaskVT, V1, V2, VPerm2MaskOp,
40241 (MaskVT == MVT::v2f64 || MaskVT == MVT::v4f64 || MaskVT == MVT::v8f64 ||
40242 MaskVT == MVT::v2i64 || MaskVT == MVT::v4i64 || MaskVT == MVT::v8i64 ||
40243 MaskVT == MVT::v4f32 || MaskVT == MVT::v4i32 || MaskVT == MVT::v8f32 ||
40244 MaskVT == MVT::v8i32 || MaskVT == MVT::v16f32 ||
40245 MaskVT == MVT::v16i32)) ||
40247 (MaskVT == MVT::v8i16 || MaskVT == MVT::v16i16 ||
40248 MaskVT == MVT::v32i16)) ||
40250 (MaskVT == MVT::v16i8 || MaskVT == MVT::v32i8 ||
40251 MaskVT == MVT::v64i8)))) {
40252 V1 = CanonicalizeShuffleInput(MaskVT, V1);
40253 V2 = CanonicalizeShuffleInput(MaskVT, V2);
40254 Res = lowerShuffleWithPERMV(DL, MaskVT, Mask, V1, V2, Subtarget, DAG);
40699 MVT MaskVT = MVT::getVectorVT(MaskSVT, NumMaskElts);
40700 if (!DAG.getTargetLoweringInfo().isTypeLegal(MaskVT))
40703 SDValue CstOp = getConstVector(ConstantBitData, UndefElts, MaskVT, DAG, DL);
42488 MVT MaskVT = N.getOperand(1).getSimpleValueType();
42493 SDValue NewMask = getConstVector(Mask, MaskVT, DAG, DL,
42510 SDValue NewMask = getConstVector(Mask, MaskVT, DAG, DL,
42520 getConstVector(Mask, MaskVT, DAG, DL, /*IsMask=*/true);
46967 EVT MaskVT = Mask.getValueType();
46968 assert(MaskVT.isInteger() &&
46969 DAG.ComputeNumSignBits(Mask) == MaskVT.getScalarSizeInBits() &&
46972 if (X.getValueType() != MaskVT || Y.getValueType() != MaskVT)
46974 if (!DAG.getTargetLoweringInfo().isOperationLegal(ISD::SUB, MaskVT))
46990 SDValue SubOp1 = DAG.getNode(ISD::XOR, DL, MaskVT, V, Mask);
47006 SDValue Res = DAG.getNode(ISD::SUB, DL, MaskVT, SubOp1, SubOp2);
51103 EVT MaskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
51104 SDValue Mask = combineBitcastvxi1(DAG, MaskVT, SrcOps[0], dl, Subtarget);
51106 Mask = DAG.getBitcast(MaskVT, SrcOps[0]);
51110 SDValue PartialBits = DAG.getConstant(SrcPartials[0], dl, MaskVT);
51111 Mask = DAG.getNode(ISD::AND, dl, MaskVT, Mask, PartialBits);
51458 EVT MaskVT = Mask.getValueType();
51459 unsigned EltBits = MaskVT.getScalarSizeInBits();
51462 if (!MaskVT.isInteger() || DAG.ComputeNumSignBits(Mask) != EltBits)
51911 EVT MaskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
51912 SDValue Mask = combineBitcastvxi1(DAG, MaskVT, SrcOps[0], dl, Subtarget);
51914 Mask = DAG.getBitcast(MaskVT, SrcOps[0]);
51918 SDValue ZeroBits = DAG.getConstant(0, dl, MaskVT);
51919 SDValue PartialBits = DAG.getConstant(SrcPartials[0], dl, MaskVT);
51920 Mask = DAG.getNode(ISD::AND, dl, MaskVT, Mask, PartialBits);
57993 MVT MaskVT = MVT::getVectorVT(MVT::i1, VT.getVectorNumElements());
57995 DAG.getBitcast(MaskVT, DAG.getConstant(Mask, DL, MaskSVT));