[llvm] 55d371a - [InstSimplify] add folds for fmin/fmax with 'nnan'

[Sanjay Patel via llvm-commits]

Author: Sanjay Patel
Date: 2020-09-14T11:46:11-04:00
New Revision: 55d371abd7f470496f45d960c29bb66da0e81aee

URL: https://github.com/llvm/llvm-project/commit/55d371abd7f470496f45d960c29bb66da0e81aee
DIFF: https://github.com/llvm/llvm-project/commit/55d371abd7f470496f45d960c29bb66da0e81aee.diff

LOG: [InstSimplify] add folds for fmin/fmax with 'nnan'

maximum(nnan X, +INF) --> +INF
minimum(nnan X, -INF) --> -INF

This is based on the similar codegen transform proposed in:
D87571

Added: 
    

Modified: 
    llvm/lib/Analysis/InstructionSimplify.cpp
    llvm/test/Transforms/InstSimplify/fminmax-folds.ll

Removed: 
    


################################################################################
diff  --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp
index 88cfe5a1fa85..716af06769f9 100644
--- a/llvm/lib/Analysis/InstructionSimplify.cpp
+++ b/llvm/lib/Analysis/InstructionSimplify.cpp
@@ -5470,10 +5470,13 @@ static Value *simplifyBinaryIntrinsic(Function *F, Value *Op0, Value *Op1,
     const APFloat *C;
     if (match(Op1, m_APFloat(C)) &&
         (C->isInfinity() || (Q.CxtI->hasNoInfs() && C->isLargest()))) {
-      // min(X, -Inf) --> -Inf
-      // max(X, +Inf) --> +Inf
-      if (C->isNegative() == IsMin && !PropagateNaN)
+      // minnum(X, -inf) -> -inf
+      // maxnum(X, +inf) -> +inf
+      // minimum(X, -inf) -> -inf if nnan
+      // maximum(X, +inf) -> +inf if nnan
+      if (C->isNegative() == IsMin && (!PropagateNaN || Q.CxtI->hasNoNaNs()))
         return ConstantFP::get(ReturnType, *C);
+
       // TODO: minimum(nnan x, inf) -> x
       // TODO: minnum(nnan ninf x, flt_max) -> x
       // TODO: maximum(nnan x, -inf) -> x

diff  --git a/llvm/test/Transforms/InstSimplify/fminmax-folds.ll b/llvm/test/Transforms/InstSimplify/fminmax-folds.ll
index 3811ae81e8d3..f05837a8c2f6 100644
--- a/llvm/test/Transforms/InstSimplify/fminmax-folds.ll
+++ b/llvm/test/Transforms/InstSimplify/fminmax-folds.ll
@@ -140,8 +140,7 @@ define float @test_maxnum_const_inf_nnan(float %x) {
 
 define float @test_maximum_const_inf_nnan(float %x) {
 ; CHECK-LABEL: @test_maximum_const_inf_nnan(
-; CHECK-NEXT:    [[R:%.*]] = call nnan float @llvm.maximum.f32(float [[X:%.*]], float 0x7FF0000000000000)
-; CHECK-NEXT:    ret float [[R]]
+; CHECK-NEXT:    ret float 0x7FF0000000000000
 ;
   %r = call nnan float @llvm.maximum.f32(float %x, float 0x7ff0000000000000)
   ret float %r
@@ -175,8 +174,7 @@ define float @test_maxnum_const_inf_nnan_comm(float %x) {
 
 define float @test_maximum_const_inf_nnan_comm(float %x) {
 ; CHECK-LABEL: @test_maximum_const_inf_nnan_comm(
-; CHECK-NEXT:    [[R:%.*]] = call nnan float @llvm.maximum.f32(float 0x7FF0000000000000, float [[X:%.*]])
-; CHECK-NEXT:    ret float [[R]]
+; CHECK-NEXT:    ret float 0x7FF0000000000000
 ;
   %r = call nnan float @llvm.maximum.f32(float 0x7ff0000000000000, float %x)
   ret float %r
@@ -210,8 +208,7 @@ define <2 x float> @test_maxnum_const_inf_nnan_comm_vec(<2 x float> %x) {
 
 define <2 x float> @test_maximum_const_inf_nnan_comm_vec(<2 x float> %x) {
 ; CHECK-LABEL: @test_maximum_const_inf_nnan_comm_vec(
-; CHECK-NEXT:    [[R:%.*]] = call nnan <2 x float> @llvm.maximum.v2f32(<2 x float> <float 0x7FF0000000000000, float 0x7FF0000000000000>, <2 x float> [[X:%.*]])
-; CHECK-NEXT:    ret <2 x float> [[R]]
+; CHECK-NEXT:    ret <2 x float> <float 0x7FF0000000000000, float 0x7FF0000000000000>
 ;
   %r = call nnan <2 x float> @llvm.maximum.v2f32(<2 x float> <float 0x7ff0000000000000, float 0x7ff0000000000000>, <2 x float> %x)
   ret <2 x float> %r
@@ -254,8 +251,7 @@ define float @test_maximum_const_neg_inf_nnan(float %x) {
 
 define float @test_minimum_const_neg_inf_nnan(float %x) {
 ; CHECK-LABEL: @test_minimum_const_neg_inf_nnan(
-; CHECK-NEXT:    [[R:%.*]] = call nnan float @llvm.minimum.f32(float [[X:%.*]], float 0xFFF0000000000000)
-; CHECK-NEXT:    ret float [[R]]
+; CHECK-NEXT:    ret float 0xFFF0000000000000
 ;
   %r = call nnan float @llvm.minimum.f32(float %x, float 0xfff0000000000000)
   ret float %r
@@ -422,8 +418,7 @@ define float @test_maxnum_const_max_nnan_ninf(float %x) {
 
 define float @test_maximum_const_max_nnan_ninf(float %x) {
 ; CHECK-LABEL: @test_maximum_const_max_nnan_ninf(
-; CHECK-NEXT:    [[R:%.*]] = call nnan ninf float @llvm.maximum.f32(float [[X:%.*]], float 0x47EFFFFFE0000000)
-; CHECK-NEXT:    ret float [[R]]
+; CHECK-NEXT:    ret float 0x47EFFFFFE0000000
 ;
   %r = call nnan ninf float @llvm.maximum.f32(float %x, float 0x47efffffe0000000)
   ret float %r
@@ -466,8 +461,7 @@ define float @test_maximum_const_neg_max_nnan_ninf(float %x) {
 
 define float @test_minimum_const_neg_max_nnan_ninf(float %x) {
 ; CHECK-LABEL: @test_minimum_const_neg_max_nnan_ninf(
-; CHECK-NEXT:    [[R:%.*]] = call nnan ninf float @llvm.minimum.f32(float [[X:%.*]], float 0xC7EFFFFFE0000000)
-; CHECK-NEXT:    ret float [[R]]
+; CHECK-NEXT:    ret float 0xC7EFFFFFE0000000
 ;
   %r = call nnan ninf float @llvm.minimum.f32(float %x, float 0xc7efffffe0000000)
   ret float %r