[InstSimplify] More fcmp cases when comparing against negative constants.

[paulwalker-arm]

Summary

For known positive non-zero value X:

fcmp uge X, -C => true
fcmp ugt X, -C => true
fcmp une X, -C => true
fcmp oeq X, -C => false
fcmp ole X, -C => false
fcmp olt X, -C => false

Patch by Paul Walker.

[fhahn]

Looks like a straight-forward simplification to me, but it would be good if someone else could have a look too.

[spatel]

The tests should go under tests/Transforms/InstSimplify since this is handled outside of InstCombine.
I went ahead and added variants of the original tests plus a couple of extras with r319041. The extra tests show at least one possible extension to handle other fcmp predicates. A more general extension might involve a range test rather than using CannotBeOrderedLessThanZero()?

lib/Analysis/InstructionSimplify.cpp

3367–3368

We've already handled isNaN above here? Could assert instead of re-checking that condition or just remove it.

3371

Should add a comment for symmetry:
X > 0 or X > -C

[paulwalker-arm]

Broke out the isNegative case into its own block so that more conditions can be handled when it's known the constant is non-zero. Removed my original tests and updated the existing ones to reflect the optimised output.

[spatel]

LGTM.

Please add a 'TODO' comment in the new block of code about extending this. We should have cases for 'UNE' and 'OEQ' predicates too?

[paulwalker-arm]

Good point, I'll add the extra conditions along with the TODO.

[paulwalker-arm]

Extended to cover une and oeq conditions. Added an assert to protect against unintentional refactoring and a TODO for future improvements.

[spatel]

lib/Analysis/InstructionSimplify.cpp

3382

Nit: The assert string would confuse me if we ever hit that because -NaN actually is a (set of) FP value(s).

"Unexpected NaN constant" ?

test/Transforms/InstCombine/cast-int-fcmp-eq-0.ll

334–341

Can you move this and the related tests over to the instsimplify file?

Nit: I'd prefer to change these constants to '-1.0' or whatever they are rather than trying to decode hex values. :)

[paulwalker-arm]

test/Transforms/InstCombine/cast-int-fcmp-eq-0.ll

334–341

Will do. Are there any objections to me maintaining the same number of tests within InstSimplify/floating-point-compare.ll but replacing some uses of fabs with uitofp?

[spatel]

test/Transforms/InstCombine/cast-int-fcmp-eq-0.ll

334–341

Sounds ok to me. As long we're covering all of the predicates and have some vector tests too, that should keep the fold tested well enough. Might want to vary double/float/half as well just to be sure we hit more types.

[paulwalker-arm]

Removed three instcombine tests that are either covered by existing instsimplify tests of have equivalent instsimplify tests provided by this patch.

[spatel]

LGTM.

lib/Analysis/InstructionSimplify.cpp

if (C->isInfinity()) {
         case FCmpInst::FCMP_ULE:
           // All values are unordered with and at most infinity.
           return getTrue(RetTy);
         default:
           break;
         }
       }
     }
     if (C->isZero()) {
       switch (Pred) {
       case FCmpInst::FCMP_UGE:
         if (CannotBeOrderedLessThanZero(LHS, Q.TLI))
           return getTrue(RetTy);
         break;
       case FCmpInst::FCMP_OLT:
         // X < 0
         if (CannotBeOrderedLessThanZero(LHS, Q.TLI))
           return getFalse(RetTy);
         break;
       default:
         break;
       }
+    } else if (C->isNegative()) {
+      assert(!C->isNaN() && "Unexpected NaN constant!");
+      // TODO: We can catch more cases by using a range check rather than
+      //       relying on CannotBeOrderedLessThanZero.
+      switch (Pred) {
+      case FCmpInst::FCMP_UGE:
+      case FCmpInst::FCMP_UGT:
+      case FCmpInst::FCMP_UNE:
+        // (X >= 0) implies (X > C) when (C < 0)
+        if (CannotBeOrderedLessThanZero(LHS, Q.TLI))
+          return getTrue(RetTy);
+        break;
+      case FCmpInst::FCMP_OEQ:
+      case FCmpInst::FCMP_OLE:
+      case FCmpInst::FCMP_OLT:
+        // (X >= 0) implies !(X < C) when (C < 0)
+        if (CannotBeOrderedLessThanZero(LHS, Q.TLI))
+          return getFalse(RetTy);
+        break;
+      default:
+        break;
+      }
     }
   }
 
   // If the comparison is with the result of a select instruction, check whether
   // comparing with either branch of the select always yields the same value.
   if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS))
     if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, Q, MaxRecurse))
       return V;

test/Transforms/InstCombine/cast-int-fcmp-eq-0.ll

 ; CHECK: icmp slt i32 %i, 1
 ; CHECK-NEXT: ret
 define i1 @i32_cast_cmp_ole_int_0_sitofp(i32 %i) {
   %f = sitofp i32 %i to float
   %cmp = fcmp ole float %f, 0.0
   ret i1 %cmp
 }
 
-; CHECK-LABEL: @i32_cast_cmp_olt_int_0_uitofp(
-; CHECK: ret i1 false
-define i1 @i32_cast_cmp_olt_int_0_uitofp(i32 %i) {
-  %f = uitofp i32 %i to float
-  %cmp = fcmp olt float %f, 0.0
-  ret i1 %cmp
-}
-
 ; CHECK-LABEL: @i32_cast_cmp_olt_int_0_sitofp(
 ; CHECK: icmp slt i32 %i, 0
 ; CHECK-NEXT: ret
 define i1 @i32_cast_cmp_olt_int_0_sitofp(i32 %i) {
   %f = sitofp i32 %i to float
   %cmp = fcmp olt float %f, 0.0
   ret i1 %cmp
 }

 ; CHECK-LABEL: @i32_cast_cmp_oeq_int_i32umax_sitofp(
 ; CHECK-NEXT: ret i1 false
 define i1 @i32_cast_cmp_oeq_int_i32umax_sitofp(i32 %i) {
   %f = sitofp i32 %i to float
   %cmp = fcmp oeq float %f, 0x41F0000000000000
   ret i1 %cmp
 }
 
-; CHECK-LABEL: @i32_cast_cmp_oeq_int_i32imin_uitofp(
-; CHECK: uitofp
-; CHECK: fcmp oeq
-; CHECK-NEXT: ret
-define i1 @i32_cast_cmp_oeq_int_i32imin_uitofp(i32 %i) {
-  %f = uitofp i32 %i to float
-  %cmp = fcmp oeq float %f, 0xC1E0000000000000
-  ret i1 %cmp
-}
-
 ; CHECK-LABEL: @i32_cast_cmp_oeq_int_i32imin_sitofp(
 ; CHECK: sitofp
 ; CHECK: fcmp oeq
 ; CHECK-NEXT: ret
 define i1 @i32_cast_cmp_oeq_int_i32imin_sitofp(i32 %i) {
   %f = sitofp i32 %i to float
   %cmp = fcmp oeq float %f, 0xC1E0000000000000
   ret i1 %cmp
 }
 
 ; CHECK-LABEL: @i32_cast_cmp_oeq_int_i32imax_uitofp(
 ; CHECK: uitofp
 ; CHECK: fcmp oeq
 ; CHECK-NEXT: ret
 define i1 @i32_cast_cmp_oeq_int_i32imax_uitofp(i32 %i) {
   %f = uitofp i32 %i to float
   %cmp = fcmp oeq float %f, 0x41E0000000000000
   ret i1 %cmp
 }
 
 ; CHECK-LABEL: @i32_cast_cmp_oeq_int_i32imax_sitofp(
 ; CHECK: sitofp
 ; CHECK: fcmp oeq
 ; CHECK-NEXT: ret
 define i1 @i32_cast_cmp_oeq_int_i32imax_sitofp(i32 %i) {
   %f = sitofp i32 %i to float
   %cmp = fcmp oeq float %f, 0x41E0000000000000
   ret i1 %cmp
 }
 
-; CHECK-LABEL: @i32_cast_cmp_oeq_int_negi32umax_uitofp(
-; CHECK: uitofp
-; CHECK: fcmp oeq
-; CHECK-NEXT: ret
-define i1 @i32_cast_cmp_oeq_int_negi32umax_uitofp(i32 %i) {
-  %f = uitofp i32 %i to float
-  %cmp = fcmp oeq float %f, 0xC1F0000000000000
-  ret i1 %cmp
-}
-
 ; 32-bit signed integer cannot possibly round to -1<<32
 ; CHECK-LABEL: @i32_cast_cmp_oeq_int_negi32umax_sitofp(
 ; CHECK-NEXT: ret i1 false
 define i1 @i32_cast_cmp_oeq_int_negi32umax_sitofp(i32 %i) {
   %f = sitofp i32 %i to float
   %cmp = fcmp oeq float %f, 0xC1F0000000000000
   ret i1 %cmp
 }

test/Transforms/InstSimplify/floating-point-compare.ll

;
   %tmp = fcmp one double %arg, %arg
   ret i1 %tmp
 }
 
 ; These tests choose arbitrarily between float and double,
 ; and between uge and olt, to give reasonble coverage
 ; without combinatorial explosion.
 
+declare half @llvm.fabs.f16(half)
 declare float @llvm.fabs.f32(float)
 declare double @llvm.fabs.f64(double)
+declare <2 x float> @llvm.fabs.v2f32(<2 x float>)
 declare <2 x double> @llvm.fabs.v2f64(<2 x double>)
 declare float @llvm.sqrt.f32(float)
 declare double @llvm.powi.f64(double,i32)
 declare float @llvm.exp.f32(float)
 declare float @llvm.minnum.f32(float, float)
 declare float @llvm.maxnum.f32(float, float)
 declare double @llvm.exp2.f64(double)
 declare float @llvm.fma.f32(float,float,float)
;
   %a = call float @llvm.exp.f32(float %0)
   %b = call float @llvm.maxnum.f32(float %a, float %1)
   %uge = fcmp uge float %b, 0.000000e+00
   ret i1 %uge
 }
 
 define i1 @known_positive_olt_with_negative_constant(double %a) {
 ; CHECK-LABEL: @known_positive_olt_with_negative_constant(
-; CHECK-NEXT:    [[CALL:%.*]] = call double @llvm.fabs.f64(double %a)
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp olt double [[CALL]], -1.000000e+00
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 false
 ;
   %call = call double @llvm.fabs.f64(double %a)
   %cmp = fcmp olt double %call, -1.0
   ret i1 %cmp
 }
 
-define <2 x i1> @known_positive_ole_with_negative_constant_splat_vec(<2 x double> %a) {
+define <2 x i1> @known_positive_ole_with_negative_constant_splat_vec(<2 x i32> %a) {
 ; CHECK-LABEL: @known_positive_ole_with_negative_constant_splat_vec(
-; CHECK-NEXT:    [[CALL:%.*]] = call <2 x double> @llvm.fabs.v2f64(<2 x double> %a)
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ole <2 x double> [[CALL]], <double -2.000000e+00, double -2.000000e+00>
-; CHECK-NEXT:    ret <2 x i1> [[CMP]]
+; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 ;
-  %call = call <2 x double> @llvm.fabs.v2f64(<2 x double> %a)
+  %call = uitofp <2 x i32> %a to <2 x double>
   %cmp = fcmp ole <2 x double> %call, <double -2.0, double -2.0>
   ret <2 x i1> %cmp
 }
 
-define i1 @known_positive_ugt_with_negative_constant(double %a) {
+define i1 @known_positive_ugt_with_negative_constant(i32 %a) {
 ; CHECK-LABEL: @known_positive_ugt_with_negative_constant(
-; CHECK-NEXT:    [[CALL:%.*]] = call double @llvm.fabs.f64(double %a)
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double [[CALL]], -3.000000e+00
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 true
 ;
-  %call = call double @llvm.fabs.f64(double %a)
-  %cmp = fcmp ugt double %call, -3.0
+  %call = uitofp i32 %a to float
+  %cmp = fcmp ugt float %call, -3.0
   ret i1 %cmp
 }
 
-define <2 x i1> @known_positive_uge_with_negative_constant_splat_vec(<2 x double> %a) {
+define <2 x i1> @known_positive_uge_with_negative_constant_splat_vec(<2 x float> %a) {
 ; CHECK-LABEL: @known_positive_uge_with_negative_constant_splat_vec(
-; CHECK-NEXT:    [[CALL:%.*]] = call <2 x double> @llvm.fabs.v2f64(<2 x double> %a)
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge <2 x double> [[CALL]], <double -4.000000e+00, double -4.000000e+00>
-; CHECK-NEXT:    ret <2 x i1> [[CMP]]
+; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
+;
+  %call = call <2 x float> @llvm.fabs.v2f32(<2 x float> %a)
+  %cmp = fcmp uge <2 x float> %call, <float -4.0, float -4.0>
+  ret <2 x i1> %cmp
+}
+
+define i1 @known_positive_oeq_with_negative_constant(half %a) {
+; CHECK-LABEL: @known_positive_oeq_with_negative_constant(
+; CHECK-NEXT:    ret i1 false
+;
+  %call = call half @llvm.fabs.f16(half %a)
+  %cmp = fcmp oeq half %call, -5.0
+  ret i1 %cmp
+}
+
+define <2 x i1> @known_positive_une_with_negative_constant_splat_vec(<2 x i32> %a) {
+; CHECK-LABEL: @known_positive_une_with_negative_constant_splat_vec(
+; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 ;
-  %call = call <2 x double> @llvm.fabs.v2f64(<2 x double> %a)
-  %cmp = fcmp uge <2 x double> %call, <double -4.0, double -4.0>
+  %call = uitofp <2 x i32> %a to <2 x half>
+  %cmp = fcmp une <2 x half> %call, <half -6.0, half -6.0>
   ret <2 x i1> %cmp
 }
 
 define i1 @nonans1(double %in1, double %in2) {
 ; CHECK-LABEL: @nonans1(
 ; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp nnan uno double %in1, %in2