[InstSimplify] fold 'fcmp nnan oge X, 0.0' when X is not negative

[spatel]

Summary

This re-raises some of the open questions about how to apply and use fast-math-flags in IR from PR38086:
https://bugs.llvm.org/show_bug.cgi?id=38086
...but given the current implementation, I think this is the correct way to predicate the transform.

This is part of solving PR39475:
https://bugs.llvm.org/show_bug.cgi?id=39475

[mcberg2017]

lib/Analysis/InstructionSimplify.cpp

3573 ↗

(On Diff #171727)

Sure NaNs are compared as unordered so excluding them is ok. Discussion point: If X has value below -0.0, CannotBeOrderedLessThanZero will return false if it can prove it, however so will the comparison of X > 0 as an ordered compare. Now we no longer have to prove X is a NaN in CannotBeOrderedLessThanZero as we specify/assert it is not. Do we need CannotBeOrderedLessThanZero for this comparison?

[spatel]

lib/Analysis/InstructionSimplify.cpp

3573 ↗

(On Diff #171727)

I'm not seeing the alternative to using CannotBeOrderedLessThanZero for this case. Did you have something in mind?
I agree that we're probably missing an additional fold for 'OLT' and/or 'ULT' here, but I wanted to make sure we're ok with this example first.

[mcberg2017]

lib/Analysis/InstructionSimplify.cpp

3573 ↗

(On Diff #171727)

Not per say other than usage, having it is harmless at a small cost.

llvm/trunk/lib/Analysis/InstructionSimplify.cpp

if (C->isInfinity()) {
           return getTrue(RetTy);
         default:
           break;
         }
       }
     }
     if (C->isZero()) {
       switch (Pred) {
+      case FCmpInst::FCMP_OGE:
+        if (FMF.noNaNs() && CannotBeOrderedLessThanZero(LHS, Q.TLI))
+          return getTrue(RetTy);
+        break;
       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);

llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp

case Instruction::Call: {
         break;
 
       // Various optimization for fabs compared with zero.
       switch (Pred) {
       default:
         break;
       // fabs(x) < 0 --> false
       case FCmpInst::FCMP_OLT:
-        llvm_unreachable("handled by SimplifyFCmpInst");
+        llvm_unreachable("fcmp should have simplified");
           // fabs(x) > 0 --> x != 0
       case FCmpInst::FCMP_OGT:
         return new FCmpInst(FCmpInst::FCMP_ONE, CI->getArgOperand(0), RHSC);
       // fabs(x) <= 0 --> x == 0
       case FCmpInst::FCMP_OLE:
         return new FCmpInst(FCmpInst::FCMP_OEQ, CI->getArgOperand(0), RHSC);
       // fabs(x) >= 0 --> !isnan(x)
       case FCmpInst::FCMP_OGE:
+        assert(!I.hasNoNaNs() && "fcmp should have simplified");
         return new FCmpInst(FCmpInst::FCMP_ORD, CI->getArgOperand(0), RHSC);
       // fabs(x) == 0 --> x == 0
       // fabs(x) != 0 --> x != 0
       case FCmpInst::FCMP_OEQ:
       case FCmpInst::FCMP_UEQ:
       case FCmpInst::FCMP_ONE:
       case FCmpInst::FCMP_UNE:
         return new FCmpInst(Pred, CI->getArgOperand(0), RHSC);

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

 ;
   %a = uitofp <2 x i32> %x to <2 x float>
   %r = fcmp uge <2 x float> %a, zeroinitializer
   ret <2 x i1> %r
 }
 
 define i1 @UIToFP_nnan_is_positive_or_zero(i32 %x) {
 ; CHECK-LABEL: @UIToFP_nnan_is_positive_or_zero(
-; CHECK-NEXT:    [[A:%.*]] = uitofp i32 [[X:%.*]] to float
-; CHECK-NEXT:    [[R:%.*]] = fcmp nnan oge float [[A]], 0.000000e+00
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = uitofp i32 %x to float
   %r = fcmp nnan oge float %a, 0.000000e+00
   ret i1 %r
 }
 
 define <2 x i1> @UIToFP_nnan_is_positive_or_zero_vec(<2 x i32> %x) {
 ; CHECK-LABEL: @UIToFP_nnan_is_positive_or_zero_vec(
-; CHECK-NEXT:    [[A:%.*]] = uitofp <2 x i32> [[X:%.*]] to <2 x float>
-; CHECK-NEXT:    [[R:%.*]] = fcmp nnan oge <2 x float> [[A]], zeroinitializer
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 ;
   %a = uitofp <2 x i32> %x to <2 x float>
   %r = fcmp nnan oge <2 x float> %a, zeroinitializer
   ret <2 x i1> %r
 }
 
 define i1 @UIToFP_is_not_negative(i32 %x) {
 ; CHECK-LABEL: @UIToFP_is_not_negative(

 ;
   %fabs = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %x)
   %cmp = fcmp uge <2 x double> %fabs, zeroinitializer
   ret <2 x i1> %cmp
 }
 
 define i1 @fabs_nnan_is_positive_or_zero(double %x) {
 ; CHECK-LABEL: @fabs_nnan_is_positive_or_zero(
-; CHECK-NEXT:    [[FABS:%.*]] = tail call double @llvm.fabs.f64(double [[X:%.*]])
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp nnan oge double [[FABS]], 0.000000e+00
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 true
 ;
   %fabs = tail call double @llvm.fabs.f64(double %x)
   %cmp = fcmp nnan oge double %fabs, 0.0
   ret i1 %cmp
 }
 
 define <2 x i1> @fabs_nnan_is_positive_or_zero_vec(<2 x double> %x) {
 ; CHECK-LABEL: @fabs_nnan_is_positive_or_zero_vec(
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> [[X:%.*]])
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp nnan oge <2 x double> [[FABS]], zeroinitializer
-; CHECK-NEXT:    ret <2 x i1> [[CMP]]
+; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 ;
   %fabs = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %x)
   %cmp = fcmp nnan oge <2 x double> %fabs, zeroinitializer
   ret <2 x i1> %cmp
 }
 
 define i1 @fabs_is_not_negative(double %x) {
 ; CHECK-LABEL: @fabs_is_not_negative(