This is an archive of the discontinued LLVM Phabricator instance.

Differential D155437

ValueTracking: Fix computeKnownFPClass canonicalize handling
ClosedPublic

Authored by arsenm on Jul 17 2023, 4:01 AM.

Details

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

This mostly manifested as broken constant folding. This was
mishandling the dynamic denormal mode. It was also mishandling literal
signaling nans as always poison.

Diff Detail

Event Timeline

arsenm created this revision.Jul 17 2023, 4:01 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 17 2023, 4:01 AM
Herald added subscribers: StephenFan, okura, kuter, hiraditya. · View Herald Transcript
arsenm requested review of this revision.Jul 17 2023, 4:01 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptJul 17 2023, 4:01 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
Harbormaster completed remote builds in B245781: Diff 540941.Jul 17 2023, 4:02 AM
foad added a comment.Jul 18 2023, 12:14 AM

It was also mishandling literal signaling nans as always poison.

I don't see anything in this patch related to constants or poison.

foad accepted this revision.Jul 18 2023, 12:22 AM

Code LGTM.

This revision is now accepted and ready to land.Jul 18 2023, 12:22 AM
arsenm added a comment.Jul 18 2023, 2:49 AM
In D155437#4509006, @foad wrote:

It was also mishandling literal signaling nans as always poison.

I don't see anything in this patch related to constants or poison.

Constants were just demonstrating the issue, with output that could only be poison since the returned constant violated the reported class

arsenm closed this revision.Jul 18 2023, 3:37 AM

f868c22bee55dac1423a7b892b791946a5130b59

arsenm mentioned this in rGf868c22bee55: ValueTracking: Fix computeKnownFPClass canonicalize handling.Jul 18 2023, 3:37 AM

Revision Contents

PathSize
llvm/
lib/
Analysis/
26 lines
test/
Transforms/
Attributor/
120 lines

Diff 540941

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,517 Lines • ▼ Show 20 Lines if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Op)) {
II->getType()->getScalarType()->getFltSemantics()); II->getType()->getScalarType()->getFltSemantics());
if (Mode != DenormalMode::getIEEE()) if (Mode != DenormalMode::getIEEE())
Known.KnownFPClasses |= fcZero; Known.KnownFPClasses |= fcZero;
} }
break; break;
} }
case Intrinsic::canonicalize: { case Intrinsic::canonicalize: {
KnownFPClass KnownSrc;
computeKnownFPClass(II->getArgOperand(0), DemandedElts, computeKnownFPClass(II->getArgOperand(0), DemandedElts,
InterestedClasses, Known, Depth + 1, Q); InterestedClasses, KnownSrc, Depth + 1, Q);
// This is essentially a stronger form of
// propagateCanonicalizingSrc. Other "canonicalizing" operations don't
// actually have an IR canonicalization guarantee.
// Canonicalize may flush denormals to zero, so we have to consider the
// denormal mode to preserve known-not-0 knowledge.
Known.KnownFPClasses = KnownSrc.KnownFPClasses | fcZero | fcQNan;
// Stronger version of propagateNaN
// Canonicalize is guaranteed to quiet signaling nans. // Canonicalize is guaranteed to quiet signaling nans.
if (KnownSrc.isKnownNeverNaN())
Known.knownNot(fcNan);
else
Known.knownNot(fcSNan); Known.knownNot(fcSNan);
const Function *F = II->getFunction(); const Function *F = II->getFunction();
if (!F) if (!F)
break; break;
// If the parent function flushes denormals, the canonical output cannot // If the parent function flushes denormals, the canonical output cannot
// be a denormal. // be a denormal.
const fltSemantics &FPType = const fltSemantics &FPType =
II->getType()->getScalarType()->getFltSemantics(); II->getType()->getScalarType()->getFltSemantics();
DenormalMode DenormMode = F->getDenormalMode(FPType); DenormalMode DenormMode = F->getDenormalMode(FPType);
if (DenormMode == DenormalMode::getIEEE()) {
if (KnownSrc.isKnownNever(fcPosZero))
Known.knownNot(fcPosZero);
if (KnownSrc.isKnownNever(fcNegZero))
Known.knownNot(fcNegZero);
break;
}
if (DenormMode.inputsAreZero() || DenormMode.outputsAreZero()) if (DenormMode.inputsAreZero() || DenormMode.outputsAreZero())
Known.knownNot(fcSubnormal); Known.knownNot(fcSubnormal);
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);
▲ Show 20 Lines • Show All 4,180 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 188 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(snan inf zero sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF8000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(snan inf zero sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF8000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0x7FF8000000000000) %call = call float @llvm.canonicalize.f32(float 0x7FF8000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_ieee_constant_snan() "denormal-fp-math"="ieee,ieee" { define float @ret_canonicalize_ieee_constant_snan() "denormal-fp-math"="ieee,ieee" {
; CHECK-LABEL: define noundef nofpclass(all) float @ret_canonicalize_ieee_constant_snan ; CHECK-LABEL: define noundef nofpclass(snan inf zero sub norm) float @ret_canonicalize_ieee_constant_snan
; CHECK-SAME: () #[[ATTR9]] { ; CHECK-SAME: () #[[ATTR9]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(all) float @llvm.canonicalize.f32(float noundef 0x7FF1000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(snan inf zero sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF1000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0x7FF1000000000000) %call = call float @llvm.canonicalize.f32(float 0x7FF1000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_daz_constant_pos_denormal() "denormal-fp-math"="preserve-sign,preserve-sign" { define float @ret_canonicalize_daz_constant_pos_denormal() "denormal-fp-math"="preserve-sign,preserve-sign" {
; CHECK-LABEL: define noundef nofpclass(all) float @ret_canonicalize_daz_constant_pos_denormal ; CHECK-LABEL: define noundef nofpclass(nan inf sub norm) float @ret_canonicalize_daz_constant_pos_denormal
; CHECK-SAME: () #[[ATTR10:[0-9]+]] { ; CHECK-SAME: () #[[ATTR10:[0-9]+]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(all) float @llvm.canonicalize.f32(float noundef 0x36A0000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf sub norm) float @llvm.canonicalize.f32(float noundef 0x36A0000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0x36A0000000000000) %call = call float @llvm.canonicalize.f32(float 0x36A0000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_daz_constant_neg_denormal() "denormal-fp-math"="preserve-sign,preserve-sign" { define float @ret_canonicalize_daz_constant_neg_denormal() "denormal-fp-math"="preserve-sign,preserve-sign" {
; CHECK-LABEL: define noundef nofpclass(all) float @ret_canonicalize_daz_constant_neg_denormal ; CHECK-LABEL: define noundef nofpclass(nan inf sub norm) float @ret_canonicalize_daz_constant_neg_denormal
; CHECK-SAME: () #[[ATTR10]] { ; CHECK-SAME: () #[[ATTR10]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(all) float @llvm.canonicalize.f32(float noundef 0xB6A0000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf sub norm) float @llvm.canonicalize.f32(float noundef 0xB6A0000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0xb6A0000000000000) %call = call float @llvm.canonicalize.f32(float 0xb6A0000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_daz_constant_pos_zero() "denormal-fp-math"="preserve-sign,preserve-sign" { define float @ret_canonicalize_daz_constant_pos_zero() "denormal-fp-math"="preserve-sign,preserve-sign" {
; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) float @ret_canonicalize_daz_constant_pos_zero ; CHECK-LABEL: define noundef nofpclass(nan inf sub norm) float @ret_canonicalize_daz_constant_pos_zero
; CHECK-SAME: () #[[ATTR10]] { ; CHECK-SAME: () #[[ATTR10]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf nzero sub norm) float @llvm.canonicalize.f32(float noundef 0.000000e+00) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf sub norm) float @llvm.canonicalize.f32(float noundef 0.000000e+00) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0.0) %call = call float @llvm.canonicalize.f32(float 0.0)
ret float %call ret float %call
} }
define float @ret_canonicalize_daz_constant_neg_zero() "denormal-fp-math"="preserve-sign,preserve-sign" { define float @ret_canonicalize_daz_constant_neg_zero() "denormal-fp-math"="preserve-sign,preserve-sign" {
; CHECK-LABEL: define noundef nofpclass(nan inf pzero sub norm) float @ret_canonicalize_daz_constant_neg_zero ; CHECK-LABEL: define noundef nofpclass(nan inf sub norm) float @ret_canonicalize_daz_constant_neg_zero
; CHECK-SAME: () #[[ATTR10]] { ; CHECK-SAME: () #[[ATTR10]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf pzero sub norm) float @llvm.canonicalize.f32(float noundef -0.000000e+00) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf sub norm) float @llvm.canonicalize.f32(float noundef -0.000000e+00) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float -0.0) %call = call float @llvm.canonicalize.f32(float -0.0)
ret float %call ret float %call
} }
define float @ret_canonicalize_daz_constant_pos_normal() "denormal-fp-math"="preserve-sign,preserve-sign" { define float @ret_canonicalize_daz_constant_pos_normal() "denormal-fp-math"="preserve-sign,preserve-sign" {
; CHECK-LABEL: define noundef nofpclass(nan inf zero sub nnorm) float @ret_canonicalize_daz_constant_pos_normal ; CHECK-LABEL: define noundef nofpclass(nan inf sub nnorm) float @ret_canonicalize_daz_constant_pos_normal
; CHECK-SAME: () #[[ATTR10]] { ; CHECK-SAME: () #[[ATTR10]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf zero sub nnorm) float @llvm.canonicalize.f32(float noundef 8.000000e+00) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf sub nnorm) float @llvm.canonicalize.f32(float noundef 8.000000e+00) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 8.0) %call = call float @llvm.canonicalize.f32(float 8.0)
ret float %call ret float %call
} }
define float @ret_canonicalize_daz_constant_neg_normal() "denormal-fp-math"="preserve-sign,preserve-sign" { define float @ret_canonicalize_daz_constant_neg_normal() "denormal-fp-math"="preserve-sign,preserve-sign" {
; CHECK-LABEL: define noundef nofpclass(nan inf zero sub pnorm) float @ret_canonicalize_daz_constant_neg_normal ; CHECK-LABEL: define noundef nofpclass(nan inf sub pnorm) float @ret_canonicalize_daz_constant_neg_normal
; CHECK-SAME: () #[[ATTR10]] { ; CHECK-SAME: () #[[ATTR10]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf zero sub pnorm) float @llvm.canonicalize.f32(float noundef -8.000000e+00) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf sub pnorm) float @llvm.canonicalize.f32(float noundef -8.000000e+00) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float -8.0) %call = call float @llvm.canonicalize.f32(float -8.0)
ret float %call ret float %call
} }
define float @ret_canonicalize_daz_constant_pos_inf() "denormal-fp-math"="preserve-sign,preserve-sign" { define float @ret_canonicalize_daz_constant_pos_inf() "denormal-fp-math"="preserve-sign,preserve-sign" {
; CHECK-LABEL: define noundef nofpclass(nan ninf zero sub norm) float @ret_canonicalize_daz_constant_pos_inf ; CHECK-LABEL: define noundef nofpclass(nan ninf sub norm) float @ret_canonicalize_daz_constant_pos_inf
; CHECK-SAME: () #[[ATTR10]] { ; CHECK-SAME: () #[[ATTR10]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan ninf zero sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF0000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan ninf sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF0000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0x7FF0000000000000) %call = call float @llvm.canonicalize.f32(float 0x7FF0000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_daz_constant_neg_inf() "denormal-fp-math"="preserve-sign,preserve-sign" { define float @ret_canonicalize_daz_constant_neg_inf() "denormal-fp-math"="preserve-sign,preserve-sign" {
; CHECK-LABEL: define noundef nofpclass(nan pinf zero sub norm) float @ret_canonicalize_daz_constant_neg_inf ; CHECK-LABEL: define noundef nofpclass(nan pinf sub norm) float @ret_canonicalize_daz_constant_neg_inf
; CHECK-SAME: () #[[ATTR10]] { ; CHECK-SAME: () #[[ATTR10]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan pinf zero sub norm) float @llvm.canonicalize.f32(float noundef 0xFFF0000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan pinf sub norm) float @llvm.canonicalize.f32(float noundef 0xFFF0000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0xFFF0000000000000) %call = call float @llvm.canonicalize.f32(float 0xFFF0000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_daz_constant_qnan() "denormal-fp-math"="preserve-sign,preserve-sign" { define float @ret_canonicalize_daz_constant_qnan() "denormal-fp-math"="preserve-sign,preserve-sign" {
; CHECK-LABEL: define noundef nofpclass(snan inf zero sub norm) float @ret_canonicalize_daz_constant_qnan ; CHECK-LABEL: define noundef nofpclass(snan inf sub norm) float @ret_canonicalize_daz_constant_qnan
; CHECK-SAME: () #[[ATTR10]] { ; CHECK-SAME: () #[[ATTR10]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(snan inf zero sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF8000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(snan inf sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF8000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0x7FF8000000000000) %call = call float @llvm.canonicalize.f32(float 0x7FF8000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_daz_constant_snan() "denormal-fp-math"="preserve-sign,preserve-sign" { define float @ret_canonicalize_daz_constant_snan() "denormal-fp-math"="preserve-sign,preserve-sign" {
; CHECK-LABEL: define noundef nofpclass(all) float @ret_canonicalize_daz_constant_snan ; CHECK-LABEL: define noundef nofpclass(snan inf sub norm) float @ret_canonicalize_daz_constant_snan
; CHECK-SAME: () #[[ATTR10]] { ; CHECK-SAME: () #[[ATTR10]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(all) float @llvm.canonicalize.f32(float noundef 0x7FF1000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(snan inf sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF1000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0x7FF1000000000000) %call = call float @llvm.canonicalize.f32(float 0x7FF1000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_dapz_constant_pos_denormal() "denormal-fp-math"="positive-zero,positive-zero" { define float @ret_canonicalize_dapz_constant_pos_denormal() "denormal-fp-math"="positive-zero,positive-zero" {
; CHECK-LABEL: define noundef nofpclass(all) float @ret_canonicalize_dapz_constant_pos_denormal ; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) float @ret_canonicalize_dapz_constant_pos_denormal
; CHECK-SAME: () #[[ATTR11:[0-9]+]] { ; CHECK-SAME: () #[[ATTR11:[0-9]+]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(all) float @llvm.canonicalize.f32(float noundef 0x36A0000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf nzero sub norm) float @llvm.canonicalize.f32(float noundef 0x36A0000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0x36A0000000000000) %call = call float @llvm.canonicalize.f32(float 0x36A0000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_dapz_constant_neg_denormal() "denormal-fp-math"="positive-zero,positive-zero" { define float @ret_canonicalize_dapz_constant_neg_denormal() "denormal-fp-math"="positive-zero,positive-zero" {
; CHECK-LABEL: define noundef nofpclass(all) float @ret_canonicalize_dapz_constant_neg_denormal ; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) float @ret_canonicalize_dapz_constant_neg_denormal
; CHECK-SAME: () #[[ATTR11]] { ; CHECK-SAME: () #[[ATTR11]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(all) float @llvm.canonicalize.f32(float noundef 0xB6A0000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf nzero sub norm) float @llvm.canonicalize.f32(float noundef 0xB6A0000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0xb6A0000000000000) %call = call float @llvm.canonicalize.f32(float 0xb6A0000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_dapz_constant_pos_zero() "denormal-fp-math"="positive-zero,positive-zero" { define float @ret_canonicalize_dapz_constant_pos_zero() "denormal-fp-math"="positive-zero,positive-zero" {
; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) float @ret_canonicalize_dapz_constant_pos_zero ; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) float @ret_canonicalize_dapz_constant_pos_zero
; CHECK-SAME: () #[[ATTR11]] { ; CHECK-SAME: () #[[ATTR11]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf nzero sub norm) float @llvm.canonicalize.f32(float noundef 0.000000e+00) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf nzero sub norm) float @llvm.canonicalize.f32(float noundef 0.000000e+00) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0.0) %call = call float @llvm.canonicalize.f32(float 0.0)
ret float %call ret float %call
} }
define float @ret_canonicalize_dapz_constant_neg_zero() "denormal-fp-math"="positive-zero,positive-zero" { define float @ret_canonicalize_dapz_constant_neg_zero() "denormal-fp-math"="positive-zero,positive-zero" {
; CHECK-LABEL: define noundef nofpclass(all) float @ret_canonicalize_dapz_constant_neg_zero ; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) float @ret_canonicalize_dapz_constant_neg_zero
; CHECK-SAME: () #[[ATTR11]] { ; CHECK-SAME: () #[[ATTR11]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(all) float @llvm.canonicalize.f32(float noundef -0.000000e+00) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf nzero sub norm) float @llvm.canonicalize.f32(float noundef -0.000000e+00) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float -0.0) %call = call float @llvm.canonicalize.f32(float -0.0)
ret float %call ret float %call
} }
define float @ret_canonicalize_dapz_constant_pos_normal() "denormal-fp-math"="positive-zero,positive-zero" { define float @ret_canonicalize_dapz_constant_pos_normal() "denormal-fp-math"="positive-zero,positive-zero" {
; CHECK-LABEL: define noundef nofpclass(nan inf zero sub nnorm) float @ret_canonicalize_dapz_constant_pos_normal ; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub nnorm) float @ret_canonicalize_dapz_constant_pos_normal
; CHECK-SAME: () #[[ATTR11]] { ; CHECK-SAME: () #[[ATTR11]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf zero sub nnorm) float @llvm.canonicalize.f32(float noundef 8.000000e+00) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf nzero sub nnorm) float @llvm.canonicalize.f32(float noundef 8.000000e+00) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 8.0) %call = call float @llvm.canonicalize.f32(float 8.0)
ret float %call ret float %call
} }
define float @ret_canonicalize_dapz_constant_neg_normal() "denormal-fp-math"="positive-zero,positive-zero" { define float @ret_canonicalize_dapz_constant_neg_normal() "denormal-fp-math"="positive-zero,positive-zero" {
; CHECK-LABEL: define noundef nofpclass(nan inf zero sub pnorm) float @ret_canonicalize_dapz_constant_neg_normal ; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub pnorm) float @ret_canonicalize_dapz_constant_neg_normal
; CHECK-SAME: () #[[ATTR11]] { ; CHECK-SAME: () #[[ATTR11]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf zero sub pnorm) float @llvm.canonicalize.f32(float noundef -8.000000e+00) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf nzero sub pnorm) float @llvm.canonicalize.f32(float noundef -8.000000e+00) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float -8.0) %call = call float @llvm.canonicalize.f32(float -8.0)
ret float %call ret float %call
} }
define float @ret_canonicalize_dapz_constant_pos_inf() "denormal-fp-math"="positive-zero,positive-zero" { define float @ret_canonicalize_dapz_constant_pos_inf() "denormal-fp-math"="positive-zero,positive-zero" {
; CHECK-LABEL: define noundef nofpclass(nan ninf zero sub norm) float @ret_canonicalize_dapz_constant_pos_inf ; CHECK-LABEL: define noundef nofpclass(nan ninf nzero sub norm) float @ret_canonicalize_dapz_constant_pos_inf
; CHECK-SAME: () #[[ATTR11]] { ; CHECK-SAME: () #[[ATTR11]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan ninf zero sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF0000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan ninf nzero sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF0000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0x7FF0000000000000) %call = call float @llvm.canonicalize.f32(float 0x7FF0000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_dapz_constant_neg_inf() "denormal-fp-math"="positive-zero,positive-zero" { define float @ret_canonicalize_dapz_constant_neg_inf() "denormal-fp-math"="positive-zero,positive-zero" {
; CHECK-LABEL: define noundef nofpclass(nan pinf zero sub norm) float @ret_canonicalize_dapz_constant_neg_inf ; CHECK-LABEL: define noundef nofpclass(nan pinf nzero sub norm) float @ret_canonicalize_dapz_constant_neg_inf
; CHECK-SAME: () #[[ATTR11]] { ; CHECK-SAME: () #[[ATTR11]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan pinf zero sub norm) float @llvm.canonicalize.f32(float noundef 0xFFF0000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan pinf nzero sub norm) float @llvm.canonicalize.f32(float noundef 0xFFF0000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0xFFF0000000000000) %call = call float @llvm.canonicalize.f32(float 0xFFF0000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_dapz_constant_qnan() "denormal-fp-math"="positive-zero,positive-zero" { define float @ret_canonicalize_dapz_constant_qnan() "denormal-fp-math"="positive-zero,positive-zero" {
; CHECK-LABEL: define noundef nofpclass(snan inf zero sub norm) float @ret_canonicalize_dapz_constant_qnan ; CHECK-LABEL: define noundef nofpclass(snan inf nzero sub norm) float @ret_canonicalize_dapz_constant_qnan
; CHECK-SAME: () #[[ATTR11]] { ; CHECK-SAME: () #[[ATTR11]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(snan inf zero sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF8000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(snan inf nzero sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF8000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0x7FF8000000000000) %call = call float @llvm.canonicalize.f32(float 0x7FF8000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_dapz_constant_snan() "denormal-fp-math"="positive-zero,positive-zero" { define float @ret_canonicalize_dapz_constant_snan() "denormal-fp-math"="positive-zero,positive-zero" {
; CHECK-LABEL: define noundef nofpclass(all) float @ret_canonicalize_dapz_constant_snan ; CHECK-LABEL: define noundef nofpclass(snan inf nzero sub norm) float @ret_canonicalize_dapz_constant_snan
; CHECK-SAME: () #[[ATTR11]] { ; CHECK-SAME: () #[[ATTR11]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(all) float @llvm.canonicalize.f32(float noundef 0x7FF1000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(snan inf nzero sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF1000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0x7FF1000000000000) %call = call float @llvm.canonicalize.f32(float 0x7FF1000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_dynamic_constant_pos_denormal() "denormal-fp-math"="dynamic,dynamic" { define float @ret_canonicalize_dynamic_constant_pos_denormal() "denormal-fp-math"="dynamic,dynamic" {
; CHECK-LABEL: define noundef nofpclass(nan inf zero nsub norm) float @ret_canonicalize_dynamic_constant_pos_denormal ; CHECK-LABEL: define noundef nofpclass(nan inf nsub norm) float @ret_canonicalize_dynamic_constant_pos_denormal
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf zero nsub norm) float @llvm.canonicalize.f32(float noundef 0x36A0000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf nsub norm) float @llvm.canonicalize.f32(float noundef 0x36A0000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0x36A0000000000000) %call = call float @llvm.canonicalize.f32(float 0x36A0000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_dynamic_constant_neg_denormal() "denormal-fp-math"="dynamic,dynamic" { define float @ret_canonicalize_dynamic_constant_neg_denormal() "denormal-fp-math"="dynamic,dynamic" {
; CHECK-LABEL: define noundef nofpclass(nan inf zero psub norm) float @ret_canonicalize_dynamic_constant_neg_denormal ; CHECK-LABEL: define noundef nofpclass(nan inf psub norm) float @ret_canonicalize_dynamic_constant_neg_denormal
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf zero psub norm) float @llvm.canonicalize.f32(float noundef 0xB6A0000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf psub norm) float @llvm.canonicalize.f32(float noundef 0xB6A0000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0xb6A0000000000000) %call = call float @llvm.canonicalize.f32(float 0xb6A0000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_dynamic_constant_pos_zero() "denormal-fp-math"="dynamic,dynamic" { define float @ret_canonicalize_dynamic_constant_pos_zero() "denormal-fp-math"="dynamic,dynamic" {
; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) float @ret_canonicalize_dynamic_constant_pos_zero ; CHECK-LABEL: define noundef nofpclass(nan inf sub norm) float @ret_canonicalize_dynamic_constant_pos_zero
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf nzero sub norm) float @llvm.canonicalize.f32(float noundef 0.000000e+00) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf sub norm) float @llvm.canonicalize.f32(float noundef 0.000000e+00) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0.0) %call = call float @llvm.canonicalize.f32(float 0.0)
ret float %call ret float %call
} }
define float @ret_canonicalize_dynamic_constant_neg_zero() "denormal-fp-math"="dynamic,dynamic" { define float @ret_canonicalize_dynamic_constant_neg_zero() "denormal-fp-math"="dynamic,dynamic" {
; CHECK-LABEL: define noundef nofpclass(nan inf pzero sub norm) float @ret_canonicalize_dynamic_constant_neg_zero ; CHECK-LABEL: define noundef nofpclass(nan inf sub norm) float @ret_canonicalize_dynamic_constant_neg_zero
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf pzero sub norm) float @llvm.canonicalize.f32(float noundef -0.000000e+00) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf sub norm) float @llvm.canonicalize.f32(float noundef -0.000000e+00) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float -0.0) %call = call float @llvm.canonicalize.f32(float -0.0)
ret float %call ret float %call
} }
define float @ret_canonicalize_dynamic_constant_pos_normal() "denormal-fp-math"="dynamic,dynamic" { define float @ret_canonicalize_dynamic_constant_pos_normal() "denormal-fp-math"="dynamic,dynamic" {
; CHECK-LABEL: define noundef nofpclass(nan inf zero sub nnorm) float @ret_canonicalize_dynamic_constant_pos_normal ; CHECK-LABEL: define noundef nofpclass(nan inf sub nnorm) float @ret_canonicalize_dynamic_constant_pos_normal
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf zero sub nnorm) float @llvm.canonicalize.f32(float noundef 8.000000e+00) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf sub nnorm) float @llvm.canonicalize.f32(float noundef 8.000000e+00) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 8.0) %call = call float @llvm.canonicalize.f32(float 8.0)
ret float %call ret float %call
} }
define float @ret_canonicalize_dynamic_constant_neg_normal() "denormal-fp-math"="dynamic,dynamic" { define float @ret_canonicalize_dynamic_constant_neg_normal() "denormal-fp-math"="dynamic,dynamic" {
; CHECK-LABEL: define noundef nofpclass(nan inf zero sub pnorm) float @ret_canonicalize_dynamic_constant_neg_normal ; CHECK-LABEL: define noundef nofpclass(nan inf sub pnorm) float @ret_canonicalize_dynamic_constant_neg_normal
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf zero sub pnorm) float @llvm.canonicalize.f32(float noundef -8.000000e+00) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan inf sub pnorm) float @llvm.canonicalize.f32(float noundef -8.000000e+00) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float -8.0) %call = call float @llvm.canonicalize.f32(float -8.0)
ret float %call ret float %call
} }
define float @ret_canonicalize_dynamic_constant_pos_inf() "denormal-fp-math"="dynamic,dynamic" { define float @ret_canonicalize_dynamic_constant_pos_inf() "denormal-fp-math"="dynamic,dynamic" {
; CHECK-LABEL: define noundef nofpclass(nan ninf zero sub norm) float @ret_canonicalize_dynamic_constant_pos_inf ; CHECK-LABEL: define noundef nofpclass(nan ninf sub norm) float @ret_canonicalize_dynamic_constant_pos_inf
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan ninf zero sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF0000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan ninf sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF0000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0x7FF0000000000000) %call = call float @llvm.canonicalize.f32(float 0x7FF0000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_dynamic_constant_neg_inf() "denormal-fp-math"="dynamic,dynamic" { define float @ret_canonicalize_dynamic_constant_neg_inf() "denormal-fp-math"="dynamic,dynamic" {
; CHECK-LABEL: define noundef nofpclass(nan pinf zero sub norm) float @ret_canonicalize_dynamic_constant_neg_inf ; CHECK-LABEL: define noundef nofpclass(nan pinf sub norm) float @ret_canonicalize_dynamic_constant_neg_inf
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan pinf zero sub norm) float @llvm.canonicalize.f32(float noundef 0xFFF0000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(nan pinf sub norm) float @llvm.canonicalize.f32(float noundef 0xFFF0000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0xFFF0000000000000) %call = call float @llvm.canonicalize.f32(float 0xFFF0000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_dynamic_constant_qnan() "denormal-fp-math"="dynamic,dynamic" { define float @ret_canonicalize_dynamic_constant_qnan() "denormal-fp-math"="dynamic,dynamic" {
; CHECK-LABEL: define noundef nofpclass(snan inf zero sub norm) float @ret_canonicalize_dynamic_constant_qnan ; CHECK-LABEL: define noundef nofpclass(snan inf sub norm) float @ret_canonicalize_dynamic_constant_qnan
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(snan inf zero sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF8000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(snan inf sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF8000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0x7FF8000000000000) %call = call float @llvm.canonicalize.f32(float 0x7FF8000000000000)
ret float %call ret float %call
} }
define float @ret_canonicalize_dynamic_constant_snan() "denormal-fp-math"="dynamic,dynamic" { define float @ret_canonicalize_dynamic_constant_snan() "denormal-fp-math"="dynamic,dynamic" {
; CHECK-LABEL: define noundef nofpclass(all) float @ret_canonicalize_dynamic_constant_snan ; CHECK-LABEL: define noundef nofpclass(snan inf sub norm) float @ret_canonicalize_dynamic_constant_snan
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(all) float @llvm.canonicalize.f32(float noundef 0x7FF1000000000000) #[[ATTR12]] ; CHECK-NEXT: [[CALL:%.*]] = call noundef nofpclass(snan inf sub norm) float @llvm.canonicalize.f32(float noundef 0x7FF1000000000000) #[[ATTR12]]
; CHECK-NEXT: ret float [[CALL]] ; CHECK-NEXT: ret float [[CALL]]
; ;
%call = call float @llvm.canonicalize.f32(float 0x7FF1000000000000) %call = call float @llvm.canonicalize.f32(float 0x7FF1000000000000)
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: {{.*}}