Fold fmin(nnan x, inf) -> x, fmax(nnan x, -inf) -> x, fmax(nnan ninf x, -flt_max) -> x and fmin(nnan ninf x, flt_max) -> x

[karthikthecool]

Summary

Hi,
Implement few TODO's in InstCombineCalls.

This patch enables folding the following instructions-
fmin(nnan x, inf) -> x
fmax(nnan x, -inf) -> x

&

fmax(nnan ninf x, -flt_max) -> x
fmin(nnan ninf x, flt_max) -> x

Thanks
Karthik Bhat

[davide]

lib/Transforms/InstCombine/InstCombineCalls.cpp

1007–1014

You should be able to put these where // fmin(x, -inf) -> -inf is performed, so that you avoid duplicating the check C1 && C1->isInfinity().

[escha]

Is this correct? I thought "nnan" on an instruction meant that we can optimize it assuming its inputs and outputs aren't NaN -- not that we can assume *for other instructions, that aren't fast-math* that *their inputs* aren't NaN.

So for example:

float foo(float x, float y) {
float z = x +nnan y; // pseudocode for a nnan add
return fmax(z, 1.0);
}

This optimization makes it legal for this function to return NaN even though fmax isn't fast-math. I don't think (from a quick grep) that we treat nnan or the other fast-math flags in this way anywhere else in LLVM. That is, if op A is not fast-math, and op B is fast-math, and op B is an argument to op A, it feels very odd to be able to optimize op A in a fast-math fashion using this knowledge.

More practically, I think this may actually break our existing use-case: we use fmax/fmin to implement NaN-flushing behavior in shaders, i.e. we allow users to use fmax/fmin/clamp to get rid of NaNs even though fast-math is on in other respects. If we allow this NaN-flushing behavior to be violated, fmax/fmin will no longer do what we need.

lib/Transforms/InstCombine/InstCombineCalls.cpp

if (II.getIntrinsicID() == Intrinsic::minnum) {
 
     // fmin(fmin(x, y), x) -> fmin(x, y)
     // fmin(fmin(x, y), y) -> fmin(x, y)
     if (match(Arg0, m_FMin(m_Value(X), m_Value(Y)))) {
       if (Arg1 == X || Arg1 == Y)
         return Arg0;
     }
 
-    // TODO: fmin(nnan x, inf) -> x
-    // TODO: fmin(nnan ninf x, flt_max) -> x
+    // fmin(nnan x, inf) -> x
+    if (II.hasNoNaNs() && C1 && C1->isInfinity())
+      return Arg0;
+
+    if (Instruction *I = dyn_cast<Instruction>(Arg0)) {
+      if (I->hasNoNaNs() && C1 && C1->isInfinity())
+        return Arg0;
+    }
+
+    // fmin(nnan ninf x, flt_max) -> x
+    if (II.hasNoNaNs() && II.hasNoInfs() && C1 &&
+        C1->getValueAPF().isLargest() && !C1->getValueAPF().isNegative())
+      return Arg0;
+
+    if (Instruction *I = dyn_cast<Instruction>(Arg0)) {
+      if (I->hasNoNaNs() && I->hasNoInfs() && C1 &&
+          C1->getValueAPF().isLargest() && !C1->getValueAPF().isNegative())
+        return Arg0;
+    }
+
     if (C1 && C1->isInfinity()) {
       // fmin(x, -inf) -> -inf
       if (C1->isNegative())
         return Arg1;
     }
   } else {
     assert(II.getIntrinsicID() == Intrinsic::maxnum);
     // fmax(x, fmax(x, y)) -> fmax(x, y)
     // fmax(y, fmax(x, y)) -> fmax(x, y)
     if (match(Arg1, m_FMax(m_Value(X), m_Value(Y)))) {
       if (Arg0 == X || Arg0 == Y)
         return Arg1;
     }
 
     // fmax(fmax(x, y), x) -> fmax(x, y)
     // fmax(fmax(x, y), y) -> fmax(x, y)
     if (match(Arg0, m_FMax(m_Value(X), m_Value(Y)))) {
       if (Arg1 == X || Arg1 == Y)
         return Arg0;
     }
 
-    // TODO: fmax(nnan x, -inf) -> x
-    // TODO: fmax(nnan ninf x, -flt_max) -> x
+    // fmax(nnan x, -inf) -> x
+    if (II.hasNoNaNs() && C1 && C1->isInfinity() && C1->isNegative())
+      return Arg0;
+
+    if (Instruction *I = dyn_cast<Instruction>(Arg0)) {
+      if (I->hasNoNaNs() && C1 && C1->isInfinity() && C1->isNegative())
+        return Arg0;
+    }
+
+    // fmax(nnan ninf x, -flt_max) -> x
+    if (II.hasNoNaNs() && II.hasNoInfs() && C1 &&
+        C1->getValueAPF().isLargest() && C1->getValueAPF().isNegative())
+      return Arg0;
+
+    if (Instruction *I = dyn_cast<Instruction>(Arg0)) {
+      if (I->hasNoNaNs() && I->hasNoInfs() && C1 &&
+          C1->getValueAPF().isLargest() && C1->getValueAPF().isNegative())
+        return Arg0;
+    }
+
     if (C1 && C1->isInfinity()) {
       // fmax(x, inf) -> inf
       if (!C1->isNegative())
         return Arg1;
     }
   }
   return nullptr;
 }

test/Transforms/InstCombine/maxnum.ll

 ; CHECK-LABEL: @fold_maxnum_f32_neginf_val
 ; CHECK-NEXT: call float @llvm.maxnum.f32(float %x, float 0xFFF0000000000000)
 ; CHECK-NEXT: ret float
 define float @fold_maxnum_f32_neginf_val(float %x) nounwind {
   %val = call float @llvm.maxnum.f32(float 0xFFF0000000000000, float %x) #0
   ret float %val
 }
 
+; CHECK-LABEL: @fold_maxnum_nnan_fadd_neginf_val
+; CHECK-NEXT: %ret = fadd nnan float %y, %z
+; CHECK-NEXT: ret float %ret
+define float @fold_maxnum_nnan_fadd_neginf_val(float %x,float %y,float %z) nounwind {
+  %ret = fadd nnan float %y, %z
+  %val = call float @llvm.maxnum.f32(float %ret,float 0xFFF0000000000000) #0
+  ret float %val
+}
+
+; CHECK-LABEL: @fold_maxnum_nnan_x_neginf_val
+; CHECK-NEXT: ret float %x
+define float @fold_maxnum_nnan_x_neginf_val(float %x) nounwind {
+  %val = call nnan float @llvm.maxnum.f32(float 0xFFF0000000000000,float %x) #0
+  ret float %val
+}
+
+; CHECK-LABEL: @fold_maxnum_nnan_ninf_x_min_val
+; CHECK-NEXT: ret float %x
+define float @fold_maxnum_nnan_ninf_x_min_val(float %x) nounwind {
+  %val = call nnan ninf float @llvm.maxnum.f32(float 0xC7EFFFFFE0000000,float %x) #0
+  ret float %val
+}
+
+
+; CHECK-LABEL: @fold_maxnum_nnan_ninf_fadd_min_val
+; CHECK-NEXT: %ret = fadd nnan ninf float %y, %z
+; CHECK-NEXT: float %ret
+define float @fold_maxnum_nnan_ninf_fadd_min_val(float %x,float %y,float %z) nounwind {
+  %ret = fadd nnan ninf float %y, %z
+  %val = call float @llvm.maxnum.f32(float 0xC7EFFFFFE0000000,float %ret) #0
+  ret float %val
+}
+
+
 attributes #0 = { nounwind readnone }

test/Transforms/InstCombine/minnum.ll

 
 ; CHECK-LABEL: @fold_minnum_f32_minf_val
 ; CHECK-NEXT: ret float 0xFFF0000000000000
 define float @fold_minnum_f32_minf_val(float %x) nounwind {
   %val = call float @llvm.minnum.f32(float 0xFFF0000000000000, float %x) #0
   ret float %val
 }
 
+; CHECK-LABEL: @fold_minnum_nnan_fadd_inf_val
+; CHECK-NEXT: %ret = fadd nnan float %y, %z
+; CHECK-NEXT: ret float %ret
+define float @fold_minnum_nnan_fadd_inf_val(float %x,float %y,float %z) nounwind {
+  %ret = fadd nnan float %y, %z
+  %val = call float @llvm.minnum.f32(float %ret,float 0x7FF0000000000000) #0
+  ret float %val
+}
+
+; CHECK-LABEL: @fold_minnum_nnan_x_inf_val
+; CHECK-NEXT: ret float %x
+define float @fold_minnum_nnan_x_inf_val(float %x) nounwind {
+  %val = call nnan float @llvm.minnum.f32(float 0x7FF0000000000000,float %x) #0
+  ret float %val
+}
+
+; CHECK-LABEL: @fold_minnum_nnan_ninf_x_max_val
+; CHECK-NEXT: ret float %x
+define float @fold_minnum_nnan_ninf_x_max_val(float %x) nounwind {
+  %val = call nnan ninf float @llvm.minnum.f32(float 0x47EFFFFFE0000000,float %x) #0
+  ret float %val
+}
+
+
+; CHECK-LABEL: @fold_minnum_nnan_ninf_fadd_max_val
+; CHECK-NEXT: %ret = fadd nnan ninf float %y, %z
+; CHECK-NEXT: float %ret
+define float @fold_minnum_nnan_ninf_fadd_max_val(float %x,float %y,float %z) nounwind {
+  %ret = fadd nnan ninf float %y, %z
+  %val = call float @llvm.minnum.f32(float 0x47EFFFFFE0000000,float %ret) #0
+  ret float %val
+}
 attributes #0 = { nounwind readnone }