[AArch64] Emit vector FP cmp when LE is used with fast-math

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

SDValue DAGCombiner::foldSextSetcc(SDNode *N) {
 
   SDValue N00 = N0.getOperand(0);
   SDValue N01 = N0.getOperand(1);
   ISD::CondCode CC = cast<CondCodeSDNode>(N0.getOperand(2))->get();
   EVT VT = N->getValueType(0);
   EVT N00VT = N00.getValueType();
   SDLoc DL(N);
 
+  // Propagate fast-math-flags.
+  SelectionDAG::FlagInserter FlagsInserter(DAG, N0->getFlags());
+
   // On some architectures (such as SSE/NEON/etc) the SETCC result type is
   // the same size as the compared operands. Try to optimize sext(setcc())
   // if this is the case.
   if (VT.isVector() && !LegalOperations &&
       TLI.getBooleanContents(N00VT) ==
           TargetLowering::ZeroOrNegativeOneBooleanContent) {
     EVT SVT = getSetCCResultType(N00VT);
 
SDValue DAGCombiner::visitZERO_EXTEND(SDNode *N) {
   if (SDValue foldedExt = tryToFoldExtOfExtload(
           DAG, *this, TLI, VT, LegalOperations, N, N0, ISD::ZEXTLOAD))
     return foldedExt;
 
   if (SDValue V = foldExtendedSignBitTest(N, DAG, LegalOperations))
     return V;
 
   if (N0.getOpcode() == ISD::SETCC) {
+    // Propagate fast-math-flags.
+    SelectionDAG::FlagInserter FlagsInserter(DAG, N0->getFlags());
+
     // Only do this before legalize for now.
     if (!LegalOperations && VT.isVector() &&
         N0.getValueType().getVectorElementType() == MVT::i1) {
       EVT N00VT = N0.getOperand(0).getValueType();
       if (getSetCCResultType(N00VT) == N0.getValueType())
         return SDValue();
 
       // We know that the # elements of the results is the same as the #
if (!LegalOperations || TLI.isLoadExtLegal(ExtType, VT, MemVT)) {
       CombineTo(N, ExtLoad);
       DAG.ReplaceAllUsesOfValueWith(SDValue(LN0, 1), ExtLoad.getValue(1));
       recursivelyDeleteUnusedNodes(LN0);
       return SDValue(N, 0);   // Return N so it doesn't get rechecked!
     }
   }
 
   if (N0.getOpcode() == ISD::SETCC) {
+    // Propagate fast-math-flags.
+    SelectionDAG::FlagInserter FlagsInserter(DAG, N0->getFlags());
+
     // For vectors:
     // aext(setcc) -> vsetcc
     // aext(setcc) -> truncate(vsetcc)
     // aext(setcc) -> aext(vsetcc)
     // Only do this before legalize for now.
     if (VT.isVector() && !LegalOperations) {
       EVT N00VT = N0.getOperand(0).getValueType();
       if (getSetCCResultType(N00VT) == N0.getValueType())

llvm/lib/Target/AArch64/AArch64ISelLowering.cpp

if (SrcVT.getVectorElementType().isFloatingPoint()) {
     case AArch64CC::GE:
       if (IsZero)
         return DAG.getNode(AArch64ISD::FCMGEz, dl, VT, LHS);
       return DAG.getNode(AArch64ISD::FCMGE, dl, VT, LHS, RHS);
     case AArch64CC::GT:
       if (IsZero)
         return DAG.getNode(AArch64ISD::FCMGTz, dl, VT, LHS);
       return DAG.getNode(AArch64ISD::FCMGT, dl, VT, LHS, RHS);
+    case AArch64CC::LE:
+      if (!NoNans)
+        return SDValue();
+      // If we ignore NaNs then we can use to the LS implementation.
+      LLVM_FALLTHROUGH;
     case AArch64CC::LS:
       if (IsZero)
         return DAG.getNode(AArch64ISD::FCMLEz, dl, VT, LHS);
       return DAG.getNode(AArch64ISD::FCMGE, dl, VT, RHS, LHS);
     case AArch64CC::LT:
       if (!NoNans)
         return SDValue();
       // If we ignore NaNs then we can use to the MI implementation.
assert((!FullFP16 && LHS.getValueType().getVectorElementType() != MVT::f16) ||
           LHS.getValueType().getVectorElementType() != MVT::f128);
 
   // Unfortunately, the mapping of LLVM FP CC's onto AArch64 CC's isn't totally
   // clean.  Some of them require two branches to implement.
   AArch64CC::CondCode CC1, CC2;
   bool ShouldInvert;
   changeVectorFPCCToAArch64CC(CC, CC1, CC2, ShouldInvert);
 
-  bool NoNaNs = getTargetMachine().Options.NoNaNsFPMath;
+  bool NoNaNs = getTargetMachine().Options.NoNaNsFPMath || Op->getFlags().hasNoNaNs();
   SDValue Cmp =
       EmitVectorComparison(LHS, RHS, CC1, NoNaNs, CmpVT, dl, DAG);
   if (!Cmp.getNode())
     return SDValue();
 
   if (CC2 != AArch64CC::AL) {
     SDValue Cmp2 =
         EmitVectorComparison(LHS, RHS, CC2, NoNaNs, CmpVT, dl, DAG);

llvm/test/CodeGen/AArch64/neon-compare-instructions.ll

; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ogt <2 x double> %A, %B
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i64>
   ret <2 x i64> %tmp4
 }
 
 define <2 x i32> @fcmole2xfloat_fast(<2 x float> %A, <2 x float> %B) {
 ; CHECK-LABEL: fcmole2xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    // kill: def $d1 killed $d1 def $q1
-; CHECK-NEXT:    // kill: def $d0 killed $d0 def $q0
-; CHECK-NEXT:    mov s2, v1.s[1]
-; CHECK-NEXT:    mov s3, v0.s[1]
-; CHECK-NEXT:    fcmp s3, s2
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    csetm w9, le
-; CHECK-NEXT:    fmov s0, w9
-; CHECK-NEXT:    mov v0.s[1], w8
-; CHECK-NEXT:    // kill: def $d0 killed $d0 killed $q0
+; CHECK-NEXT:    fcmge v0.2s, v1.2s, v0.2s
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmole2xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmge v0.2s, v1.2s, v0.2s
 ; GISEL-NEXT:    shl v0.2s, v0.2s, #31
 ; GISEL-NEXT:    sshr v0.2s, v0.2s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ole <2 x float> %A, %B
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i32>
   ret <2 x i32> %tmp4
 }
 
 define <4 x i32> @fcmole4xfloat_fast(<4 x float> %A, <4 x float> %B) {
 ; CHECK-LABEL: fcmole4xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov s2, v1.s[1]
-; CHECK-NEXT:    mov s3, v0.s[1]
-; CHECK-NEXT:    mov s4, v0.s[2]
-; CHECK-NEXT:    fcmp s3, s2
-; CHECK-NEXT:    mov s3, v1.s[2]
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    mov s1, v1.s[3]
-; CHECK-NEXT:    mov s0, v0.s[3]
-; CHECK-NEXT:    csetm w9, le
-; CHECK-NEXT:    fcmp s4, s3
-; CHECK-NEXT:    fmov s2, w9
-; CHECK-NEXT:    mov v2.s[1], w8
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    mov v2.s[2], w8
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    mov v2.s[3], w8
-; CHECK-NEXT:    mov v0.16b, v2.16b
+; CHECK-NEXT:    fcmge v0.4s, v1.4s, v0.4s
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmole4xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmge v0.4s, v1.4s, v0.4s
 ; GISEL-NEXT:    shl v0.4s, v0.4s, #31
 ; GISEL-NEXT:    sshr v0.4s, v0.4s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ole <4 x float> %A, %B
   %tmp4 = sext <4 x i1> %tmp3 to <4 x i32>
   ret <4 x i32> %tmp4
 }
 
 define <2 x i64> @fcmole2xdouble_fast(<2 x double> %A, <2 x double> %B) {
 ; CHECK-LABEL: fcmole2xdouble_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov d2, v1.d[1]
-; CHECK-NEXT:    mov d3, v0.d[1]
-; CHECK-NEXT:    fcmp d3, d2
-; CHECK-NEXT:    csetm x8, le
-; CHECK-NEXT:    fcmp d0, d1
-; CHECK-NEXT:    csetm x9, le
-; CHECK-NEXT:    fmov d0, x9
-; CHECK-NEXT:    mov v0.d[1], x8
+; CHECK-NEXT:    fcmge v0.2d, v1.2d, v0.2d
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmole2xdouble_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmge v0.2d, v1.2d, v0.2d
 ; GISEL-NEXT:    shl v0.2d, v0.2d, #63
 ; GISEL-NEXT:    sshr v0.2d, v0.2d, #63
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ole <2 x double> %A, %B
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i64>
   ret <2 x i64> %tmp4
 }
 
 define <2 x i32> @fcmolt2xfloat_fast(<2 x float> %A, <2 x float> %B) {
 ; CHECK-LABEL: fcmolt2xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    // kill: def $d1 killed $d1 def $q1
-; CHECK-NEXT:    // kill: def $d0 killed $d0 def $q0
-; CHECK-NEXT:    mov s2, v1.s[1]
-; CHECK-NEXT:    mov s3, v0.s[1]
-; CHECK-NEXT:    fcmp s3, s2
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    csetm w9, lt
-; CHECK-NEXT:    fmov s0, w9
-; CHECK-NEXT:    mov v0.s[1], w8
-; CHECK-NEXT:    // kill: def $d0 killed $d0 killed $q0
+; CHECK-NEXT:    fcmgt v0.2s, v1.2s, v0.2s
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmolt2xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmgt v0.2s, v1.2s, v0.2s
 ; GISEL-NEXT:    shl v0.2s, v0.2s, #31
 ; GISEL-NEXT:    sshr v0.2s, v0.2s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast olt <2 x float> %A, %B
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i32>
   ret <2 x i32> %tmp4
 }
 
 define <4 x i32> @fcmolt4xfloat_fast(<4 x float> %A, <4 x float> %B) {
 ; CHECK-LABEL: fcmolt4xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov s2, v1.s[1]
-; CHECK-NEXT:    mov s3, v0.s[1]
-; CHECK-NEXT:    mov s4, v0.s[2]
-; CHECK-NEXT:    fcmp s3, s2
-; CHECK-NEXT:    mov s3, v1.s[2]
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    mov s1, v1.s[3]
-; CHECK-NEXT:    mov s0, v0.s[3]
-; CHECK-NEXT:    csetm w9, lt
-; CHECK-NEXT:    fcmp s4, s3
-; CHECK-NEXT:    fmov s2, w9
-; CHECK-NEXT:    mov v2.s[1], w8
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    mov v2.s[2], w8
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    mov v2.s[3], w8
-; CHECK-NEXT:    mov v0.16b, v2.16b
+; CHECK-NEXT:    fcmgt v0.4s, v1.4s, v0.4s
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmolt4xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmgt v0.4s, v1.4s, v0.4s
 ; GISEL-NEXT:    shl v0.4s, v0.4s, #31
 ; GISEL-NEXT:    sshr v0.4s, v0.4s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast olt <4 x float> %A, %B
   %tmp4 = sext <4 x i1> %tmp3 to <4 x i32>
   ret <4 x i32> %tmp4
 }
 
 define <2 x i64> @fcmolt2xdouble_fast(<2 x double> %A, <2 x double> %B) {
 ; CHECK-LABEL: fcmolt2xdouble_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov d2, v1.d[1]
-; CHECK-NEXT:    mov d3, v0.d[1]
-; CHECK-NEXT:    fcmp d3, d2
-; CHECK-NEXT:    csetm x8, lt
-; CHECK-NEXT:    fcmp d0, d1
-; CHECK-NEXT:    csetm x9, lt
-; CHECK-NEXT:    fmov d0, x9
-; CHECK-NEXT:    mov v0.d[1], x8
+; CHECK-NEXT:    fcmgt v0.2d, v1.2d, v0.2d
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmolt2xdouble_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmgt v0.2d, v1.2d, v0.2d
 ; GISEL-NEXT:    shl v0.2d, v0.2d, #63
 ; GISEL-NEXT:    sshr v0.2d, v0.2d, #63
 ; GISEL-NEXT:    ret
; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ugt <2 x double> %A, %B
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i64>
   ret <2 x i64> %tmp4
 }
 
 define <2 x i32> @fcmule2xfloat_fast(<2 x float> %A, <2 x float> %B) {
 ; CHECK-LABEL: fcmule2xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    // kill: def $d1 killed $d1 def $q1
-; CHECK-NEXT:    // kill: def $d0 killed $d0 def $q0
-; CHECK-NEXT:    mov s2, v1.s[1]
-; CHECK-NEXT:    mov s3, v0.s[1]
-; CHECK-NEXT:    fcmp s3, s2
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    csetm w9, le
-; CHECK-NEXT:    fmov s0, w9
-; CHECK-NEXT:    mov v0.s[1], w8
-; CHECK-NEXT:    // kill: def $d0 killed $d0 killed $q0
+; CHECK-NEXT:    fcmge v0.2s, v1.2s, v0.2s
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmule2xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmgt v0.2s, v0.2s, v1.2s
 ; GISEL-NEXT:    mvn v0.8b, v0.8b
 ; GISEL-NEXT:    shl v0.2s, v0.2s, #31
 ; GISEL-NEXT:    sshr v0.2s, v0.2s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ule <2 x float> %A, %B
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i32>
   ret <2 x i32> %tmp4
 }
 
 define <4 x i32> @fcmule4xfloat_fast(<4 x float> %A, <4 x float> %B) {
 ; CHECK-LABEL: fcmule4xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov s2, v1.s[1]
-; CHECK-NEXT:    mov s3, v0.s[1]
-; CHECK-NEXT:    mov s4, v0.s[2]
-; CHECK-NEXT:    fcmp s3, s2
-; CHECK-NEXT:    mov s3, v1.s[2]
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    mov s1, v1.s[3]
-; CHECK-NEXT:    mov s0, v0.s[3]
-; CHECK-NEXT:    csetm w9, le
-; CHECK-NEXT:    fcmp s4, s3
-; CHECK-NEXT:    fmov s2, w9
-; CHECK-NEXT:    mov v2.s[1], w8
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    mov v2.s[2], w8
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    mov v2.s[3], w8
-; CHECK-NEXT:    mov v0.16b, v2.16b
+; CHECK-NEXT:    fcmge v0.4s, v1.4s, v0.4s
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmule4xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmgt v0.4s, v0.4s, v1.4s
 ; GISEL-NEXT:    mvn v0.16b, v0.16b
 ; GISEL-NEXT:    shl v0.4s, v0.4s, #31
 ; GISEL-NEXT:    sshr v0.4s, v0.4s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ule <4 x float> %A, %B
   %tmp4 = sext <4 x i1> %tmp3 to <4 x i32>
   ret <4 x i32> %tmp4
 }
 
 define <2 x i64> @fcmule2xdouble_fast(<2 x double> %A, <2 x double> %B) {
 ; CHECK-LABEL: fcmule2xdouble_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov d2, v1.d[1]
-; CHECK-NEXT:    mov d3, v0.d[1]
-; CHECK-NEXT:    fcmp d3, d2
-; CHECK-NEXT:    csetm x8, le
-; CHECK-NEXT:    fcmp d0, d1
-; CHECK-NEXT:    csetm x9, le
-; CHECK-NEXT:    fmov d0, x9
-; CHECK-NEXT:    mov v0.d[1], x8
+; CHECK-NEXT:    fcmge v0.2d, v1.2d, v0.2d
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmule2xdouble_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmgt v0.2d, v0.2d, v1.2d
 ; GISEL-NEXT:    mvn v0.16b, v0.16b
 ; GISEL-NEXT:    shl v0.2d, v0.2d, #63
 ; GISEL-NEXT:    sshr v0.2d, v0.2d, #63
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ule <2 x double> %A, %B
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i64>
   ret <2 x i64> %tmp4
 }
 
 define <2 x i32> @fcmult2xfloat_fast(<2 x float> %A, <2 x float> %B) {
 ; CHECK-LABEL: fcmult2xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    // kill: def $d1 killed $d1 def $q1
-; CHECK-NEXT:    // kill: def $d0 killed $d0 def $q0
-; CHECK-NEXT:    mov s2, v1.s[1]
-; CHECK-NEXT:    mov s3, v0.s[1]
-; CHECK-NEXT:    fcmp s3, s2
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    csetm w9, lt
-; CHECK-NEXT:    fmov s0, w9
-; CHECK-NEXT:    mov v0.s[1], w8
-; CHECK-NEXT:    // kill: def $d0 killed $d0 killed $q0
+; CHECK-NEXT:    fcmgt v0.2s, v1.2s, v0.2s
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmult2xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmge v0.2s, v0.2s, v1.2s
 ; GISEL-NEXT:    mvn v0.8b, v0.8b
 ; GISEL-NEXT:    shl v0.2s, v0.2s, #31
 ; GISEL-NEXT:    sshr v0.2s, v0.2s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ult <2 x float> %A, %B
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i32>
   ret <2 x i32> %tmp4
 }
 
 define <4 x i32> @fcmult4xfloat_fast(<4 x float> %A, <4 x float> %B) {
 ; CHECK-LABEL: fcmult4xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov s2, v1.s[1]
-; CHECK-NEXT:    mov s3, v0.s[1]
-; CHECK-NEXT:    mov s4, v0.s[2]
-; CHECK-NEXT:    fcmp s3, s2
-; CHECK-NEXT:    mov s3, v1.s[2]
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    mov s1, v1.s[3]
-; CHECK-NEXT:    mov s0, v0.s[3]
-; CHECK-NEXT:    csetm w9, lt
-; CHECK-NEXT:    fcmp s4, s3
-; CHECK-NEXT:    fmov s2, w9
-; CHECK-NEXT:    mov v2.s[1], w8
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    mov v2.s[2], w8
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    mov v2.s[3], w8
-; CHECK-NEXT:    mov v0.16b, v2.16b
+; CHECK-NEXT:    fcmgt v0.4s, v1.4s, v0.4s
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmult4xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmge v0.4s, v0.4s, v1.4s
 ; GISEL-NEXT:    mvn v0.16b, v0.16b
 ; GISEL-NEXT:    shl v0.4s, v0.4s, #31
 ; GISEL-NEXT:    sshr v0.4s, v0.4s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ult <4 x float> %A, %B
   %tmp4 = sext <4 x i1> %tmp3 to <4 x i32>
   ret <4 x i32> %tmp4
 }
 
 define <2 x i64> @fcmult2xdouble_fast(<2 x double> %A, <2 x double> %B) {
 ; CHECK-LABEL: fcmult2xdouble_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov d2, v1.d[1]
-; CHECK-NEXT:    mov d3, v0.d[1]
-; CHECK-NEXT:    fcmp d3, d2
-; CHECK-NEXT:    csetm x8, lt
-; CHECK-NEXT:    fcmp d0, d1
-; CHECK-NEXT:    csetm x9, lt
-; CHECK-NEXT:    fmov d0, x9
-; CHECK-NEXT:    mov v0.d[1], x8
+; CHECK-NEXT:    fcmgt v0.2d, v1.2d, v0.2d
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmult2xdouble_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmge v0.2d, v0.2d, v1.2d
 ; GISEL-NEXT:    mvn v0.16b, v0.16b
 ; GISEL-NEXT:    shl v0.2d, v0.2d, #63
 ; GISEL-NEXT:    sshr v0.2d, v0.2d, #63
; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ogt <2 x double> %A, zeroinitializer
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i64>
   ret <2 x i64> %tmp4
 }
 
 define <2 x i32> @fcmoltz2xfloat_fast(<2 x float> %A) {
 ; CHECK-LABEL: fcmoltz2xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    // kill: def $d0 killed $d0 def $q0
-; CHECK-NEXT:    mov s1, v0.s[1]
-; CHECK-NEXT:    fcmp s1, #0.0
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    fcmp s0, #0.0
-; CHECK-NEXT:    csetm w9, lt
-; CHECK-NEXT:    fmov s0, w9
-; CHECK-NEXT:    mov v0.s[1], w8
-; CHECK-NEXT:    // kill: def $d0 killed $d0 killed $q0
+; CHECK-NEXT:    fcmlt v0.2s, v0.2s, #0.0
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmoltz2xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmlt v0.2s, v0.2s, #0.0
 ; GISEL-NEXT:    shl v0.2s, v0.2s, #31
 ; GISEL-NEXT:    sshr v0.2s, v0.2s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast olt <2 x float> %A, zeroinitializer
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i32>
   ret <2 x i32> %tmp4
 }
 
 define <4 x i32> @fcmoltz4xfloat_fast(<4 x float> %A) {
 ; CHECK-LABEL: fcmoltz4xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov s1, v0.s[1]
-; CHECK-NEXT:    mov s2, v0.s[2]
-; CHECK-NEXT:    fcmp s1, #0.0
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    fcmp s0, #0.0
-; CHECK-NEXT:    mov s0, v0.s[3]
-; CHECK-NEXT:    csetm w9, lt
-; CHECK-NEXT:    fcmp s2, #0.0
-; CHECK-NEXT:    fmov s1, w9
-; CHECK-NEXT:    mov v1.s[1], w8
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    fcmp s0, #0.0
-; CHECK-NEXT:    mov v1.s[2], w8
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    mov v1.s[3], w8
-; CHECK-NEXT:    mov v0.16b, v1.16b
+; CHECK-NEXT:    fcmlt v0.4s, v0.4s, #0.0
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmoltz4xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmlt v0.4s, v0.4s, #0.0
 ; GISEL-NEXT:    shl v0.4s, v0.4s, #31
 ; GISEL-NEXT:    sshr v0.4s, v0.4s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast olt <4 x float> %A, zeroinitializer
   %tmp4 = sext <4 x i1> %tmp3 to <4 x i32>
   ret <4 x i32> %tmp4
 }
 
 define <2 x i64> @fcmoltz2xdouble_fast(<2 x double> %A) {
 ; CHECK-LABEL: fcmoltz2xdouble_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov d1, v0.d[1]
-; CHECK-NEXT:    fcmp d1, #0.0
-; CHECK-NEXT:    csetm x8, lt
-; CHECK-NEXT:    fcmp d0, #0.0
-; CHECK-NEXT:    csetm x9, lt
-; CHECK-NEXT:    fmov d0, x9
-; CHECK-NEXT:    mov v0.d[1], x8
+; CHECK-NEXT:    fcmlt v0.2d, v0.2d, #0.0
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmoltz2xdouble_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmlt v0.2d, v0.2d, #0.0
 ; GISEL-NEXT:    shl v0.2d, v0.2d, #63
 ; GISEL-NEXT:    sshr v0.2d, v0.2d, #63
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast olt <2 x double> %A, zeroinitializer
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i64>
   ret <2 x i64> %tmp4
 }
 
 define <2 x i32> @fcmolez2xfloat_fast(<2 x float> %A) {
 ; CHECK-LABEL: fcmolez2xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    // kill: def $d0 killed $d0 def $q0
-; CHECK-NEXT:    mov s1, v0.s[1]
-; CHECK-NEXT:    fcmp s1, #0.0
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, #0.0
-; CHECK-NEXT:    csetm w9, le
-; CHECK-NEXT:    fmov s0, w9
-; CHECK-NEXT:    mov v0.s[1], w8
-; CHECK-NEXT:    // kill: def $d0 killed $d0 killed $q0
+; CHECK-NEXT:    fcmle v0.2s, v0.2s, #0.0
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmolez2xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmle v0.2s, v0.2s, #0.0
 ; GISEL-NEXT:    shl v0.2s, v0.2s, #31
 ; GISEL-NEXT:    sshr v0.2s, v0.2s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ole <2 x float> %A, zeroinitializer
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i32>
   ret <2 x i32> %tmp4
 }
 
 define <4 x i32> @fcmolez4xfloat_fast(<4 x float> %A) {
 ; CHECK-LABEL: fcmolez4xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov s1, v0.s[1]
-; CHECK-NEXT:    mov s2, v0.s[2]
-; CHECK-NEXT:    fcmp s1, #0.0
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, #0.0
-; CHECK-NEXT:    mov s0, v0.s[3]
-; CHECK-NEXT:    csetm w9, le
-; CHECK-NEXT:    fcmp s2, #0.0
-; CHECK-NEXT:    fmov s1, w9
-; CHECK-NEXT:    mov v1.s[1], w8
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, #0.0
-; CHECK-NEXT:    mov v1.s[2], w8
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    mov v1.s[3], w8
-; CHECK-NEXT:    mov v0.16b, v1.16b
+; CHECK-NEXT:    fcmle v0.4s, v0.4s, #0.0
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmolez4xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmle v0.4s, v0.4s, #0.0
 ; GISEL-NEXT:    shl v0.4s, v0.4s, #31
 ; GISEL-NEXT:    sshr v0.4s, v0.4s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ole <4 x float> %A, zeroinitializer
   %tmp4 = sext <4 x i1> %tmp3 to <4 x i32>
   ret <4 x i32> %tmp4
 }
 
 define <2 x i64> @fcmolez2xdouble_fast(<2 x double> %A) {
 ; CHECK-LABEL: fcmolez2xdouble_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov d1, v0.d[1]
-; CHECK-NEXT:    fcmp d1, #0.0
-; CHECK-NEXT:    csetm x8, le
-; CHECK-NEXT:    fcmp d0, #0.0
-; CHECK-NEXT:    csetm x9, le
-; CHECK-NEXT:    fmov d0, x9
-; CHECK-NEXT:    mov v0.d[1], x8
+; CHECK-NEXT:    fcmle v0.2d, v0.2d, #0.0
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmolez2xdouble_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmle v0.2d, v0.2d, #0.0
 ; GISEL-NEXT:    shl v0.2d, v0.2d, #63
 ; GISEL-NEXT:    sshr v0.2d, v0.2d, #63
 ; GISEL-NEXT:    ret
; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ugt <2 x double> %A, zeroinitializer
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i64>
   ret <2 x i64> %tmp4
 }
 
 define <2 x i32> @fcmultz2xfloat_fast(<2 x float> %A) {
 ; CHECK-LABEL: fcmultz2xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    // kill: def $d0 killed $d0 def $q0
-; CHECK-NEXT:    mov s1, v0.s[1]
-; CHECK-NEXT:    fcmp s1, #0.0
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    fcmp s0, #0.0
-; CHECK-NEXT:    csetm w9, lt
-; CHECK-NEXT:    fmov s0, w9
-; CHECK-NEXT:    mov v0.s[1], w8
-; CHECK-NEXT:    // kill: def $d0 killed $d0 killed $q0
+; CHECK-NEXT:    fcmlt v0.2s, v0.2s, #0.0
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmultz2xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmge v0.2s, v0.2s, #0.0
 ; GISEL-NEXT:    mvn v0.8b, v0.8b
 ; GISEL-NEXT:    shl v0.2s, v0.2s, #31
 ; GISEL-NEXT:    sshr v0.2s, v0.2s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ult <2 x float> %A, zeroinitializer
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i32>
   ret <2 x i32> %tmp4
 }
 
 define <4 x i32> @fcmultz4xfloat_fast(<4 x float> %A) {
 ; CHECK-LABEL: fcmultz4xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov s1, v0.s[1]
-; CHECK-NEXT:    mov s2, v0.s[2]
-; CHECK-NEXT:    fcmp s1, #0.0
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    fcmp s0, #0.0
-; CHECK-NEXT:    mov s0, v0.s[3]
-; CHECK-NEXT:    csetm w9, lt
-; CHECK-NEXT:    fcmp s2, #0.0
-; CHECK-NEXT:    fmov s1, w9
-; CHECK-NEXT:    mov v1.s[1], w8
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    fcmp s0, #0.0
-; CHECK-NEXT:    mov v1.s[2], w8
-; CHECK-NEXT:    csetm w8, lt
-; CHECK-NEXT:    mov v1.s[3], w8
-; CHECK-NEXT:    mov v0.16b, v1.16b
+; CHECK-NEXT:    fcmlt v0.4s, v0.4s, #0.0
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmultz4xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmge v0.4s, v0.4s, #0.0
 ; GISEL-NEXT:    mvn v0.16b, v0.16b
 ; GISEL-NEXT:    shl v0.4s, v0.4s, #31
 ; GISEL-NEXT:    sshr v0.4s, v0.4s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ult <4 x float> %A, zeroinitializer
   %tmp4 = sext <4 x i1> %tmp3 to <4 x i32>
   ret <4 x i32> %tmp4
 }
 
 define <2 x i64> @fcmultz2xdouble_fast(<2 x double> %A) {
 ; CHECK-LABEL: fcmultz2xdouble_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov d1, v0.d[1]
-; CHECK-NEXT:    fcmp d1, #0.0
-; CHECK-NEXT:    csetm x8, lt
-; CHECK-NEXT:    fcmp d0, #0.0
-; CHECK-NEXT:    csetm x9, lt
-; CHECK-NEXT:    fmov d0, x9
-; CHECK-NEXT:    mov v0.d[1], x8
+; CHECK-NEXT:    fcmlt v0.2d, v0.2d, #0.0
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmultz2xdouble_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmge v0.2d, v0.2d, #0.0
 ; GISEL-NEXT:    mvn v0.16b, v0.16b
 ; GISEL-NEXT:    shl v0.2d, v0.2d, #63
 ; GISEL-NEXT:    sshr v0.2d, v0.2d, #63
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ult <2 x double> %A, zeroinitializer
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i64>
   ret <2 x i64> %tmp4
 }
 
 ; ULE with zero = !OGT
 define <2 x i32> @fcmulez2xfloat_fast(<2 x float> %A) {
 ; CHECK-LABEL: fcmulez2xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    // kill: def $d0 killed $d0 def $q0
-; CHECK-NEXT:    mov s1, v0.s[1]
-; CHECK-NEXT:    fcmp s1, #0.0
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, #0.0
-; CHECK-NEXT:    csetm w9, le
-; CHECK-NEXT:    fmov s0, w9
-; CHECK-NEXT:    mov v0.s[1], w8
-; CHECK-NEXT:    // kill: def $d0 killed $d0 killed $q0
+; CHECK-NEXT:    fcmle v0.2s, v0.2s, #0.0
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmulez2xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmgt v0.2s, v0.2s, #0.0
 ; GISEL-NEXT:    mvn v0.8b, v0.8b
 ; GISEL-NEXT:    shl v0.2s, v0.2s, #31
 ; GISEL-NEXT:    sshr v0.2s, v0.2s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ule <2 x float> %A, zeroinitializer
   %tmp4 = sext <2 x i1> %tmp3 to <2 x i32>
   ret <2 x i32> %tmp4
 }
 
 define <4 x i32> @fcmulez4xfloat_fast(<4 x float> %A) {
 ; CHECK-LABEL: fcmulez4xfloat_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov s1, v0.s[1]
-; CHECK-NEXT:    mov s2, v0.s[2]
-; CHECK-NEXT:    fcmp s1, #0.0
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, #0.0
-; CHECK-NEXT:    mov s0, v0.s[3]
-; CHECK-NEXT:    csetm w9, le
-; CHECK-NEXT:    fcmp s2, #0.0
-; CHECK-NEXT:    fmov s1, w9
-; CHECK-NEXT:    mov v1.s[1], w8
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, #0.0
-; CHECK-NEXT:    mov v1.s[2], w8
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    mov v1.s[3], w8
-; CHECK-NEXT:    mov v0.16b, v1.16b
+; CHECK-NEXT:    fcmle v0.4s, v0.4s, #0.0
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmulez4xfloat_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmgt v0.4s, v0.4s, #0.0
 ; GISEL-NEXT:    mvn v0.16b, v0.16b
 ; GISEL-NEXT:    shl v0.4s, v0.4s, #31
 ; GISEL-NEXT:    sshr v0.4s, v0.4s, #31
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ule <4 x float> %A, zeroinitializer
   %tmp4 = sext <4 x i1> %tmp3 to <4 x i32>
   ret <4 x i32> %tmp4
 }
 
 define <2 x i64> @fcmulez2xdouble_fast(<2 x double> %A) {
 ; CHECK-LABEL: fcmulez2xdouble_fast:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov d1, v0.d[1]
-; CHECK-NEXT:    fcmp d1, #0.0
-; CHECK-NEXT:    csetm x8, le
-; CHECK-NEXT:    fcmp d0, #0.0
-; CHECK-NEXT:    csetm x9, le
-; CHECK-NEXT:    fmov d0, x9
-; CHECK-NEXT:    mov v0.d[1], x8
+; CHECK-NEXT:    fcmle v0.2d, v0.2d, #0.0
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmulez2xdouble_fast:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmgt v0.2d, v0.2d, #0.0
 ; GISEL-NEXT:    mvn v0.16b, v0.16b
 ; GISEL-NEXT:    shl v0.2d, v0.2d, #63
 ; GISEL-NEXT:    sshr v0.2d, v0.2d, #63
; GISEL-NEXT:    ret
   ret <2 x i64> %tmp4
 
 }
 
 ; Test SETCC fast-math flags are propagated when combining zext(setcc).
 define <4 x i32> @fcmule4xfloat_fast_zext(<4 x float> %A, <4 x float> %B) {
 ; CHECK-LABEL: fcmule4xfloat_fast_zext:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov s3, v1.s[1]
-; CHECK-NEXT:    mov s4, v0.s[1]
 ; CHECK-NEXT:    movi v2.4s, #1
-; CHECK-NEXT:    fcmp s4, s3
-; CHECK-NEXT:    mov s3, v1.s[2]
-; CHECK-NEXT:    mov s4, v0.s[2]
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    mov s1, v1.s[3]
-; CHECK-NEXT:    mov s0, v0.s[3]
-; CHECK-NEXT:    csetm w9, le
-; CHECK-NEXT:    fcmp s4, s3
-; CHECK-NEXT:    fmov s3, w9
-; CHECK-NEXT:    mov v3.s[1], w8
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    mov v3.s[2], w8
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    mov v3.s[3], w8
-; CHECK-NEXT:    and v0.16b, v3.16b, v2.16b
+; CHECK-NEXT:    fcmge v0.4s, v1.4s, v0.4s
+; CHECK-NEXT:    and v0.16b, v0.16b, v2.16b
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmule4xfloat_fast_zext:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    adrp x8, .LCPI322_0
 ; GISEL-NEXT:    fcmgt v0.4s, v0.4s, v1.4s
 ; GISEL-NEXT:    ldr q1, [x8, :lo12:.LCPI322_0]
 ; GISEL-NEXT:    bic v0.16b, v1.16b, v0.16b
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ule <4 x float> %A, %B
   %tmp4 = zext <4 x i1> %tmp3 to <4 x i32>
   ret <4 x i32> %tmp4
 }
 
 ; Test SETCC fast-math flags are propagated when combining aext(setcc).
 define <4 x i1> @fcmule4xfloat_fast_aext(<4 x float> %A, <4 x float> %B) {
 ; CHECK-LABEL: fcmule4xfloat_fast_aext:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    mov s2, v1.s[1]
-; CHECK-NEXT:    mov s3, v0.s[1]
-; CHECK-NEXT:    fcmp s3, s2
-; CHECK-NEXT:    mov s2, v1.s[2]
-; CHECK-NEXT:    mov s3, v0.s[2]
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    mov s1, v1.s[3]
-; CHECK-NEXT:    mov s0, v0.s[3]
-; CHECK-NEXT:    csetm w9, le
-; CHECK-NEXT:    fcmp s3, s2
-; CHECK-NEXT:    fmov s4, w9
-; CHECK-NEXT:    mov v4.s[1], w8
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    fcmp s0, s1
-; CHECK-NEXT:    mov v4.s[2], w8
-; CHECK-NEXT:    csetm w8, le
-; CHECK-NEXT:    mov v4.s[3], w8
-; CHECK-NEXT:    xtn v0.4h, v4.4s
+; CHECK-NEXT:    fcmge v0.4s, v1.4s, v0.4s
+; CHECK-NEXT:    xtn v0.4h, v0.4s
 ; CHECK-NEXT:    ret
 ;
 ; GISEL-LABEL: fcmule4xfloat_fast_aext:
 ; GISEL:       // %bb.0:
 ; GISEL-NEXT:    fcmgt v0.4s, v0.4s, v1.4s
 ; GISEL-NEXT:    mvn v0.16b, v0.16b
 ; GISEL-NEXT:    xtn v0.4h, v0.4s
 ; GISEL-NEXT:    ret
   %tmp3 = fcmp fast ule <4 x float> %A, %B
   ret <4 x i1> %tmp3
 }