ValueTracking: Fix nan result handling for fmul

[arsenm]

Summary

This was mishandling maybe 0 * inf.

Fixes issue #63316

[foad]

llvm/lib/Analysis/ValueTracking.cpp

4777–4780

Independent of the bug fix, a stronger form of this check is...
i.e. it can't be 0*inf AND it can't be inf*0
Your version misses some simple cases like when all we know is that neither operand is infinity.

[arsenm]

Handle all the cases

[foad]

llvm/lib/Analysis/ValueTracking.cpp

4785

Would it be worth changing isKnownNeverLogicalZero to take a Function * and handle the nullptr case conservatively?

4787–4792

This is still simpler.

[arsenm]

llvm/lib/Analysis/ValueTracking.cpp

4785

I was more looking into removing the allow-unparented instructions case since SimplifyInstruction now requires parents

[arsenm]

a632ca4b00279baf18e72a171ec0ce526e9d80aa

llvm/lib/Analysis/ValueTracking.cpp

void computeKnownFPClass(const Value *V, const APInt &DemandedElts,
   case Instruction::FMul: {
     // X * X is always non-negative or a NaN.
     if (Op->getOperand(0) == Op->getOperand(1))
       Known.knownNot(fcNegative);
 
     if ((InterestedClasses & fcNan) != fcNan)
       break;
 
+    // fcSubnormal is only needed in case of DAZ.
+    const FPClassTest NeedForNan = fcNan | fcInf | fcZero | fcSubnormal;
+
     KnownFPClass KnownLHS, KnownRHS;
-    computeKnownFPClass(Op->getOperand(1), DemandedElts,
-                        fcNan | fcInf | fcZero | fcSubnormal, KnownRHS,
+    computeKnownFPClass(Op->getOperand(1), DemandedElts, NeedForNan, KnownRHS,
+                        Depth + 1, Q);
+    if (!KnownRHS.isKnownNeverNaN())
+      break;
+
+    computeKnownFPClass(Op->getOperand(0), DemandedElts, NeedForNan, KnownLHS,
                         Depth + 1, Q);
-    if (KnownRHS.isKnownNeverNaN() &&
-        (KnownRHS.isKnownNeverInfinity() || KnownRHS.isKnownNeverZero())) {
-      computeKnownFPClass(Op->getOperand(0), DemandedElts,
-                          fcNan | fcInf | fcZero, KnownLHS, Depth + 1, Q);
-      if (!KnownLHS.isKnownNeverNaN())
-        break;
 
-      const Function *F = cast<Instruction>(Op)->getFunction();
+    // If 0 * +/-inf produces NaN.
+    if (KnownLHS.isKnownNeverInfinity() && KnownRHS.isKnownNeverInfinity()) {
+      Known.knownNot(fcNan);
+      break;
+    }
+
+    if (!F)
+      break;
 
-      // If neither side can be zero (or nan) fmul never produces NaN.
-      // TODO: Check operand combinations.
-      // e.g. fmul nofpclass(inf nan zero), nofpclass(nan) -> nofpclass(nan)
-      if ((KnownLHS.isKnownNeverInfinity() ||
-           (F && KnownLHS.isKnownNeverLogicalZero(*F, Op->getType()))) &&
-          (KnownRHS.isKnownNeverInfinity() ||
-           (F && KnownRHS.isKnownNeverLogicalZero(*F, Op->getType()))))
-        Known.knownNot(fcNan);
-    }
+    if ((KnownRHS.isKnownNeverInfinity() &&
+         KnownRHS.isKnownNeverLogicalZero(*F, Op->getType())) ||
+        (KnownLHS.isKnownNeverInfinity() &&
+         KnownLHS.isKnownNeverLogicalZero(*F, Op->getType())) ||
+        (KnownLHS.isKnownNeverLogicalZero(*F, Op->getType()) &&
+         KnownRHS.isKnownNeverLogicalZero(*F, Op->getType())))
 
     break;
   }
   case Instruction::FDiv:
   case Instruction::FRem: {
     if (Op->getOperand(0) == Op->getOperand(1)) {
       // TODO: Could filter out snan if we inspect the operand
       if (Op->getOpcode() == Instruction::FDiv) {

llvm/test/Transforms/Attributor/nofpclass-nan-fmul.ll

 ; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[FMUL]]
 ;
   %fmul = fmul float %arg0, %arg1
   ret float %fmul
 }
 
 define float @ret_fmul_ieee_nonan_nozero__nonan_noinf(float nofpclass(nan zero) %arg0, float nofpclass(nan inf) %arg1) #0 {
-; CHECK-LABEL: define nofpclass(nan) float @ret_fmul_ieee_nonan_nozero__nonan_noinf
+; CHECK-LABEL: define float @ret_fmul_ieee_nonan_nozero__nonan_noinf
 ; CHECK-SAME: (float nofpclass(nan zero) [[ARG0:%.*]], float nofpclass(nan inf) [[ARG1:%.*]]) #[[ATTR0]] {
 ; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[FMUL]]
 ;
   %fmul = fmul float %arg0, %arg1
   ret float %fmul
 }
 
 define float @ret_fmul_ieee_nonan_noinf__nonan_nozero(float nofpclass(nan inf) %arg0, float nofpclass(nan zero) %arg1) #0 {
-; CHECK-LABEL: define nofpclass(nan) float @ret_fmul_ieee_nonan_noinf__nonan_nozero
+; CHECK-LABEL: define float @ret_fmul_ieee_nonan_noinf__nonan_nozero
 ; CHECK-SAME: (float nofpclass(nan inf) [[ARG0:%.*]], float nofpclass(nan zero) [[ARG1:%.*]]) #[[ATTR0]] {
 ; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[FMUL]]
 ;
   %fmul = fmul float %arg0, %arg1
   ret float %fmul
 }
 

 ; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[FMUL]]
 ;
   %fmul = fmul float %arg0, %arg1
   ret float %fmul
 }
 
 define float @ret_fmul_ieee_nozero_nonan__noinf_nonan(float nofpclass(zero nan) %arg0, float nofpclass(inf nan) %arg1) {
-; CHECK-LABEL: define nofpclass(nan) float @ret_fmul_ieee_nozero_nonan__noinf_nonan
+; CHECK-LABEL: define float @ret_fmul_ieee_nozero_nonan__noinf_nonan
 ; CHECK-SAME: (float nofpclass(nan zero) [[ARG0:%.*]], float nofpclass(nan inf) [[ARG1:%.*]]) #[[ATTR4]] {
 ; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[FMUL]]
 ;
   %fmul = fmul float %arg0, %arg1
   ret float %fmul
 }
 
 define float @ret_fmul_ieee_noinf_nonan__nozero_nonan(float nofpclass(inf nan) %arg0, float nofpclass(zero nan) %arg1) {
-; CHECK-LABEL: define nofpclass(nan) float @ret_fmul_ieee_noinf_nonan__nozero_nonan
+; CHECK-LABEL: define float @ret_fmul_ieee_noinf_nonan__nozero_nonan
 ; CHECK-SAME: (float nofpclass(nan inf) [[ARG0:%.*]], float nofpclass(nan zero) [[ARG1:%.*]]) #[[ATTR4]] {
 ; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[FMUL]]
 ;
   %fmul = fmul float %arg0, %arg1
   ret float %fmul
 }
 

 ; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[FMUL]]
 ;
   %fmul = fmul float %arg0, %arg1
   ret float %fmul
 }
 
 define float @ret_fmul_ieee_nozero_nonan_noinf__nonan(float nofpclass(zero nan inf) %arg0, float nofpclass(nan) %arg1) {
-; CHECK-LABEL: define float @ret_fmul_ieee_nozero_nonan_noinf__nonan
+; CHECK-LABEL: define nofpclass(nan) float @ret_fmul_ieee_nozero_nonan_noinf__nonan
 ; CHECK-SAME: (float nofpclass(nan inf zero) [[ARG0:%.*]], float nofpclass(nan) [[ARG1:%.*]]) #[[ATTR4]] {
 ; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[FMUL]]
 ;
   %fmul = fmul float %arg0, %arg1
   ret float %fmul
 }
 
 define float @ret_fmul_ieee_nonan__nozero_nonan_noinf(float nofpclass(nan) %arg0, float nofpclass(zero nan inf) %arg1) {
-; CHECK-LABEL: define float @ret_fmul_ieee_nonan__nozero_nonan_noinf
+; CHECK-LABEL: define nofpclass(nan) float @ret_fmul_ieee_nonan__nozero_nonan_noinf
 ; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]], float nofpclass(nan inf zero) [[ARG1:%.*]]) #[[ATTR4]] {
 ; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[FMUL]]
 ;
   %fmul = fmul float %arg0, %arg1
   ret float %fmul
 }
 
 attributes #0 = { "denormal-fp-math"="ieee,ieee" }
 attributes #1 = { "denormal-fp-math"="ieee,preserve-sign" }
 attributes #2 = { "denormal-fp-math"="ieee,positive-zero" }
 attributes #3 = { "denormal-fp-math"="ieee,dynamic" }
 ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
 ; TUNIT: {{.*}}

llvm/test/Transforms/Inline/simplify-instruction-computeKnownFPClass-context.ll

 
 ; Make sure we hit the denormal query in isKnownNeverLogicalZero
 define internal i1 @simplify_fcmp_ord_frem_callee(double %a, double %b) {
   %sub.double.sub = frem double %a, %b
   %cmp = fcmp ord double %sub.double.sub, 0.0
   ret i1 %cmp
 }
 
-define i1 @simplify_fcmp_ord_fmul_caller(double nofpclass(zero nan) %i0, double nofpclass(zero nan) %i1) {
+define i1 @simplify_fcmp_ord_fmul_caller(double nofpclass(zero nan inf) %i0, double nofpclass(zero nan inf) %i1) {
 ; CHECK-LABEL: define i1 @simplify_fcmp_ord_fmul_caller
-; CHECK-SAME: (double nofpclass(nan zero) [[I0:%.*]], double nofpclass(nan zero) [[I1:%.*]]) {
+; CHECK-SAME: (double nofpclass(nan inf zero) [[I0:%.*]], double nofpclass(nan inf zero) [[I1:%.*]]) {
 ; CHECK-NEXT:    [[SUB_DOUBLE_SUB_I:%.*]] = fmul double [[I0]], [[I1]]
 ; CHECK-NEXT:    ret i1 true
 ;
   %call = call i1 @simplify_fcmp_ord_fmul_callee(double %i0, double %i1)
   ret i1 %call
 }
 
 ; Make sure we hit the denormal query in isKnownNeverLogicalZero

llvm/test/Transforms/InstSimplify/known-never-nan.ll

 unwind:
   landingpad ptr cleanup
   resume ptr null
 }
 
 ; This should not fold to false because fmul 0 * inf = nan
 define i1 @issue63316(i64 %arg) {
 ; CHECK-LABEL: @issue63316(
-; CHECK-NEXT:    ret i1 false
+; CHECK-NEXT:    [[SITOFP:%.*]] = sitofp i64 [[ARG:%.*]] to float
+; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[SITOFP]], 0x7FF0000000000000
+; CHECK-NEXT:    [[FCMP:%.*]] = fcmp uno float [[FMUL]], 0.000000e+00
+; CHECK-NEXT:    ret i1 [[FCMP]]
 ;
   %sitofp = sitofp i64 %arg to float
   %fmul = fmul float %sitofp, 0x7FF0000000000000
   %fcmp = fcmp uno float %fmul, 0.000000e+00
   ret i1 %fcmp
 }
 
 define i1 @issue63316_commute(i64 %arg) {
 ; CHECK-LABEL: @issue63316_commute(
-; CHECK-NEXT:    ret i1 false
+; CHECK-NEXT:    [[SITOFP:%.*]] = sitofp i64 [[ARG:%.*]] to float
+; CHECK-NEXT:    [[FMUL:%.*]] = fmul float 0x7FF0000000000000, [[SITOFP]]
+; CHECK-NEXT:    [[FCMP:%.*]] = fcmp uno float [[FMUL]], 0.000000e+00
+; CHECK-NEXT:    ret i1 [[FCMP]]
 ;
   %sitofp = sitofp i64 %arg to float
   %fmul = fmul float 0x7FF0000000000000, %sitofp
   %fcmp = fcmp uno float %fmul, 0.000000e+00
   ret i1 %fcmp
 }