From 8a87b868f52b00658b89aa42b7b3ed07b90501ef Mon Sep 17 00:00:00 2001 From: Sanjay Patel Date: Sun, 9 Jun 2019 13:48:59 +0000 Subject: [PATCH] [InstSimplify] enhance fcmp fold with never-nan operand This is another step towards correcting our usage of fast-math-flags when applied on an fcmp. In this case, we are checking for 'nnan' on the fcmp itself rather than the operand of the fcmp. But I'm leaving that clause in until we're more confident that we can stop relying on fcmp's FMF. 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 in addition to the FMF on the fcmp. This is a continuation of D62979 / rL362879. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@362903 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Analysis/InstructionSimplify.cpp | 4 ++-- test/Transforms/InstSimplify/floating-point-compare.ll | 16 ++++------------ 2 files changed, 6 insertions(+), 14 deletions(-) diff --git a/lib/Analysis/InstructionSimplify.cpp b/lib/Analysis/InstructionSimplify.cpp index 47369db4b46..ad9d40b6c12 100644 --- a/lib/Analysis/InstructionSimplify.cpp +++ b/lib/Analysis/InstructionSimplify.cpp @@ -3486,8 +3486,8 @@ static Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, return getTrue(RetTy); break; case FCmpInst::FCMP_ULT: - // TODO: This should match 'oge'. - if (FMF.noNaNs() && CannotBeOrderedLessThanZero(LHS, Q.TLI)) + if ((FMF.noNaNs() || isKnownNeverNaN(LHS, Q.TLI)) && + CannotBeOrderedLessThanZero(LHS, Q.TLI)) return getFalse(RetTy); break; case FCmpInst::FCMP_OLT: diff --git a/test/Transforms/InstSimplify/floating-point-compare.ll b/test/Transforms/InstSimplify/floating-point-compare.ll index b02248d3afc..c44ce6988b4 100644 --- a/test/Transforms/InstSimplify/floating-point-compare.ll +++ b/test/Transforms/InstSimplify/floating-point-compare.ll @@ -313,9 +313,7 @@ define <2 x i1> @UIToFP_is_not_negative_vec(<2 x i32> %x) { define i1 @UIToFP_is_not_negative_or_nan(i32 %x) { ; CHECK-LABEL: @UIToFP_is_not_negative_or_nan( -; CHECK-NEXT: [[A:%.*]] = uitofp i32 [[X:%.*]] to float -; CHECK-NEXT: [[R:%.*]] = fcmp ult float [[A]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[R]] +; CHECK-NEXT: ret i1 false ; %a = uitofp i32 %x to float %r = fcmp ult float %a, 0.000000e+00 @@ -324,9 +322,7 @@ define i1 @UIToFP_is_not_negative_or_nan(i32 %x) { define <2 x i1> @UIToFP_is_not_negative_or_nan_vec(<2 x i32> %x) { ; CHECK-LABEL: @UIToFP_is_not_negative_or_nan_vec( -; CHECK-NEXT: [[A:%.*]] = uitofp <2 x i32> [[X:%.*]] to <2 x float> -; CHECK-NEXT: [[R:%.*]] = fcmp ult <2 x float> [[A]], zeroinitializer -; CHECK-NEXT: ret <2 x i1> [[R]] +; CHECK-NEXT: ret <2 x i1> zeroinitializer ; %a = uitofp <2 x i32> %x to <2 x float> %r = fcmp ult <2 x float> %a, zeroinitializer @@ -425,9 +421,7 @@ define <2 x i1> @fabs_is_not_negative_vec(<2 x double> %x) { define i1 @fabs_nnan_is_not_negative(double %x) { ; CHECK-LABEL: @fabs_nnan_is_not_negative( -; CHECK-NEXT: [[FABS:%.*]] = tail call nnan double @llvm.fabs.f64(double [[X:%.*]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ult double [[FABS]], 0.000000e+00 -; CHECK-NEXT: ret i1 [[CMP]] +; CHECK-NEXT: ret i1 false ; %fabs = tail call nnan double @llvm.fabs.f64(double %x) %cmp = fcmp ult double %fabs, 0.0 @@ -436,9 +430,7 @@ define i1 @fabs_nnan_is_not_negative(double %x) { define <2 x i1> @fabs_nnan_is_not_negative_vec(<2 x double> %x) { ; CHECK-LABEL: @fabs_nnan_is_not_negative_vec( -; CHECK-NEXT: [[FABS:%.*]] = tail call nnan <2 x double> @llvm.fabs.v2f64(<2 x double> [[X:%.*]]) -; CHECK-NEXT: [[CMP:%.*]] = fcmp ult <2 x double> [[FABS]], zeroinitializer -; CHECK-NEXT: ret <2 x i1> [[CMP]] +; CHECK-NEXT: ret <2 x i1> zeroinitializer ; %fabs = tail call nnan <2 x double> @llvm.fabs.v2f64(<2 x double> %x) %cmp = fcmp ult <2 x double> %fabs, zeroinitializer -- 2.11.0