[InstSimplify] enhance/fix fcmp fold with never-nan operand

[spatel]

Summary

This is 1 step towards correcting our usage of fast-math-flags when applied on an fcmp. In this case, we were checking for 'nnan' on the fcmp itself rather than the operand of the fcmp.

By using the more general "isKnownNeverNaN()", we gain a simplification shown on the tests with 'uitofp' regardless of the FMF on the fcmp (uitofp never produces a NaN). On the tests with 'fabs', we are now relying on the FMF for the call fabs instruction rather than the FMF on the fcmp.

If this looks ok, I'll update the 'ult' case below here as a follow-up.

[cameron.mcinally]

This LGTM, with one clarification inline...

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

371

Why can't we infer that the operand here is >=0 (from the fabs) and not a NaN (from the fcmp's nnan)? Is it not safe to combine that information?

I suppose a poison value could be lost...

[spatel]

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

371

We're trying to move away from the specialized usage of FMF on fcmp because that introduces strangeness like:
https://bugs.llvm.org/show_bug.cgi?id=38086

More discussion here:
https://reviews.llvm.org/D61917

But now that I'm looking at this again, it would be better to split this change into 2 parts:
(1) add the check for isKnownNeverNan()
(2) remove the check for FMF on the fcmp

...because I'm not sure if we will introduce regressions by not checking for FMF on fcmp. We need to get further along with propagating/using FMF on select and possibly other instructions before we tighten up the fcmp semantics.

[spatel]

Patch updated:
Only add a check for isKnownNeverNaN(). We can remove FMF.noNaNs() independently when that's less likely to introduce regressions.

[cameron.mcinally]

Good compromise. LGTM.

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

371

I'll read through the links this weekend, but no reason to delay your updated patch...

llvm/lib/Analysis/InstructionSimplify.cpp

if ((match(LHS, m_Intrinsic<Intrinsic::minnum>(m_Value(), m_APFloat(C2))) &&
         llvm_unreachable("Unexpected fcmp predicate");
       }
     }
   }
 
   if (match(RHS, m_AnyZeroFP())) {
     switch (Pred) {
     case FCmpInst::FCMP_OGE:
-      if (FMF.noNaNs() && CannotBeOrderedLessThanZero(LHS, Q.TLI))
+      if (isKnownNeverNaN(LHS, Q.TLI) &&
+          CannotBeOrderedLessThanZero(LHS, Q.TLI))
         return getTrue(RetTy);
       break;
     case FCmpInst::FCMP_UGE:
       if (CannotBeOrderedLessThanZero(LHS, Q.TLI))
         return getTrue(RetTy);
       break;
     case FCmpInst::FCMP_ULT:
+      // TODO: This should match 'oge'.
       if (FMF.noNaNs() && CannotBeOrderedLessThanZero(LHS, Q.TLI))
         return getFalse(RetTy);
       break;
     case FCmpInst::FCMP_OLT:
       if (CannotBeOrderedLessThanZero(LHS, Q.TLI))
         return getFalse(RetTy);
       break;
     default:

llvm/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_is_positive_or_zero(i32 %x) {
 ; CHECK-LABEL: @UIToFP_is_positive_or_zero(
-; CHECK-NEXT:    [[A:%.*]] = uitofp i32 [[X:%.*]] to float
-; CHECK-NEXT:    [[R:%.*]] = fcmp oge float [[A]], 0.000000e+00
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 true
 ;
   %a = uitofp i32 %x to float
   %r = fcmp oge float %a, 0.000000e+00
   ret i1 %r
 }
 
 define <2 x i1> @UIToFP_is_positive_or_zero_vec(<2 x i32> %x) {
 ; CHECK-LABEL: @UIToFP_is_positive_or_zero_vec(
-; CHECK-NEXT:    [[A:%.*]] = uitofp <2 x i32> [[X:%.*]] to <2 x float>
-; CHECK-NEXT:    [[R:%.*]] = fcmp 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 oge <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(

 ;
   %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 nnan double @llvm.fabs.f64(double [[X:%.*]])
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp oge double [[FABS]], 0.000000e+00
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 true
 ;
   %fabs = tail call nnan double @llvm.fabs.f64(double %x)
   %cmp = fcmp 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 nnan <2 x double> @llvm.fabs.v2f64(<2 x double> [[X:%.*]])
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp 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 nnan <2 x double> @llvm.fabs.v2f64(<2 x double> %x)
   %cmp = fcmp oge <2 x double> %fabs, zeroinitializer
   ret <2 x i1> %cmp
 }
 
 define i1 @fabs_fcmp-nnan_is_positive_or_zero(double %x) {
 ; CHECK-LABEL: @fabs_fcmp-nnan_is_positive_or_zero(
-; CHECK-NEXT:    ret i1 true
+; 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]]
 ;
   %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_fcmp-nnan_is_positive_or_zero_vec(<2 x double> %x) {
 ; CHECK-LABEL: @fabs_fcmp-nnan_is_positive_or_zero_vec(
-; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
+; 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]]
 ;
   %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(