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