This is an archive of the discontinued LLVM Phabricator instance.

Differential D147865

ValueTracking: Implement computeKnownFPClass for sin/cos
ClosedPublic

Authored by arsenm on Apr 8 2023, 4:18 PM.

Details

Reviewers
jcranmer-intel
kpn
bkramer
sepavloff
scanon
cameron.mcinally
jdoerfert
sstefan1
nikic

Diff Detail

Event Timeline

arsenm created this revision.Apr 8 2023, 4:18 PM
Herald added a project: Restricted Project. · View Herald TranscriptApr 8 2023, 4:18 PM
Herald added subscribers: okura, kuter, hiraditya. · View Herald Transcript
arsenm requested review of this revision.Apr 8 2023, 4:18 PM
Herald added a reviewer: jdoerfert. · View Herald TranscriptApr 8 2023, 4:18 PM
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
Harbormaster completed remote builds in B224399: Diff 511933.Apr 8 2023, 4:19 PM
arsenm added a child revision: D147942: ValueTracking: Delete body of isKnownNeverInfinity.Apr 10 2023, 7:48 AM
nikic added a subscriber: nikic.Apr 11 2023, 12:37 PM
nikic added inline comments.
llvm/lib/Analysis/ValueTracking.cpp
4442

Doesn't this also require that the src is non-nan as well?

arsenm added inline comments.Apr 11 2023, 12:42 PM
llvm/lib/Analysis/ValueTracking.cpp
4442

Yes. Annoyingly this applies to every operation

arsenm updated this revision to Diff 512639.Apr 11 2023, 7:14 PM

Also check for nan sources

Harbormaster completed remote builds in B224915: Diff 512639.Apr 11 2023, 7:15 PM
nikic accepted this revision.Apr 12 2023, 12:20 AM

LGTM

This revision is now accepted and ready to land.Apr 12 2023, 12:20 AM
Herald added a subscriber: StephenFan. · View Herald TranscriptApr 12 2023, 12:20 AM
arsenm closed this revision.Apr 14 2023, 11:37 AM

c603fd2f39beab13cd1df700467afcc324ec1d85

Revision Contents

PathSize
llvm/
lib/
Analysis/
11 lines
test/
Transforms/
Attributor/
40 lines
2 lines

Diff 512639

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,426 Lines • ▼ Show 20 Lines if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Op)) {
computeKnownFPClass(II->getArgOperand(0), DemandedElts, computeKnownFPClass(II->getArgOperand(0), DemandedElts,
InterestedClasses, Known, Depth + 1, Q, TLI); InterestedClasses, Known, Depth + 1, Q, TLI);
computeKnownFPClass(II->getArgOperand(1), DemandedElts, computeKnownFPClass(II->getArgOperand(1), DemandedElts,
InterestedClasses, KnownSign, Depth + 1, Q, TLI); InterestedClasses, KnownSign, Depth + 1, Q, TLI);
Known.copysign(KnownSign); Known.copysign(KnownSign);
break; break;
} }
case Intrinsic::sin:
case Intrinsic::cos: {
// Return NaN on infinite inputs.
KnownFPClass KnownSrc;
computeKnownFPClass(II->getArgOperand(0), DemandedElts,
InterestedClasses, KnownSrc, Depth + 1, Q, TLI);
Known.knownNot(fcInf);
if (KnownSrc.isKnownNeverNaN() && KnownSrc.isKnownNeverInfinity())
nikicUnsubmitted
Not Done
ReplyInline Actions

Doesn't this also require that the src is non-nan as well?

nikic: Doesn't this also require that the src is non-nan as well?
arsenmAuthorUnsubmitted
Done
ReplyInline Actions

Yes. Annoyingly this applies to every operation

arsenm: Yes. Annoyingly this applies to every operation
Known.knownNot(fcNan);
break;
}
default: default:
break; break;
} }
} }
break; break;
} }
case Instruction::FAdd: case Instruction::FAdd:
▲ Show 20 Lines • Show All 3,687 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/nofpclass-sin-cos.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
declare float @llvm.sin.f32(float) declare float @llvm.sin.f32(float)
declare float @llvm.cos.f32(float) declare float @llvm.cos.f32(float)
define float @ret_sin(float %arg) { define float @ret_sin(float %arg) {
; CHECK-LABEL: define float @ret_sin ; CHECK-LABEL: define nofpclass(inf) float @ret_sin
; CHECK-SAME: (float [[ARG:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (float [[ARG:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.sin.f32(float [[ARG]]) #[[ATTR2:[0-9]+]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf) float @llvm.sin.f32(float [[ARG]]) #[[ATTR2:[0-9]+]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.sin.f32(float %arg) %call = call float @llvm.sin.f32(float %arg)
ret float %call ret float %call
} }
define float @ret_cos(float %arg) { define float @ret_cos(float %arg) {
; CHECK-LABEL: define float @ret_cos ; CHECK-LABEL: define nofpclass(inf) float @ret_cos
; CHECK-SAME: (float [[ARG:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float [[ARG:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.cos.f32(float [[ARG]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf) float @llvm.cos.f32(float [[ARG]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.cos.f32(float %arg) %call = call float @llvm.cos.f32(float %arg)
ret float %call ret float %call
} }
define float @ret_sin_noinf(float nofpclass(inf) %arg) { define float @ret_sin_noinf(float nofpclass(inf) %arg) {
; CHECK-LABEL: define float @ret_sin_noinf ; CHECK-LABEL: define nofpclass(inf) float @ret_sin_noinf
; CHECK-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.sin.f32(float [[ARG]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf) float @llvm.sin.f32(float [[ARG]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.sin.f32(float %arg) %call = call float @llvm.sin.f32(float %arg)
ret float %call ret float %call
} }
define float @ret_cos_noinf(float nofpclass(inf) %arg) { define float @ret_cos_noinf(float nofpclass(inf) %arg) {
; CHECK-LABEL: define float @ret_cos_noinf ; CHECK-LABEL: define nofpclass(inf) float @ret_cos_noinf
; CHECK-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.cos.f32(float [[ARG]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf) float @llvm.cos.f32(float [[ARG]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.cos.f32(float %arg) %call = call float @llvm.cos.f32(float %arg)
ret float %call ret float %call
} }
define float @ret_sin_nonan(float nofpclass(nan) %arg) { define float @ret_sin_nonan(float nofpclass(nan) %arg) {
; CHECK-LABEL: define float @ret_sin_nonan ; CHECK-LABEL: define nofpclass(inf) float @ret_sin_nonan
; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.sin.f32(float [[ARG]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf) float @llvm.sin.f32(float [[ARG]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.sin.f32(float %arg) %call = call float @llvm.sin.f32(float %arg)
ret float %call ret float %call
} }
define float @ret_cos_nonan(float nofpclass(nan) %arg) { define float @ret_cos_nonan(float nofpclass(nan) %arg) {
; CHECK-LABEL: define float @ret_cos_nonan ; CHECK-LABEL: define nofpclass(inf) float @ret_cos_nonan
; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.cos.f32(float [[ARG]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf) float @llvm.cos.f32(float [[ARG]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.cos.f32(float %arg) %call = call float @llvm.cos.f32(float %arg)
ret float %call ret float %call
} }
define float @ret_sin_nonan_noinf(float nofpclass(nan inf) %arg) { define float @ret_sin_nonan_noinf(float nofpclass(nan inf) %arg) {
; CHECK-LABEL: define float @ret_sin_nonan_noinf ; CHECK-LABEL: define nofpclass(nan inf) float @ret_sin_nonan_noinf
; CHECK-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.sin.f32(float [[ARG]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan inf) float @llvm.sin.f32(float [[ARG]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.sin.f32(float %arg) %call = call float @llvm.sin.f32(float %arg)
ret float %call ret float %call
} }
define float @ret_cos_nonan_noinf(float nofpclass(nan inf) %arg) { define float @ret_cos_nonan_noinf(float nofpclass(nan inf) %arg) {
; CHECK-LABEL: define float @ret_cos_nonan_noinf ; CHECK-LABEL: define nofpclass(nan inf) float @ret_cos_nonan_noinf
; CHECK-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.cos.f32(float [[ARG]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan inf) float @llvm.cos.f32(float [[ARG]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.cos.f32(float %arg) %call = call float @llvm.cos.f32(float %arg)
ret float %call ret float %call
} }
define float @ret_sin_noqnan(float nofpclass(qnan) %arg) { define float @ret_sin_noqnan(float nofpclass(qnan) %arg) {
; CHECK-LABEL: define float @ret_sin_noqnan ; CHECK-LABEL: define nofpclass(inf) float @ret_sin_noqnan
; CHECK-SAME: (float nofpclass(qnan) [[ARG:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(qnan) [[ARG:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.sin.f32(float [[ARG]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf) float @llvm.sin.f32(float [[ARG]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.sin.f32(float %arg) %call = call float @llvm.sin.f32(float %arg)
ret float %call ret float %call
} }
define float @ret_cos_noqnan(float nofpclass(qnan) %arg) { define float @ret_cos_noqnan(float nofpclass(qnan) %arg) {
; CHECK-LABEL: define float @ret_cos_noqnan ; CHECK-LABEL: define nofpclass(inf) float @ret_cos_noqnan
; CHECK-SAME: (float nofpclass(qnan) [[ARG:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(qnan) [[ARG:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.cos.f32(float [[ARG]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf) float @llvm.cos.f32(float [[ARG]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.cos.f32(float %arg) %call = call float @llvm.cos.f32(float %arg)
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: {{.*}}

llvm/test/Transforms/Attributor/nosync.ll

Show First 20 Lines • Show All 430 Lines • ▼ Show 20 Lines;
call float @llvm.cos(float %x) call float @llvm.cos(float %x)
ret i32 4 ret i32 4
} }
define float @cos_test2(float %x) { define float @cos_test2(float %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@cos_test2 ; CHECK-LABEL: define {{[^@]+}}@cos_test2
; CHECK-SAME: (float [[X:%.*]]) #[[ATTR15]] { ; CHECK-SAME: (float [[X:%.*]]) #[[ATTR15]] {
; CHECK-NEXT: [[C:%.*]] = call float @llvm.cos.f32(float [[X]]) #[[ATTR20]] ; CHECK-NEXT: [[C:%.*]] = call nofpclass(inf) float @llvm.cos.f32(float [[X]]) #[[ATTR20]]
; CHECK-NEXT: ret float [[C]] ; CHECK-NEXT: ret float [[C]]
; ;
%c = call float @llvm.cos(float %x) %c = call float @llvm.cos(float %x)
ret float %c ret float %c
} }
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind optsize ssp willreturn memory(none) uwtable } ; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind optsize ssp willreturn memory(none) uwtable }
; CHECK: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable } ; CHECK: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable }
Show All 20 Lines