This is an archive of the discontinued LLVM Phabricator instance.

Differential D157891

ValueTracking: Handle exp10 in computeKnownFPClass
ClosedPublic

Authored by arsenm on Aug 14 2023, 8:44 AM.

Details

Reviewers
jcranmer-intel
foad
sepavloff
kpn
andrew.w.kaylor
jdoerfert
sstefan1
Summary

It's the same as the other exps.

Diff Detail

Event Timeline

arsenm created this revision.Aug 14 2023, 8:44 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 14 2023, 8:44 AM
Herald added subscribers: StephenFan, okura, kuter, hiraditya. · View Herald Transcript
arsenm requested review of this revision.Aug 14 2023, 8:44 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptAug 14 2023, 8:44 AM
Herald added a reviewer: sstefan1. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added a subscriber: wdng. · View Herald Transcript
arsenm added a parent revision: D157871: IR: Add llvm.exp10 intrinsic.Aug 14 2023, 8:44 AM
Harbormaster completed remote builds in B252379: Diff 549966.Aug 14 2023, 8:45 AM
foad accepted this revision.Aug 15 2023, 1:56 AM
This revision is now accepted and ready to land.Aug 15 2023, 1:56 AM
arsenm closed this revision.Sep 1 2023, 5:23 PM

301b0e477b0882ef8f8e67c72edbcd304631472c

arsenm mentioned this in rG301b0e477b08: ValueTracking: Handle exp10 in computeKnownFPClass.Sep 1 2023, 5:23 PM

Revision Contents

PathSize
llvm/
lib/
Analysis/
3 lines
test/
Transforms/
Attributor/
44 lines

Diff 549966

llvm/lib/Analysis/ValueTracking.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,645 Lines • ▼ Show 20 Lines case Intrinsic::roundeven: {
if (KnownSrc.isKnownNever(fcPosFinite)) if (KnownSrc.isKnownNever(fcPosFinite))
Known.knownNot(fcPosFinite); Known.knownNot(fcPosFinite);
if (KnownSrc.isKnownNever(fcNegFinite)) if (KnownSrc.isKnownNever(fcNegFinite))
Known.knownNot(fcNegFinite); Known.knownNot(fcNegFinite);
break; break;
} }
case Intrinsic::exp: case Intrinsic::exp:
case Intrinsic::exp2: { case Intrinsic::exp2:
case Intrinsic::exp10: {
Known.knownNot(fcNegative); Known.knownNot(fcNegative);
if ((InterestedClasses & fcNan) == fcNone) if ((InterestedClasses & fcNan) == fcNone)
break; break;
KnownFPClass KnownSrc; KnownFPClass KnownSrc;
computeKnownFPClass(II->getArgOperand(0), DemandedElts, InterestedClasses, computeKnownFPClass(II->getArgOperand(0), DemandedElts, InterestedClasses,
KnownSrc, Depth + 1, Q); KnownSrc, Depth + 1, Q);
if (KnownSrc.isKnownNeverNaN()) { if (KnownSrc.isKnownNeverNaN()) {
▲ Show 20 Lines • Show All 4,175 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/nofpclass-exp.ll

Show First 20 Lines • Show All 230 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%unknown.sign.not.nan = fmul nnan float %arg0, %arg1 %unknown.sign.not.nan = fmul nnan float %arg0, %arg1
%call = call float @llvm.exp2.f32(float %unknown.sign.not.nan) %call = call float @llvm.exp2.f32(float %unknown.sign.not.nan)
ret float %call ret float %call
} }
define float @ret_exp10(float %arg0) { define float @ret_exp10(float %arg0) {
; CHECK-LABEL: define float @ret_exp10 ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_exp10
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.exp10.f32(float %arg0) %call = call float @llvm.exp10.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_exp10_noinf(float nofpclass(inf) %arg0) { define float @ret_exp10_noinf(float nofpclass(inf) %arg0) {
; CHECK-LABEL: define float @ret_exp10_noinf ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_exp10_noinf
; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.exp10.f32(float %arg0) %call = call float @llvm.exp10.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_exp10_nopinf(float nofpclass(pinf) %arg0) { define float @ret_exp10_nopinf(float nofpclass(pinf) %arg0) {
; CHECK-LABEL: define float @ret_exp10_nopinf ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_exp10_nopinf
; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.exp10.f32(float %arg0) %call = call float @llvm.exp10.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_exp10_noninf(float nofpclass(ninf) %arg0) { define float @ret_exp10_noninf(float nofpclass(ninf) %arg0) {
; CHECK-LABEL: define float @ret_exp10_noninf ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_exp10_noninf
; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.exp10.f32(float %arg0) %call = call float @llvm.exp10.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_exp10_nonan(float nofpclass(nan) %arg0) { define float @ret_exp10_nonan(float nofpclass(nan) %arg0) {
; CHECK-LABEL: define float @ret_exp10_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_exp10_nonan
; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.exp10.f32(float %arg0) %call = call float @llvm.exp10.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_exp10_nonan_noinf(float nofpclass(nan inf) %arg0) { define float @ret_exp10_nonan_noinf(float nofpclass(nan inf) %arg0) {
; CHECK-LABEL: define float @ret_exp10_nonan_noinf ; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_exp10_nonan_noinf
; CHECK-SAME: (float nofpclass(nan inf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan inf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.exp10.f32(float %arg0) %call = call float @llvm.exp10.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_exp10_nonan_noinf_nozero(float nofpclass(nan inf zero) %arg0) { define float @ret_exp10_nonan_noinf_nozero(float nofpclass(nan inf zero) %arg0) {
; CHECK-LABEL: define float @ret_exp10_nonan_noinf_nozero ; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_exp10_nonan_noinf_nozero
; CHECK-SAME: (float nofpclass(nan inf zero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan inf zero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.exp10.f32(float %arg0) %call = call float @llvm.exp10.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_exp10_noinf_nozero(float nofpclass(inf zero) %arg0) { define float @ret_exp10_noinf_nozero(float nofpclass(inf zero) %arg0) {
; CHECK-LABEL: define float @ret_exp10_noinf_nozero ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_exp10_noinf_nozero
; CHECK-SAME: (float nofpclass(inf zero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(inf zero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.exp10.f32(float %arg0) %call = call float @llvm.exp10.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_exp10_noinf_nonegzero(float nofpclass(inf nzero) %arg0) { define float @ret_exp10_noinf_nonegzero(float nofpclass(inf nzero) %arg0) {
; CHECK-LABEL: define float @ret_exp10_noinf_nonegzero ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_exp10_noinf_nonegzero
; CHECK-SAME: (float nofpclass(inf nzero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(inf nzero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.exp10.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.exp10.f32(float %arg0) %call = call float @llvm.exp10.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_exp10_positive_source(i32 %arg) { define float @ret_exp10_positive_source(i32 %arg) {
; CHECK-LABEL: define float @ret_exp10_positive_source ; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_exp10_positive_source
; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[UITOFP:%.*]] = uitofp i32 [[ARG]] to float ; CHECK-NEXT: [[UITOFP:%.*]] = uitofp i32 [[ARG]] to float
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.exp10.f32(float [[UITOFP]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.exp10.f32(float [[UITOFP]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%uitofp = uitofp i32 %arg to float %uitofp = uitofp i32 %arg to float
%call = call float @llvm.exp10.f32(float %uitofp) %call = call float @llvm.exp10.f32(float %uitofp)
ret float %call ret float %call
} }
; Could produce a nan because we don't know if the multiply is negative. ; Could produce a nan because we don't know if the multiply is negative.
define float @ret_exp10_unknown_sign(float nofpclass(nan) %arg0, float nofpclass(nan) %arg1) { define float @ret_exp10_unknown_sign(float nofpclass(nan) %arg0, float nofpclass(nan) %arg1) {
; CHECK-LABEL: define float @ret_exp10_unknown_sign ; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_exp10_unknown_sign
; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]], float nofpclass(nan) [[ARG1:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]], float nofpclass(nan) [[ARG1:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[UNKNOWN_SIGN_NOT_NAN:%.*]] = fmul nnan float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[UNKNOWN_SIGN_NOT_NAN:%.*]] = fmul nnan float [[ARG0]], [[ARG1]]
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.exp10.f32(float [[UNKNOWN_SIGN_NOT_NAN]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.exp10.f32(float [[UNKNOWN_SIGN_NOT_NAN]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%unknown.sign.not.nan = fmul nnan float %arg0, %arg1 %unknown.sign.not.nan = fmul nnan float %arg0, %arg1
%call = call float @llvm.exp10.f32(float %unknown.sign.not.nan) %call = call float @llvm.exp10.f32(float %unknown.sign.not.nan)
ret float %call ret float %call
} }
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; TUNIT: {{.*}} ; TUNIT: {{.*}}