[llvm-branch-commits] [llvm] InstCombine: Handle minimumnum/maximumnum in SimplifyDemandedFPClass (PR #173977)
Matt Arsenault via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Mon Jan 5 02:04:54 PST 2026
https://github.com/arsenm updated https://github.com/llvm/llvm-project/pull/173977
>From f8ecc3ccd2bb1bdbdcbe996d2151fa4dfb27bd69 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Mon, 29 Dec 2025 23:33:55 +0100
Subject: [PATCH] InstCombine: Handle minimumnum/maximumnum in
SimplifyDemandedFPClass
---
.../InstCombineSimplifyDemanded.cpp | 76 ++++++++++++---
.../simplify-demanded-fpclass-maximumnum.ll | 91 +++++++----------
.../simplify-demanded-fpclass-minimumnum.ll | 97 +++++++------------
3 files changed, 136 insertions(+), 128 deletions(-)
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
index f6b70e6d00a2a..98e4aa8aa8e19 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
@@ -2254,26 +2254,35 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Value *V,
break;
}
case Intrinsic::maximum:
- case Intrinsic::minimum: {
- KnownFPClass KnownLHS, KnownRHS;
+ case Intrinsic::minimum:
+ case Intrinsic::maximumnum:
+ case Intrinsic::minimumnum: {
+ const bool PropagateNaN =
+ IID == Intrinsic::maximum || IID == Intrinsic::minimum;
// We can't tell much based on the demanded result without inspecting the
// operands (e.g., a known-positive result could have been clamped), but
// we can still prune known-nan inputs.
- FPClassTest SrcDemandedMask = DemandedMask | ~fcNan;
+ FPClassTest SrcDemandedMask =
+ PropagateNaN ? DemandedMask | ~fcNan : fcAllFlags;
+ KnownFPClass KnownLHS, KnownRHS;
if (SimplifyDemandedFPClass(CI, 1, SrcDemandedMask, KnownRHS,
Depth + 1) ||
SimplifyDemandedFPClass(CI, 0, SrcDemandedMask, KnownLHS, Depth + 1))
return I;
/// Propagate nnan-ness to simplify edge case checks.
- if ((DemandedMask & fcNan) == fcNone) {
+ if (PropagateNaN && (DemandedMask & fcNan) == fcNone) {
KnownLHS.knownNot(fcNan);
KnownRHS.knownNot(fcNan);
}
+ KnownFPClass::MinMaxKind OpKind;
+
if (IID == Intrinsic::maximum) {
+ OpKind = KnownFPClass::MinMaxKind::maximum;
+
// If at least one operand is known to be positive and the other
// negative, the result must be the positive (unless the other operand
// may be propagating a nan).
@@ -2293,7 +2302,9 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Value *V,
if (KnownRHS.isKnownAlways(fcPosInf | fcNan) &&
KnownLHS.isKnownNever(fcNan))
return CI->getArgOperand(1);
- } else {
+ } else if (IID == Intrinsic::minimum) {
+ OpKind = KnownFPClass::MinMaxKind::minimum;
+
// If one operand is known to be negative, and the other positive, the
// result must be the negative (unless the other operand may be
// propagating a nan).
@@ -2313,15 +2324,54 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Value *V,
if (KnownRHS.isKnownAlways(fcNegInf | fcNan) &&
KnownLHS.isKnownNever(fcNan))
return CI->getArgOperand(1);
- }
+ } else if (IID == Intrinsic::maximumnum) {
+ OpKind = KnownFPClass::MinMaxKind::maximumnum;
+
+ // If at least one operand is known to be positive and the other
+ // negative, the result must be the positive.
+ if (KnownLHS.isKnownNever(fcNegative | fcNan) &&
+ KnownRHS.isKnownNever(fcPositive))
+ return CI->getArgOperand(0);
+
+ if (KnownRHS.isKnownNever(fcNegative | fcNan) &&
+ KnownLHS.isKnownNever(fcPositive))
+ return CI->getArgOperand(1);
+
+ // If one value must be ninf or nan, the other value must be returned
+ if (KnownLHS.isKnownAlways(fcNegInf | fcNan) &&
+ KnownRHS.isKnownNever(fcNan))
+ return CI->getArgOperand(1);
+
+ if (KnownRHS.isKnownAlways(fcNegInf | fcNan) &&
+ KnownLHS.isKnownNever(fcNan))
+ return CI->getArgOperand(0);
+ } else if (IID == Intrinsic::minimumnum) {
+ OpKind = KnownFPClass::MinMaxKind::minimumnum;
+
+ // If at least one operand is known to be negative and the other
+ // positive, the result must be the negative
+ if (KnownLHS.isKnownNever(fcPositive | fcNan) &&
+ KnownRHS.isKnownNever(fcNegative))
+ return CI->getArgOperand(0);
+
+ if (KnownRHS.isKnownNever(fcPositive | fcNan) &&
+ KnownLHS.isKnownNever(fcNegative))
+ return CI->getArgOperand(1);
+
+ // If one value must be pinf or nan, the other value must be returned
+ if (KnownLHS.isKnownAlways(fcPosInf | fcNan) &&
+ KnownRHS.isKnownNever(fcNan))
+ return CI->getArgOperand(1);
+
+ if (KnownRHS.isKnownAlways(fcPosInf | fcNan) &&
+ KnownLHS.isKnownNever(fcNan))
+ return CI->getArgOperand(0);
+ } else
+ llvm_unreachable("not a min/max intrinsic");
Type *EltTy = VTy->getScalarType();
DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
- Known = KnownFPClass::minMaxLike(KnownLHS, KnownRHS,
- IID == Intrinsic::maximum
- ? KnownFPClass::MinMaxKind::maximum
- : KnownFPClass::MinMaxKind::minimum,
- Mode);
+ Known = KnownFPClass::minMaxLike(KnownLHS, KnownRHS, OpKind, Mode);
FPClassTest ValidResults = DemandedMask & Known.KnownFPClasses;
@@ -2335,7 +2385,9 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Value *V,
// TODO: Add NSZ flag if we know the result will not be sensitive on the
// sign of 0.
- if (!FPOp->hasNoNaNs() && (ValidResults & fcNan) == fcNone) {
+ if (!FPOp->hasNoNaNs() &&
+ ((PropagateNaN && (ValidResults & fcNan) == fcNone) ||
+ (KnownLHS.isKnownNeverNaN() && KnownRHS.isKnownNeverNaN()))) {
CI->removeRetAttr(Attribute::NoUndef);
CI->setHasNoNaNs(true);
ChangedFlags = true;
diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll
index b8bef8e840145..b94bd3085a405 100644
--- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll
+++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll
@@ -34,8 +34,7 @@ declare nofpclass(norm sub zero) float @returns_inf_or_nan()
define nofpclass(inf norm sub zero) float @ret_only_nan(float %x, float %y) {
; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_only_nan(
; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[X]], float [[Y]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF8000000000000
;
%result = call float @llvm.maximumnum.f32(float %x, float %y)
ret float %result
@@ -152,8 +151,7 @@ define nofpclass(ninf nnorm nsub nzero) float @ret_known_positive_or_nan__maximu
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_known_positive_or_nan__maximumnum__negative_or_nan___negative_or_nan() {
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN0:%.*]] = call float @returns_negative_or_nan()
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN1:%.*]] = call float @returns_negative_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_NEGATIVE_OR_NAN0]], float [[MUST_BE_NEGATIVE_OR_NAN1]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF8000000000000
;
%must.be.negative.or.nan0 = call float @returns_negative_or_nan()
%must.be.negative.or.nan1 = call float @returns_negative_or_nan()
@@ -166,8 +164,7 @@ define nofpclass(pinf pnorm psub pzero) float @ret_known_negative_or_nan__maximu
; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @ret_known_negative_or_nan__maximumnum__positive_or_nan___positive_or_nan() {
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN0:%.*]] = call float @returns_positive_or_nan()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN1:%.*]] = call float @returns_positive_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_POSITIVE_OR_NAN0]], float [[MUST_BE_POSITIVE_OR_NAN1]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF8000000000000
;
%must.be.positive.or.nan0 = call float @returns_positive_or_nan()
%must.be.positive.or.nan1 = call float @returns_positive_or_nan()
@@ -352,7 +349,7 @@ define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_0()
; CHECK-LABEL: define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_0() {
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]])
; CHECK-NEXT: ret float [[RESULT]]
;
%must.be.negative.or.zero = call float @returns_positive_or_zero()
@@ -366,7 +363,7 @@ define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_1()
; CHECK-LABEL: define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_1() {
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]])
; CHECK-NEXT: ret float [[RESULT]]
;
%must.be.negative.or.zero = call float @returns_positive_or_zero()
@@ -398,8 +395,7 @@ define nofpclass(nsub) float @rhs_must_be_pinf_or_nan(float nofpclass(ninf norm
define nofpclass(nsub) float @lhs_must_be_pinf(float %unknown, float nofpclass(nan ninf norm zero sub) %must.be.pinf) {
; CHECK-LABEL: define nofpclass(nsub) float @lhs_must_be_pinf(
; CHECK-SAME: float [[UNKNOWN:%.*]], float nofpclass(nan ninf zero sub norm) [[MUST_BE_PINF:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_PINF]], float [[UNKNOWN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%result = call float @llvm.maximumnum.f32(float %must.be.pinf, float %unknown)
ret float %result
@@ -408,8 +404,7 @@ define nofpclass(nsub) float @lhs_must_be_pinf(float %unknown, float nofpclass(n
define nofpclass(nsub) float @rhs_must_be_pinf(float nofpclass(nan ninf norm zero sub) %must.be.pinf, float %unknown) {
; CHECK-LABEL: define nofpclass(nsub) float @rhs_must_be_pinf(
; CHECK-SAME: float nofpclass(nan ninf zero sub norm) [[MUST_BE_PINF:%.*]], float [[UNKNOWN:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[UNKNOWN]], float [[MUST_BE_PINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%result = call float @llvm.maximumnum.f32(float %unknown, float %must.be.pinf)
ret float %result
@@ -419,8 +414,7 @@ define nofpclass(nsub) float @rhs_must_be_pinf(float nofpclass(nan ninf norm zer
define nofpclass(nsub) float @lhs_must_be_pinf_rhs_non_nan(float nofpclass(nan) %not.nan, float nofpclass(nan ninf norm zero sub) %must.be.pinf) {
; CHECK-LABEL: define nofpclass(nsub) float @lhs_must_be_pinf_rhs_non_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]], float nofpclass(nan ninf zero sub norm) [[MUST_BE_PINF:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_PINF]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%result = call float @llvm.maximumnum.f32(float %must.be.pinf, float %not.nan)
ret float %result
@@ -430,8 +424,7 @@ define nofpclass(nsub) float @lhs_must_be_pinf_rhs_non_nan(float nofpclass(nan)
define nofpclass(nsub) float @rhs_must_be_pinf_lhs_non_nan(float nofpclass(nan ninf norm zero sub) %must.be.pinf, float nofpclass(nan) %not.nan) {
; CHECK-LABEL: define nofpclass(nsub) float @rhs_must_be_pinf_lhs_non_nan(
; CHECK-SAME: float nofpclass(nan ninf zero sub norm) [[MUST_BE_PINF:%.*]], float nofpclass(nan) [[NOT_NAN:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NOT_NAN]], float [[MUST_BE_PINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%result = call float @llvm.maximumnum.f32(float %not.nan, float %must.be.pinf)
ret float %result
@@ -460,7 +453,7 @@ define nofpclass(nsub) float @rhs_must_be_ninf_or_nan(float nofpclass(pinf norm
define nofpclass(nsub) float @lhs_must_be_ninf(float %unknown, float nofpclass(nan pinf norm zero sub) %must.be.ninf) {
; CHECK-LABEL: define nofpclass(nsub) float @lhs_must_be_ninf(
; CHECK-SAME: float [[UNKNOWN:%.*]], float nofpclass(nan pinf zero sub norm) [[MUST_BE_NINF:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_NINF]], float [[UNKNOWN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[UNKNOWN]], float 0xFFF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximumnum.f32(float %must.be.ninf, float %unknown)
@@ -470,7 +463,7 @@ define nofpclass(nsub) float @lhs_must_be_ninf(float %unknown, float nofpclass(n
define nofpclass(nsub) float @rhs_must_be_ninf(float nofpclass(nan pinf norm zero sub) %must.be.ninf, float %unknown) {
; CHECK-LABEL: define nofpclass(nsub) float @rhs_must_be_ninf(
; CHECK-SAME: float nofpclass(nan pinf zero sub norm) [[MUST_BE_NINF:%.*]], float [[UNKNOWN:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[UNKNOWN]], float [[MUST_BE_NINF]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[UNKNOWN]], float 0xFFF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximumnum.f32(float %unknown, float %must.be.ninf)
@@ -482,8 +475,7 @@ define nofpclass(nsub) float @rhs_must_be_ninf(float nofpclass(nan pinf norm zer
define nofpclass(nsub) float @lhs_must_be_ninf_rhs_non_nan(float nofpclass(nan) %not.nan, float nofpclass(nan pinf norm zero sub) %must.be.ninf) {
; CHECK-LABEL: define nofpclass(nsub) float @lhs_must_be_ninf_rhs_non_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]], float nofpclass(nan pinf zero sub norm) [[MUST_BE_NINF:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_NINF]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%result = call float @llvm.maximumnum.f32(float %must.be.ninf, float %not.nan)
ret float %result
@@ -493,8 +485,7 @@ define nofpclass(nsub) float @lhs_must_be_ninf_rhs_non_nan(float nofpclass(nan)
define nofpclass(nsub) float @rhs_must_be_ninf_lhs_non_nan(float nofpclass(nan pinf norm zero sub) %must.be.ninf, float nofpclass(nan) %not.nan) {
; CHECK-LABEL: define nofpclass(nsub) float @rhs_must_be_ninf_lhs_non_nan(
; CHECK-SAME: float nofpclass(nan pinf zero sub norm) [[MUST_BE_NINF:%.*]], float nofpclass(nan) [[NOT_NAN:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NOT_NAN]], float [[MUST_BE_NINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%result = call float @llvm.maximumnum.f32(float %not.nan, float %must.be.ninf)
ret float %result
@@ -803,7 +794,7 @@ define nofpclass(snan) float @unknown__maximumnum__not_nan(float %x, float nofpc
define nofpclass(snan) float @not_nan__maximumnum__not_nan(float nofpclass(nan) %x, float nofpclass(nan) %y) {
; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximumnum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[X:%.*]], float nofpclass(nan) [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximumnum.f32(float %x, float %y)
@@ -834,7 +825,7 @@ define nofpclass(snan) float @known_positive__maximumnum__only_zero() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximumnum__only_zero() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_ZERO]])
; CHECK-NEXT: ret float [[RESULT]]
;
%known.positive = call float @returns_positive()
@@ -847,7 +838,7 @@ define nofpclass(snan) float @only_zero__maximumnum__known_positive() {
; CHECK-LABEL: define nofpclass(snan) float @only_zero__maximumnum__known_positive() {
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE]])
; CHECK-NEXT: ret float [[RESULT]]
;
%known.zero = call float @returns_zero()
@@ -912,8 +903,7 @@ define nofpclass(snan) float @known_positive__maximumnum__only_nzero() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximumnum__only_nzero() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_NZERO:%.*]] = call float @returns_nzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_NZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.positive = call float @returns_positive()
%known.nzero = call float @returns_nzero()
@@ -925,8 +915,7 @@ define nofpclass(snan) float @only_nzero__maximumnum__known_positive() {
; CHECK-LABEL: define nofpclass(snan) float @only_nzero__maximumnum__known_positive() {
; CHECK-NEXT: [[KNOWN_NZERO:%.*]] = call float @returns_nzero()
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_NZERO]], float [[KNOWN_POSITIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.nzero = call float @returns_nzero()
%known.positive = call float @returns_positive()
@@ -938,7 +927,7 @@ define nofpclass(snan) float @known_positive__maximumnum__only_pzero() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximumnum__only_pzero() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_PZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float 0.000000e+00)
; CHECK-NEXT: ret float [[RESULT]]
;
%known.positive = call float @returns_positive()
@@ -951,7 +940,7 @@ define nofpclass(snan) float @only_pzero__maximumnum__known_positive() {
; CHECK-LABEL: define nofpclass(snan) float @only_pzero__maximumnum__known_positive() {
; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero()
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_PZERO]], float [[KNOWN_POSITIVE]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float 0.000000e+00)
; CHECK-NEXT: ret float [[RESULT]]
;
%known.pzero = call float @returns_pzero()
@@ -1259,8 +1248,7 @@ define nofpclass(snan) float @known_always_positive__maximumnum__known_always_ne
; CHECK-LABEL: define nofpclass(snan) float @known_always_positive__maximumnum__known_always_negative_or_nan() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_NEGATIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.positive = call float @returns_positive()
%known.negative.or.nan = call float @returns_negative_or_nan()
@@ -1272,8 +1260,7 @@ define nofpclass(snan) float @known_always_negative_or_nan__maximumnum__known_al
; CHECK-LABEL: define nofpclass(snan) float @known_always_negative_or_nan__maximumnum__known_always_positive() {
; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_NEGATIVE_OR_NAN]], float [[KNOWN_POSITIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.negative.or.nan = call float @returns_negative_or_nan()
%known.positive = call float @returns_positive()
@@ -1337,8 +1324,7 @@ define nofpclass(snan) float @pinf__maximumnum__unknown(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @pinf__maximumnum__unknown(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[PINF]], float [[UNKNOWN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%pinf = call float @returns_pinf()
%result = call float @llvm.maximumnum.f32(float %pinf, float %unknown)
@@ -1349,8 +1335,7 @@ define nofpclass(snan) float @unknown__maximumnum__pinf(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @unknown__maximumnum__pinf(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[UNKNOWN]], float [[PINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%pinf = call float @returns_pinf()
%result = call float @llvm.maximumnum.f32(float %unknown, float %pinf)
@@ -1385,7 +1370,7 @@ define nofpclass(snan) float @ninf__maximumnum__unknown(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @ninf__maximumnum__unknown(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NINF]], float [[UNKNOWN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[UNKNOWN]], float 0xFFF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%ninf = call float @returns_ninf()
@@ -1397,7 +1382,7 @@ define nofpclass(snan) float @unknown__maximumnum__ninf(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @unknown__maximumnum__ninf(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[UNKNOWN]], float [[NINF]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[UNKNOWN]], float 0xFFF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%ninf = call float @returns_ninf()
@@ -1481,8 +1466,7 @@ define nofpclass(snan) float @ninf_or_nan__maximumnum__not_nan(float nofpclass(n
; CHECK-LABEL: define nofpclass(snan) float @ninf_or_nan__maximumnum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NINF_OR_NAN]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%ninf.or.nan = call float @returns_ninf_or_nan()
%result = call float @llvm.maximumnum.f32(float %ninf.or.nan, float %not.nan)
@@ -1493,8 +1477,7 @@ define nofpclass(snan) float @not_nan__maximumnum__ninf_or_nan(float nofpclass(n
; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximumnum__ninf_or_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NOT_NAN]], float [[NINF_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%ninf.or.nan = call float @returns_ninf_or_nan()
%result = call float @llvm.maximumnum.f32(float %not.nan, float %ninf.or.nan)
@@ -1553,8 +1536,7 @@ define nofpclass(snan) float @ninf__maximumnum__not_nan(float nofpclass(nan) %no
; CHECK-LABEL: define nofpclass(snan) float @ninf__maximumnum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NINF_OR_NAN]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%ninf.or.nan = call float @returns_ninf()
%result = call float @llvm.maximumnum.f32(float %ninf.or.nan, float %not.nan)
@@ -1565,8 +1547,7 @@ define nofpclass(snan) float @not_nan__maximumnum__ninf(float nofpclass(nan) %no
; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximumnum__ninf(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NOT_NAN]], float [[NINF_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%ninf.or.nan = call float @returns_ninf()
%result = call float @llvm.maximumnum.f32(float %not.nan, float %ninf.or.nan)
@@ -1577,8 +1558,7 @@ define nofpclass(snan) float @pinf__maximumnum__not_nan(float nofpclass(nan) %no
; CHECK-LABEL: define nofpclass(snan) float @pinf__maximumnum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[PINF_OR_NAN]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%pinf.or.nan = call float @returns_pinf()
%result = call float @llvm.maximumnum.f32(float %pinf.or.nan, float %not.nan)
@@ -1589,8 +1569,7 @@ define nofpclass(snan) float @not_nan__maximumnum__pinf(float nofpclass(nan) %no
; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximumnum__pinf(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NOT_NAN]], float [[PINF_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%pinf.or.nan = call float @returns_pinf()
%result = call float @llvm.maximumnum.f32(float %not.nan, float %pinf.or.nan)
@@ -1601,7 +1580,7 @@ define nofpclass(snan) float @inf__maximumnum__not_nan(float nofpclass(nan) %not
; CHECK-LABEL: define nofpclass(snan) float @inf__maximumnum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call float @returns_inf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[INF_OR_NAN]], float [[NOT_NAN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[INF_OR_NAN]], float [[NOT_NAN]])
; CHECK-NEXT: ret float [[RESULT]]
;
%inf.or.nan = call float @returns_inf()
@@ -1613,7 +1592,7 @@ define nofpclass(snan) float @not_nan__maximumnum__inf(float nofpclass(nan) %not
; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximumnum__inf(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call float @returns_inf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NOT_NAN]], float [[INF_OR_NAN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[NOT_NAN]], float [[INF_OR_NAN]])
; CHECK-NEXT: ret float [[RESULT]]
;
%inf.or.nan = call float @returns_inf()
@@ -1654,7 +1633,7 @@ define nofpclass(snan) float @unknown__noundef_maximumnum__not_nan(float %unknow
define nofpclass(snan) float @not_nan__noundef_maximumnum__not_nan(float nofpclass(nan) %not.nan0, float nofpclass(nan) %not.nan1) {
; CHECK-LABEL: define nofpclass(snan) float @not_nan__noundef_maximumnum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN0:%.*]], float nofpclass(nan) [[NOT_NAN1:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call noundef float @llvm.maximumnum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call noundef float @llvm.maximumnum.f32(float %not.nan0, float %not.nan1)
diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll
index 6f6b68b8e973c..125c88542bddd 100644
--- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll
+++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll
@@ -34,8 +34,7 @@ declare nofpclass(norm sub zero) float @returns_inf_or_nan()
define nofpclass(inf norm sub zero) float @ret_only_nan(float %x, float %y) {
; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_only_nan(
; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[X]], float [[Y]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF8000000000000
;
%result = call float @llvm.minimumnum.f32(float %x, float %y)
ret float %result
@@ -152,8 +151,7 @@ define nofpclass(ninf nnorm nsub nzero) float @ret_known_positive_or_nan__minimu
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_known_positive_or_nan__minimumnum__negative_or_nan___negative_or_nan() {
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN0:%.*]] = call float @returns_negative_or_nan()
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN1:%.*]] = call float @returns_negative_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[MUST_BE_NEGATIVE_OR_NAN0]], float [[MUST_BE_NEGATIVE_OR_NAN1]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF8000000000000
;
%must.be.negative.or.nan0 = call float @returns_negative_or_nan()
%must.be.negative.or.nan1 = call float @returns_negative_or_nan()
@@ -166,8 +164,7 @@ define nofpclass(pinf pnorm psub pzero) float @ret_known_negative_or_nan__minimu
; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @ret_known_negative_or_nan__minimumnum__positive_or_nan___positive_or_nan() {
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN0:%.*]] = call float @returns_positive_or_nan()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN1:%.*]] = call float @returns_positive_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[MUST_BE_POSITIVE_OR_NAN0]], float [[MUST_BE_POSITIVE_OR_NAN1]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF8000000000000
;
%must.be.positive.or.nan0 = call float @returns_positive_or_nan()
%must.be.positive.or.nan1 = call float @returns_positive_or_nan()
@@ -205,8 +202,7 @@ define nofpclass(snan) float @known_positive_or_nan__minimumnum__known_negative(
; CHECK-LABEL: define nofpclass(snan) float @known_positive_or_nan__minimumnum__known_negative() {
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan()
; CHECK-NEXT: [[MUST_BE_NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[MUST_BE_POSITIVE_OR_NAN]], float [[MUST_BE_NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_NEGATIVE]]
;
%must.be.positive.or.nan = call float @returns_positive_or_nan()
%must.be.negative = call float @returns_negative()
@@ -218,8 +214,7 @@ define nofpclass(snan) float @known_negative__minimumnum__known_positive_or_nan(
; CHECK-LABEL: define nofpclass(snan) float @known_negative__minimumnum__known_positive_or_nan() {
; CHECK-NEXT: [[MUST_BE_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[MUST_BE_NEGATIVE]], float [[MUST_BE_POSITIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_NEGATIVE]]
;
%must.be.negative = call float @returns_negative()
%must.be.positive.or.nan = call float @returns_positive_or_nan()
@@ -352,7 +347,7 @@ define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_0()
; CHECK-LABEL: define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_0() {
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimumnum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]])
; CHECK-NEXT: ret float [[RESULT]]
;
%must.be.negative.or.zero = call float @returns_positive_or_zero()
@@ -366,7 +361,7 @@ define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_1()
; CHECK-LABEL: define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_1() {
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimumnum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]])
; CHECK-NEXT: ret float [[RESULT]]
;
%must.be.negative.or.zero = call float @returns_positive_or_zero()
@@ -398,7 +393,7 @@ define nofpclass(nsub) float @rhs_must_be_pinf_or_nan(float nofpclass(ninf norm
define nofpclass(nsub) float @lhs_must_be_pinf(float %unknown, float nofpclass(nan ninf norm zero sub) %must.be.pinf) {
; CHECK-LABEL: define nofpclass(nsub) float @lhs_must_be_pinf(
; CHECK-SAME: float [[UNKNOWN:%.*]], float nofpclass(nan ninf zero sub norm) [[MUST_BE_PINF:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[MUST_BE_PINF]], float [[UNKNOWN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[UNKNOWN]], float 0x7FF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.minimumnum.f32(float %must.be.pinf, float %unknown)
@@ -408,7 +403,7 @@ define nofpclass(nsub) float @lhs_must_be_pinf(float %unknown, float nofpclass(n
define nofpclass(nsub) float @rhs_must_be_pinf(float nofpclass(nan ninf norm zero sub) %must.be.pinf, float %unknown) {
; CHECK-LABEL: define nofpclass(nsub) float @rhs_must_be_pinf(
; CHECK-SAME: float nofpclass(nan ninf zero sub norm) [[MUST_BE_PINF:%.*]], float [[UNKNOWN:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[UNKNOWN]], float [[MUST_BE_PINF]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[UNKNOWN]], float 0x7FF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.minimumnum.f32(float %unknown, float %must.be.pinf)
@@ -419,8 +414,7 @@ define nofpclass(nsub) float @rhs_must_be_pinf(float nofpclass(nan ninf norm zer
define nofpclass(nsub) float @lhs_must_be_pinf_rhs_non_nan(float nofpclass(nan) %not.nan, float nofpclass(nan ninf norm zero sub) %must.be.pinf) {
; CHECK-LABEL: define nofpclass(nsub) float @lhs_must_be_pinf_rhs_non_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]], float nofpclass(nan ninf zero sub norm) [[MUST_BE_PINF:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[MUST_BE_PINF]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%result = call float @llvm.minimumnum.f32(float %must.be.pinf, float %not.nan)
ret float %result
@@ -430,8 +424,7 @@ define nofpclass(nsub) float @lhs_must_be_pinf_rhs_non_nan(float nofpclass(nan)
define nofpclass(nsub) float @rhs_must_be_pinf_lhs_non_nan(float nofpclass(nan ninf norm zero sub) %must.be.pinf, float nofpclass(nan) %not.nan) {
; CHECK-LABEL: define nofpclass(nsub) float @rhs_must_be_pinf_lhs_non_nan(
; CHECK-SAME: float nofpclass(nan ninf zero sub norm) [[MUST_BE_PINF:%.*]], float nofpclass(nan) [[NOT_NAN:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NOT_NAN]], float [[MUST_BE_PINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%result = call float @llvm.minimumnum.f32(float %not.nan, float %must.be.pinf)
ret float %result
@@ -460,8 +453,7 @@ define nofpclass(nsub) float @rhs_must_be_ninf_or_nan(float nofpclass(pinf norm
define nofpclass(nsub) float @lhs_must_be_ninf(float %unknown, float nofpclass(nan pinf norm zero sub) %must.be.ninf) {
; CHECK-LABEL: define nofpclass(nsub) float @lhs_must_be_ninf(
; CHECK-SAME: float [[UNKNOWN:%.*]], float nofpclass(nan pinf zero sub norm) [[MUST_BE_NINF:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[MUST_BE_NINF]], float [[UNKNOWN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%result = call float @llvm.minimumnum.f32(float %must.be.ninf, float %unknown)
ret float %result
@@ -470,8 +462,7 @@ define nofpclass(nsub) float @lhs_must_be_ninf(float %unknown, float nofpclass(n
define nofpclass(nsub) float @rhs_must_be_ninf(float nofpclass(nan pinf norm zero sub) %must.be.ninf, float %unknown) {
; CHECK-LABEL: define nofpclass(nsub) float @rhs_must_be_ninf(
; CHECK-SAME: float nofpclass(nan pinf zero sub norm) [[MUST_BE_NINF:%.*]], float [[UNKNOWN:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[UNKNOWN]], float [[MUST_BE_NINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%result = call float @llvm.minimumnum.f32(float %unknown, float %must.be.ninf)
ret float %result
@@ -482,8 +473,7 @@ define nofpclass(nsub) float @rhs_must_be_ninf(float nofpclass(nan pinf norm zer
define nofpclass(nsub) float @lhs_must_be_ninf_rhs_non_nan(float nofpclass(nan) %not.nan, float nofpclass(nan pinf norm zero sub) %must.be.ninf) {
; CHECK-LABEL: define nofpclass(nsub) float @lhs_must_be_ninf_rhs_non_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]], float nofpclass(nan pinf zero sub norm) [[MUST_BE_NINF:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[MUST_BE_NINF]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%result = call float @llvm.minimumnum.f32(float %must.be.ninf, float %not.nan)
ret float %result
@@ -493,8 +483,7 @@ define nofpclass(nsub) float @lhs_must_be_ninf_rhs_non_nan(float nofpclass(nan)
define nofpclass(nsub) float @rhs_must_be_ninf_lhs_non_nan(float nofpclass(nan pinf norm zero sub) %must.be.ninf, float nofpclass(nan) %not.nan) {
; CHECK-LABEL: define nofpclass(nsub) float @rhs_must_be_ninf_lhs_non_nan(
; CHECK-SAME: float nofpclass(nan pinf zero sub norm) [[MUST_BE_NINF:%.*]], float nofpclass(nan) [[NOT_NAN:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NOT_NAN]], float [[MUST_BE_NINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%result = call float @llvm.minimumnum.f32(float %not.nan, float %must.be.ninf)
ret float %result
@@ -803,7 +792,7 @@ define nofpclass(snan) float @unknown__minimumnum__not_nan(float %x, float nofpc
define nofpclass(snan) float @not_nan__minimumnum__not_nan(float nofpclass(nan) %x, float nofpclass(nan) %y) {
; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimumnum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[X:%.*]], float nofpclass(nan) [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimumnum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.minimumnum.f32(float %x, float %y)
@@ -834,7 +823,7 @@ define nofpclass(snan) float @known_positive__minimumnum__only_zero() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__minimumnum__only_zero() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimumnum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_ZERO]])
; CHECK-NEXT: ret float [[RESULT]]
;
%known.positive = call float @returns_positive()
@@ -847,7 +836,7 @@ define nofpclass(snan) float @only_zero__minimumnum__known_positive() {
; CHECK-LABEL: define nofpclass(snan) float @only_zero__minimumnum__known_positive() {
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimumnum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE]])
; CHECK-NEXT: ret float [[RESULT]]
;
%known.zero = call float @returns_zero()
@@ -1012,7 +1001,7 @@ define nofpclass(snan) float @known_negative__minimumnum__only_nzero() {
; CHECK-LABEL: define nofpclass(snan) float @known_negative__minimumnum__only_nzero() {
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[KNOWN_NZERO:%.*]] = call float @returns_nzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[KNOWN_NEGATIVE]], float [[KNOWN_NZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimumnum.f32(float [[KNOWN_NEGATIVE]], float -0.000000e+00)
; CHECK-NEXT: ret float [[RESULT]]
;
%known.negative = call float @returns_negative()
@@ -1025,7 +1014,7 @@ define nofpclass(snan) float @only_nzero__minimumnum__known_negative() {
; CHECK-LABEL: define nofpclass(snan) float @only_nzero__minimumnum__known_negative() {
; CHECK-NEXT: [[KNOWN_NZERO:%.*]] = call float @returns_nzero()
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[KNOWN_NZERO]], float [[KNOWN_NEGATIVE]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimumnum.f32(float [[KNOWN_NEGATIVE]], float -0.000000e+00)
; CHECK-NEXT: ret float [[RESULT]]
;
%known.nzero = call float @returns_nzero()
@@ -1064,8 +1053,7 @@ define nofpclass(snan) float @known_negative__minimumnum__only_pzero() {
; CHECK-LABEL: define nofpclass(snan) float @known_negative__minimumnum__only_pzero() {
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[KNOWN_NEGATIVE]], float [[KNOWN_PZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.negative = call float @returns_negative()
%known.pzero = call float @returns_pzero()
@@ -1077,8 +1065,7 @@ define nofpclass(snan) float @only_pzero__minimumnum__known_negative() {
; CHECK-LABEL: define nofpclass(snan) float @only_pzero__minimumnum__known_negative() {
; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero()
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[KNOWN_PZERO]], float [[KNOWN_NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.pzero = call float @returns_pzero()
%known.negative = call float @returns_negative()
@@ -1090,8 +1077,7 @@ define nofpclass(snan) float @known_negative__minimumnum__only_pzero_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @known_negative__minimumnum__only_pzero_or_nan() {
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[KNOWN_PZERO_OR_NAN:%.*]] = call float @returns_pzero_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[KNOWN_NEGATIVE]], float [[KNOWN_PZERO_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.negative = call float @returns_negative()
%known.pzero.or.nan = call float @returns_pzero_or_nan()
@@ -1103,8 +1089,7 @@ define nofpclass(snan) float @only_pzero_or_nan__minimumnum__known_negative() {
; CHECK-LABEL: define nofpclass(snan) float @only_pzero_or_nan__minimumnum__known_negative() {
; CHECK-NEXT: [[KNOWN_PZERO_OR_NAN:%.*]] = call float @returns_pzero_or_nan()
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[KNOWN_PZERO_OR_NAN]], float [[KNOWN_NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.pzero.or.nan = call float @returns_pzero_or_nan()
%known.negative = call float @returns_negative()
@@ -1337,7 +1322,7 @@ define nofpclass(snan) float @pinf__minimumnum__unknown(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @pinf__minimumnum__unknown(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[PINF]], float [[UNKNOWN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[UNKNOWN]], float 0x7FF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%pinf = call float @returns_pinf()
@@ -1349,7 +1334,7 @@ define nofpclass(snan) float @unknown__minimumnum__pinf(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @unknown__minimumnum__pinf(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[UNKNOWN]], float [[PINF]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[UNKNOWN]], float 0x7FF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%pinf = call float @returns_pinf()
@@ -1385,8 +1370,7 @@ define nofpclass(snan) float @ninf__minimumnum__unknown(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @ninf__minimumnum__unknown(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NINF]], float [[UNKNOWN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%ninf = call float @returns_ninf()
%result = call float @llvm.minimumnum.f32(float %ninf, float %unknown)
@@ -1397,8 +1381,7 @@ define nofpclass(snan) float @unknown__minimumnum__ninf(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @unknown__minimumnum__ninf(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[UNKNOWN]], float [[NINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%ninf = call float @returns_ninf()
%result = call float @llvm.minimumnum.f32(float %unknown, float %ninf)
@@ -1505,8 +1488,7 @@ define nofpclass(snan) float @pinf_or_nan__minimumnum__not_nan(float nofpclass(n
; CHECK-LABEL: define nofpclass(snan) float @pinf_or_nan__minimumnum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[PINF_OR_NAN]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%pinf.or.nan = call float @returns_pinf_or_nan()
%result = call float @llvm.minimumnum.f32(float %pinf.or.nan, float %not.nan)
@@ -1517,8 +1499,7 @@ define nofpclass(snan) float @not_nan__minimumnum__pinf_or_nan(float nofpclass(n
; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimumnum__pinf_or_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NOT_NAN]], float [[PINF_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%pinf.or.nan = call float @returns_pinf_or_nan()
%result = call float @llvm.minimumnum.f32(float %not.nan, float %pinf.or.nan)
@@ -1553,8 +1534,7 @@ define nofpclass(snan) float @ninf__minimumnum__not_nan(float nofpclass(nan) %no
; CHECK-LABEL: define nofpclass(snan) float @ninf__minimumnum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NINF_OR_NAN]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%ninf.or.nan = call float @returns_ninf()
%result = call float @llvm.minimumnum.f32(float %ninf.or.nan, float %not.nan)
@@ -1565,8 +1545,7 @@ define nofpclass(snan) float @not_nan__minimumnum__ninf(float nofpclass(nan) %no
; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimumnum__ninf(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NOT_NAN]], float [[NINF_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%ninf.or.nan = call float @returns_ninf()
%result = call float @llvm.minimumnum.f32(float %not.nan, float %ninf.or.nan)
@@ -1577,8 +1556,7 @@ define nofpclass(snan) float @pinf__minimumnum__not_nan(float nofpclass(nan) %no
; CHECK-LABEL: define nofpclass(snan) float @pinf__minimumnum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[PINF_OR_NAN]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%pinf.or.nan = call float @returns_pinf()
%result = call float @llvm.minimumnum.f32(float %pinf.or.nan, float %not.nan)
@@ -1589,8 +1567,7 @@ define nofpclass(snan) float @not_nan__minimumnum__pinf(float nofpclass(nan) %no
; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimumnum__pinf(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NOT_NAN]], float [[PINF_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%pinf.or.nan = call float @returns_pinf()
%result = call float @llvm.minimumnum.f32(float %not.nan, float %pinf.or.nan)
@@ -1601,7 +1578,7 @@ define nofpclass(snan) float @inf__minimumnum__not_nan(float nofpclass(nan) %not
; CHECK-LABEL: define nofpclass(snan) float @inf__minimumnum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call float @returns_inf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[INF_OR_NAN]], float [[NOT_NAN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimumnum.f32(float [[INF_OR_NAN]], float [[NOT_NAN]])
; CHECK-NEXT: ret float [[RESULT]]
;
%inf.or.nan = call float @returns_inf()
@@ -1613,7 +1590,7 @@ define nofpclass(snan) float @not_nan__minimumnum__inf(float nofpclass(nan) %not
; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimumnum__inf(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call float @returns_inf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NOT_NAN]], float [[INF_OR_NAN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimumnum.f32(float [[NOT_NAN]], float [[INF_OR_NAN]])
; CHECK-NEXT: ret float [[RESULT]]
;
%inf.or.nan = call float @returns_inf()
@@ -1654,7 +1631,7 @@ define nofpclass(snan) float @unknown__noundef_minimumnum__not_nan(float %unknow
define nofpclass(snan) float @not_nan__noundef_minimumnum__not_nan(float nofpclass(nan) %not.nan0, float nofpclass(nan) %not.nan1) {
; CHECK-LABEL: define nofpclass(snan) float @not_nan__noundef_minimumnum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN0:%.*]], float nofpclass(nan) [[NOT_NAN1:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call noundef float @llvm.minimumnum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimumnum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call noundef float @llvm.minimumnum.f32(float %not.nan0, float %not.nan1)
More information about the llvm-branch-commits
mailing list