[InstSimplify] allow exp/log simplifications with only 'reassoc' FMF

[spatel]

Summary

As discussed on llvm-dev recently, we should refine our FP transforms based on the minimum subset of fast-math-flags needed to enable those transforms.

These intrinsic folds were just added with D41381, but we let them slide with isFast(). I think 'reassoc' is enough given that we're just eliminating ops based on their math inverses.

[wristow]

Code change LGTM. A minor tweak to each test-change (to replace 'fast' with 'reassoc') would test it more precisely.

test/Transforms/InstSimplify/exp-intrinsic.ll

22 ↗

(On Diff #133753)

'reassoc' instead of 'fast' should also be all that's needed for the llvm.log.f64 call to enable this transformation.

test/Transforms/InstSimplify/exp2-intrinsic.ll

22 ↗

(On Diff #133753)

Again, 'reassoc' is all that's needed.

test/Transforms/InstSimplify/log-intrinsic.ll

22 ↗

(On Diff #133753)

'reassoc' is all that's needed here, too.

test/Transforms/InstSimplify/log2-intrinsic.ll

22 ↗

(On Diff #133753)

One last one where 'reassoc' is all that's needed.

[spatel]

test/Transforms/InstSimplify/exp-intrinsic.ll

22 ↗

(On Diff #133753)

Hmm...looking a bit closer, this test doesn't add much value. We show that the FMF on the first instruction is irrelevant in the next test (and the same is true in each file). Should I just delete this and its siblings?

[wristow]

test/Transforms/InstSimplify/exp-intrinsic.ll

22 ↗

(On Diff #133753)

Now that you mention it, yes, that makes more sense.

llvm/trunk/lib/Analysis/InstructionSimplify.cpp

if (NumOperands == 1) {
     case Intrinsic::bitreverse: {
       // bitreverse(bitreverse(x)) -> x
       if (match(IIOperand, m_BitReverse(m_Value(X))))
         return X;
       return nullptr;
     }
     case Intrinsic::exp: {
       // exp(log(x)) -> x
-      if (Q.CxtI->isFast() &&
+      if (Q.CxtI->hasAllowReassoc() &&
           match(IIOperand, m_Intrinsic<Intrinsic::log>(m_Value(X))))
         return X;
       return nullptr;
     }
     case Intrinsic::exp2: {
       // exp2(log2(x)) -> x
-      if (Q.CxtI->isFast() &&
+      if (Q.CxtI->hasAllowReassoc() &&
           match(IIOperand, m_Intrinsic<Intrinsic::log2>(m_Value(X))))
         return X;
       return nullptr;
     }
     case Intrinsic::log: {
       // log(exp(x)) -> x
-      if (Q.CxtI->isFast() &&
+      if (Q.CxtI->hasAllowReassoc() &&
           match(IIOperand, m_Intrinsic<Intrinsic::exp>(m_Value(X))))
         return X;
       return nullptr;
     }
     case Intrinsic::log2: {
       // log2(exp2(x)) -> x
-      if (Q.CxtI->isFast() &&
+      if (Q.CxtI->hasAllowReassoc() &&
           match(IIOperand, m_Intrinsic<Intrinsic::exp2>(m_Value(X)))) {
         return X;
       }
       return nullptr;
     }
     default:
       return nullptr;
     }

llvm/trunk/test/Transforms/InstSimplify/log-exp-intrinsic.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare double @llvm.log.f64(double)
 declare double @llvm.exp.f64(double)
+declare double @llvm.log2.f64(double)
+declare double @llvm.exp2.f64(double)
 
-define double @log_fast_exp_strict(double %a) {
-; CHECK-LABEL: @log_fast_exp_strict(
+define double @log_reassoc_exp_strict(double %a) {
+; CHECK-LABEL: @log_reassoc_exp_strict(
 ; CHECK-NEXT:    ret double [[A:%.*]]
 ;
   %1 = call double @llvm.exp.f64(double %a)
-  %2 = call fast double @llvm.log.f64(double %1)
+  %2 = call reassoc double @llvm.log.f64(double %1)
   ret double %2
 }
 
-define double @log_strict_exp_fast(double %a) {
-; CHECK-LABEL: @log_strict_exp_fast(
-; CHECK-NEXT:    [[TMP1:%.*]] = call fast double @llvm.exp.f64(double [[A:%.*]])
+define double @log_strict_exp_reassoc(double %a) {
+; CHECK-LABEL: @log_strict_exp_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = call reassoc double @llvm.exp.f64(double [[A:%.*]])
 ; CHECK-NEXT:    [[TMP2:%.*]] = call double @llvm.log.f64(double [[TMP1]])
 ; CHECK-NEXT:    ret double [[TMP2]]
 ;
-  %1 = call fast double @llvm.exp.f64(double %a)
+  %1 = call reassoc double @llvm.exp.f64(double %a)
   %2 = call double @llvm.log.f64(double %1)
   ret double %2
 }
 
 define double @log_exp_log_exp(double %a) {
 ; CHECK-LABEL: @log_exp_log_exp(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.exp.f64(double [[A:%.*]])
 ; CHECK-NEXT:    [[TMP2:%.*]] = call double @llvm.log.f64(double [[TMP1]])
 ; CHECK-NEXT:    [[TMP3:%.*]] = call double @llvm.exp.f64(double [[TMP2]])
 ; CHECK-NEXT:    [[TMP4:%.*]] = call double @llvm.log.f64(double [[TMP3]])
 ; CHECK-NEXT:    ret double [[TMP4]]
 ;
   %1 = call double @llvm.exp.f64(double %a)
   %2 = call double @llvm.log.f64(double %1)
   %3 = call double @llvm.exp.f64(double %2)
   %4 = call double @llvm.log.f64(double %3)
   ret double %4
 }
 
-define double @log_exp_log_exp_fast(double %a) {
-; CHECK-LABEL: @log_exp_log_exp_fast(
+define double @log_exp_log_exp_reassoc(double %a) {
+; CHECK-LABEL: @log_exp_log_exp_reassoc(
 ; CHECK-NEXT:    ret double [[A:%.*]]
 ;
   %1 = call double @llvm.exp.f64(double %a)
-  %2 = call fast double @llvm.log.f64(double %1)
+  %2 = call reassoc double @llvm.log.f64(double %1)
   %3 = call double @llvm.exp.f64(double %2)
-  %4 = call fast double @llvm.log.f64(double %3)
+  %4 = call reassoc double @llvm.log.f64(double %3)
   ret double %4
 }
 
-declare double @llvm.log2.f64(double)
-declare double @llvm.exp2.f64(double)
-
-define double @log2_fast_exp2_strict(double %a) {
-; CHECK-LABEL: @log2_fast_exp2_strict(
+define double @log2_reassoc_exp2_strict(double %a) {
+; CHECK-LABEL: @log2_reassoc_exp2_strict(
 ; CHECK-NEXT:    ret double [[A:%.*]]
 ;
   %1 = call double @llvm.exp2.f64(double %a)
-  %2 = call fast double @llvm.log2.f64(double %1)
+  %2 = call reassoc double @llvm.log2.f64(double %1)
   ret double %2
 }
 
-define double @log2_strict_exp2_fast(double %a) {
-; CHECK-LABEL: @log2_strict_exp2_fast(
-; CHECK-NEXT:    [[TMP1:%.*]] = call fast double @llvm.exp2.f64(double [[A:%.*]])
+define double @log2_strict_exp2_reassoc(double %a) {
+; CHECK-LABEL: @log2_strict_exp2_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = call reassoc double @llvm.exp2.f64(double [[A:%.*]])
 ; CHECK-NEXT:    [[TMP2:%.*]] = call double @llvm.log2.f64(double [[TMP1]])
 ; CHECK-NEXT:    ret double [[TMP2]]
 ;
-  %1 = call fast double @llvm.exp2.f64(double %a)
+  %1 = call reassoc double @llvm.exp2.f64(double %a)
   %2 = call double @llvm.log2.f64(double %1)
   ret double %2
 }
 
 define double @log2_exp2_log2_exp2(double %a) {
 ; CHECK-LABEL: @log2_exp2_log2_exp2(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.exp2.f64(double [[A:%.*]])
 ; CHECK-NEXT:    [[TMP2:%.*]] = call double @llvm.log2.f64(double [[TMP1]])
 ; CHECK-NEXT:    [[TMP3:%.*]] = call double @llvm.exp2.f64(double [[TMP2]])
 ; CHECK-NEXT:    [[TMP4:%.*]] = call double @llvm.log2.f64(double [[TMP3]])
 ; CHECK-NEXT:    ret double [[TMP4]]
 ;
   %1 = call double @llvm.exp2.f64(double %a)
   %2 = call double @llvm.log2.f64(double %1)
   %3 = call double @llvm.exp2.f64(double %2)
   %4 = call double @llvm.log2.f64(double %3)
   ret double %4
 }
 
-define double @log2_exp2_log2_exp2_fast(double %a) {
-; CHECK-LABEL: @log2_exp2_log2_exp2_fast(
+define double @log2_exp2_log2_exp2_reassoc(double %a) {
+; CHECK-LABEL: @log2_exp2_log2_exp2_reassoc(
 ; CHECK-NEXT:    ret double [[A:%.*]]
 ;
   %1 = call double @llvm.exp2.f64(double %a)
-  %2 = call fast double @llvm.log2.f64(double %1)
+  %2 = call reassoc double @llvm.log2.f64(double %1)
   %3 = call double @llvm.exp2.f64(double %2)
-  %4 = call fast double @llvm.log2.f64(double %3)
+  %4 = call reassoc double @llvm.log2.f64(double %3)
   ret double %4
 }
 
-define double @exp_fast_log_strict(double %a) {
-; CHECK-LABEL: @exp_fast_log_strict(
+define double @exp_reassoc_log_strict(double %a) {
+; CHECK-LABEL: @exp_reassoc_log_strict(
 ; CHECK-NEXT:    ret double [[A:%.*]]
 ;
   %1 = call double @llvm.log.f64(double %a)
-  %2 = call fast double @llvm.exp.f64(double %1)
+  %2 = call reassoc double @llvm.exp.f64(double %1)
   ret double %2
 }
 
-define double @exp_strict_log_fast(double %a) {
-; CHECK-LABEL: @exp_strict_log_fast(
-; CHECK-NEXT:    [[TMP1:%.*]] = call fast double @llvm.log.f64(double [[A:%.*]])
+define double @exp_strict_log_reassoc(double %a) {
+; CHECK-LABEL: @exp_strict_log_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = call reassoc double @llvm.log.f64(double [[A:%.*]])
 ; CHECK-NEXT:    [[TMP2:%.*]] = call double @llvm.exp.f64(double [[TMP1]])
 ; CHECK-NEXT:    ret double [[TMP2]]
 ;
-  %1 = call fast double @llvm.log.f64(double %a)
+  %1 = call reassoc double @llvm.log.f64(double %a)
   %2 = call double @llvm.exp.f64(double %1)
   ret double %2
 }
 
 define double @exp_log_exp_log(double %a) {
 ; CHECK-LABEL: @exp_log_exp_log(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.log.f64(double [[A:%.*]])
 ; CHECK-NEXT:    [[TMP2:%.*]] = call double @llvm.exp.f64(double [[TMP1]])
 ; CHECK-NEXT:    [[TMP3:%.*]] = call double @llvm.log.f64(double [[TMP2]])
 ; CHECK-NEXT:    [[TMP4:%.*]] = call double @llvm.exp.f64(double [[TMP3]])
 ; CHECK-NEXT:    ret double [[TMP4]]
 ;
   %1 = call double @llvm.log.f64(double %a)
   %2 = call double @llvm.exp.f64(double %1)
   %3 = call double @llvm.log.f64(double %2)
   %4 = call double @llvm.exp.f64(double %3)
   ret double %4
 }
 
-define double @exp_log_exp_log_fast(double %a) {
-; CHECK-LABEL: @exp_log_exp_log_fast(
+define double @exp_log_exp_log_reassoc(double %a) {
+; CHECK-LABEL: @exp_log_exp_log_reassoc(
 ; CHECK-NEXT:    ret double [[A:%.*]]
 ;
   %1 = call double @llvm.log.f64(double %a)
-  %2 = call fast double @llvm.exp.f64(double %1)
+  %2 = call reassoc double @llvm.exp.f64(double %1)
   %3 = call double @llvm.log.f64(double %2)
-  %4 = call fast double @llvm.exp.f64(double %3)
+  %4 = call reassoc double @llvm.exp.f64(double %3)
   ret double %4
 }
 
-define double @exp2_fast_log2_strict(double %a) {
-; CHECK-LABEL: @exp2_fast_log2_strict(
+define double @exp2_reassoc_log2_strict(double %a) {
+; CHECK-LABEL: @exp2_reassoc_log2_strict(
 ; CHECK-NEXT:    ret double [[A:%.*]]
 ;
   %1 = call double @llvm.log2.f64(double %a)
-  %2 = call fast double @llvm.exp2.f64(double %1)
+  %2 = call reassoc double @llvm.exp2.f64(double %1)
   ret double %2
 }
 
-define double @exp2_strict_log2_fast(double %a) {
-; CHECK-LABEL: @exp2_strict_log2_fast(
-; CHECK-NEXT:    [[TMP1:%.*]] = call fast double @llvm.log2.f64(double [[A:%.*]])
+define double @exp2_strict_log2_reassoc(double %a) {
+; CHECK-LABEL: @exp2_strict_log2_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = call reassoc double @llvm.log2.f64(double [[A:%.*]])
 ; CHECK-NEXT:    [[TMP2:%.*]] = call double @llvm.exp2.f64(double [[TMP1]])
 ; CHECK-NEXT:    ret double [[TMP2]]
 ;
-  %1 = call fast double @llvm.log2.f64(double %a)
+  %1 = call reassoc double @llvm.log2.f64(double %a)
   %2 = call double @llvm.exp2.f64(double %1)
   ret double %2
 }
 
 define double @exp2_log2_exp2_log2(double %a) {
 ; CHECK-LABEL: @exp2_log2_exp2_log2(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.log2.f64(double [[A:%.*]])
 ; CHECK-NEXT:    [[TMP2:%.*]] = call double @llvm.exp2.f64(double [[TMP1]])
 ; CHECK-NEXT:    [[TMP3:%.*]] = call double @llvm.log2.f64(double [[TMP2]])
 ; CHECK-NEXT:    [[TMP4:%.*]] = call double @llvm.exp2.f64(double [[TMP3]])
 ; CHECK-NEXT:    ret double [[TMP4]]
 ;
   %1 = call double @llvm.log2.f64(double %a)
   %2 = call double @llvm.exp2.f64(double %1)
   %3 = call double @llvm.log2.f64(double %2)
   %4 = call double @llvm.exp2.f64(double %3)
   ret double %4
 }
 
-define double @exp2_log2_exp2_log2_fast(double %a) {
-; CHECK-LABEL: @exp2_log2_exp2_log2_fast(
+define double @exp2_log2_exp2_log2_reassoc(double %a) {
+; CHECK-LABEL: @exp2_log2_exp2_log2_reassoc(
 ; CHECK-NEXT:    ret double [[A:%.*]]
 ;
   %1 = call double @llvm.log2.f64(double %a)
-  %2 = call fast double @llvm.exp2.f64(double %1)
+  %2 = call reassoc double @llvm.exp2.f64(double %1)
   %3 = call double @llvm.log2.f64(double %2)
-  %4 = call fast double @llvm.exp2.f64(double %3)
+  %4 = call reassoc double @llvm.exp2.f64(double %3)
   ret double %4
 }