This is an archive of the discontinued LLVM Phabricator instance.

Differential D43160

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

Authored by spatel on Feb 10 2018, 8:56 AM.

Details

Reviewers
MatzeB
qcolombet
hfinkel
Quolyk
scanon
efriedma
wristow
Commits
rG246d769232df: [InstSimplify] allow exp/log simplifications with only 'reassoc' FMF
rL324967: [InstSimplify] allow exp/log simplifications with only 'reassoc' FMF
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.

Diff Detail

Event Timeline

spatel created this revision.Feb 10 2018, 8:56 AM
Herald added a subscriber: mcrosier. · View Herald TranscriptFeb 10 2018, 8:56 AM
wristow added a comment.Feb 12 2018, 11:28 AM

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

'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

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

test/Transforms/InstSimplify/log-intrinsic.ll
22

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

test/Transforms/InstSimplify/log2-intrinsic.ll
22

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

spatel added inline comments.Feb 12 2018, 11:47 AM
test/Transforms/InstSimplify/exp-intrinsic.ll
22

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 added inline comments.Feb 12 2018, 2:24 PM
test/Transforms/InstSimplify/exp-intrinsic.ll
22

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

spatel mentioned this in rL324963: [InstSimplify] change tests to 'fast' to reflect current folds.Feb 12 2018, 3:41 PM
This revision was not accepted when it landed; it landed in state Needs Review.Feb 12 2018, 3:53 PM
Closed by commit rL324967: [InstSimplify] allow exp/log simplifications with only 'reassoc' FMF (authored by spatel). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lib/
Analysis/
8 lines
test/
Transforms/
InstSimplify/
32 lines
32 lines
32 lines
32 lines

Diff 133753

lib/Analysis/InstructionSimplify.cpp

Show First 20 Lines • Show All 4,565 Lines • ▼ Show 20 Lines if (NumOperands == 1) {
case Intrinsic::bitreverse: { case Intrinsic::bitreverse: {
// bitreverse(bitreverse(x)) -> x // bitreverse(bitreverse(x)) -> x
if (match(IIOperand, m_BitReverse(m_Value(X)))) if (match(IIOperand, m_BitReverse(m_Value(X))))
return X; return X;
return nullptr; return nullptr;
} }
case Intrinsic::exp: { case Intrinsic::exp: {
// exp(log(x)) -> x // exp(log(x)) -> x
if (Q.CxtI->isFast() && if (Q.CxtI->hasAllowReassoc() &&
match(IIOperand, m_Intrinsic<Intrinsic::log>(m_Value(X)))) match(IIOperand, m_Intrinsic<Intrinsic::log>(m_Value(X))))
return X; return X;
return nullptr; return nullptr;
} }
case Intrinsic::exp2: { case Intrinsic::exp2: {
// exp2(log2(x)) -> x // exp2(log2(x)) -> x
if (Q.CxtI->isFast() && if (Q.CxtI->hasAllowReassoc() &&
match(IIOperand, m_Intrinsic<Intrinsic::log2>(m_Value(X)))) match(IIOperand, m_Intrinsic<Intrinsic::log2>(m_Value(X))))
return X; return X;
return nullptr; return nullptr;
} }
case Intrinsic::log: { case Intrinsic::log: {
// log(exp(x)) -> x // log(exp(x)) -> x
if (Q.CxtI->isFast() && if (Q.CxtI->hasAllowReassoc() &&
match(IIOperand, m_Intrinsic<Intrinsic::exp>(m_Value(X)))) match(IIOperand, m_Intrinsic<Intrinsic::exp>(m_Value(X))))
return X; return X;
return nullptr; return nullptr;
} }
case Intrinsic::log2: { case Intrinsic::log2: {
// log2(exp2(x)) -> x // log2(exp2(x)) -> x
if (Q.CxtI->isFast() && if (Q.CxtI->hasAllowReassoc() &&
match(IIOperand, m_Intrinsic<Intrinsic::exp2>(m_Value(X)))) { match(IIOperand, m_Intrinsic<Intrinsic::exp2>(m_Value(X)))) {
return X; return X;
} }
return nullptr; return nullptr;
} }
default: default:
return nullptr; return nullptr;
} }
▲ Show 20 Lines • Show All 408 Lines • Show Last 20 Lines

test/Transforms/InstSimplify/exp-intrinsic.ll

Show All 9 Lines
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.exp.f64(double [[TMP1]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.exp.f64(double [[TMP1]])
; CHECK-NEXT: ret double [[TMP2]] ; CHECK-NEXT: ret double [[TMP2]]
; ;
%1 = call double @llvm.log.f64(double %a) %1 = call double @llvm.log.f64(double %a)
%2 = call double @llvm.exp.f64(double %1) %2 = call double @llvm.exp.f64(double %1)
ret double %2 ret double %2
} }
define double @exp_log_fast(double %a) { define double @exp_log_reassoc(double %a) {
; CHECK-LABEL: @exp_log_fast( ; CHECK-LABEL: @exp_log_reassoc(
; CHECK-NEXT: ret double [[A:%.*]] ; CHECK-NEXT: ret double [[A:%.*]]
; ;
%1 = call fast double @llvm.log.f64(double %a) %1 = call fast double @llvm.log.f64(double %a)
wristowUnsubmitted
Not Done
ReplyInline Actions

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

wristow: 'reassoc' instead of 'fast' should also be all that's needed for the llvm.log.f64 call to…
spatelAuthorUnsubmitted
Not Done
ReplyInline Actions

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?

spatel: Hmm...looking a bit closer, this test doesn't add much value. We show that the FMF on the first…
wristowUnsubmitted
Not Done
ReplyInline Actions

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

wristow: Now that you mention it, yes, that makes more sense.
%2 = call fast double @llvm.exp.f64(double %1) %2 = call reassoc double @llvm.exp.f64(double %1)
ret double %2 ret double %2
} }
define double @exp_fast_log_strict(double %a) { define double @exp_reassoc_log_strict(double %a) {
; CHECK-LABEL: @exp_fast_log_strict( ; CHECK-LABEL: @exp_reassoc_log_strict(
; CHECK-NEXT: ret double [[A:%.*]] ; CHECK-NEXT: ret double [[A:%.*]]
; ;
%1 = call double @llvm.log.f64(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 ret double %2
} }
define double @exp_strict_log_fast(double %a) { define double @exp_strict_log_reassoc(double %a) {
; CHECK-LABEL: @exp_strict_log_fast( ; CHECK-LABEL: @exp_strict_log_reassoc(
; CHECK-NEXT: [[TMP1:%.*]] = call fast double @llvm.log.f64(double [[A:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call reassoc double @llvm.log.f64(double [[A:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.exp.f64(double [[TMP1]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.exp.f64(double [[TMP1]])
; CHECK-NEXT: ret double [[TMP2]] ; 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) %2 = call double @llvm.exp.f64(double %1)
ret double %2 ret double %2
} }
define double @exp_log_exp_log(double %a) { define double @exp_log_exp_log(double %a) {
; CHECK-LABEL: @exp_log_exp_log( ; CHECK-LABEL: @exp_log_exp_log(
; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.log.f64(double [[A:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.log.f64(double [[A:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.exp.f64(double [[TMP1]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.exp.f64(double [[TMP1]])
; CHECK-NEXT: [[TMP3:%.*]] = call double @llvm.log.f64(double [[TMP2]]) ; CHECK-NEXT: [[TMP3:%.*]] = call double @llvm.log.f64(double [[TMP2]])
; CHECK-NEXT: [[TMP4:%.*]] = call double @llvm.exp.f64(double [[TMP3]]) ; CHECK-NEXT: [[TMP4:%.*]] = call double @llvm.exp.f64(double [[TMP3]])
; CHECK-NEXT: ret double [[TMP4]] ; CHECK-NEXT: ret double [[TMP4]]
; ;
%1 = call double @llvm.log.f64(double %a) %1 = call double @llvm.log.f64(double %a)
%2 = call double @llvm.exp.f64(double %1) %2 = call double @llvm.exp.f64(double %1)
%3 = call double @llvm.log.f64(double %2) %3 = call double @llvm.log.f64(double %2)
%4 = call double @llvm.exp.f64(double %3) %4 = call double @llvm.exp.f64(double %3)
ret double %4 ret double %4
} }
define double @exp_log_exp_log_fast(double %a) { define double @exp_log_exp_log_reassoc(double %a) {
; CHECK-LABEL: @exp_log_exp_log_fast( ; CHECK-LABEL: @exp_log_exp_log_reassoc(
; CHECK-NEXT: ret double [[A:%.*]] ; CHECK-NEXT: ret double [[A:%.*]]
; ;
%1 = call fast double @llvm.log.f64(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 fast double @llvm.log.f64(double %2) %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 ret double %4
} }

test/Transforms/InstSimplify/exp2-intrinsic.ll

Show All 9 Lines
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.exp2.f64(double [[TMP1]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.exp2.f64(double [[TMP1]])
; CHECK-NEXT: ret double [[TMP2]] ; CHECK-NEXT: ret double [[TMP2]]
; ;
%1 = call double @llvm.log2.f64(double %a) %1 = call double @llvm.log2.f64(double %a)
%2 = call double @llvm.exp2.f64(double %1) %2 = call double @llvm.exp2.f64(double %1)
ret double %2 ret double %2
} }
define double @exp2_log2_fast(double %a) { define double @exp2_log2_reassoc(double %a) {
; CHECK-LABEL: @exp2_log2_fast( ; CHECK-LABEL: @exp2_log2_reassoc(
; CHECK-NEXT: ret double [[A:%.*]] ; CHECK-NEXT: ret double [[A:%.*]]
; ;
%1 = call fast double @llvm.log2.f64(double %a) %1 = call fast double @llvm.log2.f64(double %a)
wristowUnsubmitted
Not Done
ReplyInline Actions

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

wristow: Again, 'reassoc' is all that's needed.
%2 = call fast double @llvm.exp2.f64(double %1) %2 = call reassoc double @llvm.exp2.f64(double %1)
ret double %2 ret double %2
} }
define double @exp2_fast_log2_strict(double %a) { define double @exp2_reassoc_log2_strict(double %a) {
; CHECK-LABEL: @exp2_fast_log2_strict( ; CHECK-LABEL: @exp2_reassoc_log2_strict(
; CHECK-NEXT: ret double [[A:%.*]] ; CHECK-NEXT: ret double [[A:%.*]]
; ;
%1 = call double @llvm.log2.f64(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 ret double %2
} }
define double @exp2_strict_log2_fast(double %a) { define double @exp2_strict_log2_reassoc(double %a) {
; CHECK-LABEL: @exp2_strict_log2_fast( ; CHECK-LABEL: @exp2_strict_log2_reassoc(
; CHECK-NEXT: [[TMP1:%.*]] = call fast double @llvm.log2.f64(double [[A:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call reassoc double @llvm.log2.f64(double [[A:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.exp2.f64(double [[TMP1]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.exp2.f64(double [[TMP1]])
; CHECK-NEXT: ret double [[TMP2]] ; 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) %2 = call double @llvm.exp2.f64(double %1)
ret double %2 ret double %2
} }
define double @exp2_log2_exp2_log2(double %a) { define double @exp2_log2_exp2_log2(double %a) {
; CHECK-LABEL: @exp2_log2_exp2_log2( ; CHECK-LABEL: @exp2_log2_exp2_log2(
; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.log2.f64(double [[A:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.log2.f64(double [[A:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.exp2.f64(double [[TMP1]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.exp2.f64(double [[TMP1]])
; CHECK-NEXT: [[TMP3:%.*]] = call double @llvm.log2.f64(double [[TMP2]]) ; CHECK-NEXT: [[TMP3:%.*]] = call double @llvm.log2.f64(double [[TMP2]])
; CHECK-NEXT: [[TMP4:%.*]] = call double @llvm.exp2.f64(double [[TMP3]]) ; CHECK-NEXT: [[TMP4:%.*]] = call double @llvm.exp2.f64(double [[TMP3]])
; CHECK-NEXT: ret double [[TMP4]] ; CHECK-NEXT: ret double [[TMP4]]
; ;
%1 = call double @llvm.log2.f64(double %a) %1 = call double @llvm.log2.f64(double %a)
%2 = call double @llvm.exp2.f64(double %1) %2 = call double @llvm.exp2.f64(double %1)
%3 = call double @llvm.log2.f64(double %2) %3 = call double @llvm.log2.f64(double %2)
%4 = call double @llvm.exp2.f64(double %3) %4 = call double @llvm.exp2.f64(double %3)
ret double %4 ret double %4
} }
define double @exp2_log2_exp2_log2_fast(double %a) { define double @exp2_log2_exp2_log2_reassoc(double %a) {
; CHECK-LABEL: @exp2_log2_exp2_log2_fast( ; CHECK-LABEL: @exp2_log2_exp2_log2_reassoc(
; CHECK-NEXT: ret double [[A:%.*]] ; CHECK-NEXT: ret double [[A:%.*]]
; ;
%1 = call fast double @llvm.log2.f64(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 fast double @llvm.log2.f64(double %2) %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 ret double %4
} }

test/Transforms/InstSimplify/log-intrinsic.ll

Show All 9 Lines
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.log.f64(double [[TMP1]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.log.f64(double [[TMP1]])
; CHECK-NEXT: ret double [[TMP2]] ; CHECK-NEXT: ret double [[TMP2]]
; ;
%1 = call double @llvm.exp.f64(double %a) %1 = call double @llvm.exp.f64(double %a)
%2 = call double @llvm.log.f64(double %1) %2 = call double @llvm.log.f64(double %1)
ret double %2 ret double %2
} }
define double @log_exp_fast(double %a) { define double @log_exp_reassoc(double %a) {
; CHECK-LABEL: @log_exp_fast( ; CHECK-LABEL: @log_exp_reassoc(
; CHECK-NEXT: ret double [[A:%.*]] ; CHECK-NEXT: ret double [[A:%.*]]
; ;
%1 = call fast double @llvm.exp.f64(double %a) %1 = call fast double @llvm.exp.f64(double %a)
wristowUnsubmitted
Not Done
ReplyInline Actions

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

wristow: 'reassoc' is all that's needed here, too.
%2 = call fast double @llvm.log.f64(double %1) %2 = call reassoc double @llvm.log.f64(double %1)
ret double %2 ret double %2
} }
define double @log_fast_exp_strict(double %a) { define double @log_reassoc_exp_strict(double %a) {
; CHECK-LABEL: @log_fast_exp_strict( ; CHECK-LABEL: @log_reassoc_exp_strict(
; CHECK-NEXT: ret double [[A:%.*]] ; CHECK-NEXT: ret double [[A:%.*]]
; ;
%1 = call double @llvm.exp.f64(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 ret double %2
} }
define double @log_strict_exp_fast(double %a) { define double @log_strict_exp_reassoc(double %a) {
; CHECK-LABEL: @log_strict_exp_fast( ; CHECK-LABEL: @log_strict_exp_reassoc(
; CHECK-NEXT: [[TMP1:%.*]] = call fast double @llvm.exp.f64(double [[A:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call reassoc double @llvm.exp.f64(double [[A:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.log.f64(double [[TMP1]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.log.f64(double [[TMP1]])
; CHECK-NEXT: ret double [[TMP2]] ; 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) %2 = call double @llvm.log.f64(double %1)
ret double %2 ret double %2
} }
define double @log_exp_log_exp(double %a) { define double @log_exp_log_exp(double %a) {
; CHECK-LABEL: @log_exp_log_exp( ; CHECK-LABEL: @log_exp_log_exp(
; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.exp.f64(double [[A:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.exp.f64(double [[A:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.log.f64(double [[TMP1]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.log.f64(double [[TMP1]])
; CHECK-NEXT: [[TMP3:%.*]] = call double @llvm.exp.f64(double [[TMP2]]) ; CHECK-NEXT: [[TMP3:%.*]] = call double @llvm.exp.f64(double [[TMP2]])
; CHECK-NEXT: [[TMP4:%.*]] = call double @llvm.log.f64(double [[TMP3]]) ; CHECK-NEXT: [[TMP4:%.*]] = call double @llvm.log.f64(double [[TMP3]])
; CHECK-NEXT: ret double [[TMP4]] ; CHECK-NEXT: ret double [[TMP4]]
; ;
%1 = call double @llvm.exp.f64(double %a) %1 = call double @llvm.exp.f64(double %a)
%2 = call double @llvm.log.f64(double %1) %2 = call double @llvm.log.f64(double %1)
%3 = call double @llvm.exp.f64(double %2) %3 = call double @llvm.exp.f64(double %2)
%4 = call double @llvm.log.f64(double %3) %4 = call double @llvm.log.f64(double %3)
ret double %4 ret double %4
} }
define double @log_exp_log_exp_fast(double %a) { define double @log_exp_log_exp_reassoc(double %a) {
; CHECK-LABEL: @log_exp_log_exp_fast( ; CHECK-LABEL: @log_exp_log_exp_reassoc(
; CHECK-NEXT: ret double [[A:%.*]] ; CHECK-NEXT: ret double [[A:%.*]]
; ;
%1 = call fast double @llvm.exp.f64(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 fast double @llvm.exp.f64(double %2) %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 ret double %4
} }

test/Transforms/InstSimplify/log2-intrinsic.ll

Show All 9 Lines
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.log2.f64(double [[TMP1]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.log2.f64(double [[TMP1]])
; CHECK-NEXT: ret double [[TMP2]] ; CHECK-NEXT: ret double [[TMP2]]
; ;
%1 = call double @llvm.exp2.f64(double %a) %1 = call double @llvm.exp2.f64(double %a)
%2 = call double @llvm.log2.f64(double %1) %2 = call double @llvm.log2.f64(double %1)
ret double %2 ret double %2
} }
define double @log2_exp2_fast(double %a) { define double @log2_exp2_reassoc(double %a) {
; CHECK-LABEL: @log2_exp2_fast( ; CHECK-LABEL: @log2_exp2_reassoc(
; CHECK-NEXT: ret double [[A:%.*]] ; CHECK-NEXT: ret double [[A:%.*]]
; ;
%1 = call fast double @llvm.exp2.f64(double %a) %1 = call fast double @llvm.exp2.f64(double %a)
wristowUnsubmitted
Not Done
ReplyInline Actions

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

wristow: One last one where 'reassoc' is all that's needed.
%2 = call fast double @llvm.log2.f64(double %1) %2 = call reassoc double @llvm.log2.f64(double %1)
ret double %2 ret double %2
} }
define double @log2_fast_exp2_strict(double %a) { define double @log2_reassoc_exp2_strict(double %a) {
; CHECK-LABEL: @log2_fast_exp2_strict( ; CHECK-LABEL: @log2_reassoc_exp2_strict(
; CHECK-NEXT: ret double [[A:%.*]] ; CHECK-NEXT: ret double [[A:%.*]]
; ;
%1 = call double @llvm.exp2.f64(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 ret double %2
} }
define double @log2_strict_exp2_fast(double %a) { define double @log2_strict_exp2_reassoc(double %a) {
; CHECK-LABEL: @log2_strict_exp2_fast( ; CHECK-LABEL: @log2_strict_exp2_reassoc(
; CHECK-NEXT: [[TMP1:%.*]] = call fast double @llvm.exp2.f64(double [[A:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call reassoc double @llvm.exp2.f64(double [[A:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.log2.f64(double [[TMP1]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.log2.f64(double [[TMP1]])
; CHECK-NEXT: ret double [[TMP2]] ; 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) %2 = call double @llvm.log2.f64(double %1)
ret double %2 ret double %2
} }
define double @log2_exp2_log2_exp2(double %a) { define double @log2_exp2_log2_exp2(double %a) {
; CHECK-LABEL: @log2_exp2_log2_exp2( ; CHECK-LABEL: @log2_exp2_log2_exp2(
; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.exp2.f64(double [[A:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.exp2.f64(double [[A:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.log2.f64(double [[TMP1]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.log2.f64(double [[TMP1]])
; CHECK-NEXT: [[TMP3:%.*]] = call double @llvm.exp2.f64(double [[TMP2]]) ; CHECK-NEXT: [[TMP3:%.*]] = call double @llvm.exp2.f64(double [[TMP2]])
; CHECK-NEXT: [[TMP4:%.*]] = call double @llvm.log2.f64(double [[TMP3]]) ; CHECK-NEXT: [[TMP4:%.*]] = call double @llvm.log2.f64(double [[TMP3]])
; CHECK-NEXT: ret double [[TMP4]] ; CHECK-NEXT: ret double [[TMP4]]
; ;
%1 = call double @llvm.exp2.f64(double %a) %1 = call double @llvm.exp2.f64(double %a)
%2 = call double @llvm.log2.f64(double %1) %2 = call double @llvm.log2.f64(double %1)
%3 = call double @llvm.exp2.f64(double %2) %3 = call double @llvm.exp2.f64(double %2)
%4 = call double @llvm.log2.f64(double %3) %4 = call double @llvm.log2.f64(double %3)
ret double %4 ret double %4
} }
define double @log2_exp2_log2_exp2_fast(double %a) { define double @log2_exp2_log2_exp2_reassoc(double %a) {
; CHECK-LABEL: @log2_exp2_log2_exp2_fast( ; CHECK-LABEL: @log2_exp2_log2_exp2_reassoc(
; CHECK-NEXT: ret double [[A:%.*]] ; CHECK-NEXT: ret double [[A:%.*]]
; ;
%1 = call fast double @llvm.exp2.f64(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 fast double @llvm.exp2.f64(double %2) %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 ret double %4
} }