[llvm-branch-commits] [llvm] InstCombine: Improve SimplifyDemandedFPClass min/max handling (PR #175382)
Matt Arsenault via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Wed Jan 14 07:59:17 PST 2026
https://github.com/arsenm updated https://github.com/llvm/llvm-project/pull/175382
>From b41b40afe38fdfb4392c3c4101a44bd44878db4a Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Sat, 10 Jan 2026 17:53:41 +0100
Subject: [PATCH] InstCombine: Improve SimplifyDemandedFPClass min/max handling
Refine handling of minimum/maximum and minimumnum/maximumnum. The
previous folds to input were based on sign bit checks. This was too
conservative with 0s. This can now consider -0 as less than or equal
to +0 as appropriate, account for nsz. It additionally can handle
cases like one half is known positive normal and the other subnormal.
---
.../InstCombineSimplifyDemanded.cpp | 85 ++----
.../simplify-demanded-fpclass-maximum.ll | 232 ++++++-----------
.../simplify-demanded-fpclass-maximumnum.ll | 191 +++++---------
.../simplify-demanded-fpclass-minimum.ll | 241 ++++++------------
.../simplify-demanded-fpclass-minimumnum.ll | 202 +++++----------
5 files changed, 330 insertions(+), 621 deletions(-)
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
index 05ed123b8be75..6275d5624197e 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
@@ -2453,29 +2453,23 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
KnownRHS.knownNot(fcNan);
}
- KnownFPClass::MinMaxKind OpKind;
+ bool OrderedZeroSign = !FMF.noSignedZeros();
+ KnownFPClass::MinMaxKind OpKind;
switch (IID) {
case 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).
- if (KnownLHS.isKnownNever(fcNegative) &&
- KnownRHS.isKnownNever(fcPositive | fcNan))
- return CI->getArgOperand(0);
-
- if (KnownRHS.isKnownNever(fcNegative) &&
- KnownLHS.isKnownNever(fcPositive | fcNan))
- return CI->getArgOperand(1);
-
- // If one value must be pinf, the result is pinf or a propagated nan.
- if (KnownLHS.isKnownAlways(fcPosInf | fcNan) &&
+ // If one operand is known greater than the other, it must be that
+ // operand unless the other is a nan.
+ if (cannotOrderStrictlyLess(KnownLHS.KnownFPClasses,
+ KnownRHS.KnownFPClasses, OrderedZeroSign) &&
KnownRHS.isKnownNever(fcNan))
return CI->getArgOperand(0);
- if (KnownRHS.isKnownAlways(fcPosInf | fcNan) &&
+ if (cannotOrderStrictlyGreater(KnownLHS.KnownFPClasses,
+ KnownRHS.KnownFPClasses,
+ OrderedZeroSign) &&
KnownLHS.isKnownNever(fcNan))
return CI->getArgOperand(1);
@@ -2484,23 +2478,16 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
case 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).
- if (KnownLHS.isKnownNever(fcPositive) &&
- KnownRHS.isKnownNever(fcNegative | fcNan))
- return CI->getArgOperand(0);
-
- if (KnownRHS.isKnownNever(fcPositive) &&
- KnownLHS.isKnownNever(fcNegative | fcNan))
- return CI->getArgOperand(1);
-
- // If one value must be ninf, the result is ninf or a propagated nan.
- if (KnownLHS.isKnownAlways(fcNegInf | fcNan) &&
+ // If one operand is known less than the other, it must be that operand
+ // unless the other is a nan.
+ if (cannotOrderStrictlyGreater(KnownLHS.KnownFPClasses,
+ KnownRHS.KnownFPClasses,
+ OrderedZeroSign) &&
KnownRHS.isKnownNever(fcNan))
return CI->getArgOperand(0);
- if (KnownRHS.isKnownAlways(fcNegInf | fcNan) &&
+ if (cannotOrderStrictlyLess(KnownLHS.KnownFPClasses,
+ KnownRHS.KnownFPClasses, OrderedZeroSign) &&
KnownLHS.isKnownNever(fcNan))
return CI->getArgOperand(1);
@@ -2509,49 +2496,33 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
case 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))
+ if (cannotOrderStrictlyLess(KnownLHS.KnownFPClasses,
+ KnownRHS.KnownFPClasses, OrderedZeroSign) &&
+ KnownLHS.isKnownNever(fcNan))
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) &&
+ if (cannotOrderStrictlyGreater(KnownLHS.KnownFPClasses,
+ KnownRHS.KnownFPClasses,
+ OrderedZeroSign) &&
KnownRHS.isKnownNever(fcNan))
return CI->getArgOperand(1);
- if (KnownRHS.isKnownAlways(fcNegInf | fcNan) &&
- KnownLHS.isKnownNever(fcNan))
- return CI->getArgOperand(0);
-
break;
}
case 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))
+ if (cannotOrderStrictlyGreater(KnownLHS.KnownFPClasses,
+ KnownRHS.KnownFPClasses,
+ OrderedZeroSign) &&
+ KnownLHS.isKnownNever(fcNan))
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) &&
+ if (cannotOrderStrictlyLess(KnownLHS.KnownFPClasses,
+ KnownRHS.KnownFPClasses, OrderedZeroSign) &&
KnownRHS.isKnownNever(fcNan))
return CI->getArgOperand(1);
- if (KnownRHS.isKnownAlways(fcPosInf | fcNan) &&
- KnownLHS.isKnownNever(fcNan))
- return CI->getArgOperand(0);
-
break;
}
default:
diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll
index 639bda0226661..4792e5198f96f 100644
--- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll
+++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll
@@ -49,8 +49,7 @@ declare nofpclass(ninf nnorm nsub zero) float @returns_positive_nonzero_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.maximum.f32(float [[X]], float [[Y]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF8000000000000
;
%result = call float @llvm.maximum.f32(float %x, float %y)
ret float %result
@@ -79,7 +78,7 @@ define nofpclass(inf norm sub zero snan) float @ret_only_qnan(float %x, float %y
define nofpclass(nan norm sub zero) float @ret_only_inf(float %x, float %y) {
; CHECK-LABEL: define nofpclass(nan zero sub norm) float @ret_only_inf(
; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximum.f32(float %x, float %y)
@@ -107,7 +106,7 @@ define nofpclass(nan ninf norm sub zero) float @ret_only_pinf(float %x, float %y
define nofpclass(inf nan norm sub) float @ret_only_zero(float %x, float %y) {
; CHECK-LABEL: define nofpclass(nan inf sub norm) float @ret_only_zero(
; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximum.f32(float %x, float %y)
@@ -135,7 +134,7 @@ define nofpclass(inf nan norm sub pzero) float @ret_only_nzero(float %x, float %
define nofpclass(nan) float @ret_no_nans(float %x, float %y) {
; CHECK-LABEL: define nofpclass(nan) float @ret_no_nans(
; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximum.f32(float %x, float %y)
@@ -155,7 +154,7 @@ define nofpclass(inf) float @ret_no_infs(float %x, float %y) {
define nofpclass(nan inf) float @ret_no_nans_no_infs(float %x, float %y) {
; CHECK-LABEL: define nofpclass(nan inf) float @ret_no_nans_no_infs(
; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximum.f32(float %x, float %y)
@@ -167,8 +166,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__maximum__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.maximum.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()
@@ -181,8 +179,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__maximum__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.maximum.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()
@@ -220,8 +217,7 @@ define nofpclass(snan) float @known_positive_or_nan__maximum__known_negative() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive_or_nan__maximum__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.maximum.f32(float [[MUST_BE_POSITIVE_OR_NAN]], float [[MUST_BE_NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_NAN]]
;
%must.be.positive.or.nan = call float @returns_positive_or_nan()
%must.be.negative = call float @returns_negative()
@@ -233,8 +229,7 @@ define nofpclass(snan) float @known_negative__maximum__known_positive_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @known_negative__maximum__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.maximum.f32(float [[MUST_BE_NEGATIVE]], float [[MUST_BE_POSITIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_NAN]]
;
%must.be.negative = call float @returns_negative()
%must.be.positive.or.nan = call float @returns_positive_or_nan()
@@ -275,7 +270,7 @@ define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_positive__select_a
; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) {
; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]]
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]])
; CHECK-NEXT: ret float [[RESULT]]
;
%always.negative = call float @returns_negative()
@@ -289,7 +284,7 @@ define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_positive__unknown_
; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) {
; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]]
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]])
; CHECK-NEXT: ret float [[RESULT]]
;
%always.negative = call float @returns_negative()
@@ -323,7 +318,7 @@ define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_negative__simplify
; CHECK-NEXT: [[ALWAYS_NEGATIVE1:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE0]], float [[UNKNOWN0]]
; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[UNKNOWN1]], float [[ALWAYS_NEGATIVE1]]
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[SELECT_LHS]], float [[SELECT_RHS]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[SELECT_LHS]], float [[SELECT_RHS]])
; CHECK-NEXT: ret float [[RESULT]]
;
%always.negative0 = call float @returns_negative()
@@ -339,7 +334,7 @@ define nofpclass(nan) float @no_fold_select_always_negative_0(i1 %cond, float %u
; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) {
; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]]
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]])
; CHECK-NEXT: ret float [[RESULT]]
;
%always.negative = call float @returns_negative()
@@ -353,7 +348,7 @@ define nofpclass(nan) float @no_fold_select_always_negative_1(i1 %cond, float %u
; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) {
; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]]
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]])
; CHECK-NEXT: ret float [[RESULT]]
;
%always.negative = call float @returns_negative()
@@ -367,7 +362,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.maximum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.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()
@@ -381,7 +376,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.maximum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.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()
@@ -394,8 +389,7 @@ define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_0() {
; CHECK-LABEL: define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_0() {
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO1:%.*]] = call float @returns_positive_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call nsz float @llvm.maximum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO1]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_ZERO1]]
;
%must.be.negative.or.zero = call float @returns_negative_or_zero()
%must.be.positive.or.zero = call float @returns_positive_or_zero()
@@ -407,8 +401,7 @@ define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_1() {
; CHECK-LABEL: define nofpclass(snan) float @nsz_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 nsz float @llvm.maximum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_NEGATIVE_OR_ZERO]]
;
%must.be.positive.or.zero = call float @returns_positive_or_zero()
%must.be.negative.or.zero = call float @returns_negative_or_zero()
@@ -439,7 +432,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.maximum.f32(float [[MUST_BE_PINF]], float [[UNKNOWN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN]], float 0x7FF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximum.f32(float %must.be.pinf, float %unknown)
@@ -449,7 +442,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.maximum.f32(float [[UNKNOWN]], float [[MUST_BE_PINF]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN]], float 0x7FF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximum.f32(float %unknown, float %must.be.pinf)
@@ -460,8 +453,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.maximum.f32(float [[MUST_BE_PINF]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%result = call float @llvm.maximum.f32(float %must.be.pinf, float %not.nan)
ret float %result
@@ -471,8 +463,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.maximum.f32(float [[NOT_NAN]], float [[MUST_BE_PINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%result = call float @llvm.maximum.f32(float %not.nan, float %must.be.pinf)
ret float %result
@@ -501,8 +492,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.maximum.f32(float [[MUST_BE_NINF]], float [[UNKNOWN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[UNKNOWN]]
;
%result = call float @llvm.maximum.f32(float %must.be.ninf, float %unknown)
ret float %result
@@ -511,8 +501,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.maximum.f32(float [[UNKNOWN]], float [[MUST_BE_NINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[UNKNOWN]]
;
%result = call float @llvm.maximum.f32(float %unknown, float %must.be.ninf)
ret float %result
@@ -523,8 +512,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.maximum.f32(float [[MUST_BE_NINF]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%result = call float @llvm.maximum.f32(float %must.be.ninf, float %not.nan)
ret float %result
@@ -534,8 +522,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.maximum.f32(float [[NOT_NAN]], float [[MUST_BE_NINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%result = call float @llvm.maximum.f32(float %not.nan, float %must.be.ninf)
ret float %result
@@ -844,7 +831,7 @@ define nofpclass(snan) float @unknown__maximum__not_nan(float %x, float nofpclas
define nofpclass(snan) float @not_nan__maximum__not_nan(float nofpclass(nan) %x, float nofpclass(nan) %y) {
; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[X:%.*]], float nofpclass(nan) [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximum.f32(float %x, float %y)
@@ -875,8 +862,7 @@ define nofpclass(snan) float @known_positive__maximum__only_zero() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximum__only_zero() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.positive = call float @returns_positive()
%known.zero = call float @returns_zero()
@@ -888,8 +874,7 @@ define nofpclass(snan) float @only_zero__maximum__known_positive() {
; CHECK-LABEL: define nofpclass(snan) float @only_zero__maximum__known_positive() {
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.zero = call float @returns_zero()
%known.positive = call float @returns_positive()
@@ -927,8 +912,7 @@ define nofpclass(snan) float @known_positive_or_nan__maximum__only_zero() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive_or_nan__maximum__only_zero() {
; CHECK-NEXT: [[KNOWN_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan()
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_POSITIVE_OR_NAN]], float [[KNOWN_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE_OR_NAN]]
;
%known.positive.or.nan = call float @returns_positive_or_nan()
%known.zero = call float @returns_zero()
@@ -940,8 +924,7 @@ define nofpclass(snan) float @only_zero__maximum__known_positive_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @only_zero__maximum__known_positive_or_nan() {
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
; CHECK-NEXT: [[KNOWN_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE_OR_NAN]]
;
%known.zero = call float @returns_zero()
%known.positive.or.nan = call float @returns_positive_or_nan()
@@ -953,8 +936,7 @@ define nofpclass(snan) float @known_positive__maximum__only_nzero() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximum__only_nzero() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_NZERO:%.*]] = call float @returns_nzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.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()
@@ -966,8 +948,7 @@ define nofpclass(snan) float @only_nzero__maximum__known_positive() {
; CHECK-LABEL: define nofpclass(snan) float @only_nzero__maximum__known_positive() {
; CHECK-NEXT: [[KNOWN_NZERO:%.*]] = call float @returns_nzero()
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.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()
@@ -979,8 +960,7 @@ define nofpclass(snan) float @known_positive__maximum__only_pzero() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximum__only_pzero() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_PZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.positive = call float @returns_positive()
%known.pzero = call float @returns_pzero()
@@ -992,8 +972,7 @@ define nofpclass(snan) float @only_pzero__maximum__known_positive() {
; CHECK-LABEL: define nofpclass(snan) float @only_pzero__maximum__known_positive() {
; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero()
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_PZERO]], float [[KNOWN_POSITIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.pzero = call float @returns_pzero()
%known.positive = call float @returns_positive()
@@ -1005,8 +984,7 @@ define nofpclass(snan) float @known_negative__maximum__only_zero_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @known_negative__maximum__only_zero_or_nan() {
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[KNOWN_ZERO_OR_NAN:%.*]] = call float @returns_zero_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_NEGATIVE]], float [[KNOWN_ZERO_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_ZERO_OR_NAN]]
;
%known.negative = call float @returns_negative()
%known.zero.or.nan = call float @returns_zero_or_nan()
@@ -1018,8 +996,7 @@ define nofpclass(snan) float @only_zero_or_nan__maximum__known_negative() {
; CHECK-LABEL: define nofpclass(snan) float @only_zero_or_nan__maximum__known_negative() {
; CHECK-NEXT: [[KNOWN_ZERO_OR_NAN:%.*]] = call float @returns_zero_or_nan()
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_ZERO_OR_NAN]], float [[KNOWN_NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_ZERO_OR_NAN]]
;
%known.zero.or.nan = call float @returns_zero_or_nan()
%known.negative = call float @returns_negative()
@@ -1081,8 +1058,7 @@ define nofpclass(snan) float @known_negative__maximum__only_nzero_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @known_negative__maximum__only_nzero_or_nan() {
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[KNOWN_NZERO_OR_NAN:%.*]] = call float @returns_nzero_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_NEGATIVE]], float [[KNOWN_NZERO_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NZERO_OR_NAN]]
;
%known.negative = call float @returns_negative()
%known.nzero.or.nan = call float @returns_nzero_or_nan()
@@ -1094,8 +1070,7 @@ define nofpclass(snan) float @only_nzero_or_nan__maximum__known_negative() {
; CHECK-LABEL: define nofpclass(snan) float @only_nzero_or_nan__maximum__known_negative() {
; CHECK-NEXT: [[KNOWN_NZERO_OR_NAN:%.*]] = call float @returns_nzero_or_nan()
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_NZERO_OR_NAN]], float [[KNOWN_NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NZERO_OR_NAN]]
;
%known.nzero.or.nan = call float @returns_nzero_or_nan()
%known.negative = call float @returns_negative()
@@ -1131,8 +1106,7 @@ define nofpclass(snan) float @known_negative__maximum__only_pzero_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @known_negative__maximum__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.maximum.f32(float [[KNOWN_NEGATIVE]], float [[KNOWN_PZERO_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_PZERO_OR_NAN]]
;
%known.negative = call float @returns_negative()
%known.pzero.or.nan = call float @returns_pzero_or_nan()
@@ -1144,8 +1118,7 @@ define nofpclass(snan) float @only_pzero_or_nan__maximum__known_negative() {
; CHECK-LABEL: define nofpclass(snan) float @only_pzero_or_nan__maximum__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.maximum.f32(float [[KNOWN_PZERO_OR_NAN]], float [[KNOWN_NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_PZERO_OR_NAN]]
;
%known.pzero.or.nan = call float @returns_pzero_or_nan()
%known.negative = call float @returns_negative()
@@ -1226,8 +1199,7 @@ define nofpclass(nan) float @ret_nonan__known_negative_or_nan__maximum__known_po
; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__known_negative_or_nan__maximum__known_positive_or_nan() {
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[MUST_BE_NEGATIVE_OR_NAN]], float [[MUST_BE_POSITIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_NAN]]
;
%must.be.negative.or.nan = call float @returns_negative_or_nan()
%must.be.positive.or.nan = call float @returns_positive_or_nan()
@@ -1239,8 +1211,7 @@ define nofpclass(nan) float @ret_nonan__known_positive_or_nan__maximum__known_ne
; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__known_positive_or_nan__maximum__known_negative_or_nan() {
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan()
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[MUST_BE_POSITIVE_OR_NAN]], float [[MUST_BE_NEGATIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_NAN]]
;
%must.be.positive.or.nan = call float @returns_positive_or_nan()
%must.be.negative.or.nan = call float @returns_negative_or_nan()
@@ -1252,8 +1223,7 @@ define nofpclass(nan) float @ret_nonan__select_nan_or_unknown__maximum__unknown(
; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__select_nan_or_unknown__maximum__unknown(
; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) {
; CHECK-NEXT: [[ALWAYS_NAN:%.*]] = call float @returns_nan()
-; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NAN]], float [[UNKNOWN0]]
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[UNKNOWN0]], float [[UNKNOWN1]])
; CHECK-NEXT: ret float [[RESULT]]
;
%always.nan = call float @returns_nan()
@@ -1266,8 +1236,7 @@ define nofpclass(nan) float @ret_nonan__unknown__maximum__select_nan_or_unknown(
; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__unknown__maximum__select_nan_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) {
; CHECK-NEXT: [[ALWAYS_NAN:%.*]] = call float @returns_nan()
-; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[UNKNOWN0]], float [[ALWAYS_NAN]]
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[UNKNOWN1]], float [[UNKNOWN0]])
; CHECK-NEXT: ret float [[RESULT]]
;
%always.nan = call float @returns_nan()
@@ -1352,8 +1321,7 @@ define nofpclass(nan) float @ret_no_nan__known_always_positive_or_nan__maximum__
; CHECK-LABEL: define nofpclass(nan) float @ret_no_nan__known_always_positive_or_nan__maximum__known_always_negative_or_nan() {
; CHECK-NEXT: [[KNOWN_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan()
; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_POSITIVE_OR_NAN]], float [[KNOWN_NEGATIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE_OR_NAN]]
;
%known.positive.or.nan = call float @returns_positive_or_nan()
%known.negative.or.nan = call float @returns_negative_or_nan()
@@ -1365,8 +1333,7 @@ define nofpclass(nan) float @ret_no_nan__known_always_negative_or_nan__maximum__
; CHECK-LABEL: define nofpclass(nan) float @ret_no_nan__known_always_negative_or_nan__maximum__known_always_positive_or_nan() {
; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
; CHECK-NEXT: [[KNOWN_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_NEGATIVE_OR_NAN]], float [[KNOWN_POSITIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE_OR_NAN]]
;
%known.negative.or.nan = call float @returns_negative_or_nan()
%known.positive.or.nan = call float @returns_positive_or_nan()
@@ -1378,7 +1345,7 @@ define nofpclass(snan) float @pinf__maximum__unknown(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @pinf__maximum__unknown(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[PINF]], float [[UNKNOWN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN]], float 0x7FF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%pinf = call float @returns_pinf()
@@ -1390,7 +1357,7 @@ define nofpclass(snan) float @unknown__maximum__pinf(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @unknown__maximum__pinf(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN]], float [[PINF]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN]], float 0x7FF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%pinf = call float @returns_pinf()
@@ -1426,8 +1393,7 @@ define nofpclass(snan) float @ninf__maximum__unknown(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @ninf__maximum__unknown(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NINF]], float [[UNKNOWN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[UNKNOWN]]
;
%ninf = call float @returns_ninf()
%result = call float @llvm.maximum.f32(float %ninf, float %unknown)
@@ -1438,8 +1404,7 @@ define nofpclass(snan) float @unknown__maximum__ninf(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @unknown__maximum__ninf(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN]], float [[NINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[UNKNOWN]]
;
%ninf = call float @returns_ninf()
%result = call float @llvm.maximum.f32(float %unknown, float %ninf)
@@ -1546,8 +1511,7 @@ define nofpclass(snan) float @pinf_or_nan__maximum__not_nan(float nofpclass(nan)
; CHECK-LABEL: define nofpclass(snan) float @pinf_or_nan__maximum__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.maximum.f32(float [[PINF_OR_NAN]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[PINF_OR_NAN]]
;
%pinf.or.nan = call float @returns_pinf_or_nan()
%result = call float @llvm.maximum.f32(float %pinf.or.nan, float %not.nan)
@@ -1558,8 +1522,7 @@ define nofpclass(snan) float @not_nan__maximum__pinf_or_nan(float nofpclass(nan)
; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximum__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.maximum.f32(float [[NOT_NAN]], float [[PINF_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[PINF_OR_NAN]]
;
%pinf.or.nan = call float @returns_pinf_or_nan()
%result = call float @llvm.maximum.f32(float %not.nan, float %pinf.or.nan)
@@ -1594,8 +1557,7 @@ define nofpclass(snan) float @ninf__maximum__not_nan(float nofpclass(nan) %not.n
; CHECK-LABEL: define nofpclass(snan) float @ninf__maximum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.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.maximum.f32(float %ninf.or.nan, float %not.nan)
@@ -1606,8 +1568,7 @@ define nofpclass(snan) float @not_nan__maximum__ninf(float nofpclass(nan) %not.n
; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximum__ninf(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.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.maximum.f32(float %not.nan, float %ninf.or.nan)
@@ -1618,8 +1579,7 @@ define nofpclass(snan) float @pinf__maximum__not_nan(float nofpclass(nan) %not.n
; CHECK-LABEL: define nofpclass(snan) float @pinf__maximum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.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.maximum.f32(float %pinf.or.nan, float %not.nan)
@@ -1630,8 +1590,7 @@ define nofpclass(snan) float @not_nan__maximum__pinf(float nofpclass(nan) %not.n
; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximum__pinf(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.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.maximum.f32(float %not.nan, float %pinf.or.nan)
@@ -1642,7 +1601,7 @@ define nofpclass(snan) float @inf__maximum__not_nan(float nofpclass(nan) %not.na
; CHECK-LABEL: define nofpclass(snan) float @inf__maximum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call float @returns_inf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[INF_OR_NAN]], float [[NOT_NAN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[INF_OR_NAN]], float [[NOT_NAN]])
; CHECK-NEXT: ret float [[RESULT]]
;
%inf.or.nan = call float @returns_inf()
@@ -1654,7 +1613,7 @@ define nofpclass(snan) float @not_nan__maximum__inf(float nofpclass(nan) %not.na
; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximum__inf(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call float @returns_inf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NOT_NAN]], float [[INF_OR_NAN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[NOT_NAN]], float [[INF_OR_NAN]])
; CHECK-NEXT: ret float [[RESULT]]
;
%inf.or.nan = call float @returns_inf()
@@ -1665,7 +1624,7 @@ define nofpclass(snan) float @not_nan__maximum__inf(float nofpclass(nan) %not.na
define nofpclass(nan) float @ret_no_nans__noundef_call_attr(float %x, float %y) {
; CHECK-LABEL: define nofpclass(nan) float @ret_no_nans__noundef_call_attr(
; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call noundef float @llvm.maximum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call noundef float @llvm.maximum.f32(float %x, float %y)
@@ -1695,7 +1654,7 @@ define nofpclass(snan) float @unknown__noundef_maximum__not_nan(float %unknown,
define nofpclass(snan) float @not_nan__noundef_maximum__not_nan(float nofpclass(nan) %not.nan0, float nofpclass(nan) %not.nan1) {
; CHECK-LABEL: define nofpclass(snan) float @not_nan__noundef_maximum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN0:%.*]], float nofpclass(nan) [[NOT_NAN1:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call noundef float @llvm.maximum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call noundef float @llvm.maximum.f32(float %not.nan0, float %not.nan1)
@@ -1755,7 +1714,7 @@ define nofpclass(inf) float @not_inf__noundef_maximum__not_inf(float nofpclass(i
define nofpclass(snan) float @not_nan__maximum_noundef_md__not_nan(float nofpclass(nan) %not.nan0, float nofpclass(nan) %not.nan1) {
; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximum_noundef_md__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN0:%.*]], float nofpclass(nan) [[NOT_NAN1:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]]), !noundef [[META0:![0-9]+]], !unknown.md [[META0]]
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximum.f32(float %not.nan0, float %not.nan1), !noundef !0, !unknown.md !0
@@ -1769,8 +1728,7 @@ define nofpclass(snan) float @select_is_positive_or_0__maximum__nnorm_0(float no
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[SELECT]], float [[NNORM]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[SELECT]]
;
%is.pos.or.zero = fcmp oge float %arg, 0.0
%select = select i1 %is.pos.or.zero, float %arg, float 0.0
@@ -1785,8 +1743,7 @@ define nofpclass(snan) float @select_is_positive_or_0__maximum__nnorm_1(float no
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NNORM]], float [[SELECT]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[SELECT]]
;
%nnorm = call float @returns_nnorm()
%is.pos.or.zero = fcmp oge float %arg, 0.0
@@ -1833,8 +1790,7 @@ define nofpclass(snan) float @select_is_positive_or_0__maximum__negative(float n
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[SELECT]], float [[NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[SELECT]]
;
%is.pos.or.zero = fcmp oge float %arg, 0.0
%select = select i1 %is.pos.or.zero, float %arg, float 0.0
@@ -1849,8 +1805,7 @@ define nofpclass(snan) float @negative__maximum__select_is_positive_or_0(float n
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NEGATIVE]], float [[SELECT]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[SELECT]]
;
%negative = call float @returns_negative()
%is.pos.or.zero = fcmp oge float %arg, 0.0
@@ -1865,7 +1820,7 @@ define nofpclass(snan) float @select_is_positive_or_0__maximum__negative_or_zero
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
; CHECK-NEXT: [[NEGATIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[SELECT]], float [[NEGATIVE_OR_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[SELECT]], float [[NEGATIVE_OR_ZERO]])
; CHECK-NEXT: ret float [[RESULT]]
;
%is.pos.or.zero = fcmp oge float %arg, 0.0
@@ -1881,7 +1836,7 @@ define nofpclass(snan) float @negative_or_zero__maximum__select_is_positive_or_0
; CHECK-NEXT: [[NEGATIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NEGATIVE_OR_ZERO]], float [[SELECT]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[NEGATIVE_OR_ZERO]], float [[SELECT]])
; CHECK-NEXT: ret float [[RESULT]]
;
%negative.or.zero = call float @returns_negative_or_zero()
@@ -1895,8 +1850,7 @@ define nofpclass(snan) float @negative_or_zero__maximum__positive() {
; CHECK-LABEL: define nofpclass(snan) float @negative_or_zero__maximum__positive() {
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
; CHECK-NEXT: [[POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NEG_NONZERO]], float [[POSITIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POSITIVE]]
;
%neg.nonzero = call float @returns_negative_nonzero()
%positive = call float @returns_positive()
@@ -1908,8 +1862,7 @@ define nofpclass(snan) float @positive__maximum__negative_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @positive__maximum__negative_or_zero() {
; CHECK-NEXT: [[POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[POSITIVE]], float [[NEG_NONZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POSITIVE]]
;
%positive = call float @returns_positive()
%neg.nonzero = call float @returns_negative_nonzero()
@@ -1921,8 +1874,7 @@ define nofpclass(snan) float @negative_or_zero__maximum__positive_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @negative_or_zero__maximum__positive_or_zero() {
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
; CHECK-NEXT: [[POSITIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NEG_NONZERO]], float [[POSITIVE_OR_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POSITIVE_OR_ZERO]]
;
%neg.nonzero = call float @returns_negative_nonzero()
%positive.or.zero = call float @returns_positive_or_zero()
@@ -1934,8 +1886,7 @@ define nofpclass(snan) float @positive_or_zero__maximum__negative_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @positive_or_zero__maximum__negative_or_zero() {
; CHECK-NEXT: [[POSITIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero()
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[POSITIVE_OR_ZERO]], float [[NEG_NONZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POSITIVE_OR_ZERO]]
;
%positive.or.zero = call float @returns_positive_or_zero()
%neg.nonzero = call float @returns_negative_nonzero()
@@ -1947,8 +1898,7 @@ define nofpclass(snan) float @positive_or_zero__maximum__negative() {
; CHECK-LABEL: define nofpclass(snan) float @positive_or_zero__maximum__negative() {
; CHECK-NEXT: [[POS_NONZERO:%.*]] = call float @returns_positive_nonzero()
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[POS_NONZERO]], float [[NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POS_NONZERO]]
;
%pos.nonzero = call float @returns_positive_nonzero()
%negative = call float @returns_negative()
@@ -1960,8 +1910,7 @@ define nofpclass(snan) float @negative__maximum__positive_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @negative__maximum__positive_or_zero() {
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[POS_NONZERO:%.*]] = call float @returns_positive_nonzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NEGATIVE]], float [[POS_NONZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POS_NONZERO]]
;
%negative = call float @returns_negative()
%pos.nonzero = call float @returns_positive_nonzero()
@@ -1999,8 +1948,7 @@ define nofpclass(snan) float @positive_or_zero_or_nan__maximum__negative() {
; CHECK-LABEL: define nofpclass(snan) float @positive_or_zero_or_nan__maximum__negative() {
; CHECK-NEXT: [[POS_NONZERO_OR_NAN:%.*]] = call float @returns_positive_nonzero_or_nan()
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[POS_NONZERO_OR_NAN]], float [[NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POS_NONZERO_OR_NAN]]
;
%pos.nonzero.or.nan = call float @returns_positive_nonzero_or_nan()
%negative = call float @returns_negative()
@@ -2012,8 +1960,7 @@ define nofpclass(snan) float @negative__maximum__positive_or_zero_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @negative__maximum__positive_or_zero_or_nan() {
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[POS_NONZERO_OR_NAN:%.*]] = call float @returns_positive_nonzero_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NEGATIVE]], float [[POS_NONZERO_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POS_NONZERO_OR_NAN]]
;
%negative = call float @returns_negative()
%pos.nonzero.or.nan = call float @returns_positive_nonzero_or_nan()
@@ -2025,8 +1972,7 @@ define nofpclass(snan) float @known_pnorm__maximum__known_psub() {
; CHECK-LABEL: define nofpclass(snan) float @known_pnorm__maximum__known_psub() {
; CHECK-NEXT: [[PNORM:%.*]] = call float @returns_pnorm()
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[PNORM]], float [[PSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[PNORM]]
;
%pnorm = call float @returns_pnorm()
%psub = call float @returns_psub()
@@ -2038,8 +1984,7 @@ define nofpclass(snan) float @known_psub__maximum__known_pnorm() {
; CHECK-LABEL: define nofpclass(snan) float @known_psub__maximum__known_pnorm() {
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
; CHECK-NEXT: [[PNORM:%.*]] = call float @returns_pnorm()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[PSUB]], float [[PNORM]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[PNORM]]
;
%psub = call float @returns_psub()
%pnorm = call float @returns_pnorm()
@@ -2051,8 +1996,7 @@ define nofpclass(snan) float @known_pinf__maximum__known_psub() {
; CHECK-LABEL: define nofpclass(snan) float @known_pinf__maximum__known_psub() {
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[PINF]], float [[PSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%pinf = call float @returns_pinf()
%psub = call float @returns_psub()
@@ -2064,8 +2008,7 @@ define nofpclass(snan) float @known_psub__maximum__known_pinf() {
; CHECK-LABEL: define nofpclass(snan) float @known_psub__maximum__known_pinf() {
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[PSUB]], float [[PINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%psub = call float @returns_psub()
%pinf = call float @returns_pinf()
@@ -2077,8 +2020,7 @@ define nofpclass(snan) float @known_nnorm__maximum__known_nsub() {
; CHECK-LABEL: define nofpclass(snan) float @known_nnorm__maximum__known_nsub() {
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NNORM]], float [[NSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NSUB]]
;
%nnorm = call float @returns_nnorm()
%nsub = call float @returns_nsub()
@@ -2090,8 +2032,7 @@ define nofpclass(snan) float @known_nsub__maximum__known_nnorm() {
; CHECK-LABEL: define nofpclass(snan) float @known_nsub__maximum__known_nnorm() {
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NSUB]], float [[NNORM]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NSUB]]
;
%nsub = call float @returns_nsub()
%nnorm = call float @returns_nnorm()
@@ -2103,8 +2044,7 @@ define nofpclass(snan) float @known_ninf__maximum__known_nsub() {
; CHECK-LABEL: define nofpclass(snan) float @known_ninf__maximum__known_nsub() {
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NINF]], float [[NSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NSUB]]
;
%ninf = call float @returns_ninf()
%nsub = call float @returns_nsub()
@@ -2116,8 +2056,7 @@ define nofpclass(snan) float @known_nsub__maximum__known_ninf() {
; CHECK-LABEL: define nofpclass(snan) float @known_nsub__maximum__known_ninf() {
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NSUB]], float [[NINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NSUB]]
;
%nsub = call float @returns_nsub()
%ninf = call float @returns_ninf()
@@ -2225,6 +2164,3 @@ define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_1__
attributes #0 = { "denormal-fp-math"="preserve-sign,preserve-sign" }
attributes #1 = { "denormal-fp-math"="dynamic,dynamic" }
-;.
-; CHECK: [[META0]] = !{}
-;.
diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll
index dd2e315a9bd04..b9e0892a10ab3 100644
--- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll
+++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll
@@ -48,8 +48,7 @@ declare nofpclass(ninf nnorm nsub zero) float @returns_positive_nonzero_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
@@ -166,8 +165,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()
@@ -180,8 +178,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()
@@ -366,7 +363,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()
@@ -380,7 +377,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()
@@ -393,8 +390,7 @@ define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_0() {
; CHECK-LABEL: define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_0() {
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO1:%.*]] = call float @returns_positive_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call nsz float @llvm.maximumnum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO1]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_ZERO1]]
;
%must.be.negative.or.zero = call float @returns_negative_or_zero()
%must.be.positive.or.zero = call float @returns_positive_or_zero()
@@ -406,8 +402,7 @@ define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_1() {
; CHECK-LABEL: define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_1() {
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO1:%.*]] = call float @returns_positive_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call nsz float @llvm.maximumnum.f32(float [[MUST_BE_POSITIVE_OR_ZERO1]], float [[MUST_BE_POSITIVE_OR_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_ZERO1]]
;
%must.be.negative.or.zero = call float @returns_negative_or_zero()
%must.be.positive.or.zero = call float @returns_positive_or_zero()
@@ -438,8 +433,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
@@ -448,8 +442,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
@@ -459,8 +452,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
@@ -470,8 +462,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
@@ -500,7 +491,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)
@@ -510,7 +501,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)
@@ -522,8 +513,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
@@ -533,8 +523,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
@@ -843,7 +832,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)
@@ -874,8 +863,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: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.positive = call float @returns_positive()
%known.zero = call float @returns_zero()
@@ -887,8 +875,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: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.zero = call float @returns_zero()
%known.positive = call float @returns_positive()
@@ -900,8 +887,7 @@ define nofpclass(snan) float @known_positive__maximumnum__only_zero_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximumnum__only_zero_or_nan() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_ZERO_OR_NAN:%.*]] = call float @returns_zero_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_ZERO_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.positive = call float @returns_positive()
%known.zero.or.nan = call float @returns_zero_or_nan()
@@ -913,8 +899,7 @@ define nofpclass(snan) float @only_zero_or_nan__maximumnum__known_positive() {
; CHECK-LABEL: define nofpclass(snan) float @only_zero_or_nan__maximumnum__known_positive() {
; CHECK-NEXT: [[KNOWN_ZERO_OR_NAN:%.*]] = call float @returns_zero_or_nan()
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_ZERO_OR_NAN]], float [[KNOWN_POSITIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.zero.or.nan = call float @returns_zero_or_nan()
%known.positive = call float @returns_positive()
@@ -952,8 +937,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()
@@ -965,8 +949,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()
@@ -978,8 +961,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: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.positive = call float @returns_positive()
%known.pzero = call float @returns_pzero()
@@ -991,8 +973,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: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.pzero = call float @returns_pzero()
%known.positive = call float @returns_positive()
@@ -1030,8 +1011,7 @@ define nofpclass(snan) float @known_negative_or_nan__maximumnum__only_zero() {
; CHECK-LABEL: define nofpclass(snan) float @known_negative_or_nan__maximumnum__only_zero() {
; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_NEGATIVE_OR_NAN]], float [[KNOWN_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_ZERO]]
;
%known.negative.or.nan = call float @returns_negative_or_nan()
%known.zero = call float @returns_zero()
@@ -1043,8 +1023,7 @@ define nofpclass(snan) float @only_zero__maximumnum__known_negative_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @only_zero__maximumnum__known_negative_or_nan() {
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_ZERO]], float [[KNOWN_NEGATIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_ZERO]]
;
%known.zero = call float @returns_zero()
%known.negative.or.nan = call float @returns_negative_or_nan()
@@ -1212,8 +1191,7 @@ define nofpclass(snan) float @known_positive__maximumnum__only_pzero_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximumnum__only_pzero_or_nan() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_PZERO_OR_NAN:%.*]] = call float @returns_pzero_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_PZERO_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.positive = call float @returns_positive()
%known.pzero.or.nan = call float @returns_pzero_or_nan()
@@ -1299,8 +1277,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()
@@ -1312,8 +1289,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()
@@ -1377,8 +1353,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)
@@ -1389,8 +1364,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)
@@ -1425,7 +1399,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()
@@ -1437,7 +1411,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()
@@ -1521,8 +1495,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)
@@ -1533,8 +1506,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)
@@ -1593,8 +1565,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)
@@ -1605,8 +1576,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)
@@ -1617,8 +1587,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)
@@ -1629,8 +1598,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)
@@ -1641,7 +1609,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()
@@ -1653,7 +1621,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()
@@ -1694,7 +1662,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)
@@ -1754,7 +1722,7 @@ define nofpclass(inf) float @not_inf__noundef_maximumnum__not_inf(float nofpclas
define nofpclass(snan) float @not_nan__maximumnum_noundef_md__not_nan(float nofpclass(nan) %not.nan0, float nofpclass(nan) %not.nan1) {
; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximumnum_noundef_md__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN0:%.*]], float nofpclass(nan) [[NOT_NAN1:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]]), !noundef [[META0:![0-9]+]], !unknown.md [[META0]]
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximumnum.f32(float %not.nan0, float %not.nan1), !noundef !0, !unknown.md !0
@@ -1767,8 +1735,7 @@ define nofpclass(snan) float @select_is_positive_or_0__maximumnum__nnorm_0(float
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[SELECT]], float [[NNORM]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[SELECT]]
;
%is.pos.or.zero = fcmp oge float %arg, 0.0
%select = select i1 %is.pos.or.zero, float %arg, float 0.0
@@ -1783,8 +1750,7 @@ define nofpclass(snan) float @select_is_positive_or_0__maximumnum__nnorm_1(float
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NNORM]], float [[SELECT]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[SELECT]]
;
%nnorm = call float @returns_nnorm()
%is.pos.or.zero = fcmp oge float %arg, 0.0
@@ -1799,8 +1765,7 @@ define nofpclass(snan) float @select_is_positive_or_0__maximumnum__nnorm_or_nan_
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
; CHECK-NEXT: [[NNORM_OR_NAN:%.*]] = call float @returns_nnorm_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[SELECT]], float [[NNORM_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[SELECT]]
;
%is.pos.or.zero = fcmp oge float %arg, 0.0
%select = select i1 %is.pos.or.zero, float %arg, float 0.0
@@ -1815,8 +1780,7 @@ define nofpclass(snan) float @select_is_positive_or_0__maximumnum__nnorm_or_nan_
; CHECK-NEXT: [[NNORM_OR_NAN:%.*]] = call float @returns_nnorm_or_nan()
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NNORM_OR_NAN]], float [[SELECT]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[SELECT]]
;
%nnorm.or.nan = call float @returns_nnorm_or_nan()
%is.pos.or.zero = fcmp oge float %arg, 0.0
@@ -1831,8 +1795,7 @@ define nofpclass(snan) float @select_is_positive_or_0__maximumnum__negative(floa
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[SELECT]], float [[NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[SELECT]]
;
%is.pos.or.zero = fcmp oge float %arg, 0.0
%select = select i1 %is.pos.or.zero, float %arg, float 0.0
@@ -1847,8 +1810,7 @@ define nofpclass(snan) float @negative__maximumnum__select_is_positive_or_0(floa
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NEGATIVE]], float [[SELECT]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[SELECT]]
;
%negative = call float @returns_negative()
%is.pos.or.zero = fcmp oge float %arg, 0.0
@@ -1863,7 +1825,7 @@ define nofpclass(snan) float @select_is_positive_or_0__maximumnum__negative_or_z
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
; CHECK-NEXT: [[NEGATIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[SELECT]], float [[NEGATIVE_OR_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[SELECT]], float [[NEGATIVE_OR_ZERO]])
; CHECK-NEXT: ret float [[RESULT]]
;
%is.pos.or.zero = fcmp oge float %arg, 0.0
@@ -1879,7 +1841,7 @@ define nofpclass(snan) float @negative_or_zero__maximumnum__select_is_positive_o
; CHECK-NEXT: [[NEGATIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NEGATIVE_OR_ZERO]], float [[SELECT]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[NEGATIVE_OR_ZERO]], float [[SELECT]])
; CHECK-NEXT: ret float [[RESULT]]
;
%negative.or.zero = call float @returns_negative_or_zero()
@@ -1893,8 +1855,7 @@ define nofpclass(snan) float @negative_or_zero__maximumnum__positive() {
; CHECK-LABEL: define nofpclass(snan) float @negative_or_zero__maximumnum__positive() {
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
; CHECK-NEXT: [[POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NEG_NONZERO]], float [[POSITIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POSITIVE]]
;
%neg.nonzero = call float @returns_negative_nonzero()
%positive = call float @returns_positive()
@@ -1906,8 +1867,7 @@ define nofpclass(snan) float @positive__maximumnum__negative_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @positive__maximumnum__negative_or_zero() {
; CHECK-NEXT: [[POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[POSITIVE]], float [[NEG_NONZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POSITIVE]]
;
%positive = call float @returns_positive()
%neg.nonzero = call float @returns_negative_nonzero()
@@ -1919,8 +1879,7 @@ define nofpclass(snan) float @negative_or_zero__maximumnum__positive_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @negative_or_zero__maximumnum__positive_or_zero() {
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
; CHECK-NEXT: [[POSITIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NEG_NONZERO]], float [[POSITIVE_OR_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POSITIVE_OR_ZERO]]
;
%neg.nonzero = call float @returns_negative_nonzero()
%positive.or.zero = call float @returns_positive_or_zero()
@@ -1932,8 +1891,7 @@ define nofpclass(snan) float @positive_or_zero__maximumnum__negative_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @positive_or_zero__maximumnum__negative_or_zero() {
; CHECK-NEXT: [[POSITIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero()
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[POSITIVE_OR_ZERO]], float [[NEG_NONZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POSITIVE_OR_ZERO]]
;
%positive.or.zero = call float @returns_positive_or_zero()
%neg.nonzero = call float @returns_negative_nonzero()
@@ -1945,8 +1903,7 @@ define nofpclass(snan) float @positive_or_zero__maximumnum__negative() {
; CHECK-LABEL: define nofpclass(snan) float @positive_or_zero__maximumnum__negative() {
; CHECK-NEXT: [[POS_NONZERO:%.*]] = call float @returns_positive_nonzero()
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[POS_NONZERO]], float [[NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POS_NONZERO]]
;
%pos.nonzero = call float @returns_positive_nonzero()
%negative = call float @returns_negative()
@@ -1958,8 +1915,7 @@ define nofpclass(snan) float @negative__maximumnum__positive_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @negative__maximumnum__positive_or_zero() {
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[POS_NONZERO:%.*]] = call float @returns_positive_nonzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NEGATIVE]], float [[POS_NONZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POS_NONZERO]]
;
%negative = call float @returns_negative()
%pos.nonzero = call float @returns_positive_nonzero()
@@ -1971,8 +1927,7 @@ define nofpclass(snan) float @positive_or_zero__maximumnum__negative_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @positive_or_zero__maximumnum__negative_or_nan() {
; CHECK-NEXT: [[POS_NONZERO:%.*]] = call float @returns_positive_nonzero()
; CHECK-NEXT: [[NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[POS_NONZERO]], float [[NEGATIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POS_NONZERO]]
;
%pos.nonzero = call float @returns_positive_nonzero()
%negative.or.nan = call float @returns_negative_or_nan()
@@ -1984,8 +1939,7 @@ define nofpclass(snan) float @negative_or_nan__maximumnum__positive_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @negative_or_nan__maximumnum__positive_or_zero() {
; CHECK-NEXT: [[NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
; CHECK-NEXT: [[POS_NONZERO:%.*]] = call float @returns_positive_nonzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NEGATIVE_OR_NAN]], float [[POS_NONZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[POS_NONZERO]]
;
%negative.or.nan = call float @returns_negative_or_nan()
%pos.nonzero = call float @returns_positive_nonzero()
@@ -2023,8 +1977,7 @@ define nofpclass(snan) float @known_pnorm__maximumnum__known_psub() {
; CHECK-LABEL: define nofpclass(snan) float @known_pnorm__maximumnum__known_psub() {
; CHECK-NEXT: [[PNORM:%.*]] = call float @returns_pnorm()
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[PNORM]], float [[PSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[PNORM]]
;
%pnorm = call float @returns_pnorm()
%psub = call float @returns_psub()
@@ -2036,8 +1989,7 @@ define nofpclass(snan) float @known_psub__maximumnum__known_pnorm() {
; CHECK-LABEL: define nofpclass(snan) float @known_psub__maximumnum__known_pnorm() {
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
; CHECK-NEXT: [[PNORM:%.*]] = call float @returns_pnorm()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[PSUB]], float [[PNORM]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[PNORM]]
;
%psub = call float @returns_psub()
%pnorm = call float @returns_pnorm()
@@ -2049,8 +2001,7 @@ define nofpclass(snan) float @known_pinf__maximumnum__known_psub() {
; CHECK-LABEL: define nofpclass(snan) float @known_pinf__maximumnum__known_psub() {
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[PINF]], float [[PSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%pinf = call float @returns_pinf()
%psub = call float @returns_psub()
@@ -2062,8 +2013,7 @@ define nofpclass(snan) float @known_psub__maximumnum__known_pinf() {
; CHECK-LABEL: define nofpclass(snan) float @known_psub__maximumnum__known_pinf() {
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[PSUB]], float [[PINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%psub = call float @returns_psub()
%pinf = call float @returns_pinf()
@@ -2075,8 +2025,7 @@ define nofpclass(snan) float @known_nnorm__maximumnum__known_nsub() {
; CHECK-LABEL: define nofpclass(snan) float @known_nnorm__maximumnum__known_nsub() {
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NNORM]], float [[NSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NSUB]]
;
%nnorm = call float @returns_nnorm()
%nsub = call float @returns_nsub()
@@ -2088,8 +2037,7 @@ define nofpclass(snan) float @known_nsub__maximumnum__known_nnorm() {
; CHECK-LABEL: define nofpclass(snan) float @known_nsub__maximumnum__known_nnorm() {
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NSUB]], float [[NNORM]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NSUB]]
;
%nsub = call float @returns_nsub()
%nnorm = call float @returns_nnorm()
@@ -2101,8 +2049,7 @@ define nofpclass(snan) float @known_ninf__maximumnum__known_nsub() {
; CHECK-LABEL: define nofpclass(snan) float @known_ninf__maximumnum__known_nsub() {
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NINF]], float [[NSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NSUB]]
;
%ninf = call float @returns_ninf()
%nsub = call float @returns_nsub()
@@ -2114,8 +2061,7 @@ define nofpclass(snan) float @known_nsub__maximumnum__known_ninf() {
; CHECK-LABEL: define nofpclass(snan) float @known_nsub__maximumnum__known_ninf() {
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NSUB]], float [[NINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NSUB]]
;
%nsub = call float @returns_nsub()
%ninf = call float @returns_ninf()
@@ -2223,6 +2169,3 @@ define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_1__
attributes #0 = { "denormal-fp-math"="preserve-sign,preserve-sign" }
attributes #1 = { "denormal-fp-math"="dynamic,dynamic" }
-;.
-; CHECK: [[META0]] = !{}
-;.
diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimum.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimum.ll
index 02904785ca39b..91954deb5e1c7 100644
--- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimum.ll
+++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimum.ll
@@ -48,8 +48,7 @@ declare nofpclass(ninf nnorm nsub zero) float @returns_positive_nonzero_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.minimum.f32(float [[X]], float [[Y]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF8000000000000
;
%result = call float @llvm.minimum.f32(float %x, float %y)
ret float %result
@@ -78,7 +77,7 @@ define nofpclass(inf norm sub zero snan) float @ret_only_qnan(float %x, float %y
define nofpclass(nan norm sub zero) float @ret_only_inf(float %x, float %y) {
; CHECK-LABEL: define nofpclass(nan zero sub norm) float @ret_only_inf(
; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.minimum.f32(float %x, float %y)
@@ -106,7 +105,7 @@ define nofpclass(nan ninf norm sub zero) float @ret_only_pinf(float %x, float %y
define nofpclass(inf nan norm sub) float @ret_only_zero(float %x, float %y) {
; CHECK-LABEL: define nofpclass(nan inf sub norm) float @ret_only_zero(
; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.minimum.f32(float %x, float %y)
@@ -134,7 +133,7 @@ define nofpclass(inf nan norm sub pzero) float @ret_only_nzero(float %x, float %
define nofpclass(nan) float @ret_no_nans(float %x, float %y) {
; CHECK-LABEL: define nofpclass(nan) float @ret_no_nans(
; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.minimum.f32(float %x, float %y)
@@ -154,7 +153,7 @@ define nofpclass(inf) float @ret_no_infs(float %x, float %y) {
define nofpclass(nan inf) float @ret_no_nans_no_infs(float %x, float %y) {
; CHECK-LABEL: define nofpclass(nan inf) float @ret_no_nans_no_infs(
; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.minimum.f32(float %x, float %y)
@@ -166,8 +165,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__minimum__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.minimum.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()
@@ -180,8 +178,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__minimum__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.minimum.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()
@@ -274,7 +271,7 @@ define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_positive__select_a
; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) {
; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]]
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]])
; CHECK-NEXT: ret float [[RESULT]]
;
%always.negative = call float @returns_negative()
@@ -288,7 +285,7 @@ define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_positive__unknown_
; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) {
; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]]
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]])
; CHECK-NEXT: ret float [[RESULT]]
;
%always.negative = call float @returns_negative()
@@ -322,7 +319,7 @@ define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_negative__simplify
; CHECK-NEXT: [[ALWAYS_NEGATIVE1:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE0]], float [[UNKNOWN0]]
; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[UNKNOWN1]], float [[ALWAYS_NEGATIVE1]]
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[SELECT_LHS]], float [[SELECT_RHS]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[SELECT_LHS]], float [[SELECT_RHS]])
; CHECK-NEXT: ret float [[RESULT]]
;
%always.negative0 = call float @returns_negative()
@@ -338,7 +335,7 @@ define nofpclass(nan) float @no_fold_select_always_negative_0(i1 %cond, float %u
; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) {
; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]]
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]])
; CHECK-NEXT: ret float [[RESULT]]
;
%always.negative = call float @returns_negative()
@@ -352,7 +349,7 @@ define nofpclass(nan) float @no_fold_select_always_negative_1(i1 %cond, float %u
; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) {
; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]]
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]])
; CHECK-NEXT: ret float [[RESULT]]
;
%always.negative = call float @returns_negative()
@@ -366,7 +363,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.minimum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.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()
@@ -380,7 +377,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.minimum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.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()
@@ -393,8 +390,7 @@ define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_0() {
; CHECK-LABEL: define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_0() {
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO1:%.*]] = call float @returns_positive_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call nsz float @llvm.minimum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO1]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_ZERO]]
;
%must.be.negative.or.zero = call float @returns_negative_or_zero()
%must.be.positive.or.zero = call float @returns_positive_or_zero()
@@ -406,8 +402,7 @@ define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_1() {
; CHECK-LABEL: define nofpclass(snan) float @nsz_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 nsz float @llvm.minimum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_ZERO]]
;
%must.be.positive.or.zero = call float @returns_positive_or_zero()
%must.be.negative.or.zero = call float @returns_negative_or_zero()
@@ -438,8 +433,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.minimum.f32(float [[MUST_BE_PINF]], float [[UNKNOWN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[UNKNOWN]]
;
%result = call float @llvm.minimum.f32(float %must.be.pinf, float %unknown)
ret float %result
@@ -448,8 +442,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.minimum.f32(float [[UNKNOWN]], float [[MUST_BE_PINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[UNKNOWN]]
;
%result = call float @llvm.minimum.f32(float %unknown, float %must.be.pinf)
ret float %result
@@ -459,8 +452,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.minimum.f32(float [[MUST_BE_PINF]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%result = call float @llvm.minimum.f32(float %must.be.pinf, float %not.nan)
ret float %result
@@ -470,8 +462,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.minimum.f32(float [[NOT_NAN]], float [[MUST_BE_PINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%result = call float @llvm.minimum.f32(float %not.nan, float %must.be.pinf)
ret float %result
@@ -500,7 +491,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.minimum.f32(float [[MUST_BE_NINF]], float [[UNKNOWN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN]], float 0xFFF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.minimum.f32(float %must.be.ninf, float %unknown)
@@ -510,7 +501,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.minimum.f32(float [[UNKNOWN]], float [[MUST_BE_NINF]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN]], float 0xFFF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.minimum.f32(float %unknown, float %must.be.ninf)
@@ -522,8 +513,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.minimum.f32(float [[MUST_BE_NINF]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%result = call float @llvm.minimum.f32(float %must.be.ninf, float %not.nan)
ret float %result
@@ -533,8 +523,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.minimum.f32(float [[NOT_NAN]], float [[MUST_BE_NINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%result = call float @llvm.minimum.f32(float %not.nan, float %must.be.ninf)
ret float %result
@@ -843,7 +832,7 @@ define nofpclass(snan) float @unknown__minimum__not_nan(float %x, float nofpclas
define nofpclass(snan) float @not_nan__minimum__not_nan(float nofpclass(nan) %x, float nofpclass(nan) %y) {
; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[X:%.*]], float nofpclass(nan) [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.minimum.f32(float %x, float %y)
@@ -874,8 +863,7 @@ define nofpclass(snan) float @known_positive__minimum__only_zero() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__minimum__only_zero() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_ZERO]]
;
%known.positive = call float @returns_positive()
%known.zero = call float @returns_zero()
@@ -887,8 +875,7 @@ define nofpclass(snan) float @only_zero__minimum__known_positive() {
; CHECK-LABEL: define nofpclass(snan) float @only_zero__minimum__known_positive() {
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_ZERO]]
;
%known.zero = call float @returns_zero()
%known.positive = call float @returns_positive()
@@ -900,8 +887,7 @@ define nofpclass(snan) float @known_positive__minimum__only_zero_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__minimum__only_zero_or_nan() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_ZERO_OR_NAN:%.*]] = call float @returns_zero_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_ZERO_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_ZERO_OR_NAN]]
;
%known.positive = call float @returns_positive()
%known.zero.or.nan = call float @returns_zero_or_nan()
@@ -913,8 +899,7 @@ define nofpclass(snan) float @only_zero_or_nan__minimum__known_positive() {
; CHECK-LABEL: define nofpclass(snan) float @only_zero_or_nan__minimum__known_positive() {
; CHECK-NEXT: [[KNOWN_ZERO_OR_NAN:%.*]] = call float @returns_zero_or_nan()
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_ZERO_OR_NAN]], float [[KNOWN_POSITIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_ZERO_OR_NAN]]
;
%known.zero.or.nan = call float @returns_zero_or_nan()
%known.positive = call float @returns_positive()
@@ -1026,8 +1011,7 @@ define nofpclass(snan) float @known_negative_or_nan__minimum__only_zero() {
; CHECK-LABEL: define nofpclass(snan) float @known_negative_or_nan__minimum__only_zero() {
; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_NEGATIVE_OR_NAN]], float [[KNOWN_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE_OR_NAN]]
;
%known.negative.or.nan = call float @returns_negative_or_nan()
%known.zero = call float @returns_zero()
@@ -1039,8 +1023,7 @@ define nofpclass(snan) float @only_zero__minimum__known_negative_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @only_zero__minimum__known_negative_or_nan() {
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_ZERO]], float [[KNOWN_NEGATIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE_OR_NAN]]
;
%known.zero = call float @returns_zero()
%known.negative.or.nan = call float @returns_negative_or_nan()
@@ -1052,8 +1035,7 @@ define nofpclass(snan) float @known_negative__minimum__only_nzero() {
; CHECK-LABEL: define nofpclass(snan) float @known_negative__minimum__only_nzero() {
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[KNOWN_NZERO:%.*]] = call float @returns_nzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_NEGATIVE]], float [[KNOWN_NZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.negative = call float @returns_negative()
%known.nzero = call float @returns_nzero()
@@ -1065,8 +1047,7 @@ define nofpclass(snan) float @only_nzero__minimum__known_negative() {
; CHECK-LABEL: define nofpclass(snan) float @only_nzero__minimum__known_negative() {
; CHECK-NEXT: [[KNOWN_NZERO:%.*]] = call float @returns_nzero()
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_NZERO]], float [[KNOWN_NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.nzero = call float @returns_nzero()
%known.negative = call float @returns_negative()
@@ -1104,8 +1085,7 @@ define nofpclass(snan) float @known_negative__minimum__only_pzero() {
; CHECK-LABEL: define nofpclass(snan) float @known_negative__minimum__only_pzero() {
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.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()
@@ -1117,8 +1097,7 @@ define nofpclass(snan) float @only_pzero__minimum__known_negative() {
; CHECK-LABEL: define nofpclass(snan) float @only_pzero__minimum__known_negative() {
; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero()
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.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()
@@ -1212,8 +1191,7 @@ define nofpclass(snan) float @known_positive__minimum__only_pzero_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__minimum__only_pzero_or_nan() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_PZERO_OR_NAN:%.*]] = call float @returns_pzero_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_PZERO_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_PZERO_OR_NAN]]
;
%known.positive = call float @returns_positive()
%known.pzero.or.nan = call float @returns_pzero_or_nan()
@@ -1225,8 +1203,7 @@ define nofpclass(nan) float @ret_nonan__known_negative_or_nan__minimum__known_po
; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__known_negative_or_nan__minimum__known_positive_or_nan() {
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[MUST_BE_NEGATIVE_OR_NAN]], float [[MUST_BE_POSITIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_NEGATIVE_OR_NAN]]
;
%must.be.negative.or.nan = call float @returns_negative_or_nan()
%must.be.positive.or.nan = call float @returns_positive_or_nan()
@@ -1238,8 +1215,7 @@ define nofpclass(nan) float @ret_nonan__known_positive_or_nan__minimum__known_ne
; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__known_positive_or_nan__minimum__known_negative_or_nan() {
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan()
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[MUST_BE_POSITIVE_OR_NAN]], float [[MUST_BE_NEGATIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_NEGATIVE_OR_NAN]]
;
%must.be.positive.or.nan = call float @returns_positive_or_nan()
%must.be.negative.or.nan = call float @returns_negative_or_nan()
@@ -1251,8 +1227,7 @@ define nofpclass(nan) float @ret_nonan__select_nan_or_unknown__minimum__unknown(
; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__select_nan_or_unknown__minimum__unknown(
; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) {
; CHECK-NEXT: [[ALWAYS_NAN:%.*]] = call float @returns_nan()
-; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NAN]], float [[UNKNOWN0]]
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[UNKNOWN0]], float [[UNKNOWN1]])
; CHECK-NEXT: ret float [[RESULT]]
;
%always.nan = call float @returns_nan()
@@ -1265,8 +1240,7 @@ define nofpclass(nan) float @ret_nonan__unknown__minimum__select_nan_or_unknown(
; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__unknown__minimum__select_nan_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) {
; CHECK-NEXT: [[ALWAYS_NAN:%.*]] = call float @returns_nan()
-; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[UNKNOWN0]], float [[ALWAYS_NAN]]
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[UNKNOWN1]], float [[UNKNOWN0]])
; CHECK-NEXT: ret float [[RESULT]]
;
%always.nan = call float @returns_nan()
@@ -1299,8 +1273,7 @@ define nofpclass(snan) float @known_always_positive__minimum__known_always_negat
; CHECK-LABEL: define nofpclass(snan) float @known_always_positive__minimum__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.minimum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_NEGATIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE_OR_NAN]]
;
%known.positive = call float @returns_positive()
%known.negative.or.nan = call float @returns_negative_or_nan()
@@ -1312,8 +1285,7 @@ define nofpclass(snan) float @known_always_negative_or_nan__minimum__known_alway
; CHECK-LABEL: define nofpclass(snan) float @known_always_negative_or_nan__minimum__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.minimum.f32(float [[KNOWN_NEGATIVE_OR_NAN]], float [[KNOWN_POSITIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE_OR_NAN]]
;
%known.negative.or.nan = call float @returns_negative_or_nan()
%known.positive = call float @returns_positive()
@@ -1351,8 +1323,7 @@ define nofpclass(nan) float @ret_no_nan__known_always_positive_or_nan__minimum__
; CHECK-LABEL: define nofpclass(nan) float @ret_no_nan__known_always_positive_or_nan__minimum__known_always_negative_or_nan() {
; CHECK-NEXT: [[KNOWN_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan()
; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_POSITIVE_OR_NAN]], float [[KNOWN_NEGATIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE_OR_NAN]]
;
%known.positive.or.nan = call float @returns_positive_or_nan()
%known.negative.or.nan = call float @returns_negative_or_nan()
@@ -1364,8 +1335,7 @@ define nofpclass(nan) float @ret_no_nan__known_always_negative_or_nan__minimum__
; CHECK-LABEL: define nofpclass(nan) float @ret_no_nan__known_always_negative_or_nan__minimum__known_always_positive_or_nan() {
; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
; CHECK-NEXT: [[KNOWN_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_NEGATIVE_OR_NAN]], float [[KNOWN_POSITIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE_OR_NAN]]
;
%known.negative.or.nan = call float @returns_negative_or_nan()
%known.positive.or.nan = call float @returns_positive_or_nan()
@@ -1377,8 +1347,7 @@ define nofpclass(snan) float @pinf__minimum__unknown(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @pinf__minimum__unknown(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[PINF]], float [[UNKNOWN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[UNKNOWN]]
;
%pinf = call float @returns_pinf()
%result = call float @llvm.minimum.f32(float %pinf, float %unknown)
@@ -1389,8 +1358,7 @@ define nofpclass(snan) float @unknown__minimum__pinf(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @unknown__minimum__pinf(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN]], float [[PINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[UNKNOWN]]
;
%pinf = call float @returns_pinf()
%result = call float @llvm.minimum.f32(float %unknown, float %pinf)
@@ -1425,7 +1393,7 @@ define nofpclass(snan) float @ninf__minimum__unknown(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @ninf__minimum__unknown(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NINF]], float [[UNKNOWN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN]], float 0xFFF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%ninf = call float @returns_ninf()
@@ -1437,7 +1405,7 @@ define nofpclass(snan) float @unknown__minimum__ninf(float %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @unknown__minimum__ninf(
; CHECK-SAME: float [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN]], float [[NINF]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN]], float 0xFFF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%ninf = call float @returns_ninf()
@@ -1521,8 +1489,7 @@ define nofpclass(snan) float @ninf_or_nan__minimum__not_nan(float nofpclass(nan)
; CHECK-LABEL: define nofpclass(snan) float @ninf_or_nan__minimum__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.minimum.f32(float [[NINF_OR_NAN]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NINF_OR_NAN]]
;
%ninf.or.nan = call float @returns_ninf_or_nan()
%result = call float @llvm.minimum.f32(float %ninf.or.nan, float %not.nan)
@@ -1533,8 +1500,7 @@ define nofpclass(snan) float @not_nan__minimum__ninf_or_nan(float nofpclass(nan)
; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimum__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.minimum.f32(float [[NOT_NAN]], float [[NINF_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NINF_OR_NAN]]
;
%ninf.or.nan = call float @returns_ninf_or_nan()
%result = call float @llvm.minimum.f32(float %not.nan, float %ninf.or.nan)
@@ -1593,8 +1559,7 @@ define nofpclass(snan) float @ninf__minimum__not_nan(float nofpclass(nan) %not.n
; CHECK-LABEL: define nofpclass(snan) float @ninf__minimum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.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.minimum.f32(float %ninf.or.nan, float %not.nan)
@@ -1605,8 +1570,7 @@ define nofpclass(snan) float @not_nan__minimum__ninf(float nofpclass(nan) %not.n
; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimum__ninf(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.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.minimum.f32(float %not.nan, float %ninf.or.nan)
@@ -1617,8 +1581,7 @@ define nofpclass(snan) float @pinf__minimum__not_nan(float nofpclass(nan) %not.n
; CHECK-LABEL: define nofpclass(snan) float @pinf__minimum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.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.minimum.f32(float %pinf.or.nan, float %not.nan)
@@ -1629,8 +1592,7 @@ define nofpclass(snan) float @not_nan__minimum__pinf(float nofpclass(nan) %not.n
; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimum__pinf(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.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.minimum.f32(float %not.nan, float %pinf.or.nan)
@@ -1641,7 +1603,7 @@ define nofpclass(snan) float @inf__minimum__not_nan(float nofpclass(nan) %not.na
; CHECK-LABEL: define nofpclass(snan) float @inf__minimum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call float @returns_inf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[INF_OR_NAN]], float [[NOT_NAN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[INF_OR_NAN]], float [[NOT_NAN]])
; CHECK-NEXT: ret float [[RESULT]]
;
%inf.or.nan = call float @returns_inf()
@@ -1653,7 +1615,7 @@ define nofpclass(snan) float @not_nan__minimum__inf(float nofpclass(nan) %not.na
; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimum__inf(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) {
; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call float @returns_inf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NOT_NAN]], float [[INF_OR_NAN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[NOT_NAN]], float [[INF_OR_NAN]])
; CHECK-NEXT: ret float [[RESULT]]
;
%inf.or.nan = call float @returns_inf()
@@ -1664,7 +1626,7 @@ define nofpclass(snan) float @not_nan__minimum__inf(float nofpclass(nan) %not.na
define nofpclass(nan) float @ret_no_nans__noundef_call_attr(float %x, float %y) {
; CHECK-LABEL: define nofpclass(nan) float @ret_no_nans__noundef_call_attr(
; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call noundef float @llvm.minimum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call noundef float @llvm.minimum.f32(float %x, float %y)
@@ -1694,7 +1656,7 @@ define nofpclass(snan) float @unknown__noundef_minimum__not_nan(float %unknown,
define nofpclass(snan) float @not_nan__noundef_minimum__not_nan(float nofpclass(nan) %not.nan0, float nofpclass(nan) %not.nan1) {
; CHECK-LABEL: define nofpclass(snan) float @not_nan__noundef_minimum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN0:%.*]], float nofpclass(nan) [[NOT_NAN1:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call noundef float @llvm.minimum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call noundef float @llvm.minimum.f32(float %not.nan0, float %not.nan1)
@@ -1754,7 +1716,7 @@ define nofpclass(inf) float @not_inf__noundef_minimum__not_inf(float nofpclass(i
define nofpclass(snan) float @not_nan__minimum_noundef_md__not_nan(float nofpclass(nan) %not.nan0, float nofpclass(nan) %not.nan1) {
; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimum_noundef_md__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN0:%.*]], float nofpclass(nan) [[NOT_NAN1:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]]), !noundef [[META0:![0-9]+]], !unknown.md [[META0]]
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.minimum.f32(float %not.nan0, float %not.nan1), !noundef !0, !unknown.md !0
@@ -1765,11 +1727,8 @@ define nofpclass(snan) float @not_nan__minimum_noundef_md__not_nan(float nofpcla
define nofpclass(snan) float @select_is_positive_or_0__minimum__nnorm_0(float noundef %arg) {
; CHECK-LABEL: define nofpclass(snan) float @select_is_positive_or_0__minimum__nnorm_0(
; CHECK-SAME: float noundef [[ARG:%.*]]) {
-; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[SELECT]], float [[NNORM]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NNORM]]
;
%is.pos.or.zero = fcmp oge float %arg, 0.0
%select = select i1 %is.pos.or.zero, float %arg, float 0.0
@@ -1782,10 +1741,7 @@ define nofpclass(snan) float @select_is_positive_or_0__minimum__nnorm_1(float no
; CHECK-LABEL: define nofpclass(snan) float @select_is_positive_or_0__minimum__nnorm_1(
; CHECK-SAME: float noundef [[ARG:%.*]]) {
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
-; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NNORM]], float [[SELECT]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NNORM]]
;
%nnorm = call float @returns_nnorm()
%is.pos.or.zero = fcmp oge float %arg, 0.0
@@ -1797,11 +1753,8 @@ define nofpclass(snan) float @select_is_positive_or_0__minimum__nnorm_1(float no
define nofpclass(snan) float @select_is_positive_or_0__minimum__nnorm_or_nan_0(float noundef %arg) {
; CHECK-LABEL: define nofpclass(snan) float @select_is_positive_or_0__minimum__nnorm_or_nan_0(
; CHECK-SAME: float noundef [[ARG:%.*]]) {
-; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
; CHECK-NEXT: [[NNORM_OR_NAN:%.*]] = call float @returns_nnorm_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[SELECT]], float [[NNORM_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NNORM_OR_NAN]]
;
%is.pos.or.zero = fcmp oge float %arg, 0.0
%select = select i1 %is.pos.or.zero, float %arg, float 0.0
@@ -1814,10 +1767,7 @@ define nofpclass(snan) float @select_is_positive_or_0__minimum__nnorm_or_nan_1(f
; CHECK-LABEL: define nofpclass(snan) float @select_is_positive_or_0__minimum__nnorm_or_nan_1(
; CHECK-SAME: float noundef [[ARG:%.*]]) {
; CHECK-NEXT: [[NNORM_OR_NAN:%.*]] = call float @returns_nnorm_or_nan()
-; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NNORM_OR_NAN]], float [[SELECT]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NNORM_OR_NAN]]
;
%nnorm.or.nan = call float @returns_nnorm_or_nan()
%is.pos.or.zero = fcmp oge float %arg, 0.0
@@ -1829,11 +1779,8 @@ define nofpclass(snan) float @select_is_positive_or_0__minimum__nnorm_or_nan_1(f
define nofpclass(snan) float @select_is_positive_or_0__minimum__negative(float noundef %arg) {
; CHECK-LABEL: define nofpclass(snan) float @select_is_positive_or_0__minimum__negative(
; CHECK-SAME: float noundef [[ARG:%.*]]) {
-; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[SELECT]], float [[NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEGATIVE]]
;
%is.pos.or.zero = fcmp oge float %arg, 0.0
%select = select i1 %is.pos.or.zero, float %arg, float 0.0
@@ -1846,10 +1793,7 @@ define nofpclass(snan) float @negative__minimum__select_is_positive_or_0(float n
; CHECK-LABEL: define nofpclass(snan) float @negative__minimum__select_is_positive_or_0(
; CHECK-SAME: float noundef [[ARG:%.*]]) {
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NEGATIVE]], float [[SELECT]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEGATIVE]]
;
%negative = call float @returns_negative()
%is.pos.or.zero = fcmp oge float %arg, 0.0
@@ -1864,7 +1808,7 @@ define nofpclass(snan) float @select_is_positive_or_0__minimum__negative_or_zero
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
; CHECK-NEXT: [[NEGATIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[SELECT]], float [[NEGATIVE_OR_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[SELECT]], float [[NEGATIVE_OR_ZERO]])
; CHECK-NEXT: ret float [[RESULT]]
;
%is.pos.or.zero = fcmp oge float %arg, 0.0
@@ -1880,7 +1824,7 @@ define nofpclass(snan) float @negative_or_zero__minimum__select_is_positive_or_0
; CHECK-NEXT: [[NEGATIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NEGATIVE_OR_ZERO]], float [[SELECT]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[NEGATIVE_OR_ZERO]], float [[SELECT]])
; CHECK-NEXT: ret float [[RESULT]]
;
%negative.or.zero = call float @returns_negative_or_zero()
@@ -1894,8 +1838,7 @@ define nofpclass(snan) float @negative_or_zero__minimum__positive() {
; CHECK-LABEL: define nofpclass(snan) float @negative_or_zero__minimum__positive() {
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
; CHECK-NEXT: [[POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NEG_NONZERO]], float [[POSITIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEG_NONZERO]]
;
%neg.nonzero = call float @returns_negative_nonzero()
%positive = call float @returns_positive()
@@ -1907,8 +1850,7 @@ define nofpclass(snan) float @positive__minimum__negative_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @positive__minimum__negative_or_zero() {
; CHECK-NEXT: [[POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[POSITIVE]], float [[NEG_NONZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEG_NONZERO]]
;
%positive = call float @returns_positive()
%neg.nonzero = call float @returns_negative_nonzero()
@@ -1920,8 +1862,7 @@ define nofpclass(snan) float @negative_or_zero__minimum__positive_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @negative_or_zero__minimum__positive_or_zero() {
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
; CHECK-NEXT: [[POSITIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NEG_NONZERO]], float [[POSITIVE_OR_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEG_NONZERO]]
;
%neg.nonzero = call float @returns_negative_nonzero()
%positive.or.zero = call float @returns_positive_or_zero()
@@ -1933,8 +1874,7 @@ define nofpclass(snan) float @positive_or_zero__minimum__negative_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @positive_or_zero__minimum__negative_or_zero() {
; CHECK-NEXT: [[POSITIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero()
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[POSITIVE_OR_ZERO]], float [[NEG_NONZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEG_NONZERO]]
;
%positive.or.zero = call float @returns_positive_or_zero()
%neg.nonzero = call float @returns_negative_nonzero()
@@ -1946,8 +1886,7 @@ define nofpclass(snan) float @positive_or_zero__minimum__negative() {
; CHECK-LABEL: define nofpclass(snan) float @positive_or_zero__minimum__negative() {
; CHECK-NEXT: [[POS_NONZERO:%.*]] = call float @returns_positive_nonzero()
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[POS_NONZERO]], float [[NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEGATIVE]]
;
%pos.nonzero = call float @returns_positive_nonzero()
%negative = call float @returns_negative()
@@ -1959,8 +1898,7 @@ define nofpclass(snan) float @negative__minimum__positive_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @negative__minimum__positive_or_zero() {
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[POS_NONZERO:%.*]] = call float @returns_positive_nonzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NEGATIVE]], float [[POS_NONZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEGATIVE]]
;
%negative = call float @returns_negative()
%pos.nonzero = call float @returns_positive_nonzero()
@@ -1972,8 +1910,7 @@ define nofpclass(snan) float @positive_or_zero__minimum__negative_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @positive_or_zero__minimum__negative_or_nan() {
; CHECK-NEXT: [[POS_NONZERO:%.*]] = call float @returns_positive_nonzero()
; CHECK-NEXT: [[NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[POS_NONZERO]], float [[NEGATIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEGATIVE_OR_NAN]]
;
%pos.nonzero = call float @returns_positive_nonzero()
%negative.or.nan = call float @returns_negative_or_nan()
@@ -1985,8 +1922,7 @@ define nofpclass(snan) float @negative_or_nan__minimum__positive_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @negative_or_nan__minimum__positive_or_zero() {
; CHECK-NEXT: [[NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
; CHECK-NEXT: [[POS_NONZERO:%.*]] = call float @returns_positive_nonzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NEGATIVE_OR_NAN]], float [[POS_NONZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEGATIVE_OR_NAN]]
;
%negative.or.nan = call float @returns_negative_or_nan()
%pos.nonzero = call float @returns_positive_nonzero()
@@ -2024,8 +1960,7 @@ define nofpclass(snan) float @known_pnorm__minimum__known_psub() {
; CHECK-LABEL: define nofpclass(snan) float @known_pnorm__minimum__known_psub() {
; CHECK-NEXT: [[PNORM:%.*]] = call float @returns_pnorm()
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[PNORM]], float [[PSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[PSUB]]
;
%pnorm = call float @returns_pnorm()
%psub = call float @returns_psub()
@@ -2037,8 +1972,7 @@ define nofpclass(snan) float @known_psub__minimum__known_pnorm() {
; CHECK-LABEL: define nofpclass(snan) float @known_psub__minimum__known_pnorm() {
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
; CHECK-NEXT: [[PNORM:%.*]] = call float @returns_pnorm()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[PSUB]], float [[PNORM]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[PSUB]]
;
%psub = call float @returns_psub()
%pnorm = call float @returns_pnorm()
@@ -2050,8 +1984,7 @@ define nofpclass(snan) float @known_pinf__minimum__known_psub() {
; CHECK-LABEL: define nofpclass(snan) float @known_pinf__minimum__known_psub() {
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[PINF]], float [[PSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[PSUB]]
;
%pinf = call float @returns_pinf()
%psub = call float @returns_psub()
@@ -2063,8 +1996,7 @@ define nofpclass(snan) float @known_psub__minimum__known_pinf() {
; CHECK-LABEL: define nofpclass(snan) float @known_psub__minimum__known_pinf() {
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[PSUB]], float [[PINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[PSUB]]
;
%psub = call float @returns_psub()
%pinf = call float @returns_pinf()
@@ -2076,8 +2008,7 @@ define nofpclass(snan) float @known_nnorm__minimum__known_nsub() {
; CHECK-LABEL: define nofpclass(snan) float @known_nnorm__minimum__known_nsub() {
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NNORM]], float [[NSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NNORM]]
;
%nnorm = call float @returns_nnorm()
%nsub = call float @returns_nsub()
@@ -2089,8 +2020,7 @@ define nofpclass(snan) float @known_nsub__minimum__known_nnorm() {
; CHECK-LABEL: define nofpclass(snan) float @known_nsub__minimum__known_nnorm() {
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NSUB]], float [[NNORM]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NNORM]]
;
%nsub = call float @returns_nsub()
%nnorm = call float @returns_nnorm()
@@ -2102,8 +2032,7 @@ define nofpclass(snan) float @known_ninf__minimum__known_nsub() {
; CHECK-LABEL: define nofpclass(snan) float @known_ninf__minimum__known_nsub() {
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NINF]], float [[NSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%ninf = call float @returns_ninf()
%nsub = call float @returns_nsub()
@@ -2115,8 +2044,7 @@ define nofpclass(snan) float @known_nsub__minimum__known_ninf() {
; CHECK-LABEL: define nofpclass(snan) float @known_nsub__minimum__known_ninf() {
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NSUB]], float [[NINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%nsub = call float @returns_nsub()
%ninf = call float @returns_ninf()
@@ -2224,6 +2152,3 @@ define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_1__
attributes #0 = { "denormal-fp-math"="preserve-sign,preserve-sign" }
attributes #1 = { "denormal-fp-math"="dynamic,dynamic" }
-;.
-; CHECK: [[META0]] = !{}
-;.
diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll
index b39b611bbeec2..c0b73029b2a0a 100644
--- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll
+++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll
@@ -48,8 +48,7 @@ declare nofpclass(ninf nnorm nsub zero) float @returns_positive_nonzero_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
@@ -166,8 +165,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()
@@ -180,8 +178,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()
@@ -219,8 +216,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()
@@ -232,8 +228,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()
@@ -366,7 +361,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()
@@ -380,7 +375,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()
@@ -393,8 +388,7 @@ define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_0() {
; CHECK-LABEL: define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_0() {
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO1:%.*]] = call float @returns_positive_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call nsz float @llvm.minimumnum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO1]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_ZERO]]
;
%must.be.negative.or.zero = call float @returns_negative_or_zero()
%must.be.positive.or.zero = call float @returns_positive_or_zero()
@@ -406,8 +400,7 @@ define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_1() {
; CHECK-LABEL: define nofpclass(snan) float @nsz_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 nsz float @llvm.minimumnum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_ZERO]]
;
%must.be.positive.or.zero = call float @returns_positive_or_zero()
%must.be.negative.or.zero = call float @returns_negative_or_zero()
@@ -438,7 +431,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)
@@ -448,7 +441,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)
@@ -459,8 +452,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
@@ -470,8 +462,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
@@ -500,8 +491,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
@@ -510,8 +500,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
@@ -522,8 +511,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
@@ -533,8 +521,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
@@ -843,7 +830,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)
@@ -874,8 +861,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: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_ZERO]]
;
%known.positive = call float @returns_positive()
%known.zero = call float @returns_zero()
@@ -887,8 +873,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: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_ZERO]]
;
%known.zero = call float @returns_zero()
%known.positive = call float @returns_positive()
@@ -926,8 +911,7 @@ define nofpclass(snan) float @known_positive_or_nan__minimumnum__only_zero() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive_or_nan__minimumnum__only_zero() {
; CHECK-NEXT: [[KNOWN_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan()
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[KNOWN_POSITIVE_OR_NAN]], float [[KNOWN_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_ZERO]]
;
%known.positive.or.nan = call float @returns_positive_or_nan()
%known.zero = call float @returns_zero()
@@ -939,8 +923,7 @@ define nofpclass(snan) float @only_zero__minimumnum__known_positive_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @only_zero__minimumnum__known_positive_or_nan() {
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
; CHECK-NEXT: [[KNOWN_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_ZERO]]
;
%known.zero = call float @returns_zero()
%known.positive.or.nan = call float @returns_positive_or_nan()
@@ -1000,8 +983,7 @@ define nofpclass(snan) float @known_negative__minimumnum__only_zero_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @known_negative__minimumnum__only_zero_or_nan() {
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[KNOWN_ZERO_OR_NAN:%.*]] = call float @returns_zero_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[KNOWN_NEGATIVE]], float [[KNOWN_ZERO_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.negative = call float @returns_negative()
%known.zero.or.nan = call float @returns_zero_or_nan()
@@ -1013,8 +995,7 @@ define nofpclass(snan) float @only_zero_or_nan__minimumnum__known_negative() {
; CHECK-LABEL: define nofpclass(snan) float @only_zero_or_nan__minimumnum__known_negative() {
; CHECK-NEXT: [[KNOWN_ZERO_OR_NAN:%.*]] = call float @returns_zero_or_nan()
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[KNOWN_ZERO_OR_NAN]], float [[KNOWN_NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.zero.or.nan = call float @returns_zero_or_nan()
%known.negative = call float @returns_negative()
@@ -1052,8 +1033,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: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.negative = call float @returns_negative()
%known.nzero = call float @returns_nzero()
@@ -1065,8 +1045,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: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.nzero = call float @returns_nzero()
%known.negative = call float @returns_negative()
@@ -1078,8 +1057,7 @@ define nofpclass(snan) float @known_negative__minimumnum__only_nzero_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @known_negative__minimumnum__only_nzero_or_nan() {
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[KNOWN_NZERO_OR_NAN:%.*]] = call float @returns_nzero_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[KNOWN_NEGATIVE]], float [[KNOWN_NZERO_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.negative = call float @returns_negative()
%known.nzero.or.nan = call float @returns_nzero_or_nan()
@@ -1091,8 +1069,7 @@ define nofpclass(snan) float @only_nzero_or_nan__minimumnum__known_negative() {
; CHECK-LABEL: define nofpclass(snan) float @only_nzero_or_nan__minimumnum__known_negative() {
; CHECK-NEXT: [[KNOWN_NZERO_OR_NAN:%.*]] = call float @returns_nzero_or_nan()
; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[KNOWN_NZERO_OR_NAN]], float [[KNOWN_NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.nzero.or.nan = call float @returns_nzero_or_nan()
%known.negative = call float @returns_negative()
@@ -1104,8 +1081,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()
@@ -1117,8 +1093,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()
@@ -1130,8 +1105,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()
@@ -1143,8 +1117,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()
@@ -1377,7 +1350,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()
@@ -1389,7 +1362,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()
@@ -1425,8 +1398,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)
@@ -1437,8 +1409,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)
@@ -1545,8 +1516,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)
@@ -1557,8 +1527,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)
@@ -1593,8 +1562,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)
@@ -1605,8 +1573,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)
@@ -1617,8 +1584,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)
@@ -1629,8 +1595,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)
@@ -1641,7 +1606,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()
@@ -1653,7 +1618,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()
@@ -1694,7 +1659,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)
@@ -1754,7 +1719,7 @@ define nofpclass(inf) float @not_inf__noundef_minimumnum__not_inf(float nofpclas
define nofpclass(snan) float @not_nan__minimumnum_noundef_md__not_nan(float nofpclass(nan) %not.nan0, float nofpclass(nan) %not.nan1) {
; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimumnum_noundef_md__not_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN0:%.*]], float nofpclass(nan) [[NOT_NAN1:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]]), !noundef [[META0:![0-9]+]], !unknown.md [[META0]]
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimumnum.f32(float [[NOT_NAN0]], float [[NOT_NAN1]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.minimumnum.f32(float %not.nan0, float %not.nan1), !noundef !0, !unknown.md !0
@@ -1764,11 +1729,8 @@ define nofpclass(snan) float @not_nan__minimumnum_noundef_md__not_nan(float nofp
define nofpclass(snan) float @select_is_positive_or_0__minimumnum__nnorm_0(float noundef %arg) {
; CHECK-LABEL: define nofpclass(snan) float @select_is_positive_or_0__minimumnum__nnorm_0(
; CHECK-SAME: float noundef [[ARG:%.*]]) {
-; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[SELECT]], float [[NNORM]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NNORM]]
;
%is.pos.or.zero = fcmp oge float %arg, 0.0
%select = select i1 %is.pos.or.zero, float %arg, float 0.0
@@ -1781,10 +1743,7 @@ define nofpclass(snan) float @select_is_positive_or_0__minimumnum__nnorm_1(float
; CHECK-LABEL: define nofpclass(snan) float @select_is_positive_or_0__minimumnum__nnorm_1(
; CHECK-SAME: float noundef [[ARG:%.*]]) {
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
-; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NNORM]], float [[SELECT]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NNORM]]
;
%nnorm = call float @returns_nnorm()
%is.pos.or.zero = fcmp oge float %arg, 0.0
@@ -1828,11 +1787,8 @@ define nofpclass(snan) float @select_is_positive_or_0__minimumnum__nnorm_or_nan_
define nofpclass(snan) float @select_is_positive_or_0__minimumnum__negative(float noundef %arg) {
; CHECK-LABEL: define nofpclass(snan) float @select_is_positive_or_0__minimumnum__negative(
; CHECK-SAME: float noundef [[ARG:%.*]]) {
-; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[SELECT]], float [[NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEGATIVE]]
;
%is.pos.or.zero = fcmp oge float %arg, 0.0
%select = select i1 %is.pos.or.zero, float %arg, float 0.0
@@ -1845,10 +1801,7 @@ define nofpclass(snan) float @negative__minimumnum__select_is_positive_or_0(floa
; CHECK-LABEL: define nofpclass(snan) float @negative__minimumnum__select_is_positive_or_0(
; CHECK-SAME: float noundef [[ARG:%.*]]) {
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NEGATIVE]], float [[SELECT]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEGATIVE]]
;
%negative = call float @returns_negative()
%is.pos.or.zero = fcmp oge float %arg, 0.0
@@ -1863,7 +1816,7 @@ define nofpclass(snan) float @select_is_positive_or_0__minimumnum__negative_or_z
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
; CHECK-NEXT: [[NEGATIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[SELECT]], float [[NEGATIVE_OR_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimumnum.f32(float [[SELECT]], float [[NEGATIVE_OR_ZERO]])
; CHECK-NEXT: ret float [[RESULT]]
;
%is.pos.or.zero = fcmp oge float %arg, 0.0
@@ -1879,7 +1832,7 @@ define nofpclass(snan) float @negative_or_zero__minimumnum__select_is_positive_o
; CHECK-NEXT: [[NEGATIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NEGATIVE_OR_ZERO]], float [[SELECT]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimumnum.f32(float [[NEGATIVE_OR_ZERO]], float [[SELECT]])
; CHECK-NEXT: ret float [[RESULT]]
;
%negative.or.zero = call float @returns_negative_or_zero()
@@ -1893,8 +1846,7 @@ define nofpclass(snan) float @negative_or_zero__minimumnum__positive() {
; CHECK-LABEL: define nofpclass(snan) float @negative_or_zero__minimumnum__positive() {
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
; CHECK-NEXT: [[POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NEG_NONZERO]], float [[POSITIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEG_NONZERO]]
;
%neg.nonzero = call float @returns_negative_nonzero()
%positive = call float @returns_positive()
@@ -1906,8 +1858,7 @@ define nofpclass(snan) float @positive__minimumnum__negative_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @positive__minimumnum__negative_or_zero() {
; CHECK-NEXT: [[POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[POSITIVE]], float [[NEG_NONZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEG_NONZERO]]
;
%positive = call float @returns_positive()
%neg.nonzero = call float @returns_negative_nonzero()
@@ -1919,8 +1870,7 @@ define nofpclass(snan) float @negative_or_zero__minimumnum__positive_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @negative_or_zero__minimumnum__positive_or_zero() {
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
; CHECK-NEXT: [[POSITIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NEG_NONZERO]], float [[POSITIVE_OR_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEG_NONZERO]]
;
%neg.nonzero = call float @returns_negative_nonzero()
%positive.or.zero = call float @returns_positive_or_zero()
@@ -1932,8 +1882,7 @@ define nofpclass(snan) float @positive_or_zero__minimumnum__negative_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @positive_or_zero__minimumnum__negative_or_zero() {
; CHECK-NEXT: [[POSITIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero()
; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[POSITIVE_OR_ZERO]], float [[NEG_NONZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEG_NONZERO]]
;
%positive.or.zero = call float @returns_positive_or_zero()
%neg.nonzero = call float @returns_negative_nonzero()
@@ -1945,8 +1894,7 @@ define nofpclass(snan) float @positive_or_zero__minimumnum__negative() {
; CHECK-LABEL: define nofpclass(snan) float @positive_or_zero__minimumnum__negative() {
; CHECK-NEXT: [[POS_NONZERO:%.*]] = call float @returns_positive_nonzero()
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[POS_NONZERO]], float [[NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEGATIVE]]
;
%pos.nonzero = call float @returns_positive_nonzero()
%negative = call float @returns_negative()
@@ -1958,8 +1906,7 @@ define nofpclass(snan) float @negative__minimumnum__positive_or_zero() {
; CHECK-LABEL: define nofpclass(snan) float @negative__minimumnum__positive_or_zero() {
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[POS_NONZERO:%.*]] = call float @returns_positive_nonzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NEGATIVE]], float [[POS_NONZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEGATIVE]]
;
%negative = call float @returns_negative()
%pos.nonzero = call float @returns_positive_nonzero()
@@ -1997,8 +1944,7 @@ define nofpclass(snan) float @positive_or_zero_or_nan__minimumnum__negative() {
; CHECK-LABEL: define nofpclass(snan) float @positive_or_zero_or_nan__minimumnum__negative() {
; CHECK-NEXT: [[POS_NONZERO_OR_NAN:%.*]] = call float @returns_positive_nonzero_or_nan()
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[POS_NONZERO_OR_NAN]], float [[NEGATIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEGATIVE]]
;
%pos.nonzero.or.nan = call float @returns_positive_nonzero_or_nan()
%negative = call float @returns_negative()
@@ -2010,8 +1956,7 @@ define nofpclass(snan) float @negative__minimumnum__positive_or_zero_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @negative__minimumnum__positive_or_zero_or_nan() {
; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative()
; CHECK-NEXT: [[POS_NONZERO_OR_NAN:%.*]] = call float @returns_positive_nonzero_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NEGATIVE]], float [[POS_NONZERO_OR_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NEGATIVE]]
;
%negative = call float @returns_negative()
%pos.nonzero.or.nan = call float @returns_positive_nonzero_or_nan()
@@ -2023,8 +1968,7 @@ define nofpclass(snan) float @known_pnorm__minimumnum__known_psub() {
; CHECK-LABEL: define nofpclass(snan) float @known_pnorm__minimumnum__known_psub() {
; CHECK-NEXT: [[PNORM:%.*]] = call float @returns_pnorm()
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[PNORM]], float [[PSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[PSUB]]
;
%pnorm = call float @returns_pnorm()
%psub = call float @returns_psub()
@@ -2036,8 +1980,7 @@ define nofpclass(snan) float @known_psub__minimumnum__known_pnorm() {
; CHECK-LABEL: define nofpclass(snan) float @known_psub__minimumnum__known_pnorm() {
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
; CHECK-NEXT: [[PNORM:%.*]] = call float @returns_pnorm()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[PSUB]], float [[PNORM]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[PSUB]]
;
%psub = call float @returns_psub()
%pnorm = call float @returns_pnorm()
@@ -2049,8 +1992,7 @@ define nofpclass(snan) float @known_pinf__minimumnum__known_psub() {
; CHECK-LABEL: define nofpclass(snan) float @known_pinf__minimumnum__known_psub() {
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[PINF]], float [[PSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[PSUB]]
;
%pinf = call float @returns_pinf()
%psub = call float @returns_psub()
@@ -2062,8 +2004,7 @@ define nofpclass(snan) float @known_psub__minimumnum__known_pinf() {
; CHECK-LABEL: define nofpclass(snan) float @known_psub__minimumnum__known_pinf() {
; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub()
; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[PSUB]], float [[PINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[PSUB]]
;
%psub = call float @returns_psub()
%pinf = call float @returns_pinf()
@@ -2075,8 +2016,7 @@ define nofpclass(snan) float @known_nnorm__minimumnum__known_nsub() {
; CHECK-LABEL: define nofpclass(snan) float @known_nnorm__minimumnum__known_nsub() {
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NNORM]], float [[NSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NNORM]]
;
%nnorm = call float @returns_nnorm()
%nsub = call float @returns_nsub()
@@ -2088,8 +2028,7 @@ define nofpclass(snan) float @known_nsub__minimumnum__known_nnorm() {
; CHECK-LABEL: define nofpclass(snan) float @known_nsub__minimumnum__known_nnorm() {
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NSUB]], float [[NNORM]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NNORM]]
;
%nsub = call float @returns_nsub()
%nnorm = call float @returns_nnorm()
@@ -2101,8 +2040,7 @@ define nofpclass(snan) float @known_ninf__minimumnum__known_nsub() {
; CHECK-LABEL: define nofpclass(snan) float @known_ninf__minimumnum__known_nsub() {
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NINF]], float [[NSUB]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%ninf = call float @returns_ninf()
%nsub = call float @returns_nsub()
@@ -2114,8 +2052,7 @@ define nofpclass(snan) float @known_nsub__minimumnum__known_ninf() {
; CHECK-LABEL: define nofpclass(snan) float @known_nsub__minimumnum__known_ninf() {
; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub()
; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimumnum.f32(float [[NSUB]], float [[NINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0xFFF0000000000000
;
%nsub = call float @returns_nsub()
%ninf = call float @returns_ninf()
@@ -2223,6 +2160,3 @@ define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_1__
attributes #0 = { "denormal-fp-math"="preserve-sign,preserve-sign" }
attributes #1 = { "denormal-fp-math"="dynamic,dynamic" }
-;.
-; CHECK: [[META0]] = !{}
-;.
More information about the llvm-branch-commits
mailing list