llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-llvm-analysis Author: Matt Arsenault (arsenm) <details> <summary>Changes</summary> --- Patch is 51.79 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/173977.diff 3 Files Affected: - (modified) llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp (+64-12) - (modified) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll (+34-55) - (modified) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll (+36-59) ``````````diff diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp index 2ae9221a00cbd..3cf5615ecb43f 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 ... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/173977 _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
