[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
Mon Jan 12 08:59:08 PST 2026
https://github.com/arsenm updated https://github.com/llvm/llvm-project/pull/175382
>From 1aa5f28cb53d18811c3e8af28649f608741f6972 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 | 66 +++++---------
.../simplify-demanded-fpclass-maximumnum.ll | 69 +++++----------
.../simplify-demanded-fpclass-minimum.ll | 81 +++++-------------
.../simplify-demanded-fpclass-minimumnum.ll | 74 +++++-----------
5 files changed, 118 insertions(+), 257 deletions(-)
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
index 22064638bb229..f06dbed0d1cb4 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
@@ -2329,29 +2329,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);
@@ -2360,23 +2354,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);
@@ -2385,49 +2372,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 4ebbc064c16f3..8d11ce6bfccc9 100644
--- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll
+++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll
@@ -389,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_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 nnan 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.negative.or.zero = call float @returns_positive_or_zero()
%must.be.positive.or.zero = call float @returns_negative_or_zero()
@@ -402,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 nnan nsz float @llvm.maximum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_NEGATIVE_OR_ZERO]]
;
%must.be.negative.or.zero = call float @returns_positive_or_zero()
%must.be.positive.or.zero = call float @returns_negative_or_zero()
@@ -864,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 nnan 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()
@@ -877,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 nnan 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()
@@ -916,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()
@@ -929,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()
@@ -966,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 nnan float @llvm.maximum.f32(float [[KNOWN_POSITIVE]], float 0.000000e+00)
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.positive = call float @returns_positive()
%known.pzero = call float @returns_pzero()
@@ -979,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 nnan float @llvm.maximum.f32(float [[KNOWN_POSITIVE]], float 0.000000e+00)
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.pzero = call float @returns_pzero()
%known.positive = call float @returns_positive()
@@ -992,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()
@@ -1005,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()
@@ -1068,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()
@@ -1081,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()
@@ -1740,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 nnan 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
@@ -1756,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 nnan 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
@@ -1804,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 nnan 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
@@ -1820,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 nnan 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
@@ -1890,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 nnan 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()
@@ -1903,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 nnan 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()
@@ -1990,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 nnan 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()
@@ -2003,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 nnan 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()
@@ -2040,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 nnan 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()
@@ -2053,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 nnan 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()
diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll
index c8f48c8ef3171..1596277592095 100644
--- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll
+++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll
@@ -390,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_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 nnan nsz float @llvm.maximumnum.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.negative.or.zero = call float @returns_positive_or_zero()
%must.be.positive.or.zero = call float @returns_negative_or_zero()
@@ -403,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 nnan nsz float @llvm.maximumnum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_NEGATIVE_OR_ZERO]]
;
%must.be.negative.or.zero = call float @returns_positive_or_zero()
%must.be.positive.or.zero = call float @returns_negative_or_zero()
@@ -865,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 nnan 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()
@@ -878,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 nnan 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()
@@ -891,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()
@@ -904,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()
@@ -967,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 nnan float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float 0.000000e+00)
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.positive = call float @returns_positive()
%known.pzero = call float @returns_pzero()
@@ -980,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 nnan float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float 0.000000e+00)
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.pzero = call float @returns_pzero()
%known.positive = call float @returns_positive()
@@ -1019,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()
@@ -1032,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()
@@ -1201,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()
@@ -1746,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 nnan 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
@@ -1762,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 nnan 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
@@ -1778,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
@@ -1794,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
@@ -1810,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 nnan 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
@@ -1826,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 nnan 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
@@ -1896,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 nnan 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()
@@ -1909,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 nnan 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()
@@ -1996,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 nnan 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()
@@ -2009,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 nnan 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()
@@ -2046,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 nnan 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()
@@ -2059,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 nnan 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()
diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimum.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimum.ll
index f840c211baf55..b0e382016de70 100644
--- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimum.ll
+++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimum.ll
@@ -390,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_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 nnan 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.negative.or.zero = call float @returns_positive_or_zero()
%must.be.positive.or.zero = call float @returns_negative_or_zero()
@@ -403,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 nnan nsz float @llvm.minimum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_ZERO]]
;
%must.be.negative.or.zero = call float @returns_positive_or_zero()
%must.be.positive.or.zero = call float @returns_negative_or_zero()
@@ -865,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 nnan 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()
@@ -878,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 nnan 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()
@@ -891,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()
@@ -904,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()
@@ -1017,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()
@@ -1030,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()
@@ -1043,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 nnan float @llvm.minimum.f32(float [[KNOWN_NEGATIVE]], float -0.000000e+00)
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.negative = call float @returns_negative()
%known.nzero = call float @returns_nzero()
@@ -1056,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 nnan float @llvm.minimum.f32(float [[KNOWN_NEGATIVE]], float -0.000000e+00)
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.nzero = call float @returns_nzero()
%known.negative = call float @returns_negative()
@@ -1201,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()
@@ -1738,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 nnan 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
@@ -1755,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 nnan 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
@@ -1770,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
@@ -1787,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
@@ -1802,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 nnan 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
@@ -1819,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 nnan 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
@@ -1891,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 nnan 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()
@@ -1904,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 nnan 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()
@@ -1991,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 nnan 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()
@@ -2004,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 nnan 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()
@@ -2041,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 nnan 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()
@@ -2054,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 nnan 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()
diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll
index 6c78b4515f76d..b2ceee4d93234 100644
--- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll
+++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll
@@ -388,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_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 nnan 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.negative.or.zero = call float @returns_positive_or_zero()
%must.be.positive.or.zero = call float @returns_negative_or_zero()
@@ -401,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 nnan nsz float @llvm.minimumnum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_ZERO]]
;
%must.be.negative.or.zero = call float @returns_positive_or_zero()
%must.be.positive.or.zero = call float @returns_negative_or_zero()
@@ -863,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 nnan 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()
@@ -876,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 nnan 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()
@@ -915,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()
@@ -928,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()
@@ -989,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()
@@ -1002,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()
@@ -1041,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 nnan float @llvm.minimumnum.f32(float [[KNOWN_NEGATIVE]], float -0.000000e+00)
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.negative = call float @returns_negative()
%known.nzero = call float @returns_nzero()
@@ -1054,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 nnan float @llvm.minimumnum.f32(float [[KNOWN_NEGATIVE]], float -0.000000e+00)
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]]
;
%known.nzero = call float @returns_nzero()
%known.negative = call float @returns_negative()
@@ -1067,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()
@@ -1080,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()
@@ -1741,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 nnan 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
@@ -1758,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 nnan 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
@@ -1805,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 nnan 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
@@ -1822,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 nnan 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
@@ -1894,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 nnan 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()
@@ -1907,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 nnan 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()
@@ -1994,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 nnan 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()
@@ -2007,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 nnan 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()
@@ -2044,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 nnan 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()
@@ -2057,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 nnan 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()
More information about the llvm-branch-commits
mailing list