[X86] Don't widen 128/256-bit strict compares with vXi1 result to 512-bits on KNL.

[craig.topper]

Summary

If we widen the compare we might trigger a spurious exception from
the garbage data.

We have two choices here. Explicitly force the upper bits to zero.
Or use a legacy VEX vcmpps/pd instruction and convert the XMM/YMM
result to mask register.

I've chosen to go with the second option. I'm not sure which is
really best. In some cases we could get rid of the zeroing since
the producing instruction probably already zeroed it. But we lose
the ability to fold a load. So which is best is dependent on
surrounding code.

[spatel]

LGTM.

This is my first view of these test files, so it might just be me...but I didn't inspect every test diff. It looks like we're brute-forcing through a matrix of {x preds, y data types, (non)signalling, 32/64-bit targets, ... }. I'd interleave those parameters to reduce the number of tests by 8-16x or more. Save test and review time if we're pretty confident that the lowering logic is fairly uniform. :)

llvm/lib/Target/X86/X86ISelLowering.cpp

21760

Extra // in re-flowed comment text.

llvm/lib/Target/X86/X86ISelLowering.cpp

 #ifndef NDEBUG
     MVT EltVT = Op0.getSimpleValueType().getVectorElementType();
     assert(EltVT == MVT::f32 || EltVT == MVT::f64);
 #endif
 
     bool IsSignaling = Op.getOpcode() == ISD::STRICT_FSETCCS;
     SDValue Chain = IsStrict ? Op.getOperand(0) : SDValue();
 
+    // If we have a strict compare with a vXi1 result and the input is 128/256
+    // bits we can't use a masked compare unless we have VLX. If we use a wider
+    // compare like we do for non-strict, we might trigger spurious exceptions
+    // from the upper elements. Instead emit a AVX compare and convert to mask.
     unsigned Opc;
-    if (Subtarget.hasAVX512() && VT.getVectorElementType() == MVT::i1) {
+    if (Subtarget.hasAVX512() && VT.getVectorElementType() == MVT::i1 &&
+        (!IsStrict || Subtarget.hasVLX() ||
+         Op0.getSimpleValueType().is512BitVector())) {
       assert(VT.getVectorNumElements() <= 16);
       Opc = IsStrict ? X86ISD::STRICT_CMPM : X86ISD::CMPM;
     } else {
       Opc = IsStrict ? X86ISD::STRICT_CMPP : X86ISD::CMPP;
       // The SSE/AVX packed FP comparison nodes are defined with a
       // floating-point vector result that matches the operand type. This allows
       // them to work with an SSE1 target (integer vector types are not legal).
       VT = Op0.getSimpleValueType();
if (!Subtarget.hasAVX()) {
             Opc, dl, {VT, MVT::Other},
             {Chain, Op0, Op1, DAG.getTargetConstant(SSECC, dl, MVT::i8)});
         Chain = Cmp.getValue(1);
       } else
         Cmp = DAG.getNode(
             Opc, dl, VT, Op0, Op1, DAG.getTargetConstant(SSECC, dl, MVT::i8));
     }
 
-    // If this is SSE/AVX CMPP, bitcast the result back to integer to match the
-    // result type of SETCC. The bitcast is expected to be optimized away
-    // during combining/isel.
+    if (VT.getSizeInBits() > Op.getSimpleValueType().getSizeInBits()) {
+      // We emitted a compare with an XMM/YMM result. Finish converting to a
+      // mask register using a vptestm.
+      EVT CastVT = EVT(VT).changeVectorElementTypeToInteger();
+      Cmp = DAG.getBitcast(CastVT, Cmp);
+      Cmp = DAG.getSetCC(dl, Op.getSimpleValueType(), Cmp,
+                         DAG.getConstant(0, dl, CastVT), ISD::SETNE);
+    } else {
+      // If this is SSE/AVX CMPP, bitcast the result back to integer to match
+      // the result type of SETCC. The bitcast is expected to be optimized
+      // away during combining/isel.
       Cmp = DAG.getBitcast(Op.getSimpleValueType(), Cmp);
+    }
 
     if (IsStrict)
       return DAG.getMergeValues({Cmp, Chain}, dl);
 
     return Cmp;
   }
 
   assert(!IsStrict && "Strict SETCC only handles FP operands.");

llvm/lib/Target/X86/X86InstrAVX512.td

def : Pat<(Narrow.KVT (and Narrow.KRC:$mask,
            (Wide.VT (INSERT_SUBREG (IMPLICIT_DEF), Narrow.RC:$src1, Narrow.SubRegIdx)),
            addr:$src2, (CommFrag_su.OperandTransform $cc)), Narrow.KRC)>;
 }
 
 // Same as above, but for fp types which don't use PatFrags.
 multiclass axv512_cmp_packed_cc_no_vlx_lowering<string InstStr,
                                                 X86VectorVTInfo Narrow,
                                                 X86VectorVTInfo Wide> {
-def : Pat<(Narrow.KVT (X86any_cmpm (Narrow.VT Narrow.RC:$src1),
-                                   (Narrow.VT Narrow.RC:$src2), timm:$cc)),
+def : Pat<(Narrow.KVT (X86cmpm (Narrow.VT Narrow.RC:$src1),
           (COPY_TO_REGCLASS
            (!cast<Instruction>(InstStr#"Zrri")
             (Wide.VT (INSERT_SUBREG (IMPLICIT_DEF), Narrow.RC:$src1, Narrow.SubRegIdx)),
             (Wide.VT (INSERT_SUBREG (IMPLICIT_DEF), Narrow.RC:$src2, Narrow.SubRegIdx)),
             timm:$cc), Narrow.KRC)>;
 
 def : Pat<(Narrow.KVT (and Narrow.KRC:$mask,
                            (X86cmpm_su (Narrow.VT Narrow.RC:$src1),
                                        (Narrow.VT Narrow.RC:$src2), timm:$cc))),
           (COPY_TO_REGCLASS (!cast<Instruction>(InstStr#"Zrrik")
            (COPY_TO_REGCLASS Narrow.KRC:$mask, Wide.KRC),
            (Wide.VT (INSERT_SUBREG (IMPLICIT_DEF), Narrow.RC:$src1, Narrow.SubRegIdx)),
            (Wide.VT (INSERT_SUBREG (IMPLICIT_DEF), Narrow.RC:$src2, Narrow.SubRegIdx)),
            timm:$cc), Narrow.KRC)>;
 
 // Broadcast load.
-def : Pat<(Narrow.KVT (X86any_cmpm (Narrow.VT Narrow.RC:$src1),
-                                   (Narrow.VT (Narrow.BroadcastLdFrag addr:$src2)), timm:$cc)),
+def : Pat<(Narrow.KVT (X86cmpm (Narrow.VT Narrow.RC:$src1),
           (COPY_TO_REGCLASS
            (!cast<Instruction>(InstStr#"Zrmbi")
             (Wide.VT (INSERT_SUBREG (IMPLICIT_DEF), Narrow.RC:$src1, Narrow.SubRegIdx)),
             addr:$src2, timm:$cc), Narrow.KRC)>;
 
 def : Pat<(Narrow.KVT (and Narrow.KRC:$mask,
                            (X86cmpm_su (Narrow.VT Narrow.RC:$src1),
                                        (Narrow.VT (Narrow.BroadcastLdFrag addr:$src2)), timm:$cc))),
           (COPY_TO_REGCLASS (!cast<Instruction>(InstStr#"Zrmbik")
            (COPY_TO_REGCLASS Narrow.KRC:$mask, Wide.KRC),
            (Wide.VT (INSERT_SUBREG (IMPLICIT_DEF), Narrow.RC:$src1, Narrow.SubRegIdx)),
            addr:$src2, timm:$cc), Narrow.KRC)>;
 
 // Commuted with broadcast load.
-def : Pat<(Narrow.KVT (X86any_cmpm (Narrow.VT (Narrow.BroadcastLdFrag addr:$src2)),
-                                   (Narrow.VT Narrow.RC:$src1), timm:$cc)),
+def : Pat<(Narrow.KVT (X86cmpm (Narrow.VT (Narrow.BroadcastLdFrag addr:$src2)),
           (COPY_TO_REGCLASS
            (!cast<Instruction>(InstStr#"Zrmbi")
             (Wide.VT (INSERT_SUBREG (IMPLICIT_DEF), Narrow.RC:$src1, Narrow.SubRegIdx)),
             addr:$src2, (X86cmpm_imm_commute timm:$cc)), Narrow.KRC)>;
 
 def : Pat<(Narrow.KVT (and Narrow.KRC:$mask,
                            (X86cmpm_su (Narrow.VT (Narrow.BroadcastLdFrag addr:$src2)),
                                        (Narrow.VT Narrow.RC:$src1), timm:$cc))),

llvm/test/CodeGen/X86/vec-strict-cmp-128.ll

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_oeq_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpeqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeqps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_oeq_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeqps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"oeq",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_ogt_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmplt_oqps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmplt_oqps %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_ogt_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmplt_oqps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmplt_oqps %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"ogt",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_oge_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmple_oqps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmple_oqps %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_oge_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmple_oqps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmple_oqps %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"oge",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_olt_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmplt_oqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmplt_oqps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_olt_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmplt_oqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmplt_oqps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"olt",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_ole_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmple_oqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmple_oqps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_ole_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmple_oqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmple_oqps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"ole",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_one_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpneq_oqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneq_oqps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_one_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneq_oqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneq_oqps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"one",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_ord_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpordps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpordps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_ord_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpordps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpordps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"ord",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_ueq_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpeq_uqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeq_uqps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_ueq_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeq_uqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeq_uqps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"ueq",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_ugt_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnle_uqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnle_uqps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_ugt_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnle_uqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnle_uqps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"ugt",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_uge_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnlt_uqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnlt_uqps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_uge_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnlt_uqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnlt_uqps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"uge",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_ult_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnle_uqps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnle_uqps %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_ult_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnle_uqps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnle_uqps %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"ult",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_ule_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnlt_uqps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnlt_uqps %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_ule_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnlt_uqps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnlt_uqps %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"ule",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_une_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpneqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneqps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_une_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneqps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"une",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_uno_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpunordps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpunordps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_uno_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpunordps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpunordps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"uno",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_oeq_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpeqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeqpd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_oeq_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeqpd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"oeq",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_ogt_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmplt_oqpd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmplt_oqpd %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_ogt_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmplt_oqpd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmplt_oqpd %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"ogt",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_oge_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmple_oqpd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmple_oqpd %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_oge_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmple_oqpd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmple_oqpd %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"oge",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_olt_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmplt_oqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmplt_oqpd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_olt_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmplt_oqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmplt_oqpd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"olt",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_ole_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmple_oqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmple_oqpd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_ole_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmple_oqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmple_oqpd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"ole",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_one_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpneq_oqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneq_oqpd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_one_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneq_oqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneq_oqpd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"one",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_ord_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpordpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpordpd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_ord_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpordpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpordpd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"ord",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_ueq_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpeq_uqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeq_uqpd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_ueq_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeq_uqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeq_uqpd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"ueq",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_ugt_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnle_uqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnle_uqpd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_ugt_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnle_uqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnle_uqpd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"ugt",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_uge_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnlt_uqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnlt_uqpd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_uge_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnlt_uqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnlt_uqpd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"uge",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_ult_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnle_uqpd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnle_uqpd %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_ult_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnle_uqpd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnle_uqpd %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"ult",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_ule_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnlt_uqpd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnlt_uqpd %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_ule_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnlt_uqpd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnlt_uqpd %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"ule",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_une_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpneqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneqpd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_une_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneqpd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"une",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_uno_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpunordpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpunordpd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_uno_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpunordpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpunordpd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"uno",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_oeq_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpeq_osps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeq_osps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_oeq_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeq_osps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeq_osps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"oeq",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_ogt_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpltps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpltps %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_ogt_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpltps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpltps %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"ogt",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_oge_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpleps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpleps %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_oge_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpleps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpleps %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"oge",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_olt_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpltps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpltps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_olt_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpltps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpltps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"olt",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_ole_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpleps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpleps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_ole_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpleps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpleps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"ole",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_one_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpneq_osps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneq_osps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_one_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneq_osps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneq_osps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"one",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_ord_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpord_sps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpord_sps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_ord_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpord_sps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpord_sps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"ord",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_ueq_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpeq_usps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeq_usps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_ueq_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeq_usps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeq_usps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"ueq",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_ugt_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnleps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnleps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_ugt_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnleps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnleps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"ugt",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_uge_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnltps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnltps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_uge_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnltps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnltps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"uge",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_ult_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnleps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnleps %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_ult_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnleps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnleps %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"ult",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_ule_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnltps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnltps %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_ule_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnltps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnltps %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"ule",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_une_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpneq_usps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneq_usps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_une_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneq_usps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneq_usps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"une",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f32_uno_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpunord_sps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpunord_sps 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f32_uno_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpunord_sps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpunord_sps %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(
                                                <4 x float> %f1, <4 x float> %f2, metadata !"uno",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i32> %a, <4 x i32> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_oeq_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpeq_ospd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeq_ospd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_oeq_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeq_ospd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeq_ospd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"oeq",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_ogt_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpltpd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpltpd %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_ogt_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpltpd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpltpd %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"ogt",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_oge_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmplepd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmplepd %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_oge_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmplepd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmplepd %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"oge",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_olt_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpltpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpltpd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_olt_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpltpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpltpd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"olt",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_ole_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmplepd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmplepd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_ole_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmplepd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmplepd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"ole",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_one_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpneq_ospd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneq_ospd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_one_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneq_ospd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneq_ospd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"one",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_ord_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpord_spd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpord_spd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_ord_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpord_spd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpord_spd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"ord",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_ueq_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpeq_uspd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeq_uspd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_ueq_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeq_uspd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeq_uspd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"ueq",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_ugt_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnlepd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnlepd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_ugt_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnlepd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnlepd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"ugt",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_uge_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnltpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnltpd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_uge_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnltpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnltpd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"uge",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_ult_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnlepd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnlepd %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_ult_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnlepd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnlepd %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"ult",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_ule_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpnltpd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnltpd %xmm2, %xmm3, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_ule_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnltpd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnltpd %xmm2, %xmm3, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"ule",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_une_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpneq_uspd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneq_uspd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_une_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneq_uspd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneq_uspd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"une",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v2f64_uno_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-16, %esp
 ; AVX512F-32-NEXT:    subl $16, %esp
-; AVX512F-32-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %xmm3
-; AVX512F-32-NEXT:    vcmpunord_spd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpunord_spd 8(%ebp), %xmm2, %xmm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    vzeroupper
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v2f64_uno_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $xmm3 killed $xmm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $xmm2 killed $xmm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpunord_spd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpunord_spd %xmm3, %xmm2, %xmm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-64-NEXT:    vzeroupper
 ; AVX512F-64-NEXT:    retq
   %cond = call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(
                                                <2 x double> %f1, <2 x double> %f2, metadata !"uno",
                                                metadata !"fpexcept.strict") #0
   %res = select <2 x i1> %cond, <2 x i64> %a, <2 x i64> %b

llvm/test/CodeGen/X86/vec-strict-cmp-256.ll

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_oeq_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpeqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeqps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_oeq_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeqps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"oeq",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_ogt_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmplt_oqps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmplt_oqps %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_ogt_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmplt_oqps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmplt_oqps %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"ogt",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_oge_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmple_oqps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmple_oqps %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_oge_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmple_oqps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmple_oqps %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"oge",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_olt_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmplt_oqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmplt_oqps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_olt_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmplt_oqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmplt_oqps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"olt",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_ole_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmple_oqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmple_oqps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_ole_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmple_oqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmple_oqps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"ole",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_one_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpneq_oqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneq_oqps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_one_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneq_oqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneq_oqps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"one",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_ord_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpordps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpordps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_ord_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpordps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpordps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"ord",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_ueq_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpeq_uqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeq_uqps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_ueq_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeq_uqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeq_uqps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"ueq",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_ugt_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnle_uqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnle_uqps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_ugt_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnle_uqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnle_uqps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"ugt",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_uge_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnlt_uqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnlt_uqps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_uge_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnlt_uqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnlt_uqps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"uge",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_ult_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnle_uqps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnle_uqps %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_ult_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnle_uqps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnle_uqps %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"ult",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_ule_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnlt_uqps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnlt_uqps %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_ule_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnlt_uqps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnlt_uqps %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"ule",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_une_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpneqps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneqps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_une_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneqps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneqps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"une",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_uno_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpunordps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpunordps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_uno_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpunordps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpunordps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"uno",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_oeq_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpeqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeqpd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_oeq_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeqpd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"oeq",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_ogt_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmplt_oqpd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmplt_oqpd %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_ogt_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmplt_oqpd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmplt_oqpd %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"ogt",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_oge_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmple_oqpd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmple_oqpd %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_oge_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmple_oqpd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmple_oqpd %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"oge",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_olt_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmplt_oqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmplt_oqpd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_olt_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmplt_oqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmplt_oqpd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"olt",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_ole_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmple_oqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmple_oqpd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_ole_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmple_oqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmple_oqpd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"ole",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_one_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpneq_oqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneq_oqpd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_one_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneq_oqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneq_oqpd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"one",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_ord_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpordpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpordpd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_ord_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpordpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpordpd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"ord",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_ueq_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpeq_uqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeq_uqpd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_ueq_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeq_uqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeq_uqpd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"ueq",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_ugt_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnle_uqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnle_uqpd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_ugt_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnle_uqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnle_uqpd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"ugt",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_uge_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnlt_uqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnlt_uqpd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_uge_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnlt_uqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnlt_uqpd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"uge",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_ult_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnle_uqpd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnle_uqpd %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_ult_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnle_uqpd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnle_uqpd %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"ult",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_ule_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnlt_uqpd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnlt_uqpd %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_ule_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnlt_uqpd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnlt_uqpd %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"ule",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_une_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpneqpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneqpd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_une_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneqpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneqpd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"une",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_uno_q:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpunordpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpunordpd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_uno_q:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpunordpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpunordpd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"uno",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_oeq_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpeq_osps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeq_osps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_oeq_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeq_osps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeq_osps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"oeq",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_ogt_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpltps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpltps %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_ogt_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpltps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpltps %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"ogt",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_oge_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpleps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpleps %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_oge_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpleps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpleps %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"oge",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_olt_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpltps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpltps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_olt_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpltps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpltps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"olt",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_ole_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpleps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpleps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_ole_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpleps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpleps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"ole",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_one_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpneq_osps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneq_osps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_one_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneq_osps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneq_osps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"one",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_ord_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpord_sps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpord_sps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_ord_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpord_sps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpord_sps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"ord",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_ueq_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpeq_usps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeq_usps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_ueq_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeq_usps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeq_usps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"ueq",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_ugt_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnleps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnleps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_ugt_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnleps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnleps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"ugt",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_uge_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnltps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnltps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_uge_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnltps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnltps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"uge",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_ult_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnleps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnleps %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_ult_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnleps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnleps %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"ult",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_ule_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnltps %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnltps %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_ule_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnltps %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnltps %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"ule",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_une_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpneq_usps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneq_usps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_une_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneq_usps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneq_usps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"une",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v8f32_uno_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovaps 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpunord_sps %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpunord_sps 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v8f32_uno_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpunord_sps %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpunord_sps %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmd %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(
                                                <8 x float> %f1, <8 x float> %f2, metadata !"uno",
                                                metadata !"fpexcept.strict") #0
   %res = select <8 x i1> %cond, <8 x i32> %a, <8 x i32> %b
   ret <8 x i32> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_oeq_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpeq_ospd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeq_ospd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_oeq_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeq_ospd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeq_ospd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"oeq",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_ogt_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpltpd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpltpd %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_ogt_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpltpd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpltpd %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"ogt",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_oge_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmplepd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmplepd %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_oge_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmplepd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmplepd %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"oge",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_olt_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpltpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpltpd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_olt_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpltpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpltpd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"olt",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_ole_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmplepd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmplepd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_ole_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmplepd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmplepd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"ole",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_one_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpneq_ospd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneq_ospd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_one_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneq_ospd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneq_ospd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"one",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_ord_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpord_spd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpord_spd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_ord_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpord_spd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpord_spd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"ord",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_ueq_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpeq_uspd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpeq_uspd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_ueq_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpeq_uspd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpeq_uspd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"ueq",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_ugt_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnlepd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnlepd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_ugt_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnlepd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnlepd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"ugt",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_uge_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnltpd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpnltpd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_uge_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnltpd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpnltpd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"uge",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_ult_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnlepd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnlepd %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_ult_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnlepd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnlepd %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"ult",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_ule_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
 ; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpnltpd %zmm2, %zmm3, %k1
+; AVX512F-32-NEXT:    vcmpnltpd %ymm2, %ymm3, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_ule_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpnltpd %zmm2, %zmm3, %k1
+; AVX512F-64-NEXT:    vcmpnltpd %ymm2, %ymm3, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"ule",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_une_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpneq_uspd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpneq_uspd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_une_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpneq_uspd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpneq_uspd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"une",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res

 ; AVX512-64-NEXT:    retq
 ;
 ; AVX512F-32-LABEL: test_v4f64_uno_s:
 ; AVX512F-32:       # %bb.0:
 ; AVX512F-32-NEXT:    pushl %ebp
 ; AVX512F-32-NEXT:    movl %esp, %ebp
 ; AVX512F-32-NEXT:    andl $-32, %esp
 ; AVX512F-32-NEXT:    subl $32, %esp
-; AVX512F-32-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-32-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-32-NEXT:    vmovapd 8(%ebp), %ymm3
-; AVX512F-32-NEXT:    vcmpunord_spd %zmm3, %zmm2, %k1
+; AVX512F-32-NEXT:    vcmpunord_spd 8(%ebp), %ymm2, %ymm2
+; AVX512F-32-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-32-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-32-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-32-NEXT:    movl %ebp, %esp
 ; AVX512F-32-NEXT:    popl %ebp
 ; AVX512F-32-NEXT:    retl
 ;
 ; AVX512F-64-LABEL: test_v4f64_uno_s:
 ; AVX512F-64:       # %bb.0:
-; AVX512F-64-NEXT:    # kill: def $ymm3 killed $ymm3 def $zmm3
-; AVX512F-64-NEXT:    # kill: def $ymm2 killed $ymm2 def $zmm2
 ; AVX512F-64-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
-; AVX512F-64-NEXT:    vcmpunord_spd %zmm3, %zmm2, %k1
+; AVX512F-64-NEXT:    vcmpunord_spd %ymm3, %ymm2, %ymm2
+; AVX512F-64-NEXT:    vptestmq %zmm2, %zmm2, %k1
 ; AVX512F-64-NEXT:    vpblendmq %zmm0, %zmm1, %zmm0 {%k1}
 ; AVX512F-64-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; AVX512F-64-NEXT:    retq
   %cond = call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(
                                                <4 x double> %f1, <4 x double> %f2, metadata !"uno",
                                                metadata !"fpexcept.strict") #0
   %res = select <4 x i1> %cond, <4 x i64> %a, <4 x i64> %b
   ret <4 x i64> %res
 }
 
 attributes #0 = { strictfp nounwind }
 
 declare <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float>, <8 x float>, metadata, metadata)
 declare <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double>, <4 x double>, metadata, metadata)
 declare <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float>, <8 x float>, metadata, metadata)
 declare <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double>, <4 x double>, metadata, metadata)