This is an archive of the discontinued LLVM Phabricator instance.

Differential D147932

ValueTracking: Implement computeKnownFPClass for various rounding intrinsics
ClosedPublic

Authored by arsenm on Apr 10 2023, 5:46 AM.

Details

Reviewers
jcranmer-intel
kpn
cameron.mcinally
sepavloff
nikic
andrew.w.kaylor
scanon
jdoerfert
sstefan1
foad

Diff Detail

Event Timeline

arsenm created this revision.Apr 10 2023, 5:46 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 10 2023, 5:46 AM
Herald added subscribers: StephenFan, okura, kuter, hiraditya. · View Herald Transcript
arsenm requested review of this revision.Apr 10 2023, 5:46 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptApr 10 2023, 5:46 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: D147879: ValueTracking: Implement computeKnownFPClass for llvm.trunc.Apr 10 2023, 5:46 AM
Harbormaster completed remote builds in B224554: Diff 512123.Apr 10 2023, 5:47 AM
arsenm added a child revision: D147942: ValueTracking: Delete body of isKnownNeverInfinity.Apr 10 2023, 7:48 AM
arsenm updated this revision to Diff 514231.Apr 17 2023, 7:47 AM

rebase

Harbormaster completed remote builds in B226100: Diff 514231.Apr 17 2023, 7:48 AM
arsenm added a comment.Apr 24 2023, 11:47 AM

ping

arsenm added a parent revision: D148533: ValueTracking: Improve trunc handling in computeKnownFPClass.Apr 25 2023, 3:57 AM
arsenm updated this revision to Diff 516737.Apr 25 2023, 4:01 AM

Rebase

Harbormaster completed remote builds in B227981: Diff 516737.Apr 25 2023, 4:01 AM
arsenm updated this revision to Diff 516891.Apr 25 2023, 1:47 PM

Stronger sign handling which avoids regressions when old functions are replaced

Harbormaster completed remote builds in B228088: Diff 516891.Apr 25 2023, 1:52 PM
arsenm added a comment.May 2 2023, 5:28 PM

ping

kpn added inline comments.May 3 2023, 10:44 AM
llvm/lib/Analysis/ValueTracking.cpp
4949

Couldn't a subnormal value be the input for rounding? The result won't be subnormal, but why remove the checks for subnormal inputs?

arsenm updated this revision to Diff 522535.May 16 2023, 4:16 AM
arsenm marked an inline comment as done.

Denormal inputs

arsenm updated this revision to Diff 522542.May 16 2023, 4:35 AM
arsenm added a reviewer: foad.
Harbormaster completed remote builds in B232268: Diff 522542.May 16 2023, 5:38 AM
foad added inline comments.May 16 2023, 6:18 AM
llvm/lib/Analysis/ValueTracking.cpp
4923–4924

This doesn't seem to match the code any more? I guess you want:

if (InterestedClass & fcPosFinite)
  InterestedSrcs |= fcPosFinite;

etc.

(Strictly I think you ought to do this for fcNan too, throughout computeKnownFPClass, in case InterestedClasses only contains one of fcSNan or fcQNan.)

arsenm added inline comments.May 16 2023, 6:57 AM
llvm/lib/Analysis/ValueTracking.cpp
4923–4924

I don't see the point of enabling more bits here, not sure why I put this here in the first place

arsenm updated this revision to Diff 522596.May 16 2023, 6:57 AM
Harbormaster completed remote builds in B232303: Diff 522596.May 16 2023, 9:00 AM
foad added inline comments.May 17 2023, 1:54 AM
llvm/lib/Analysis/ValueTracking.cpp
4923–4924

The point is that if you're only interested in whether the result is (say) negzero, you can't prove that unless you know the source is none of negzero|negsubnormal|negfinite. Isn't that the way InterestedClasses is supposed to work?

arsenm updated this revision to Diff 522983.May 17 2023, 3:38 AM

Enable more interested

arsenm updated this revision to Diff 522986.May 17 2023, 3:40 AM
Harbormaster completed remote builds in B232564: Diff 522986.May 17 2023, 4:49 AM
foad accepted this revision.May 17 2023, 4:53 AM
This revision is now accepted and ready to land.May 17 2023, 4:53 AM
arsenm closed this revision.May 17 2023, 3:41 PM

6666969a08001c37b564cdd9e8da7b5c7291788c

Revision Contents

PathSize
llvm/
include/
llvm/
Analysis/
12 lines
lib/
Analysis/
55 lines
test/
Transforms/
Attributor/
136 lines
165 lines
136 lines
136 lines
166 lines
166 lines
63 lines
2 lines
4 lines

Diff 522986

llvm/include/llvm/Analysis/ValueTracking.h

Show First 20 Lines • Show All 387 Lines • ▼ Show 20 Lines void copysign(const KnownFPClass &Sign) {
// Clear sign bits based on the input sign mask. // Clear sign bits based on the input sign mask.
if (Sign.isKnownNever(fcPositive | fcNan) || (SignBit && *SignBit)) if (Sign.isKnownNever(fcPositive | fcNan) || (SignBit && *SignBit))
KnownFPClasses &= (fcNegative | fcNan); KnownFPClasses &= (fcNegative | fcNan);
if (Sign.isKnownNever(fcNegative | fcNan) || (SignBit && !*SignBit)) if (Sign.isKnownNever(fcNegative | fcNan) || (SignBit && !*SignBit))
KnownFPClasses &= (fcPositive | fcNan); KnownFPClasses &= (fcPositive | fcNan);
} }
// Propagate knowledge that a non-NaN source implies the result can also not
// be a NaN. For unconstrained operations, signaling nans are not guaranteed
// to be quieted but cannot be introduced.
void propagateNaN(const KnownFPClass &Src, bool PreserveSign = false) {
if (Src.isKnownNever(fcNan)) {
knownNot(fcNan);
if (PreserveSign)
SignBit = Src.SignBit;
} else if (Src.isKnownNever(fcSNan))
knownNot(fcSNan);
}
void resetAll() { *this = KnownFPClass(); } void resetAll() { *this = KnownFPClass(); }
}; };
inline KnownFPClass operator|(KnownFPClass LHS, const KnownFPClass &RHS) { inline KnownFPClass operator|(KnownFPClass LHS, const KnownFPClass &RHS) {
LHS |= RHS; LHS |= RHS;
return LHS; return LHS;
} }
▲ Show 20 Lines • Show All 705 Lines • Show Last 20 Lines

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,906 Lines • ▼ Show 20 Lines if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Op)) {
if (DenormMode.Input == DenormalMode::PositiveZero || if (DenormMode.Input == DenormalMode::PositiveZero ||
(DenormMode.Output == DenormalMode::PositiveZero && (DenormMode.Output == DenormalMode::PositiveZero &&
DenormMode.Input == DenormalMode::IEEE)) DenormMode.Input == DenormalMode::IEEE))
Known.knownNot(fcNegZero); Known.knownNot(fcNegZero);
break; break;
} }
case Intrinsic::trunc: { case Intrinsic::trunc:
case Intrinsic::floor:
case Intrinsic::ceil:
case Intrinsic::rint:
case Intrinsic::nearbyint:
case Intrinsic::round:
case Intrinsic::roundeven: {
KnownFPClass KnownSrc; KnownFPClass KnownSrc;
FPClassTest InterestedSrcs = InterestedClasses; FPClassTest InterestedSrcs = InterestedClasses;
if (InterestedClasses & fcZero) if (InterestedSrcs & fcPosFinite)
foadUnsubmitted
Not Done
ReplyInline Actions

This doesn't seem to match the code any more? I guess you want:

if (InterestedClass & fcPosFinite)
  InterestedSrcs |= fcPosFinite;

etc.

(Strictly I think you ought to do this for fcNan too, throughout computeKnownFPClass, in case InterestedClasses only contains one of fcSNan or fcQNan.)

foad: This doesn't seem to match the code any more? I guess you want: ``` if (InterestedClass &…
arsenmAuthorUnsubmitted
Done
ReplyInline Actions

I don't see the point of enabling more bits here, not sure why I put this here in the first place

arsenm: I don't see the point of enabling more bits here, not sure why I put this here in the first…
foadUnsubmitted
Not Done
ReplyInline Actions

The point is that if you're only interested in whether the result is (say) negzero, you can't prove that unless you know the source is none of negzero|negsubnormal|negfinite. Isn't that the way InterestedClasses is supposed to work?

foad: The point is that if you're only interested in whether the result is (say) negzero, you can't…
InterestedClasses |= fcNormal | fcSubnormal; InterestedSrcs |= fcPosFinite;
if (InterestedSrcs & fcNegFinite)
computeKnownFPClass(II->getArgOperand(0), DemandedElts, InterestedSrcs, InterestedSrcs |= fcNegFinite;
KnownSrc, Depth + 1, Q, TLI); computeKnownFPClass(II->getArgOperand(0), DemandedElts,
InterestedSrcs, KnownSrc, Depth + 1, Q, TLI);
// Integer results cannot be subnormal. // Integer results cannot be subnormal.
Known.knownNot(fcSubnormal); Known.knownNot(fcSubnormal);
// trunc passes through infinities. Known.propagateNaN(KnownSrc, true);
// Pass through infinities, except PPC_FP128 is a special case for
// intrinsics other than trunc.
if (IID == Intrinsic::trunc || !V->getType()->isMultiUnitFPType()) {
if (KnownSrc.isKnownNeverPosInfinity()) if (KnownSrc.isKnownNeverPosInfinity())
Known.knownNot(fcPosInf); Known.knownNot(fcPosInf);
if (KnownSrc.isKnownNeverNegInfinity()) if (KnownSrc.isKnownNeverNegInfinity())
Known.knownNot(fcNegInf); Known.knownNot(fcNegInf);
}
// Non-constrained intrinsics do not guarantee signaling nan quieting. // Negative round ups to 0 produce -0
if (KnownSrc.isKnownNeverNaN()) if (KnownSrc.isKnownNever(fcPosFinite))
Known.knownNot(fcNan); Known.knownNot(fcPosFinite);
if (KnownSrc.isKnownNever(fcNegFinite))
if (KnownSrc.isKnownNever(fcPosNormal)) Known.knownNot(fcNegFinite);
kpnUnsubmitted
Done
ReplyInline Actions

Couldn't a subnormal value be the input for rounding? The result won't be subnormal, but why remove the checks for subnormal inputs?

kpn: Couldn't a subnormal value be the input for rounding? The result won't be subnormal, but why…
Known.knownNot(fcPosNormal);
if (KnownSrc.isKnownNever(fcNegNormal))
Known.knownNot(fcNegNormal);
if (KnownSrc.isKnownNever(fcPosZero | fcPosSubnormal | fcPosNormal))
Known.knownNot(fcPosZero);
if (KnownSrc.isKnownNever(fcNegZero | fcNegSubnormal | fcNegNormal))
Known.knownNot(fcNegZero);
// Sign should be preserved
Known.SignBit = KnownSrc.SignBit;
break; break;
} }
case Intrinsic::exp: case Intrinsic::exp:
case Intrinsic::exp2: { case Intrinsic::exp2: {
Known.knownNot(fcNegative); Known.knownNot(fcNegative);
if ((InterestedClasses & fcNan) == fcNone) if ((InterestedClasses & fcNan) == fcNone)
break; break;
▲ Show 20 Lines • Show All 3,983 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/nofpclass-ceil.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.ceil.f32(float) declare float @llvm.ceil.f32(float)
declare ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128) declare ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128)
define float @ret_ceil(float %arg0) { define float @ret_ceil(float %arg0) {
; CHECK-LABEL: define float @ret_ceil ; CHECK-LABEL: define nofpclass(sub) float @ret_ceil
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2:[0-9]+]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2:[0-9]+]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_noinf(float nofpclass(inf) %arg0) { define float @ret_ceil_noinf(float nofpclass(inf) %arg0) {
; CHECK-LABEL: define float @ret_ceil_noinf ; CHECK-LABEL: define nofpclass(inf sub) float @ret_ceil_noinf
; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nopinf(float nofpclass(pinf) %arg0) { define float @ret_ceil_nopinf(float nofpclass(pinf) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nopinf ; CHECK-LABEL: define nofpclass(pinf sub) float @ret_ceil_nopinf
; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_noninf(float nofpclass(ninf) %arg0) { define float @ret_ceil_noninf(float nofpclass(ninf) %arg0) {
; CHECK-LABEL: define float @ret_ceil_noninf ; CHECK-LABEL: define nofpclass(ninf sub) float @ret_ceil_noninf
; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nonan(float nofpclass(nan) %arg0) { define float @ret_ceil_nonan(float nofpclass(nan) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nonan ; CHECK-LABEL: define nofpclass(nan sub) float @ret_ceil_nonan
; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_noqnan(float nofpclass(qnan) %arg0) { define float @ret_ceil_noqnan(float nofpclass(qnan) %arg0) {
; CHECK-LABEL: define float @ret_ceil_noqnan ; CHECK-LABEL: define nofpclass(sub) float @ret_ceil_noqnan
; CHECK-SAME: (float nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nosnan(float nofpclass(snan) %arg0) { define float @ret_ceil_nosnan(float nofpclass(snan) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nosnan ; CHECK-LABEL: define nofpclass(snan sub) float @ret_ceil_nosnan
; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(snan sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nozero(float nofpclass(zero) %arg0) { define float @ret_ceil_nozero(float nofpclass(zero) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nozero ; CHECK-LABEL: define nofpclass(sub) float @ret_ceil_nozero
; CHECK-SAME: (float nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nopzero(float nofpclass(pzero) %arg0) { define float @ret_ceil_nopzero(float nofpclass(pzero) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nopzero ; CHECK-LABEL: define nofpclass(sub) float @ret_ceil_nopzero
; CHECK-SAME: (float nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nonzero(float nofpclass(nzero) %arg0) { define float @ret_ceil_nonzero(float nofpclass(nzero) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nonzero ; CHECK-LABEL: define nofpclass(sub) float @ret_ceil_nonzero
; CHECK-SAME: (float nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nonorm(float nofpclass(norm) %arg0) { define float @ret_ceil_nonorm(float nofpclass(norm) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nonorm ; CHECK-LABEL: define nofpclass(sub) float @ret_ceil_nonorm
; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nonnorm(float nofpclass(nnorm) %arg0) { define float @ret_ceil_nonnorm(float nofpclass(nnorm) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nonnorm ; CHECK-LABEL: define nofpclass(sub) float @ret_ceil_nonnorm
; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nopnorm(float nofpclass(pnorm) %arg0) { define float @ret_ceil_nopnorm(float nofpclass(pnorm) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nopnorm ; CHECK-LABEL: define nofpclass(sub) float @ret_ceil_nopnorm
; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nonsub(float nofpclass(nsub) %arg0) { define float @ret_ceil_nonsub(float nofpclass(nsub) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_ceil_nonsub
; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nopsub(float nofpclass(psub) %arg0) { define float @ret_ceil_nopsub(float nofpclass(psub) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nopsub ; CHECK-LABEL: define nofpclass(sub) float @ret_ceil_nopsub
; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nonorm_nosub(float nofpclass(norm sub) %arg0) { define float @ret_ceil_nonorm_nosub(float nofpclass(norm sub) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nonorm_nosub ; CHECK-LABEL: define nofpclass(sub) float @ret_ceil_nonorm_nosub
; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) { define float @ret_ceil_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nopnorm_nopsub ; CHECK-LABEL: define nofpclass(sub) float @ret_ceil_nopnorm_nopsub
; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) { define float @ret_ceil_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nonnorm_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_ceil_nonnorm_nonsub
; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) { define float @ret_ceil_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nopnorm_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_ceil_nopnorm_nonsub
; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define ppc_fp128 @ret_ceil_ppcf128(ppc_fp128 %arg0) { define ppc_fp128 @ret_ceil_ppcf128(ppc_fp128 %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_ceil_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_ceil_ppcf128
; CHECK-SAME: (ppc_fp128 [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_ceil_noinf_ppcf128(ppc_fp128 nofpclass(inf) %arg0) { define ppc_fp128 @ret_ceil_noinf_ppcf128(ppc_fp128 nofpclass(inf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_ceil_noinf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_ceil_noinf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_ceil_nopinf_ppcf128(ppc_fp128 nofpclass(pinf) %arg0) { define ppc_fp128 @ret_ceil_nopinf_ppcf128(ppc_fp128 nofpclass(pinf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_ceil_nopinf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_ceil_nopinf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_ceil_noninf_ppcf128(ppc_fp128 nofpclass(ninf) %arg0) { define ppc_fp128 @ret_ceil_noninf_ppcf128(ppc_fp128 nofpclass(ninf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_ceil_noninf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_ceil_noninf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_ceil_nonan_ppcf128(ppc_fp128 nofpclass(nan) %arg0) { define ppc_fp128 @ret_ceil_nonan_ppcf128(ppc_fp128 nofpclass(nan) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_ceil_nonan_ppcf128 ; CHECK-LABEL: define nofpclass(nan sub) ppc_fp128 @ret_ceil_nonan_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define float @ret_ceil_noneg(float nofpclass(ninf nsub nnorm) %arg0) { define float @ret_ceil_noneg(float nofpclass(ninf nsub nnorm) %arg0) {
; CHECK-LABEL: define float @ret_ceil_noneg ; CHECK-LABEL: define nofpclass(ninf sub) float @ret_ceil_noneg
; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_noneg_nonegzero(float nofpclass(ninf nsub nnorm nzero) %arg0) { define float @ret_ceil_noneg_nonegzero(float nofpclass(ninf nsub nnorm nzero) %arg0) {
; CHECK-LABEL: define float @ret_ceil_noneg_nonegzero ; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @ret_ceil_noneg_nonegzero
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero sub nnorm) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_noneg_nonegzero_nonan(float nofpclass(ninf nsub nnorm nzero nan) %arg0) { define float @ret_ceil_noneg_nonegzero_nonan(float nofpclass(ninf nsub nnorm nzero nan) %arg0) {
; CHECK-LABEL: define float @ret_ceil_noneg_nonegzero_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @ret_ceil_noneg_nonegzero_nonan
; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_noneg_nozero(float nofpclass(ninf nsub nnorm zero) %arg0) { define float @ret_ceil_noneg_nozero(float nofpclass(ninf nsub nnorm zero) %arg0) {
; CHECK-LABEL: define float @ret_ceil_noneg_nozero ; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @ret_ceil_noneg_nozero
; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero sub nnorm) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_noneg_nozero_nonan(float nofpclass(ninf nsub nnorm zero nan) %arg0) { define float @ret_ceil_noneg_nozero_nonan(float nofpclass(ninf nsub nnorm zero nan) %arg0) {
; CHECK-LABEL: define float @ret_ceil_noneg_nozero_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @ret_ceil_noneg_nozero_nonan
; CHECK-SAME: (float nofpclass(nan ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nopos(float nofpclass(pinf psub pnorm) %arg0) { define float @ret_ceil_nopos(float nofpclass(pinf psub pnorm) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nopos ; CHECK-LABEL: define nofpclass(pinf sub) float @ret_ceil_nopos
; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf sub) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nopos_nopzero(float nofpclass(pinf psub pnorm pzero) %arg0) { define float @ret_ceil_nopos_nopzero(float nofpclass(pinf psub pnorm pzero) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nopos_nopzero ; CHECK-LABEL: define nofpclass(pinf pzero sub pnorm) float @ret_ceil_nopos_nopzero
; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf pzero sub pnorm) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nopos_nopzero_nonan(float nofpclass(pinf psub pnorm pzero nan) %arg0) { define float @ret_ceil_nopos_nopzero_nonan(float nofpclass(pinf psub pnorm pzero nan) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nopos_nopzero_nonan ; CHECK-LABEL: define nofpclass(nan pinf pzero sub pnorm) float @ret_ceil_nopos_nopzero_nonan
; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan pinf pzero sub pnorm) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nopos_nozero(float nofpclass(pinf psub pnorm zero) %arg0) { define float @ret_ceil_nopos_nozero(float nofpclass(pinf psub pnorm zero) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nopos_nozero ; CHECK-LABEL: define nofpclass(pinf pzero sub pnorm) float @ret_ceil_nopos_nozero
; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf pzero sub pnorm) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_ceil_nopos_nozero_nonan(float nofpclass(pinf psub pnorm zero nan) %arg0) { define float @ret_ceil_nopos_nozero_nonan(float nofpclass(pinf psub pnorm zero nan) %arg0) {
; CHECK-LABEL: define float @ret_ceil_nopos_nozero_nonan ; CHECK-LABEL: define nofpclass(nan pinf pzero sub pnorm) float @ret_ceil_nopos_nozero_nonan
; CHECK-SAME: (float nofpclass(nan pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan pinf pzero sub pnorm) float @llvm.ceil.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.ceil.f32(float %arg0) %call = call float @llvm.ceil.f32(float %arg0)
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/nofpclass-floor.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.floor.f32(float) declare float @llvm.floor.f32(float)
declare ppc_fp128 @llvm.floor.ppcf128(ppc_fp128) declare ppc_fp128 @llvm.floor.ppcf128(ppc_fp128)
define float @ret_floor(float %arg0) { define float @ret_floor(float %arg0) {
; CHECK-LABEL: define float @ret_floor ; CHECK-LABEL: define nofpclass(sub) float @ret_floor
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2:[0-9]+]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2:[0-9]+]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_noinf(float nofpclass(inf) %arg0) { define float @ret_floor_noinf(float nofpclass(inf) %arg0) {
; CHECK-LABEL: define float @ret_floor_noinf ; CHECK-LABEL: define nofpclass(inf sub) float @ret_floor_noinf
; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nopinf(float nofpclass(pinf) %arg0) { define float @ret_floor_nopinf(float nofpclass(pinf) %arg0) {
; CHECK-LABEL: define float @ret_floor_nopinf ; CHECK-LABEL: define nofpclass(pinf sub) float @ret_floor_nopinf
; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_noninf(float nofpclass(ninf) %arg0) { define float @ret_floor_noninf(float nofpclass(ninf) %arg0) {
; CHECK-LABEL: define float @ret_floor_noninf ; CHECK-LABEL: define nofpclass(ninf sub) float @ret_floor_noninf
; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nonan(float nofpclass(nan) %arg0) { define float @ret_floor_nonan(float nofpclass(nan) %arg0) {
; CHECK-LABEL: define float @ret_floor_nonan ; CHECK-LABEL: define nofpclass(nan sub) float @ret_floor_nonan
; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_noqnan(float nofpclass(qnan) %arg0) { define float @ret_floor_noqnan(float nofpclass(qnan) %arg0) {
; CHECK-LABEL: define float @ret_floor_noqnan ; CHECK-LABEL: define nofpclass(sub) float @ret_floor_noqnan
; CHECK-SAME: (float nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nosnan(float nofpclass(snan) %arg0) { define float @ret_floor_nosnan(float nofpclass(snan) %arg0) {
; CHECK-LABEL: define float @ret_floor_nosnan ; CHECK-LABEL: define nofpclass(snan sub) float @ret_floor_nosnan
; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(snan sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nozero(float nofpclass(zero) %arg0) { define float @ret_floor_nozero(float nofpclass(zero) %arg0) {
; CHECK-LABEL: define float @ret_floor_nozero ; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nozero
; CHECK-SAME: (float nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nopzero(float nofpclass(pzero) %arg0) { define float @ret_floor_nopzero(float nofpclass(pzero) %arg0) {
; CHECK-LABEL: define float @ret_floor_nopzero ; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nopzero
; CHECK-SAME: (float nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nonzero(float nofpclass(nzero) %arg0) { define float @ret_floor_nonzero(float nofpclass(nzero) %arg0) {
; CHECK-LABEL: define float @ret_floor_nonzero ; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nonzero
; CHECK-SAME: (float nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nonorm(float nofpclass(norm) %arg0) { define float @ret_floor_nonorm(float nofpclass(norm) %arg0) {
; CHECK-LABEL: define float @ret_floor_nonorm ; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nonorm
; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nonnorm(float nofpclass(nnorm) %arg0) { define float @ret_floor_nonnorm(float nofpclass(nnorm) %arg0) {
; CHECK-LABEL: define float @ret_floor_nonnorm ; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nonnorm
; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nopnorm(float nofpclass(pnorm) %arg0) { define float @ret_floor_nopnorm(float nofpclass(pnorm) %arg0) {
; CHECK-LABEL: define float @ret_floor_nopnorm ; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nopnorm
; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nonsub(float nofpclass(nsub) %arg0) { define float @ret_floor_nonsub(float nofpclass(nsub) %arg0) {
; CHECK-LABEL: define float @ret_floor_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nonsub
; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nopsub(float nofpclass(psub) %arg0) { define float @ret_floor_nopsub(float nofpclass(psub) %arg0) {
; CHECK-LABEL: define float @ret_floor_nopsub ; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nopsub
; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nonorm_nosub(float nofpclass(norm sub) %arg0) { define float @ret_floor_nonorm_nosub(float nofpclass(norm sub) %arg0) {
; CHECK-LABEL: define float @ret_floor_nonorm_nosub ; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nonorm_nosub
; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) { define float @ret_floor_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) {
; CHECK-LABEL: define float @ret_floor_nopnorm_nopsub ; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nopnorm_nopsub
; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) { define float @ret_floor_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) {
; CHECK-LABEL: define float @ret_floor_nonnorm_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nonnorm_nonsub
; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) { define float @ret_floor_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) {
; CHECK-LABEL: define float @ret_floor_nopnorm_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nopnorm_nonsub
; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define ppc_fp128 @ret_floor_ppcf128(ppc_fp128 %arg0) { define ppc_fp128 @ret_floor_ppcf128(ppc_fp128 %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_floor_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_floor_ppcf128
; CHECK-SAME: (ppc_fp128 [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_floor_noinf_ppcf128(ppc_fp128 nofpclass(inf) %arg0) { define ppc_fp128 @ret_floor_noinf_ppcf128(ppc_fp128 nofpclass(inf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_floor_noinf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_floor_noinf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_floor_nopinf_ppcf128(ppc_fp128 nofpclass(pinf) %arg0) { define ppc_fp128 @ret_floor_nopinf_ppcf128(ppc_fp128 nofpclass(pinf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_floor_nopinf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_floor_nopinf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_floor_noninf_ppcf128(ppc_fp128 nofpclass(ninf) %arg0) { define ppc_fp128 @ret_floor_noninf_ppcf128(ppc_fp128 nofpclass(ninf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_floor_noninf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_floor_noninf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_floor_nonan_ppcf128(ppc_fp128 nofpclass(nan) %arg0) { define ppc_fp128 @ret_floor_nonan_ppcf128(ppc_fp128 nofpclass(nan) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_floor_nonan_ppcf128 ; CHECK-LABEL: define nofpclass(nan sub) ppc_fp128 @ret_floor_nonan_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define float @ret_floor_noneg(float nofpclass(ninf nsub nnorm) %arg0) { define float @ret_floor_noneg(float nofpclass(ninf nsub nnorm) %arg0) {
; CHECK-LABEL: define float @ret_floor_noneg ; CHECK-LABEL: define nofpclass(ninf sub) float @ret_floor_noneg
; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_noneg_nonegzero(float nofpclass(ninf nsub nnorm nzero) %arg0) { define float @ret_floor_noneg_nonegzero(float nofpclass(ninf nsub nnorm nzero) %arg0) {
; CHECK-LABEL: define float @ret_floor_noneg_nonegzero ; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @ret_floor_noneg_nonegzero
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero sub nnorm) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_noneg_nonegzero_nonan(float nofpclass(ninf nsub nnorm nzero nan) %arg0) { define float @ret_floor_noneg_nonegzero_nonan(float nofpclass(ninf nsub nnorm nzero nan) %arg0) {
; CHECK-LABEL: define float @ret_floor_noneg_nonegzero_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @ret_floor_noneg_nonegzero_nonan
; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_noneg_nozero(float nofpclass(ninf nsub nnorm zero) %arg0) { define float @ret_floor_noneg_nozero(float nofpclass(ninf nsub nnorm zero) %arg0) {
; CHECK-LABEL: define float @ret_floor_noneg_nozero ; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @ret_floor_noneg_nozero
; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero sub nnorm) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_noneg_nozero_nonan(float nofpclass(ninf nsub nnorm zero nan) %arg0) { define float @ret_floor_noneg_nozero_nonan(float nofpclass(ninf nsub nnorm zero nan) %arg0) {
; CHECK-LABEL: define float @ret_floor_noneg_nozero_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @ret_floor_noneg_nozero_nonan
; CHECK-SAME: (float nofpclass(nan ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nopos(float nofpclass(pinf psub pnorm) %arg0) { define float @ret_floor_nopos(float nofpclass(pinf psub pnorm) %arg0) {
; CHECK-LABEL: define float @ret_floor_nopos ; CHECK-LABEL: define nofpclass(pinf sub) float @ret_floor_nopos
; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nopos_nopzero(float nofpclass(pinf psub pnorm pzero) %arg0) { define float @ret_floor_nopos_nopzero(float nofpclass(pinf psub pnorm pzero) %arg0) {
; CHECK-LABEL: define float @ret_floor_nopos_nopzero ; CHECK-LABEL: define nofpclass(pinf pzero sub pnorm) float @ret_floor_nopos_nopzero
; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf pzero sub pnorm) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nopos_nopzero_nonan(float nofpclass(pinf psub pnorm pzero nan) %arg0) { define float @ret_floor_nopos_nopzero_nonan(float nofpclass(pinf psub pnorm pzero nan) %arg0) {
; CHECK-LABEL: define float @ret_floor_nopos_nopzero_nonan ; CHECK-LABEL: define nofpclass(nan pinf pzero sub pnorm) float @ret_floor_nopos_nopzero_nonan
; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan pinf pzero sub pnorm) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nopos_nozero(float nofpclass(pinf psub pnorm zero) %arg0) { define float @ret_floor_nopos_nozero(float nofpclass(pinf psub pnorm zero) %arg0) {
; CHECK-LABEL: define float @ret_floor_nopos_nozero ; CHECK-LABEL: define nofpclass(pinf pzero sub pnorm) float @ret_floor_nopos_nozero
; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf pzero sub pnorm) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nopos_nozero_nonan(float nofpclass(pinf psub pnorm zero nan) %arg0) { define float @ret_floor_nopos_nozero_nonan(float nofpclass(pinf psub pnorm zero nan) %arg0) {
; CHECK-LABEL: define float @ret_floor_nopos_nozero_nonan ; CHECK-LABEL: define nofpclass(nan pinf pzero sub pnorm) float @ret_floor_nopos_nozero_nonan
; CHECK-SAME: (float nofpclass(nan pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan pinf pzero sub pnorm) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.floor.f32(float %arg0) %call = call float @llvm.floor.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_floor_nopzero_nopnorm(float nofpclass(pzero pnorm) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nopzero_nopnorm
; CHECK-SAME: (float nofpclass(pzero pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]]
;
%call = call float @llvm.floor.f32(float %arg0)
ret float %call
}
define float @ret_floor_nonzero_nonnorm(float nofpclass(nzero nnorm) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nonzero_nonnorm
; CHECK-SAME: (float nofpclass(nzero nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]]
;
%call = call float @llvm.floor.f32(float %arg0)
ret float %call
}
define float @ret_floor_nozero_nonorm(float nofpclass(zero norm) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_floor_nozero_nonorm
; CHECK-SAME: (float nofpclass(zero norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.floor.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]]
;
%call = call float @llvm.floor.f32(float %arg0)
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/nofpclass-nearbyint.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.nearbyint.f32(float) declare float @llvm.nearbyint.f32(float)
declare ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128) declare ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128)
define float @ret_nearbyint(float %arg0) { define float @ret_nearbyint(float %arg0) {
; CHECK-LABEL: define float @ret_nearbyint ; CHECK-LABEL: define nofpclass(sub) float @ret_nearbyint
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2:[0-9]+]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2:[0-9]+]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_noinf(float nofpclass(inf) %arg0) { define float @ret_nearbyint_noinf(float nofpclass(inf) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_noinf ; CHECK-LABEL: define nofpclass(inf sub) float @ret_nearbyint_noinf
; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nopinf(float nofpclass(pinf) %arg0) { define float @ret_nearbyint_nopinf(float nofpclass(pinf) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nopinf ; CHECK-LABEL: define nofpclass(pinf sub) float @ret_nearbyint_nopinf
; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_noninf(float nofpclass(ninf) %arg0) { define float @ret_nearbyint_noninf(float nofpclass(ninf) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_noninf ; CHECK-LABEL: define nofpclass(ninf sub) float @ret_nearbyint_noninf
; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nonan(float nofpclass(nan) %arg0) { define float @ret_nearbyint_nonan(float nofpclass(nan) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nonan ; CHECK-LABEL: define nofpclass(nan sub) float @ret_nearbyint_nonan
; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_noqnan(float nofpclass(qnan) %arg0) { define float @ret_nearbyint_noqnan(float nofpclass(qnan) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_noqnan ; CHECK-LABEL: define nofpclass(sub) float @ret_nearbyint_noqnan
; CHECK-SAME: (float nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nosnan(float nofpclass(snan) %arg0) { define float @ret_nearbyint_nosnan(float nofpclass(snan) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nosnan ; CHECK-LABEL: define nofpclass(snan sub) float @ret_nearbyint_nosnan
; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(snan sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nozero(float nofpclass(zero) %arg0) { define float @ret_nearbyint_nozero(float nofpclass(zero) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nozero ; CHECK-LABEL: define nofpclass(sub) float @ret_nearbyint_nozero
; CHECK-SAME: (float nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nopzero(float nofpclass(pzero) %arg0) { define float @ret_nearbyint_nopzero(float nofpclass(pzero) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nopzero ; CHECK-LABEL: define nofpclass(sub) float @ret_nearbyint_nopzero
; CHECK-SAME: (float nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nonzero(float nofpclass(nzero) %arg0) { define float @ret_nearbyint_nonzero(float nofpclass(nzero) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nonzero ; CHECK-LABEL: define nofpclass(sub) float @ret_nearbyint_nonzero
; CHECK-SAME: (float nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nonorm(float nofpclass(norm) %arg0) { define float @ret_nearbyint_nonorm(float nofpclass(norm) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nonorm ; CHECK-LABEL: define nofpclass(sub) float @ret_nearbyint_nonorm
; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nonnorm(float nofpclass(nnorm) %arg0) { define float @ret_nearbyint_nonnorm(float nofpclass(nnorm) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nonnorm ; CHECK-LABEL: define nofpclass(sub) float @ret_nearbyint_nonnorm
; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nopnorm(float nofpclass(pnorm) %arg0) { define float @ret_nearbyint_nopnorm(float nofpclass(pnorm) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nopnorm ; CHECK-LABEL: define nofpclass(sub) float @ret_nearbyint_nopnorm
; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nonsub(float nofpclass(nsub) %arg0) { define float @ret_nearbyint_nonsub(float nofpclass(nsub) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_nearbyint_nonsub
; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nopsub(float nofpclass(psub) %arg0) { define float @ret_nearbyint_nopsub(float nofpclass(psub) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nopsub ; CHECK-LABEL: define nofpclass(sub) float @ret_nearbyint_nopsub
; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nonorm_nosub(float nofpclass(norm sub) %arg0) { define float @ret_nearbyint_nonorm_nosub(float nofpclass(norm sub) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nonorm_nosub ; CHECK-LABEL: define nofpclass(sub) float @ret_nearbyint_nonorm_nosub
; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) { define float @ret_nearbyint_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nopnorm_nopsub ; CHECK-LABEL: define nofpclass(sub) float @ret_nearbyint_nopnorm_nopsub
; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) { define float @ret_nearbyint_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nonnorm_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_nearbyint_nonnorm_nonsub
; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) { define float @ret_nearbyint_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nopnorm_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_nearbyint_nopnorm_nonsub
; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define ppc_fp128 @ret_nearbyint_ppcf128(ppc_fp128 %arg0) { define ppc_fp128 @ret_nearbyint_ppcf128(ppc_fp128 %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_nearbyint_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_nearbyint_ppcf128
; CHECK-SAME: (ppc_fp128 [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_nearbyint_noinf_ppcf128(ppc_fp128 nofpclass(inf) %arg0) { define ppc_fp128 @ret_nearbyint_noinf_ppcf128(ppc_fp128 nofpclass(inf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_nearbyint_noinf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_nearbyint_noinf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_nearbyint_nopinf_ppcf128(ppc_fp128 nofpclass(pinf) %arg0) { define ppc_fp128 @ret_nearbyint_nopinf_ppcf128(ppc_fp128 nofpclass(pinf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_nearbyint_nopinf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_nearbyint_nopinf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_nearbyint_noninf_ppcf128(ppc_fp128 nofpclass(ninf) %arg0) { define ppc_fp128 @ret_nearbyint_noninf_ppcf128(ppc_fp128 nofpclass(ninf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_nearbyint_noninf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_nearbyint_noninf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_nearbyint_nonan_ppcf128(ppc_fp128 nofpclass(nan) %arg0) { define ppc_fp128 @ret_nearbyint_nonan_ppcf128(ppc_fp128 nofpclass(nan) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_nearbyint_nonan_ppcf128 ; CHECK-LABEL: define nofpclass(nan sub) ppc_fp128 @ret_nearbyint_nonan_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define float @ret_nearbyint_noneg(float nofpclass(ninf nsub nnorm) %arg0) { define float @ret_nearbyint_noneg(float nofpclass(ninf nsub nnorm) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_noneg ; CHECK-LABEL: define nofpclass(ninf sub) float @ret_nearbyint_noneg
; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_noneg_nonegzero(float nofpclass(ninf nsub nnorm nzero) %arg0) { define float @ret_nearbyint_noneg_nonegzero(float nofpclass(ninf nsub nnorm nzero) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_noneg_nonegzero ; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @ret_nearbyint_noneg_nonegzero
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero sub nnorm) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_noneg_nonegzero_nonan(float nofpclass(ninf nsub nnorm nzero nan) %arg0) { define float @ret_nearbyint_noneg_nonegzero_nonan(float nofpclass(ninf nsub nnorm nzero nan) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_noneg_nonegzero_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @ret_nearbyint_noneg_nonegzero_nonan
; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_noneg_nozero(float nofpclass(ninf nsub nnorm zero) %arg0) { define float @ret_nearbyint_noneg_nozero(float nofpclass(ninf nsub nnorm zero) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_noneg_nozero ; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @ret_nearbyint_noneg_nozero
; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero sub nnorm) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_noneg_nozero_nonan(float nofpclass(ninf nsub nnorm zero nan) %arg0) { define float @ret_nearbyint_noneg_nozero_nonan(float nofpclass(ninf nsub nnorm zero nan) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_noneg_nozero_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @ret_nearbyint_noneg_nozero_nonan
; CHECK-SAME: (float nofpclass(nan ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nopos(float nofpclass(pinf psub pnorm) %arg0) { define float @ret_nearbyint_nopos(float nofpclass(pinf psub pnorm) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nopos ; CHECK-LABEL: define nofpclass(pinf sub) float @ret_nearbyint_nopos
; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf sub) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nopos_nopzero(float nofpclass(pinf psub pnorm pzero) %arg0) { define float @ret_nearbyint_nopos_nopzero(float nofpclass(pinf psub pnorm pzero) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nopos_nopzero ; CHECK-LABEL: define nofpclass(pinf pzero sub pnorm) float @ret_nearbyint_nopos_nopzero
; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf pzero sub pnorm) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nopos_nopzero_nonan(float nofpclass(pinf psub pnorm pzero nan) %arg0) { define float @ret_nearbyint_nopos_nopzero_nonan(float nofpclass(pinf psub pnorm pzero nan) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nopos_nopzero_nonan ; CHECK-LABEL: define nofpclass(nan pinf pzero sub pnorm) float @ret_nearbyint_nopos_nopzero_nonan
; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan pinf pzero sub pnorm) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nopos_nozero(float nofpclass(pinf psub pnorm zero) %arg0) { define float @ret_nearbyint_nopos_nozero(float nofpclass(pinf psub pnorm zero) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nopos_nozero ; CHECK-LABEL: define nofpclass(pinf pzero sub pnorm) float @ret_nearbyint_nopos_nozero
; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf pzero sub pnorm) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_nearbyint_nopos_nozero_nonan(float nofpclass(pinf psub pnorm zero nan) %arg0) { define float @ret_nearbyint_nopos_nozero_nonan(float nofpclass(pinf psub pnorm zero nan) %arg0) {
; CHECK-LABEL: define float @ret_nearbyint_nopos_nozero_nonan ; CHECK-LABEL: define nofpclass(nan pinf pzero sub pnorm) float @ret_nearbyint_nopos_nozero_nonan
; CHECK-SAME: (float nofpclass(nan pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan pinf pzero sub pnorm) float @llvm.nearbyint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.nearbyint.f32(float %arg0) %call = call float @llvm.nearbyint.f32(float %arg0)
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/nofpclass-rint.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.rint.f32(float) declare float @llvm.rint.f32(float)
declare ppc_fp128 @llvm.rint.ppcf128(ppc_fp128) declare ppc_fp128 @llvm.rint.ppcf128(ppc_fp128)
define float @ret_rint(float %arg0) { define float @ret_rint(float %arg0) {
; CHECK-LABEL: define float @ret_rint ; CHECK-LABEL: define nofpclass(sub) float @ret_rint
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2:[0-9]+]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2:[0-9]+]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_noinf(float nofpclass(inf) %arg0) { define float @ret_rint_noinf(float nofpclass(inf) %arg0) {
; CHECK-LABEL: define float @ret_rint_noinf ; CHECK-LABEL: define nofpclass(inf sub) float @ret_rint_noinf
; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nopinf(float nofpclass(pinf) %arg0) { define float @ret_rint_nopinf(float nofpclass(pinf) %arg0) {
; CHECK-LABEL: define float @ret_rint_nopinf ; CHECK-LABEL: define nofpclass(pinf sub) float @ret_rint_nopinf
; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_noninf(float nofpclass(ninf) %arg0) { define float @ret_rint_noninf(float nofpclass(ninf) %arg0) {
; CHECK-LABEL: define float @ret_rint_noninf ; CHECK-LABEL: define nofpclass(ninf sub) float @ret_rint_noninf
; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nonan(float nofpclass(nan) %arg0) { define float @ret_rint_nonan(float nofpclass(nan) %arg0) {
; CHECK-LABEL: define float @ret_rint_nonan ; CHECK-LABEL: define nofpclass(nan sub) float @ret_rint_nonan
; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_noqnan(float nofpclass(qnan) %arg0) { define float @ret_rint_noqnan(float nofpclass(qnan) %arg0) {
; CHECK-LABEL: define float @ret_rint_noqnan ; CHECK-LABEL: define nofpclass(sub) float @ret_rint_noqnan
; CHECK-SAME: (float nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nosnan(float nofpclass(snan) %arg0) { define float @ret_rint_nosnan(float nofpclass(snan) %arg0) {
; CHECK-LABEL: define float @ret_rint_nosnan ; CHECK-LABEL: define nofpclass(snan sub) float @ret_rint_nosnan
; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(snan sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nozero(float nofpclass(zero) %arg0) { define float @ret_rint_nozero(float nofpclass(zero) %arg0) {
; CHECK-LABEL: define float @ret_rint_nozero ; CHECK-LABEL: define nofpclass(sub) float @ret_rint_nozero
; CHECK-SAME: (float nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nopzero(float nofpclass(pzero) %arg0) { define float @ret_rint_nopzero(float nofpclass(pzero) %arg0) {
; CHECK-LABEL: define float @ret_rint_nopzero ; CHECK-LABEL: define nofpclass(sub) float @ret_rint_nopzero
; CHECK-SAME: (float nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nonzero(float nofpclass(nzero) %arg0) { define float @ret_rint_nonzero(float nofpclass(nzero) %arg0) {
; CHECK-LABEL: define float @ret_rint_nonzero ; CHECK-LABEL: define nofpclass(sub) float @ret_rint_nonzero
; CHECK-SAME: (float nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nonorm(float nofpclass(norm) %arg0) { define float @ret_rint_nonorm(float nofpclass(norm) %arg0) {
; CHECK-LABEL: define float @ret_rint_nonorm ; CHECK-LABEL: define nofpclass(sub) float @ret_rint_nonorm
; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nonnorm(float nofpclass(nnorm) %arg0) { define float @ret_rint_nonnorm(float nofpclass(nnorm) %arg0) {
; CHECK-LABEL: define float @ret_rint_nonnorm ; CHECK-LABEL: define nofpclass(sub) float @ret_rint_nonnorm
; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nopnorm(float nofpclass(pnorm) %arg0) { define float @ret_rint_nopnorm(float nofpclass(pnorm) %arg0) {
; CHECK-LABEL: define float @ret_rint_nopnorm ; CHECK-LABEL: define nofpclass(sub) float @ret_rint_nopnorm
; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nonsub(float nofpclass(nsub) %arg0) { define float @ret_rint_nonsub(float nofpclass(nsub) %arg0) {
; CHECK-LABEL: define float @ret_rint_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_rint_nonsub
; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nopsub(float nofpclass(psub) %arg0) { define float @ret_rint_nopsub(float nofpclass(psub) %arg0) {
; CHECK-LABEL: define float @ret_rint_nopsub ; CHECK-LABEL: define nofpclass(sub) float @ret_rint_nopsub
; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nonorm_nosub(float nofpclass(norm sub) %arg0) { define float @ret_rint_nonorm_nosub(float nofpclass(norm sub) %arg0) {
; CHECK-LABEL: define float @ret_rint_nonorm_nosub ; CHECK-LABEL: define nofpclass(sub) float @ret_rint_nonorm_nosub
; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) { define float @ret_rint_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) {
; CHECK-LABEL: define float @ret_rint_nopnorm_nopsub ; CHECK-LABEL: define nofpclass(sub) float @ret_rint_nopnorm_nopsub
; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) { define float @ret_rint_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) {
; CHECK-LABEL: define float @ret_rint_nonnorm_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_rint_nonnorm_nonsub
; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) { define float @ret_rint_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) {
; CHECK-LABEL: define float @ret_rint_nopnorm_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_rint_nopnorm_nonsub
; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define ppc_fp128 @ret_rint_ppcf128(ppc_fp128 %arg0) { define ppc_fp128 @ret_rint_ppcf128(ppc_fp128 %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_rint_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_rint_ppcf128
; CHECK-SAME: (ppc_fp128 [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_rint_noinf_ppcf128(ppc_fp128 nofpclass(inf) %arg0) { define ppc_fp128 @ret_rint_noinf_ppcf128(ppc_fp128 nofpclass(inf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_rint_noinf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_rint_noinf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_rint_nopinf_ppcf128(ppc_fp128 nofpclass(pinf) %arg0) { define ppc_fp128 @ret_rint_nopinf_ppcf128(ppc_fp128 nofpclass(pinf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_rint_nopinf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_rint_nopinf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_rint_noninf_ppcf128(ppc_fp128 nofpclass(ninf) %arg0) { define ppc_fp128 @ret_rint_noninf_ppcf128(ppc_fp128 nofpclass(ninf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_rint_noninf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_rint_noninf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_rint_nonan_ppcf128(ppc_fp128 nofpclass(nan) %arg0) { define ppc_fp128 @ret_rint_nonan_ppcf128(ppc_fp128 nofpclass(nan) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_rint_nonan_ppcf128 ; CHECK-LABEL: define nofpclass(nan sub) ppc_fp128 @ret_rint_nonan_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define float @ret_rint_noneg(float nofpclass(ninf nsub nnorm) %arg0) { define float @ret_rint_noneg(float nofpclass(ninf nsub nnorm) %arg0) {
; CHECK-LABEL: define float @ret_rint_noneg ; CHECK-LABEL: define nofpclass(ninf sub) float @ret_rint_noneg
; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_noneg_nonegzero(float nofpclass(ninf nsub nnorm nzero) %arg0) { define float @ret_rint_noneg_nonegzero(float nofpclass(ninf nsub nnorm nzero) %arg0) {
; CHECK-LABEL: define float @ret_rint_noneg_nonegzero ; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @ret_rint_noneg_nonegzero
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero sub nnorm) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_noneg_nonegzero_nonan(float nofpclass(ninf nsub nnorm nzero nan) %arg0) { define float @ret_rint_noneg_nonegzero_nonan(float nofpclass(ninf nsub nnorm nzero nan) %arg0) {
; CHECK-LABEL: define float @ret_rint_noneg_nonegzero_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @ret_rint_noneg_nonegzero_nonan
; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_noneg_nozero(float nofpclass(ninf nsub nnorm zero) %arg0) { define float @ret_rint_noneg_nozero(float nofpclass(ninf nsub nnorm zero) %arg0) {
; CHECK-LABEL: define float @ret_rint_noneg_nozero ; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @ret_rint_noneg_nozero
; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero sub nnorm) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_noneg_nozero_nonan(float nofpclass(ninf nsub nnorm zero nan) %arg0) { define float @ret_rint_noneg_nozero_nonan(float nofpclass(ninf nsub nnorm zero nan) %arg0) {
; CHECK-LABEL: define float @ret_rint_noneg_nozero_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @ret_rint_noneg_nozero_nonan
; CHECK-SAME: (float nofpclass(nan ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nopos(float nofpclass(pinf psub pnorm) %arg0) { define float @ret_rint_nopos(float nofpclass(pinf psub pnorm) %arg0) {
; CHECK-LABEL: define float @ret_rint_nopos ; CHECK-LABEL: define nofpclass(pinf sub) float @ret_rint_nopos
; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf sub) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nopos_nopzero(float nofpclass(pinf psub pnorm pzero) %arg0) { define float @ret_rint_nopos_nopzero(float nofpclass(pinf psub pnorm pzero) %arg0) {
; CHECK-LABEL: define float @ret_rint_nopos_nopzero ; CHECK-LABEL: define nofpclass(pinf pzero sub pnorm) float @ret_rint_nopos_nopzero
; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf pzero sub pnorm) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nopos_nopzero_nonan(float nofpclass(pinf psub pnorm pzero nan) %arg0) { define float @ret_rint_nopos_nopzero_nonan(float nofpclass(pinf psub pnorm pzero nan) %arg0) {
; CHECK-LABEL: define float @ret_rint_nopos_nopzero_nonan ; CHECK-LABEL: define nofpclass(nan pinf pzero sub pnorm) float @ret_rint_nopos_nopzero_nonan
; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan pinf pzero sub pnorm) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nopos_nozero(float nofpclass(pinf psub pnorm zero) %arg0) { define float @ret_rint_nopos_nozero(float nofpclass(pinf psub pnorm zero) %arg0) {
; CHECK-LABEL: define float @ret_rint_nopos_nozero ; CHECK-LABEL: define nofpclass(pinf pzero sub pnorm) float @ret_rint_nopos_nozero
; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf pzero sub pnorm) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_rint_nopos_nozero_nonan(float nofpclass(pinf psub pnorm zero nan) %arg0) { define float @ret_rint_nopos_nozero_nonan(float nofpclass(pinf psub pnorm zero nan) %arg0) {
; CHECK-LABEL: define float @ret_rint_nopos_nozero_nonan ; CHECK-LABEL: define nofpclass(nan pinf pzero sub pnorm) float @ret_rint_nopos_nozero_nonan
; CHECK-SAME: (float nofpclass(nan pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan pinf pzero sub pnorm) float @llvm.rint.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.rint.f32(float %arg0) %call = call float @llvm.rint.f32(float %arg0)
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/nofpclass-round.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.round.f32(float) declare float @llvm.round.f32(float)
declare ppc_fp128 @llvm.round.ppcf128(ppc_fp128) declare ppc_fp128 @llvm.round.ppcf128(ppc_fp128)
define float @ret_round(float %arg0) { define float @ret_round(float %arg0) {
; CHECK-LABEL: define float @ret_round ; CHECK-LABEL: define nofpclass(sub) float @ret_round
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2:[0-9]+]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2:[0-9]+]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_noinf(float nofpclass(inf) %arg0) { define float @ret_round_noinf(float nofpclass(inf) %arg0) {
; CHECK-LABEL: define float @ret_round_noinf ; CHECK-LABEL: define nofpclass(inf sub) float @ret_round_noinf
; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nopinf(float nofpclass(pinf) %arg0) { define float @ret_round_nopinf(float nofpclass(pinf) %arg0) {
; CHECK-LABEL: define float @ret_round_nopinf ; CHECK-LABEL: define nofpclass(pinf sub) float @ret_round_nopinf
; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_noninf(float nofpclass(ninf) %arg0) { define float @ret_round_noninf(float nofpclass(ninf) %arg0) {
; CHECK-LABEL: define float @ret_round_noninf ; CHECK-LABEL: define nofpclass(ninf sub) float @ret_round_noninf
; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nonan(float nofpclass(nan) %arg0) { define float @ret_round_nonan(float nofpclass(nan) %arg0) {
; CHECK-LABEL: define float @ret_round_nonan ; CHECK-LABEL: define nofpclass(nan sub) float @ret_round_nonan
; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_noqnan(float nofpclass(qnan) %arg0) { define float @ret_round_noqnan(float nofpclass(qnan) %arg0) {
; CHECK-LABEL: define float @ret_round_noqnan ; CHECK-LABEL: define nofpclass(sub) float @ret_round_noqnan
; CHECK-SAME: (float nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nosnan(float nofpclass(snan) %arg0) { define float @ret_round_nosnan(float nofpclass(snan) %arg0) {
; CHECK-LABEL: define float @ret_round_nosnan ; CHECK-LABEL: define nofpclass(snan sub) float @ret_round_nosnan
; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(snan sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nozero(float nofpclass(zero) %arg0) { define float @ret_round_nozero(float nofpclass(zero) %arg0) {
; CHECK-LABEL: define float @ret_round_nozero ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nozero
; CHECK-SAME: (float nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nopzero(float nofpclass(pzero) %arg0) { define float @ret_round_nopzero(float nofpclass(pzero) %arg0) {
; CHECK-LABEL: define float @ret_round_nopzero ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nopzero
; CHECK-SAME: (float nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nonzero(float nofpclass(nzero) %arg0) { define float @ret_round_nonzero(float nofpclass(nzero) %arg0) {
; CHECK-LABEL: define float @ret_round_nonzero ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nonzero
; CHECK-SAME: (float nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nonorm(float nofpclass(norm) %arg0) { define float @ret_round_nonorm(float nofpclass(norm) %arg0) {
; CHECK-LABEL: define float @ret_round_nonorm ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nonorm
; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nonnorm(float nofpclass(nnorm) %arg0) { define float @ret_round_nonnorm(float nofpclass(nnorm) %arg0) {
; CHECK-LABEL: define float @ret_round_nonnorm ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nonnorm
; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nopnorm(float nofpclass(pnorm) %arg0) { define float @ret_round_nopnorm(float nofpclass(pnorm) %arg0) {
; CHECK-LABEL: define float @ret_round_nopnorm ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nopnorm
; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nonsub(float nofpclass(nsub) %arg0) { define float @ret_round_nonsub(float nofpclass(nsub) %arg0) {
; CHECK-LABEL: define float @ret_round_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nonsub
; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nopsub(float nofpclass(psub) %arg0) { define float @ret_round_nopsub(float nofpclass(psub) %arg0) {
; CHECK-LABEL: define float @ret_round_nopsub ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nopsub
; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nonorm_nosub(float nofpclass(norm sub) %arg0) { define float @ret_round_nonorm_nosub(float nofpclass(norm sub) %arg0) {
; CHECK-LABEL: define float @ret_round_nonorm_nosub ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nonorm_nosub
; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) { define float @ret_round_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) {
; CHECK-LABEL: define float @ret_round_nopnorm_nopsub ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nopnorm_nopsub
; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) { define float @ret_round_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) {
; CHECK-LABEL: define float @ret_round_nonnorm_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nonnorm_nonsub
; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) { define float @ret_round_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) {
; CHECK-LABEL: define float @ret_round_nopnorm_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nopnorm_nonsub
; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define ppc_fp128 @ret_round_ppcf128(ppc_fp128 %arg0) { define ppc_fp128 @ret_round_ppcf128(ppc_fp128 %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_round_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_round_ppcf128
; CHECK-SAME: (ppc_fp128 [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_round_noinf_ppcf128(ppc_fp128 nofpclass(inf) %arg0) { define ppc_fp128 @ret_round_noinf_ppcf128(ppc_fp128 nofpclass(inf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_round_noinf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_round_noinf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_round_nopinf_ppcf128(ppc_fp128 nofpclass(pinf) %arg0) { define ppc_fp128 @ret_round_nopinf_ppcf128(ppc_fp128 nofpclass(pinf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_round_nopinf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_round_nopinf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_round_noninf_ppcf128(ppc_fp128 nofpclass(ninf) %arg0) { define ppc_fp128 @ret_round_noninf_ppcf128(ppc_fp128 nofpclass(ninf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_round_noninf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_round_noninf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_round_nonan_ppcf128(ppc_fp128 nofpclass(nan) %arg0) { define ppc_fp128 @ret_round_nonan_ppcf128(ppc_fp128 nofpclass(nan) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_round_nonan_ppcf128 ; CHECK-LABEL: define nofpclass(nan sub) ppc_fp128 @ret_round_nonan_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define float @ret_round_noneg(float nofpclass(ninf nsub nnorm) %arg0) { define float @ret_round_noneg(float nofpclass(ninf nsub nnorm) %arg0) {
; CHECK-LABEL: define float @ret_round_noneg ; CHECK-LABEL: define nofpclass(ninf sub) float @ret_round_noneg
; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_noneg_nonegzero(float nofpclass(ninf nsub nnorm nzero) %arg0) { define float @ret_round_noneg_nonegzero(float nofpclass(ninf nsub nnorm nzero) %arg0) {
; CHECK-LABEL: define float @ret_round_noneg_nonegzero ; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @ret_round_noneg_nonegzero
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero sub nnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_noneg_nonegzero_nonan(float nofpclass(ninf nsub nnorm nzero nan) %arg0) { define float @ret_round_noneg_nonegzero_nonan(float nofpclass(ninf nsub nnorm nzero nan) %arg0) {
; CHECK-LABEL: define float @ret_round_noneg_nonegzero_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @ret_round_noneg_nonegzero_nonan
; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_noneg_nozero(float nofpclass(ninf nsub nnorm zero) %arg0) { define float @ret_round_noneg_nozero(float nofpclass(ninf nsub nnorm zero) %arg0) {
; CHECK-LABEL: define float @ret_round_noneg_nozero ; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @ret_round_noneg_nozero
; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero sub nnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_noneg_nozero_nonan(float nofpclass(ninf nsub nnorm zero nan) %arg0) { define float @ret_round_noneg_nozero_nonan(float nofpclass(ninf nsub nnorm zero nan) %arg0) {
; CHECK-LABEL: define float @ret_round_noneg_nozero_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @ret_round_noneg_nozero_nonan
; CHECK-SAME: (float nofpclass(nan ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nopos(float nofpclass(pinf psub pnorm) %arg0) { define float @ret_round_nopos(float nofpclass(pinf psub pnorm) %arg0) {
; CHECK-LABEL: define float @ret_round_nopos ; CHECK-LABEL: define nofpclass(pinf sub) float @ret_round_nopos
; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nopos_nopzero(float nofpclass(pinf psub pnorm pzero) %arg0) { define float @ret_round_nopos_nopzero(float nofpclass(pinf psub pnorm pzero) %arg0) {
; CHECK-LABEL: define float @ret_round_nopos_nopzero ; CHECK-LABEL: define nofpclass(pinf pzero sub pnorm) float @ret_round_nopos_nopzero
; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf pzero sub pnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nopos_nopzero_nonan(float nofpclass(pinf psub pnorm pzero nan) %arg0) { define float @ret_round_nopos_nopzero_nonan(float nofpclass(pinf psub pnorm pzero nan) %arg0) {
; CHECK-LABEL: define float @ret_round_nopos_nopzero_nonan ; CHECK-LABEL: define nofpclass(nan pinf pzero sub pnorm) float @ret_round_nopos_nopzero_nonan
; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan pinf pzero sub pnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nopos_nozero(float nofpclass(pinf psub pnorm zero) %arg0) { define float @ret_round_nopos_nozero(float nofpclass(pinf psub pnorm zero) %arg0) {
; CHECK-LABEL: define float @ret_round_nopos_nozero ; CHECK-LABEL: define nofpclass(pinf pzero sub pnorm) float @ret_round_nopos_nozero
; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf pzero sub pnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_round_nopos_nozero_nonan(float nofpclass(pinf psub pnorm zero nan) %arg0) { define float @ret_round_nopos_nozero_nonan(float nofpclass(pinf psub pnorm zero nan) %arg0) {
; CHECK-LABEL: define float @ret_round_nopos_nozero_nonan ; CHECK-LABEL: define nofpclass(nan pinf pzero sub pnorm) float @ret_round_nopos_nozero_nonan
; CHECK-SAME: (float nofpclass(nan pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan pinf pzero sub pnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]]
;
%call = call float @llvm.round.f32(float %arg0)
ret float %call
}
define float @ret_round_nopzero_nopnorm(float nofpclass(pzero pnorm) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_round_nopzero_nopnorm
; CHECK-SAME: (float nofpclass(pzero pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]]
;
%call = call float @llvm.round.f32(float %arg0)
ret float %call
}
define float @ret_round_nonzero_nonnorm(float nofpclass(nzero nnorm) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_round_nonzero_nonnorm
; CHECK-SAME: (float nofpclass(nzero nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]]
;
%call = call float @llvm.round.f32(float %arg0)
ret float %call
}
define float @ret_round_nozero_nonorm(float nofpclass(zero norm) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_round_nozero_nonorm
; CHECK-SAME: (float nofpclass(zero norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.round.f32(float %arg0) %call = call float @llvm.round.f32(float %arg0)
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/nofpclass-roundeven.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.roundeven.f32(float) declare float @llvm.roundeven.f32(float)
declare ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128) declare ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128)
define float @ret_roundeven(float %arg0) { define float @ret_roundeven(float %arg0) {
; CHECK-LABEL: define float @ret_roundeven ; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2:[0-9]+]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2:[0-9]+]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_noinf(float nofpclass(inf) %arg0) { define float @ret_roundeven_noinf(float nofpclass(inf) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_noinf ; CHECK-LABEL: define nofpclass(inf sub) float @ret_roundeven_noinf
; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nopinf(float nofpclass(pinf) %arg0) { define float @ret_roundeven_nopinf(float nofpclass(pinf) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nopinf ; CHECK-LABEL: define nofpclass(pinf sub) float @ret_roundeven_nopinf
; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_noninf(float nofpclass(ninf) %arg0) { define float @ret_roundeven_noninf(float nofpclass(ninf) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_noninf ; CHECK-LABEL: define nofpclass(ninf sub) float @ret_roundeven_noninf
; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nonan(float nofpclass(nan) %arg0) { define float @ret_roundeven_nonan(float nofpclass(nan) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nonan ; CHECK-LABEL: define nofpclass(nan sub) float @ret_roundeven_nonan
; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_noqnan(float nofpclass(qnan) %arg0) { define float @ret_roundeven_noqnan(float nofpclass(qnan) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_noqnan ; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_noqnan
; CHECK-SAME: (float nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nosnan(float nofpclass(snan) %arg0) { define float @ret_roundeven_nosnan(float nofpclass(snan) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nosnan ; CHECK-LABEL: define nofpclass(snan sub) float @ret_roundeven_nosnan
; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(snan sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nozero(float nofpclass(zero) %arg0) { define float @ret_roundeven_nozero(float nofpclass(zero) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nozero ; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nozero
; CHECK-SAME: (float nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nopzero(float nofpclass(pzero) %arg0) { define float @ret_roundeven_nopzero(float nofpclass(pzero) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nopzero ; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nopzero
; CHECK-SAME: (float nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nonzero(float nofpclass(nzero) %arg0) { define float @ret_roundeven_nonzero(float nofpclass(nzero) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nonzero ; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nonzero
; CHECK-SAME: (float nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nonorm(float nofpclass(norm) %arg0) { define float @ret_roundeven_nonorm(float nofpclass(norm) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nonorm ; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nonorm
; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nonnorm(float nofpclass(nnorm) %arg0) { define float @ret_roundeven_nonnorm(float nofpclass(nnorm) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nonnorm ; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nonnorm
; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nopnorm(float nofpclass(pnorm) %arg0) { define float @ret_roundeven_nopnorm(float nofpclass(pnorm) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nopnorm ; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nopnorm
; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nonsub(float nofpclass(nsub) %arg0) { define float @ret_roundeven_nonsub(float nofpclass(nsub) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nonsub
; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nopsub(float nofpclass(psub) %arg0) { define float @ret_roundeven_nopsub(float nofpclass(psub) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nopsub ; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nopsub
; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nonorm_nosub(float nofpclass(norm sub) %arg0) { define float @ret_roundeven_nonorm_nosub(float nofpclass(norm sub) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nonorm_nosub ; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nonorm_nosub
; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) { define float @ret_roundeven_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nopnorm_nopsub ; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nopnorm_nopsub
; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) { define float @ret_roundeven_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nonnorm_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nonnorm_nonsub
; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) { define float @ret_roundeven_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nopnorm_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nopnorm_nonsub
; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define ppc_fp128 @ret_roundeven_ppcf128(ppc_fp128 %arg0) { define ppc_fp128 @ret_roundeven_ppcf128(ppc_fp128 %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_roundeven_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_roundeven_ppcf128
; CHECK-SAME: (ppc_fp128 [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_roundeven_noinf_ppcf128(ppc_fp128 nofpclass(inf) %arg0) { define ppc_fp128 @ret_roundeven_noinf_ppcf128(ppc_fp128 nofpclass(inf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_roundeven_noinf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_roundeven_noinf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_roundeven_nopinf_ppcf128(ppc_fp128 nofpclass(pinf) %arg0) { define ppc_fp128 @ret_roundeven_nopinf_ppcf128(ppc_fp128 nofpclass(pinf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_roundeven_nopinf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_roundeven_nopinf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_roundeven_noninf_ppcf128(ppc_fp128 nofpclass(ninf) %arg0) { define ppc_fp128 @ret_roundeven_noninf_ppcf128(ppc_fp128 nofpclass(ninf) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_roundeven_noninf_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_roundeven_noninf_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define ppc_fp128 @ret_roundeven_nonan_ppcf128(ppc_fp128 nofpclass(nan) %arg0) { define ppc_fp128 @ret_roundeven_nonan_ppcf128(ppc_fp128 nofpclass(nan) %arg0) {
; CHECK-LABEL: define ppc_fp128 @ret_roundeven_nonan_ppcf128 ; CHECK-LABEL: define nofpclass(nan sub) ppc_fp128 @ret_roundeven_nonan_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define float @ret_roundeven_noneg(float nofpclass(ninf nsub nnorm) %arg0) { define float @ret_roundeven_noneg(float nofpclass(ninf nsub nnorm) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_noneg ; CHECK-LABEL: define nofpclass(ninf sub) float @ret_roundeven_noneg
; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_noneg_nonegzero(float nofpclass(ninf nsub nnorm nzero) %arg0) { define float @ret_roundeven_noneg_nonegzero(float nofpclass(ninf nsub nnorm nzero) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_noneg_nonegzero ; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @ret_roundeven_noneg_nonegzero
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero sub nnorm) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_noneg_nonegzero_nonan(float nofpclass(ninf nsub nnorm nzero nan) %arg0) { define float @ret_roundeven_noneg_nonegzero_nonan(float nofpclass(ninf nsub nnorm nzero nan) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_noneg_nonegzero_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @ret_roundeven_noneg_nonegzero_nonan
; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_noneg_nozero(float nofpclass(ninf nsub nnorm zero) %arg0) { define float @ret_roundeven_noneg_nozero(float nofpclass(ninf nsub nnorm zero) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_noneg_nozero ; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @ret_roundeven_noneg_nozero
; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero sub nnorm) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_noneg_nozero_nonan(float nofpclass(ninf nsub nnorm zero nan) %arg0) { define float @ret_roundeven_noneg_nozero_nonan(float nofpclass(ninf nsub nnorm zero nan) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_noneg_nozero_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @ret_roundeven_noneg_nozero_nonan
; CHECK-SAME: (float nofpclass(nan ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nopos(float nofpclass(pinf psub pnorm) %arg0) { define float @ret_roundeven_nopos(float nofpclass(pinf psub pnorm) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nopos ; CHECK-LABEL: define nofpclass(pinf sub) float @ret_roundeven_nopos
; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nopos_nopzero(float nofpclass(pinf psub pnorm pzero) %arg0) { define float @ret_roundeven_nopos_nopzero(float nofpclass(pinf psub pnorm pzero) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nopos_nopzero ; CHECK-LABEL: define nofpclass(pinf pzero sub pnorm) float @ret_roundeven_nopos_nopzero
; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf pzero sub pnorm) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nopos_nopzero_nonan(float nofpclass(pinf psub pnorm pzero nan) %arg0) { define float @ret_roundeven_nopos_nopzero_nonan(float nofpclass(pinf psub pnorm pzero nan) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nopos_nopzero_nonan ; CHECK-LABEL: define nofpclass(nan pinf pzero sub pnorm) float @ret_roundeven_nopos_nopzero_nonan
; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan pinf pzero sub pnorm) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nopos_nozero(float nofpclass(pinf psub pnorm zero) %arg0) { define float @ret_roundeven_nopos_nozero(float nofpclass(pinf psub pnorm zero) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nopos_nozero ; CHECK-LABEL: define nofpclass(pinf pzero sub pnorm) float @ret_roundeven_nopos_nozero
; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf pzero sub pnorm) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_roundeven_nopos_nozero_nonan(float nofpclass(pinf psub pnorm zero nan) %arg0) { define float @ret_roundeven_nopos_nozero_nonan(float nofpclass(pinf psub pnorm zero nan) %arg0) {
; CHECK-LABEL: define float @ret_roundeven_nopos_nozero_nonan ; CHECK-LABEL: define nofpclass(nan pinf pzero sub pnorm) float @ret_roundeven_nopos_nozero_nonan
; CHECK-SAME: (float nofpclass(nan pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nan pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan pinf pzero sub pnorm) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]]
;
%call = call float @llvm.roundeven.f32(float %arg0)
ret float %call
}
define float @ret_roundeven_nopzero_nopnorm(float nofpclass(pzero pnorm) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nopzero_nopnorm
; CHECK-SAME: (float nofpclass(pzero pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]]
;
%call = call float @llvm.roundeven.f32(float %arg0)
ret float %call
}
define float @ret_roundeven_nonzero_nonnorm(float nofpclass(nzero nnorm) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nonzero_nonnorm
; CHECK-SAME: (float nofpclass(nzero nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]]
;
%call = call float @llvm.roundeven.f32(float %arg0)
ret float %call
}
define float @ret_roundeven_nozero_nonorm(float nofpclass(zero norm) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_roundeven_nozero_nonorm
; CHECK-SAME: (float nofpclass(zero norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.roundeven.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.roundeven.f32(float %arg0) %call = call float @llvm.roundeven.f32(float %arg0)
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/nofpclass-trunc.ll

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.trunc.f32(float %arg0) %call = call float @llvm.trunc.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_trunc_nosnan(float nofpclass(snan) %arg0) { define float @ret_trunc_nosnan(float nofpclass(snan) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nosnan ; CHECK-LABEL: define nofpclass(snan sub) float @ret_trunc_nosnan
; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(snan sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.trunc.f32(float %arg0) %call = call float @llvm.trunc.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_trunc_nozero(float nofpclass(zero) %arg0) { define float @ret_trunc_nozero(float nofpclass(zero) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nozero ; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nozero
Show All 21 Lines
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.trunc.f32(float %arg0) %call = call float @llvm.trunc.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_trunc_nonorm(float nofpclass(norm) %arg0) { define float @ret_trunc_nonorm(float nofpclass(norm) %arg0) {
; CHECK-LABEL: define nofpclass(sub norm) float @ret_trunc_nonorm ; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nonorm
; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub norm) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.trunc.f32(float %arg0) %call = call float @llvm.trunc.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_trunc_nonnorm(float nofpclass(nnorm) %arg0) { define float @ret_trunc_nonnorm(float nofpclass(nnorm) %arg0) {
; CHECK-LABEL: define nofpclass(sub nnorm) float @ret_trunc_nonnorm ; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nonnorm
; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub nnorm) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.trunc.f32(float %arg0) %call = call float @llvm.trunc.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_trunc_nopnorm(float nofpclass(pnorm) %arg0) { define float @ret_trunc_nopnorm(float nofpclass(pnorm) %arg0) {
; CHECK-LABEL: define nofpclass(sub pnorm) float @ret_trunc_nopnorm ; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nopnorm
; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub pnorm) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.trunc.f32(float %arg0) %call = call float @llvm.trunc.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_trunc_nonsub(float nofpclass(nsub) %arg0) { define float @ret_trunc_nonsub(float nofpclass(nsub) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nonsub
Show All 11 Lines
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.trunc.f32(float %arg0) %call = call float @llvm.trunc.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_trunc_nonorm_nosub(float nofpclass(norm sub) %arg0) { define float @ret_trunc_nonorm_nosub(float nofpclass(norm sub) %arg0) {
; CHECK-LABEL: define nofpclass(sub norm) float @ret_trunc_nonorm_nosub ; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nonorm_nosub
; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub norm) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.trunc.f32(float %arg0) %call = call float @llvm.trunc.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_trunc_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) { define float @ret_trunc_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) {
; CHECK-LABEL: define nofpclass(sub pnorm) float @ret_trunc_nopnorm_nopsub ; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nopnorm_nopsub
; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub pnorm) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.trunc.f32(float %arg0) %call = call float @llvm.trunc.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_trunc_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) { define float @ret_trunc_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) {
; CHECK-LABEL: define nofpclass(sub nnorm) float @ret_trunc_nonnorm_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nonnorm_nonsub
; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub nnorm) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.trunc.f32(float %arg0) %call = call float @llvm.trunc.f32(float %arg0)
ret float %call ret float %call
} }
define float @ret_trunc_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) { define float @ret_trunc_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) {
; CHECK-LABEL: define nofpclass(sub pnorm) float @ret_trunc_nopnorm_nonsub ; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nopnorm_nonsub
; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub pnorm) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.trunc.f32(float %arg0) %call = call float @llvm.trunc.f32(float %arg0)
ret float %call ret float %call
} }
define ppc_fp128 @ret_trunc_ppcf128(ppc_fp128 %arg0) { define ppc_fp128 @ret_trunc_ppcf128(ppc_fp128 %arg0) {
; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_trunc_ppcf128 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_trunc_ppcf128
Show All 39 Lines
; CHECK-LABEL: define nofpclass(nan sub) ppc_fp128 @ret_trunc_nonan_ppcf128 ; CHECK-LABEL: define nofpclass(nan sub) ppc_fp128 @ret_trunc_nonan_ppcf128
; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) ppc_fp128 @llvm.trunc.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]] ; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) ppc_fp128 @llvm.trunc.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret ppc_fp128 [[CALL]] ; CHECK-NEXT: ret ppc_fp128 [[CALL]]
; ;
%call = call ppc_fp128 @llvm.trunc.ppcf128(ppc_fp128 %arg0) %call = call ppc_fp128 @llvm.trunc.ppcf128(ppc_fp128 %arg0)
ret ppc_fp128 %call ret ppc_fp128 %call
} }
define float @ret_trunc_nopzero_nopnorm(float nofpclass(pzero pnorm) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nopzero_nopnorm
; CHECK-SAME: (float nofpclass(pzero pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]]
;
%call = call float @llvm.trunc.f32(float %arg0)
ret float %call
}
define float @ret_trunc_nonzero_nonnorm(float nofpclass(nzero nnorm) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nonzero_nonnorm
; CHECK-SAME: (float nofpclass(nzero nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]]
;
%call = call float @llvm.trunc.f32(float %arg0)
ret float %call
}
define float @ret_trunc_nozero_nonorm(float nofpclass(zero norm) %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_trunc_nozero_nonorm
; CHECK-SAME: (float nofpclass(zero norm) [[ARG0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.trunc.f32(float [[ARG0]]) #[[ATTR2]]
; CHECK-NEXT: ret float [[CALL]]
;
%call = call float @llvm.trunc.f32(float %arg0)
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/nofree.ll

Show First 20 Lines • Show All 252 Lines • ▼ Show 20 Lines;
tail call float @llvm.floor.f32(float %a) tail call float @llvm.floor.f32(float %a)
ret void ret void
} }
define float @call_floor2(float %a) #0 { define float @call_floor2(float %a) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@call_floor2 ; CHECK-LABEL: define {{[^@]+}}@call_floor2
; CHECK-SAME: (float [[A:%.*]]) #[[ATTR3]] { ; CHECK-SAME: (float [[A:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: [[C:%.*]] = tail call float @llvm.floor.f32(float [[A]]) #[[ATTR11:[0-9]+]] ; CHECK-NEXT: [[C:%.*]] = tail call nofpclass(sub) float @llvm.floor.f32(float [[A]]) #[[ATTR11:[0-9]+]]
; CHECK-NEXT: ret float [[C]] ; CHECK-NEXT: ret float [[C]]
; ;
%c = tail call float @llvm.floor.f32(float %a) %c = tail call float @llvm.floor.f32(float %a)
ret float %c ret float %c
} }
; TEST 11 (positive case) ; TEST 11 (positive case)
; Check propagation. ; Check propagation.
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/willreturn.ll

Show First 20 Lines • Show All 306 Lines • ▼ Show 20 Lines;
tail call float @llvm.floor.f32(float %a) tail call float @llvm.floor.f32(float %a)
ret void ret void
} }
define float @call_floor2(float %a) #0 { define float @call_floor2(float %a) #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@call_floor2 ; TUNIT-LABEL: define {{[^@]+}}@call_floor2
; TUNIT-SAME: (float [[A:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (float [[A:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[C:%.*]] = tail call float @llvm.floor.f32(float [[A]]) #[[ATTR27:[0-9]+]] ; TUNIT-NEXT: [[C:%.*]] = tail call nofpclass(sub) float @llvm.floor.f32(float [[A]]) #[[ATTR27:[0-9]+]]
; TUNIT-NEXT: ret float [[C]] ; TUNIT-NEXT: ret float [[C]]
; ;
; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@call_floor2 ; CGSCC-LABEL: define {{[^@]+}}@call_floor2
; CGSCC-SAME: (float [[A:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (float [[A:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: [[C:%.*]] = tail call float @llvm.floor.f32(float [[A]]) #[[ATTR28:[0-9]+]] ; CGSCC-NEXT: [[C:%.*]] = tail call nofpclass(sub) float @llvm.floor.f32(float [[A]]) #[[ATTR28:[0-9]+]]
; CGSCC-NEXT: ret float [[C]] ; CGSCC-NEXT: ret float [[C]]
; ;
%c = tail call float @llvm.floor.f32(float %a) %c = tail call float @llvm.floor.f32(float %a)
ret float %c ret float %c
} }
; TEST 7 (negative case) ; TEST 7 (negative case)
▲ Show 20 Lines • Show All 1,015 Lines • Show Last 20 Lines