[llvm] 9fac110 - Revert "[InstCombine] fold fcmp with lossy casted constant"

[Sanjay Patel via llvm-commits]

Author: Sanjay Patel
Date: 2022-03-10T10:22:22-05:00
New Revision: 9fac110bf70896a5411cf57b3ff34fab5798ab78

URL: https://github.com/llvm/llvm-project/commit/9fac110bf70896a5411cf57b3ff34fab5798ab78
DIFF: https://github.com/llvm/llvm-project/commit/9fac110bf70896a5411cf57b3ff34fab5798ab78.diff

LOG: Revert "[InstCombine] fold fcmp with lossy casted constant"

This reverts commit 9397bdc67eb2b9eedc247a89bef01c2484b48b89.

This optimization is likely to surprise programmers as seen
in post-commit comments, so we should add a clang warning
first (that is proposed in D121306).

Added: 
    

Modified: 
    llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
    llvm/test/Transforms/InstCombine/fcmp.ll

Removed: 
    


################################################################################
diff  --git a/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
index e405dc7334b49..d3f6693b16db2 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
@@ -6654,6 +6654,7 @@ Instruction *InstCombinerImpl::visitFCmpInst(FCmpInst &I) {
     if (match(Op1, m_FPExt(m_Value(Y))) && X->getType() == Y->getType())
       return new FCmpInst(Pred, X, Y, "", &I);
 
+    // fcmp (fpext X), C -> fcmp X, (fptrunc C) if fptrunc is lossless
     const APFloat *C;
     if (match(Op1, m_APFloat(C))) {
       const fltSemantics &FPSem =
@@ -6662,31 +6663,6 @@ Instruction *InstCombinerImpl::visitFCmpInst(FCmpInst &I) {
       APFloat TruncC = *C;
       TruncC.convert(FPSem, APFloat::rmNearestTiesToEven, &Lossy);
 
-      if (Lossy) {
-        // X can't possibly equal the higher-precision constant, so reduce any
-        // equality comparison.
-        // TODO: Other predicates can be handled via getFCmpCode().
-        switch (Pred) {
-        case FCmpInst::FCMP_OEQ:
-          // X is ordered and equal to an impossible constant --> false
-          return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
-        case FCmpInst::FCMP_ONE:
-          // X is ordered and not equal to an impossible constant --> ordered
-          return new FCmpInst(FCmpInst::FCMP_ORD, X,
-                              ConstantFP::getNullValue(X->getType()));
-        case FCmpInst::FCMP_UEQ:
-          // X is unordered or equal to an impossible constant --> unordered
-          return new FCmpInst(FCmpInst::FCMP_UNO, X,
-                              ConstantFP::getNullValue(X->getType()));
-        case FCmpInst::FCMP_UNE:
-          // X is unordered or not equal to an impossible constant --> true
-          return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
-        default:
-          break;
-        }
-      }
-
-      // fcmp (fpext X), C -> fcmp X, (fptrunc C) if fptrunc is lossless
       // Avoid lossy conversions and denormals.
       // Zero is a special case that's OK to convert.
       APFloat Fabs = TruncC;

diff  --git a/llvm/test/Transforms/InstCombine/fcmp.ll b/llvm/test/Transforms/InstCombine/fcmp.ll
index fb6309262de59..de8328c35ec02 100644
--- a/llvm/test/Transforms/InstCombine/fcmp.ll
+++ b/llvm/test/Transforms/InstCombine/fcmp.ll
@@ -674,7 +674,9 @@ define i1 @is_signbit_set_simplify_nan(double %x) {
 
 define <2 x i1> @lossy_oeq(<2 x float> %x) {
 ; CHECK-LABEL: @lossy_oeq(
-; CHECK-NEXT:    ret <2 x i1> zeroinitializer
+; CHECK-NEXT:    [[E:%.*]] = fpext <2 x float> [[X:%.*]] to <2 x double>
+; CHECK-NEXT:    [[R:%.*]] = fcmp oeq <2 x double> [[E]], <double 1.000000e-01, double 1.000000e-01>
+; CHECK-NEXT:    ret <2 x i1> [[R]]
 ;
   %e = fpext <2 x float> %x to <2 x double>
   %r = fcmp oeq <2 x double> %e, <double 0.1, double 0.1>
@@ -685,7 +687,7 @@ define i1 @lossy_one(float %x, double* %p) {
 ; CHECK-LABEL: @lossy_one(
 ; CHECK-NEXT:    [[E:%.*]] = fpext float [[X:%.*]] to double
 ; CHECK-NEXT:    store double [[E]], double* [[P:%.*]], align 8
-; CHECK-NEXT:    [[R:%.*]] = fcmp ord float [[X]], 0.000000e+00
+; CHECK-NEXT:    [[R:%.*]] = fcmp one double [[E]], 1.000000e-01
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %e = fpext float %x to double
@@ -696,7 +698,8 @@ define i1 @lossy_one(float %x, double* %p) {
 
 define i1 @lossy_ueq(half %x) {
 ; CHECK-LABEL: @lossy_ueq(
-; CHECK-NEXT:    [[R:%.*]] = fcmp uno half [[X:%.*]], 0xH0000
+; CHECK-NEXT:    [[E:%.*]] = fpext half [[X:%.*]] to double
+; CHECK-NEXT:    [[R:%.*]] = fcmp ueq double [[E]], 6.553600e+04
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %e = fpext half %x to double
@@ -706,7 +709,9 @@ define i1 @lossy_ueq(half %x) {
 
 define i1 @lossy_une(half %x) {
 ; CHECK-LABEL: @lossy_une(
-; CHECK-NEXT:    ret i1 true
+; CHECK-NEXT:    [[E:%.*]] = fpext half [[X:%.*]] to float
+; CHECK-NEXT:    [[R:%.*]] = fcmp une float [[E]], 2.049000e+03
+; CHECK-NEXT:    ret i1 [[R]]
 ;
   %e = fpext half %x to float
   %r = fcmp une float %e, 2049.0