https://github.com/arsenm updated https://github.com/llvm/llvm-project/pull/173897
>From 3b3f60900344d8d466b86b154db629e320cc3803 Mon Sep 17 00:00:00 2001 From: Matt Arsenault <[email protected]> Date: Wed, 24 Dec 2025 11:38:25 +0100 Subject: [PATCH] InstCombine: Handle minimum/maximum in SimplifyDemandedFPClass --- llvm/include/llvm/Support/KnownFPClass.h | 14 ++ llvm/lib/Analysis/ValueTracking.cpp | 113 ++++----------- llvm/lib/Support/KnownFPClass.cpp | 92 ++++++++++++ .../InstCombineSimplifyDemanded.cpp | 95 ++++++++++++- .../simplify-demanded-fpclass-maximum.ll | 131 +++++++----------- .../simplify-demanded-fpclass-minimum.ll | 125 +++++++---------- 6 files changed, 326 insertions(+), 244 deletions(-) diff --git a/llvm/include/llvm/Support/KnownFPClass.h b/llvm/include/llvm/Support/KnownFPClass.h index 62df87ad8a67e..2db25eca66df4 100644 --- a/llvm/include/llvm/Support/KnownFPClass.h +++ b/llvm/include/llvm/Support/KnownFPClass.h @@ -173,6 +173,20 @@ struct KnownFPClass { signBitMustBeZero(); } + // Enum of min/max intrinsics to avoid dependency on IR. + enum class MinMaxKind { + minimum, + maximum, + minimumnum, + maximumnum, + minnum, + maxnum + }; + + LLVM_ABI static KnownFPClass + minMaxLike(const KnownFPClass &LHS, const KnownFPClass &RHS, MinMaxKind Kind, + DenormalMode DenormMode = DenormalMode::getDynamic()); + /// Apply the canonicalize intrinsic to this value. This is essentially a /// stronger form of propagateCanonicalizingSrc. LLVM_ABI static KnownFPClass diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp index cddd6f9c25074..281c59f671250 100644 --- a/llvm/lib/Analysis/ValueTracking.cpp +++ b/llvm/lib/Analysis/ValueTracking.cpp @@ -4909,6 +4909,25 @@ static void computeKnownFPClassForFPTrunc(const Operator *Op, // Infinity needs a range check. } +static constexpr KnownFPClass::MinMaxKind getMinMaxKind(Intrinsic::ID IID) { + switch (IID) { + case Intrinsic::minimum: + return KnownFPClass::MinMaxKind::minimum; + case Intrinsic::maximum: + return KnownFPClass::MinMaxKind::maximum; + case Intrinsic::minimumnum: + return KnownFPClass::MinMaxKind::minimumnum; + case Intrinsic::maximumnum: + return KnownFPClass::MinMaxKind::maximumnum; + case Intrinsic::minnum: + return KnownFPClass::MinMaxKind::minnum; + case Intrinsic::maxnum: + return KnownFPClass::MinMaxKind::maxnum; + default: + llvm_unreachable("not a floating-point min-max intrinsic"); + } +} + void computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, KnownFPClass &Known, const SimplifyQuery &Q, unsigned Depth) { @@ -5179,95 +5198,15 @@ void computeKnownFPClass(const Value *V, const APInt &DemandedElts, computeKnownFPClass(II->getArgOperand(1), DemandedElts, InterestedClasses, KnownRHS, Q, Depth + 1); - bool NeverNaN = KnownLHS.isKnownNeverNaN() || KnownRHS.isKnownNeverNaN(); - Known = KnownLHS | KnownRHS; - - // If either operand is not NaN, the result is not NaN. - if (NeverNaN && - (IID == Intrinsic::minnum || IID == Intrinsic::maxnum || - IID == Intrinsic::minimumnum || IID == Intrinsic::maximumnum)) - Known.knownNot(fcNan); - - if (IID == Intrinsic::maxnum || IID == Intrinsic::maximumnum) { - // If at least one operand is known to be positive, the result must be - // positive. - if ((KnownLHS.cannotBeOrderedLessThanZero() && - KnownLHS.isKnownNeverNaN()) || - (KnownRHS.cannotBeOrderedLessThanZero() && - KnownRHS.isKnownNeverNaN())) - Known.knownNot(KnownFPClass::OrderedLessThanZeroMask); - } else if (IID == Intrinsic::maximum) { - // If at least one operand is known to be positive, the result must be - // positive. - if (KnownLHS.cannotBeOrderedLessThanZero() || - KnownRHS.cannotBeOrderedLessThanZero()) - Known.knownNot(KnownFPClass::OrderedLessThanZeroMask); - } else if (IID == Intrinsic::minnum || IID == Intrinsic::minimumnum) { - // If at least one operand is known to be negative, the result must be - // negative. - if ((KnownLHS.cannotBeOrderedGreaterThanZero() && - KnownLHS.isKnownNeverNaN()) || - (KnownRHS.cannotBeOrderedGreaterThanZero() && - KnownRHS.isKnownNeverNaN())) - Known.knownNot(KnownFPClass::OrderedGreaterThanZeroMask); - } else if (IID == Intrinsic::minimum) { - // If at least one operand is known to be negative, the result must be - // negative. - if (KnownLHS.cannotBeOrderedGreaterThanZero() || - KnownRHS.cannotBeOrderedGreaterThanZero()) - Known.knownNot(KnownFPClass::OrderedGreaterThanZeroMask); - } else - llvm_unreachable("unhandled intrinsic"); - - // Fixup zero handling if denormals could be returned as a zero. - // - // As there's no spec for denormal flushing, be conservative with the - // treatment of denormals that could be flushed to zero. For older - // subtargets on AMDGPU the min/max instructions would not flush the - // output and return the original value. - // - if ((Known.KnownFPClasses & fcZero) != fcNone && - !Known.isKnownNeverSubnormal()) { - const Function *Parent = II->getFunction(); - if (!Parent) - break; + const Function *F = II->getFunction(); - DenormalMode Mode = Parent->getDenormalMode( - II->getType()->getScalarType()->getFltSemantics()); - if (Mode != DenormalMode::getIEEE()) - Known.KnownFPClasses |= fcZero; - } + DenormalMode Mode = + F ? F->getDenormalMode( + II->getType()->getScalarType()->getFltSemantics()) + : DenormalMode::getDynamic(); - if (Known.isKnownNeverNaN()) { - if (KnownLHS.SignBit && KnownRHS.SignBit && - *KnownLHS.SignBit == *KnownRHS.SignBit) { - if (*KnownLHS.SignBit) - Known.signBitMustBeOne(); - else - Known.signBitMustBeZero(); - } else if ((IID == Intrinsic::maximum || IID == Intrinsic::minimum || - IID == Intrinsic::maximumnum || - IID == Intrinsic::minimumnum) || - // FIXME: Should be using logical zero versions - ((KnownLHS.isKnownNeverNegZero() || - KnownRHS.isKnownNeverPosZero()) && - (KnownLHS.isKnownNeverPosZero() || - KnownRHS.isKnownNeverNegZero()))) { - // Don't take sign bit from NaN operands. - if (!KnownLHS.isKnownNeverNaN()) - KnownLHS.SignBit = std::nullopt; - if (!KnownRHS.isKnownNeverNaN()) - KnownRHS.SignBit = std::nullopt; - if ((IID == Intrinsic::maximum || IID == Intrinsic::maximumnum || - IID == Intrinsic::maxnum) && - (KnownLHS.SignBit == false || KnownRHS.SignBit == false)) - Known.signBitMustBeZero(); - else if ((IID == Intrinsic::minimum || IID == Intrinsic::minimumnum || - IID == Intrinsic::minnum) && - (KnownLHS.SignBit == true || KnownRHS.SignBit == true)) - Known.signBitMustBeOne(); - } - } + Known = KnownFPClass::minMaxLike(KnownLHS, KnownRHS, getMinMaxKind(IID), + Mode); break; } case Intrinsic::canonicalize: { diff --git a/llvm/lib/Support/KnownFPClass.cpp b/llvm/lib/Support/KnownFPClass.cpp index 125bee00c38ff..ee4114cf5a060 100644 --- a/llvm/lib/Support/KnownFPClass.cpp +++ b/llvm/lib/Support/KnownFPClass.cpp @@ -91,6 +91,98 @@ void KnownFPClass::propagateDenormal(const KnownFPClass &Src, } } +KnownFPClass KnownFPClass::minMaxLike(const KnownFPClass &LHS_, + const KnownFPClass &RHS_, MinMaxKind Kind, + DenormalMode Mode) { + KnownFPClass KnownLHS = LHS_; + KnownFPClass KnownRHS = RHS_; + + bool NeverNaN = KnownLHS.isKnownNeverNaN() || KnownRHS.isKnownNeverNaN(); + KnownFPClass Known = KnownLHS | KnownRHS; + + // If either operand is not NaN, the result is not NaN. + if (NeverNaN && + (Kind == MinMaxKind::minnum || Kind == MinMaxKind::maxnum || + Kind == MinMaxKind::minimumnum || Kind == MinMaxKind::maximumnum)) + Known.knownNot(fcNan); + + if (Kind == MinMaxKind::maxnum || Kind == MinMaxKind::maximumnum) { + // If at least one operand is known to be positive, the result must be + // positive. + if ((KnownLHS.cannotBeOrderedLessThanZero() && + KnownLHS.isKnownNeverNaN()) || + (KnownRHS.cannotBeOrderedLessThanZero() && KnownRHS.isKnownNeverNaN())) + Known.knownNot(KnownFPClass::OrderedLessThanZeroMask); + } else if (Kind == MinMaxKind::maximum) { + // If at least one operand is known to be positive, the result must be + // positive. + if (KnownLHS.cannotBeOrderedLessThanZero() || + KnownRHS.cannotBeOrderedLessThanZero()) + Known.knownNot(KnownFPClass::OrderedLessThanZeroMask); + } else if (Kind == MinMaxKind::minnum || Kind == MinMaxKind::minimumnum) { + // If at least one operand is known to be negative, the result must be + // negative. + if ((KnownLHS.cannotBeOrderedGreaterThanZero() && + KnownLHS.isKnownNeverNaN()) || + (KnownRHS.cannotBeOrderedGreaterThanZero() && + KnownRHS.isKnownNeverNaN())) + Known.knownNot(KnownFPClass::OrderedGreaterThanZeroMask); + } else if (Kind == MinMaxKind::minimum) { + // If at least one operand is known to be negative, the result must be + // negative. + if (KnownLHS.cannotBeOrderedGreaterThanZero() || + KnownRHS.cannotBeOrderedGreaterThanZero()) + Known.knownNot(KnownFPClass::OrderedGreaterThanZeroMask); + } else + llvm_unreachable("unhandled intrinsic"); + + // Fixup zero handling if denormals could be returned as a zero. + // + // As there's no spec for denormal flushing, be conservative with the + // treatment of denormals that could be flushed to zero. For older + // subtargets on AMDGPU the min/max instructions would not flush the + // output and return the original value. + // + if ((Known.KnownFPClasses & fcZero) != fcNone && + !Known.isKnownNeverSubnormal()) { + if (Mode != DenormalMode::getIEEE()) + Known.KnownFPClasses |= fcZero; + } + + if (Known.isKnownNeverNaN()) { + if (KnownLHS.SignBit && KnownRHS.SignBit && + *KnownLHS.SignBit == *KnownRHS.SignBit) { + if (*KnownLHS.SignBit) + Known.signBitMustBeOne(); + else + Known.signBitMustBeZero(); + } else if ((Kind == MinMaxKind::maximum || Kind == MinMaxKind::minimum || + Kind == MinMaxKind::maximumnum || + Kind == MinMaxKind::minimumnum) || + // FIXME: Should be using logical zero versions + ((KnownLHS.isKnownNeverNegZero() || + KnownRHS.isKnownNeverPosZero()) && + (KnownLHS.isKnownNeverPosZero() || + KnownRHS.isKnownNeverNegZero()))) { + // Don't take sign bit from NaN operands. + if (!KnownLHS.isKnownNeverNaN()) + KnownLHS.SignBit = std::nullopt; + if (!KnownRHS.isKnownNeverNaN()) + KnownRHS.SignBit = std::nullopt; + if ((Kind == MinMaxKind::maximum || Kind == MinMaxKind::maximumnum || + Kind == MinMaxKind::maxnum) && + (KnownLHS.SignBit == false || KnownRHS.SignBit == false)) + Known.signBitMustBeZero(); + else if ((Kind == MinMaxKind::minimum || Kind == MinMaxKind::minimumnum || + Kind == MinMaxKind::minnum) && + (KnownLHS.SignBit == true || KnownRHS.SignBit == true)) + Known.signBitMustBeOne(); + } + } + + return Known; +} + KnownFPClass KnownFPClass::canonicalize(const KnownFPClass &KnownSrc, DenormalMode DenormMode) { KnownFPClass Known; diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp index 6de3ad70d4ad7..abc09de9fb4e0 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp @@ -2077,7 +2077,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Value *V, } case Instruction::Call: { CallInst *CI = cast<CallInst>(I); - switch (CI->getIntrinsicID()) { + const Intrinsic::ID IID = CI->getIntrinsicID(); + switch (IID) { case Intrinsic::fabs: if (SimplifyDemandedFPClass(I, 0, llvm::inverse_fabs(DemandedMask), Known, Depth + 1)) @@ -2111,6 +2112,98 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Value *V, Known.copysign(KnownSign); break; } + case Intrinsic::maximum: + case Intrinsic::minimum: { + KnownFPClass KnownLHS, KnownRHS; + + // 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; + + 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) { + KnownLHS.knownNot(fcNan); + KnownRHS.knownNot(fcNan); + } + + if (IID == Intrinsic::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) && + KnownRHS.isKnownNever(fcNan)) + return CI->getArgOperand(0); + + if (KnownRHS.isKnownAlways(fcPosInf | fcNan) && + KnownLHS.isKnownNever(fcNan)) + return CI->getArgOperand(1); + } else { + // 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) && + KnownRHS.isKnownNever(fcNan)) + return CI->getArgOperand(0); + + if (KnownRHS.isKnownAlways(fcNegInf | fcNan) && + KnownLHS.isKnownNever(fcNan)) + return CI->getArgOperand(1); + } + + 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); + + FPClassTest ValidResults = DemandedMask & Known.KnownFPClasses; + + if (Constant *SingleVal = + getFPClassConstant(VTy, ValidResults, /*IsCanonicalizing=*/true)) + return SingleVal; + + auto *FPOp = cast<FPMathOperator>(CI); + + bool ChangedFlags = false; + + // TODO: Add NSZ flag if we know the result will not be sensitive on the + // sign of 0. + if (!FPOp->hasNoNaNs() && (ValidResults & fcNan) == fcNone) { + CI->setHasNoNaNs(true); + ChangedFlags = true; + } + + if (ChangedFlags) + return FPOp; + + return nullptr; + } case Intrinsic::exp: case Intrinsic::exp2: case Intrinsic::exp10: { diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll index 9e324e4557f60..10bf1c89e9a51 100644 --- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll +++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.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.maximum.f32(float [[X]], float [[Y]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float 0x7FF8000000000000 ; %result = call float @llvm.maximum.f32(float %x, float %y) ret float %result @@ -64,7 +63,7 @@ define nofpclass(inf norm sub zero snan) float @ret_only_qnan(float %x, float %y define nofpclass(nan norm sub zero) float @ret_only_inf(float %x, float %y) { ; CHECK-LABEL: define nofpclass(nan zero sub norm) float @ret_only_inf( ; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[X]], float [[Y]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[X]], float [[Y]]) ; CHECK-NEXT: ret float [[RESULT]] ; %result = call float @llvm.maximum.f32(float %x, float %y) @@ -92,7 +91,7 @@ define nofpclass(nan ninf norm sub zero) float @ret_only_pinf(float %x, float %y define nofpclass(inf nan norm sub) float @ret_only_zero(float %x, float %y) { ; CHECK-LABEL: define nofpclass(nan inf sub norm) float @ret_only_zero( ; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[X]], float [[Y]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[X]], float [[Y]]) ; CHECK-NEXT: ret float [[RESULT]] ; %result = call float @llvm.maximum.f32(float %x, float %y) @@ -120,7 +119,7 @@ define nofpclass(inf nan norm sub pzero) float @ret_only_nzero(float %x, float % define nofpclass(nan) float @ret_no_nans(float %x, float %y) { ; CHECK-LABEL: define nofpclass(nan) float @ret_no_nans( ; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[X]], float [[Y]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[X]], float [[Y]]) ; CHECK-NEXT: ret float [[RESULT]] ; %result = call float @llvm.maximum.f32(float %x, float %y) @@ -140,7 +139,7 @@ define nofpclass(inf) float @ret_no_infs(float %x, float %y) { define nofpclass(nan inf) float @ret_no_nans_no_infs(float %x, float %y) { ; CHECK-LABEL: define nofpclass(nan inf) float @ret_no_nans_no_infs( ; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[X]], float [[Y]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[X]], float [[Y]]) ; CHECK-NEXT: ret float [[RESULT]] ; %result = call float @llvm.maximum.f32(float %x, float %y) @@ -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__maximum__negative_or_nan___negative_or_nan() { ; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN0:%.*]] = call float @returns_negative_or_nan() ; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN1:%.*]] = call float @returns_negative_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[MUST_BE_NEGATIVE_OR_NAN0]], float [[MUST_BE_NEGATIVE_OR_NAN1]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float 0x7FF8000000000000 ; %must.be.negative.or.nan0 = call float @returns_negative_or_nan() %must.be.negative.or.nan1 = call float @returns_negative_or_nan() @@ -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__maximum__positive_or_nan___positive_or_nan() { ; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN0:%.*]] = call float @returns_positive_or_nan() ; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN1:%.*]] = call float @returns_positive_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[MUST_BE_POSITIVE_OR_NAN0]], float [[MUST_BE_POSITIVE_OR_NAN1]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float 0x7FF8000000000000 ; %must.be.positive.or.nan0 = call float @returns_positive_or_nan() %must.be.positive.or.nan1 = call float @returns_positive_or_nan() @@ -205,8 +202,7 @@ define nofpclass(snan) float @known_positive_or_nan__maximum__known_negative() { ; CHECK-LABEL: define nofpclass(snan) float @known_positive_or_nan__maximum__known_negative() { ; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan() ; CHECK-NEXT: [[MUST_BE_NEGATIVE:%.*]] = call float @returns_negative() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[MUST_BE_POSITIVE_OR_NAN]], float [[MUST_BE_NEGATIVE]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_NAN]] ; %must.be.positive.or.nan = call float @returns_positive_or_nan() %must.be.negative = call float @returns_negative() @@ -218,8 +214,7 @@ define nofpclass(snan) float @known_negative__maximum__known_positive_or_nan() { ; CHECK-LABEL: define nofpclass(snan) float @known_negative__maximum__known_positive_or_nan() { ; CHECK-NEXT: [[MUST_BE_NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[MUST_BE_NEGATIVE]], float [[MUST_BE_POSITIVE_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_NAN]] ; %must.be.negative = call float @returns_negative() %must.be.positive.or.nan = call float @returns_positive_or_nan() @@ -260,7 +255,7 @@ define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_positive__select_a ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]] -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]]) ; CHECK-NEXT: ret float [[RESULT]] ; %always.negative = call float @returns_negative() @@ -274,7 +269,7 @@ define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_positive__unknown_ ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]] -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]]) ; CHECK-NEXT: ret float [[RESULT]] ; %always.negative = call float @returns_negative() @@ -308,7 +303,7 @@ define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_negative__simplify ; CHECK-NEXT: [[ALWAYS_NEGATIVE1:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE0]], float [[UNKNOWN0]] ; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[UNKNOWN1]], float [[ALWAYS_NEGATIVE1]] -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[SELECT_LHS]], float [[SELECT_RHS]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[SELECT_LHS]], float [[SELECT_RHS]]) ; CHECK-NEXT: ret float [[RESULT]] ; %always.negative0 = call float @returns_negative() @@ -324,7 +319,7 @@ define nofpclass(nan) float @no_fold_select_always_negative_0(i1 %cond, float %u ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]] -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]]) ; CHECK-NEXT: ret float [[RESULT]] ; %always.negative = call float @returns_negative() @@ -338,7 +333,7 @@ define nofpclass(nan) float @no_fold_select_always_negative_1(i1 %cond, float %u ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]] -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]]) ; CHECK-NEXT: ret float [[RESULT]] ; %always.negative = call float @returns_negative() @@ -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.maximum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]]) ; CHECK-NEXT: ret float [[RESULT]] ; %must.be.negative.or.zero = call float @returns_positive_or_zero() @@ -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.maximum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]]) ; CHECK-NEXT: ret float [[RESULT]] ; %must.be.negative.or.zero = call float @returns_positive_or_zero() @@ -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.maximum.f32(float [[MUST_BE_PINF]], float [[UNKNOWN]]) +; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN]], float 0x7FF0000000000000) ; CHECK-NEXT: ret float [[RESULT]] ; %result = call float @llvm.maximum.f32(float %must.be.pinf, float %unknown) @@ -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.maximum.f32(float [[UNKNOWN]], float [[MUST_BE_PINF]]) +; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN]], float 0x7FF0000000000000) ; CHECK-NEXT: ret float [[RESULT]] ; %result = call float @llvm.maximum.f32(float %unknown, float %must.be.pinf) @@ -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.maximum.f32(float [[MUST_BE_PINF]], float [[NOT_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float 0x7FF0000000000000 ; %result = call float @llvm.maximum.f32(float %must.be.pinf, float %not.nan) ret float %result @@ -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.maximum.f32(float [[NOT_NAN]], float [[MUST_BE_PINF]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float 0x7FF0000000000000 ; %result = call float @llvm.maximum.f32(float %not.nan, float %must.be.pinf) ret float %result @@ -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.maximum.f32(float [[MUST_BE_NINF]], float [[UNKNOWN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[UNKNOWN]] ; %result = call float @llvm.maximum.f32(float %must.be.ninf, float %unknown) ret float %result @@ -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.maximum.f32(float [[UNKNOWN]], float [[MUST_BE_NINF]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[UNKNOWN]] ; %result = call float @llvm.maximum.f32(float %unknown, float %must.be.ninf) ret float %result @@ -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.maximum.f32(float [[MUST_BE_NINF]], float [[NOT_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[NOT_NAN]] ; %result = call float @llvm.maximum.f32(float %must.be.ninf, float %not.nan) ret float %result @@ -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.maximum.f32(float [[NOT_NAN]], float [[MUST_BE_NINF]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[NOT_NAN]] ; %result = call float @llvm.maximum.f32(float %not.nan, float %must.be.ninf) ret float %result @@ -803,7 +792,7 @@ define nofpclass(snan) float @unknown__maximum__not_nan(float %x, float nofpclas define nofpclass(snan) float @not_nan__maximum__not_nan(float nofpclass(nan) %x, float nofpclass(nan) %y) { ; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximum__not_nan( ; CHECK-SAME: float nofpclass(nan) [[X:%.*]], float nofpclass(nan) [[Y:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[X]], float [[Y]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[X]], float [[Y]]) ; CHECK-NEXT: ret float [[RESULT]] ; %result = call float @llvm.maximum.f32(float %x, float %y) @@ -834,7 +823,7 @@ define nofpclass(snan) float @known_positive__maximum__only_zero() { ; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximum__only_zero() { ; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive() ; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_ZERO]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.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__maximum__known_positive() { ; CHECK-LABEL: define nofpclass(snan) float @only_zero__maximum__known_positive() { ; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero() ; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE]]) ; CHECK-NEXT: ret float [[RESULT]] ; %known.zero = call float @returns_zero() @@ -912,8 +901,7 @@ define nofpclass(snan) float @known_positive__maximum__only_nzero() { ; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximum__only_nzero() { ; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive() ; CHECK-NEXT: [[KNOWN_NZERO:%.*]] = call float @returns_nzero() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_NZERO]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_POSITIVE]] ; %known.positive = call float @returns_positive() %known.nzero = call float @returns_nzero() @@ -925,8 +913,7 @@ define nofpclass(snan) float @only_nzero__maximum__known_positive() { ; CHECK-LABEL: define nofpclass(snan) float @only_nzero__maximum__known_positive() { ; CHECK-NEXT: [[KNOWN_NZERO:%.*]] = call float @returns_nzero() ; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_NZERO]], float [[KNOWN_POSITIVE]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_POSITIVE]] ; %known.nzero = call float @returns_nzero() %known.positive = call float @returns_positive() @@ -938,7 +925,7 @@ define nofpclass(snan) float @known_positive__maximum__only_pzero() { ; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximum__only_pzero() { ; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive() ; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_PZERO]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[KNOWN_POSITIVE]], float 0.000000e+00) ; CHECK-NEXT: ret float [[RESULT]] ; %known.positive = call float @returns_positive() @@ -951,7 +938,7 @@ define nofpclass(snan) float @only_pzero__maximum__known_positive() { ; CHECK-LABEL: define nofpclass(snan) float @only_pzero__maximum__known_positive() { ; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero() ; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_PZERO]], float [[KNOWN_POSITIVE]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[KNOWN_POSITIVE]], float 0.000000e+00) ; CHECK-NEXT: ret float [[RESULT]] ; %known.pzero = call float @returns_pzero() @@ -1090,8 +1077,7 @@ define nofpclass(snan) float @known_negative__maximum__only_pzero_or_nan() { ; CHECK-LABEL: define nofpclass(snan) float @known_negative__maximum__only_pzero_or_nan() { ; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[KNOWN_PZERO_OR_NAN:%.*]] = call float @returns_pzero_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_NEGATIVE]], float [[KNOWN_PZERO_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_PZERO_OR_NAN]] ; %known.negative = call float @returns_negative() %known.pzero.or.nan = call float @returns_pzero_or_nan() @@ -1103,8 +1089,7 @@ define nofpclass(snan) float @only_pzero_or_nan__maximum__known_negative() { ; CHECK-LABEL: define nofpclass(snan) float @only_pzero_or_nan__maximum__known_negative() { ; CHECK-NEXT: [[KNOWN_PZERO_OR_NAN:%.*]] = call float @returns_pzero_or_nan() ; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_PZERO_OR_NAN]], float [[KNOWN_NEGATIVE]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_PZERO_OR_NAN]] ; %known.pzero.or.nan = call float @returns_pzero_or_nan() %known.negative = call float @returns_negative() @@ -1185,8 +1170,7 @@ define nofpclass(nan) float @ret_nonan__known_negative_or_nan__maximum__known_po ; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__known_negative_or_nan__maximum__known_positive_or_nan() { ; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan() ; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[MUST_BE_NEGATIVE_OR_NAN]], float [[MUST_BE_POSITIVE_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_NAN]] ; %must.be.negative.or.nan = call float @returns_negative_or_nan() %must.be.positive.or.nan = call float @returns_positive_or_nan() @@ -1198,8 +1182,7 @@ define nofpclass(nan) float @ret_nonan__known_positive_or_nan__maximum__known_ne ; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__known_positive_or_nan__maximum__known_negative_or_nan() { ; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan() ; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[MUST_BE_POSITIVE_OR_NAN]], float [[MUST_BE_NEGATIVE_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[MUST_BE_POSITIVE_OR_NAN]] ; %must.be.positive.or.nan = call float @returns_positive_or_nan() %must.be.negative.or.nan = call float @returns_negative_or_nan() @@ -1211,8 +1194,7 @@ define nofpclass(nan) float @ret_nonan__select_nan_or_unknown__maximum__unknown( ; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__select_nan_or_unknown__maximum__unknown( ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ALWAYS_NAN:%.*]] = call float @returns_nan() -; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NAN]], float [[UNKNOWN0]] -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[UNKNOWN0]], float [[UNKNOWN1]]) ; CHECK-NEXT: ret float [[RESULT]] ; %always.nan = call float @returns_nan() @@ -1225,8 +1207,7 @@ define nofpclass(nan) float @ret_nonan__unknown__maximum__select_nan_or_unknown( ; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__unknown__maximum__select_nan_or_unknown( ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ALWAYS_NAN:%.*]] = call float @returns_nan() -; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[UNKNOWN0]], float [[ALWAYS_NAN]] -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[UNKNOWN1]], float [[UNKNOWN0]]) ; CHECK-NEXT: ret float [[RESULT]] ; %always.nan = call float @returns_nan() @@ -1311,8 +1292,7 @@ define nofpclass(nan) float @ret_no_nan__known_always_positive_or_nan__maximum__ ; CHECK-LABEL: define nofpclass(nan) float @ret_no_nan__known_always_positive_or_nan__maximum__known_always_negative_or_nan() { ; CHECK-NEXT: [[KNOWN_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan() ; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_POSITIVE_OR_NAN]], float [[KNOWN_NEGATIVE_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_POSITIVE_OR_NAN]] ; %known.positive.or.nan = call float @returns_positive_or_nan() %known.negative.or.nan = call float @returns_negative_or_nan() @@ -1324,8 +1304,7 @@ define nofpclass(nan) float @ret_no_nan__known_always_negative_or_nan__maximum__ ; CHECK-LABEL: define nofpclass(nan) float @ret_no_nan__known_always_negative_or_nan__maximum__known_always_positive_or_nan() { ; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan() ; CHECK-NEXT: [[KNOWN_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_NEGATIVE_OR_NAN]], float [[KNOWN_POSITIVE_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_POSITIVE_OR_NAN]] ; %known.negative.or.nan = call float @returns_negative_or_nan() %known.positive.or.nan = call float @returns_positive_or_nan() @@ -1337,7 +1316,7 @@ define nofpclass(snan) float @pinf__maximum__unknown(float %unknown) { ; CHECK-LABEL: define nofpclass(snan) float @pinf__maximum__unknown( ; CHECK-SAME: float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[PINF]], float [[UNKNOWN]]) +; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN]], float 0x7FF0000000000000) ; CHECK-NEXT: ret float [[RESULT]] ; %pinf = call float @returns_pinf() @@ -1349,7 +1328,7 @@ define nofpclass(snan) float @unknown__maximum__pinf(float %unknown) { ; CHECK-LABEL: define nofpclass(snan) float @unknown__maximum__pinf( ; CHECK-SAME: float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN]], float [[PINF]]) +; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN]], float 0x7FF0000000000000) ; CHECK-NEXT: ret float [[RESULT]] ; %pinf = call float @returns_pinf() @@ -1385,8 +1364,7 @@ define nofpclass(snan) float @ninf__maximum__unknown(float %unknown) { ; CHECK-LABEL: define nofpclass(snan) float @ninf__maximum__unknown( ; CHECK-SAME: float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NINF]], float [[UNKNOWN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[UNKNOWN]] ; %ninf = call float @returns_ninf() %result = call float @llvm.maximum.f32(float %ninf, float %unknown) @@ -1397,8 +1375,7 @@ define nofpclass(snan) float @unknown__maximum__ninf(float %unknown) { ; CHECK-LABEL: define nofpclass(snan) float @unknown__maximum__ninf( ; CHECK-SAME: float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[UNKNOWN]], float [[NINF]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[UNKNOWN]] ; %ninf = call float @returns_ninf() %result = call float @llvm.maximum.f32(float %unknown, float %ninf) @@ -1505,8 +1482,7 @@ define nofpclass(snan) float @pinf_or_nan__maximum__not_nan(float nofpclass(nan) ; CHECK-LABEL: define nofpclass(snan) float @pinf_or_nan__maximum__not_nan( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[PINF_OR_NAN]], float [[NOT_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[PINF_OR_NAN]] ; %pinf.or.nan = call float @returns_pinf_or_nan() %result = call float @llvm.maximum.f32(float %pinf.or.nan, float %not.nan) @@ -1517,8 +1493,7 @@ define nofpclass(snan) float @not_nan__maximum__pinf_or_nan(float nofpclass(nan) ; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximum__pinf_or_nan( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NOT_NAN]], float [[PINF_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[PINF_OR_NAN]] ; %pinf.or.nan = call float @returns_pinf_or_nan() %result = call float @llvm.maximum.f32(float %not.nan, float %pinf.or.nan) @@ -1553,8 +1528,7 @@ define nofpclass(snan) float @ninf__maximum__not_nan(float nofpclass(nan) %not.n ; CHECK-LABEL: define nofpclass(snan) float @ninf__maximum__not_nan( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NINF_OR_NAN]], float [[NOT_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[NOT_NAN]] ; %ninf.or.nan = call float @returns_ninf() %result = call float @llvm.maximum.f32(float %ninf.or.nan, float %not.nan) @@ -1565,8 +1539,7 @@ define nofpclass(snan) float @not_nan__maximum__ninf(float nofpclass(nan) %not.n ; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximum__ninf( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NOT_NAN]], float [[NINF_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[NOT_NAN]] ; %ninf.or.nan = call float @returns_ninf() %result = call float @llvm.maximum.f32(float %not.nan, float %ninf.or.nan) @@ -1577,8 +1550,7 @@ define nofpclass(snan) float @pinf__maximum__not_nan(float nofpclass(nan) %not.n ; CHECK-LABEL: define nofpclass(snan) float @pinf__maximum__not_nan( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[PINF_OR_NAN]], float [[NOT_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float 0x7FF0000000000000 ; %pinf.or.nan = call float @returns_pinf() %result = call float @llvm.maximum.f32(float %pinf.or.nan, float %not.nan) @@ -1589,8 +1561,7 @@ define nofpclass(snan) float @not_nan__maximum__pinf(float nofpclass(nan) %not.n ; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximum__pinf( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NOT_NAN]], float [[PINF_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float 0x7FF0000000000000 ; %pinf.or.nan = call float @returns_pinf() %result = call float @llvm.maximum.f32(float %not.nan, float %pinf.or.nan) @@ -1601,7 +1572,7 @@ define nofpclass(snan) float @inf__maximum__not_nan(float nofpclass(nan) %not.na ; CHECK-LABEL: define nofpclass(snan) float @inf__maximum__not_nan( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call float @returns_inf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[INF_OR_NAN]], float [[NOT_NAN]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[INF_OR_NAN]], float [[NOT_NAN]]) ; CHECK-NEXT: ret float [[RESULT]] ; %inf.or.nan = call float @returns_inf() @@ -1613,7 +1584,7 @@ define nofpclass(snan) float @not_nan__maximum__inf(float nofpclass(nan) %not.na ; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximum__inf( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call float @returns_inf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[NOT_NAN]], float [[INF_OR_NAN]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[NOT_NAN]], float [[INF_OR_NAN]]) ; CHECK-NEXT: ret float [[RESULT]] ; %inf.or.nan = call float @returns_inf() diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimum.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimum.ll index 29dee5946acd6..797872e172a24 100644 --- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimum.ll +++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimum.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.minimum.f32(float [[X]], float [[Y]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float 0x7FF8000000000000 ; %result = call float @llvm.minimum.f32(float %x, float %y) ret float %result @@ -64,7 +63,7 @@ define nofpclass(inf norm sub zero snan) float @ret_only_qnan(float %x, float %y define nofpclass(nan norm sub zero) float @ret_only_inf(float %x, float %y) { ; CHECK-LABEL: define nofpclass(nan zero sub norm) float @ret_only_inf( ; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[X]], float [[Y]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[X]], float [[Y]]) ; CHECK-NEXT: ret float [[RESULT]] ; %result = call float @llvm.minimum.f32(float %x, float %y) @@ -92,7 +91,7 @@ define nofpclass(nan ninf norm sub zero) float @ret_only_pinf(float %x, float %y define nofpclass(inf nan norm sub) float @ret_only_zero(float %x, float %y) { ; CHECK-LABEL: define nofpclass(nan inf sub norm) float @ret_only_zero( ; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[X]], float [[Y]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[X]], float [[Y]]) ; CHECK-NEXT: ret float [[RESULT]] ; %result = call float @llvm.minimum.f32(float %x, float %y) @@ -120,7 +119,7 @@ define nofpclass(inf nan norm sub pzero) float @ret_only_nzero(float %x, float % define nofpclass(nan) float @ret_no_nans(float %x, float %y) { ; CHECK-LABEL: define nofpclass(nan) float @ret_no_nans( ; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[X]], float [[Y]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[X]], float [[Y]]) ; CHECK-NEXT: ret float [[RESULT]] ; %result = call float @llvm.minimum.f32(float %x, float %y) @@ -140,7 +139,7 @@ define nofpclass(inf) float @ret_no_infs(float %x, float %y) { define nofpclass(nan inf) float @ret_no_nans_no_infs(float %x, float %y) { ; CHECK-LABEL: define nofpclass(nan inf) float @ret_no_nans_no_infs( ; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[X]], float [[Y]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[X]], float [[Y]]) ; CHECK-NEXT: ret float [[RESULT]] ; %result = call float @llvm.minimum.f32(float %x, float %y) @@ -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__minimum__negative_or_nan___negative_or_nan() { ; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN0:%.*]] = call float @returns_negative_or_nan() ; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN1:%.*]] = call float @returns_negative_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[MUST_BE_NEGATIVE_OR_NAN0]], float [[MUST_BE_NEGATIVE_OR_NAN1]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float 0x7FF8000000000000 ; %must.be.negative.or.nan0 = call float @returns_negative_or_nan() %must.be.negative.or.nan1 = call float @returns_negative_or_nan() @@ -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__minimum__positive_or_nan___positive_or_nan() { ; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN0:%.*]] = call float @returns_positive_or_nan() ; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN1:%.*]] = call float @returns_positive_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[MUST_BE_POSITIVE_OR_NAN0]], float [[MUST_BE_POSITIVE_OR_NAN1]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float 0x7FF8000000000000 ; %must.be.positive.or.nan0 = call float @returns_positive_or_nan() %must.be.positive.or.nan1 = call float @returns_positive_or_nan() @@ -260,7 +257,7 @@ define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_positive__select_a ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]] -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]]) ; CHECK-NEXT: ret float [[RESULT]] ; %always.negative = call float @returns_negative() @@ -274,7 +271,7 @@ define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_positive__unknown_ ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]] -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]]) ; CHECK-NEXT: ret float [[RESULT]] ; %always.negative = call float @returns_negative() @@ -308,7 +305,7 @@ define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_negative__simplify ; CHECK-NEXT: [[ALWAYS_NEGATIVE1:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE0]], float [[UNKNOWN0]] ; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[UNKNOWN1]], float [[ALWAYS_NEGATIVE1]] -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[SELECT_LHS]], float [[SELECT_RHS]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[SELECT_LHS]], float [[SELECT_RHS]]) ; CHECK-NEXT: ret float [[RESULT]] ; %always.negative0 = call float @returns_negative() @@ -324,7 +321,7 @@ define nofpclass(nan) float @no_fold_select_always_negative_0(i1 %cond, float %u ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]] -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]]) ; CHECK-NEXT: ret float [[RESULT]] ; %always.negative = call float @returns_negative() @@ -338,7 +335,7 @@ define nofpclass(nan) float @no_fold_select_always_negative_1(i1 %cond, float %u ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ALWAYS_NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NEGATIVE]], float [[UNKNOWN0]] -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]]) ; CHECK-NEXT: ret float [[RESULT]] ; %always.negative = call float @returns_negative() @@ -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.minimum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]]) ; CHECK-NEXT: ret float [[RESULT]] ; %must.be.negative.or.zero = call float @returns_positive_or_zero() @@ -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.minimum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]]) ; CHECK-NEXT: ret float [[RESULT]] ; %must.be.negative.or.zero = call float @returns_positive_or_zero() @@ -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.minimum.f32(float [[MUST_BE_PINF]], float [[UNKNOWN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[UNKNOWN]] ; %result = call float @llvm.minimum.f32(float %must.be.pinf, float %unknown) ret float %result @@ -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.minimum.f32(float [[UNKNOWN]], float [[MUST_BE_PINF]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[UNKNOWN]] ; %result = call float @llvm.minimum.f32(float %unknown, float %must.be.pinf) ret float %result @@ -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.minimum.f32(float [[MUST_BE_PINF]], float [[NOT_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[NOT_NAN]] ; %result = call float @llvm.minimum.f32(float %must.be.pinf, float %not.nan) ret float %result @@ -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.minimum.f32(float [[NOT_NAN]], float [[MUST_BE_PINF]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[NOT_NAN]] ; %result = call float @llvm.minimum.f32(float %not.nan, float %must.be.pinf) ret float %result @@ -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.minimum.f32(float [[MUST_BE_NINF]], float [[UNKNOWN]]) +; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN]], float 0xFFF0000000000000) ; CHECK-NEXT: ret float [[RESULT]] ; %result = call float @llvm.minimum.f32(float %must.be.ninf, float %unknown) @@ -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.minimum.f32(float [[UNKNOWN]], float [[MUST_BE_NINF]]) +; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN]], float 0xFFF0000000000000) ; CHECK-NEXT: ret float [[RESULT]] ; %result = call float @llvm.minimum.f32(float %unknown, float %must.be.ninf) @@ -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.minimum.f32(float [[MUST_BE_NINF]], float [[NOT_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float 0xFFF0000000000000 ; %result = call float @llvm.minimum.f32(float %must.be.ninf, float %not.nan) ret float %result @@ -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.minimum.f32(float [[NOT_NAN]], float [[MUST_BE_NINF]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float 0xFFF0000000000000 ; %result = call float @llvm.minimum.f32(float %not.nan, float %must.be.ninf) ret float %result @@ -803,7 +794,7 @@ define nofpclass(snan) float @unknown__minimum__not_nan(float %x, float nofpclas define nofpclass(snan) float @not_nan__minimum__not_nan(float nofpclass(nan) %x, float nofpclass(nan) %y) { ; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimum__not_nan( ; CHECK-SAME: float nofpclass(nan) [[X:%.*]], float nofpclass(nan) [[Y:%.*]]) { -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[X]], float [[Y]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[X]], float [[Y]]) ; CHECK-NEXT: ret float [[RESULT]] ; %result = call float @llvm.minimum.f32(float %x, float %y) @@ -834,7 +825,7 @@ define nofpclass(snan) float @known_positive__minimum__only_zero() { ; CHECK-LABEL: define nofpclass(snan) float @known_positive__minimum__only_zero() { ; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive() ; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_ZERO]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.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__minimum__known_positive() { ; CHECK-LABEL: define nofpclass(snan) float @only_zero__minimum__known_positive() { ; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero() ; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE]]) ; CHECK-NEXT: ret float [[RESULT]] ; %known.zero = call float @returns_zero() @@ -1012,7 +1003,7 @@ define nofpclass(snan) float @known_negative__minimum__only_nzero() { ; CHECK-LABEL: define nofpclass(snan) float @known_negative__minimum__only_nzero() { ; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[KNOWN_NZERO:%.*]] = call float @returns_nzero() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_NEGATIVE]], float [[KNOWN_NZERO]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[KNOWN_NEGATIVE]], float -0.000000e+00) ; CHECK-NEXT: ret float [[RESULT]] ; %known.negative = call float @returns_negative() @@ -1025,7 +1016,7 @@ define nofpclass(snan) float @only_nzero__minimum__known_negative() { ; CHECK-LABEL: define nofpclass(snan) float @only_nzero__minimum__known_negative() { ; CHECK-NEXT: [[KNOWN_NZERO:%.*]] = call float @returns_nzero() ; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_NZERO]], float [[KNOWN_NEGATIVE]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[KNOWN_NEGATIVE]], float -0.000000e+00) ; CHECK-NEXT: ret float [[RESULT]] ; %known.nzero = call float @returns_nzero() @@ -1064,8 +1055,7 @@ define nofpclass(snan) float @known_negative__minimum__only_pzero() { ; CHECK-LABEL: define nofpclass(snan) float @known_negative__minimum__only_pzero() { ; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_NEGATIVE]], float [[KNOWN_PZERO]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]] ; %known.negative = call float @returns_negative() %known.pzero = call float @returns_pzero() @@ -1077,8 +1067,7 @@ define nofpclass(snan) float @only_pzero__minimum__known_negative() { ; CHECK-LABEL: define nofpclass(snan) float @only_pzero__minimum__known_negative() { ; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero() ; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_PZERO]], float [[KNOWN_NEGATIVE]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_NEGATIVE]] ; %known.pzero = call float @returns_pzero() %known.negative = call float @returns_negative() @@ -1185,8 +1174,7 @@ define nofpclass(nan) float @ret_nonan__known_negative_or_nan__minimum__known_po ; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__known_negative_or_nan__minimum__known_positive_or_nan() { ; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan() ; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[MUST_BE_NEGATIVE_OR_NAN]], float [[MUST_BE_POSITIVE_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[MUST_BE_NEGATIVE_OR_NAN]] ; %must.be.negative.or.nan = call float @returns_negative_or_nan() %must.be.positive.or.nan = call float @returns_positive_or_nan() @@ -1198,8 +1186,7 @@ define nofpclass(nan) float @ret_nonan__known_positive_or_nan__minimum__known_ne ; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__known_positive_or_nan__minimum__known_negative_or_nan() { ; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan() ; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[MUST_BE_POSITIVE_OR_NAN]], float [[MUST_BE_NEGATIVE_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[MUST_BE_NEGATIVE_OR_NAN]] ; %must.be.positive.or.nan = call float @returns_positive_or_nan() %must.be.negative.or.nan = call float @returns_negative_or_nan() @@ -1211,8 +1198,7 @@ define nofpclass(nan) float @ret_nonan__select_nan_or_unknown__minimum__unknown( ; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__select_nan_or_unknown__minimum__unknown( ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ALWAYS_NAN:%.*]] = call float @returns_nan() -; CHECK-NEXT: [[SELECT_LHS:%.*]] = select i1 [[COND]], float [[ALWAYS_NAN]], float [[UNKNOWN0]] -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[SELECT_LHS]], float [[UNKNOWN1]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[UNKNOWN0]], float [[UNKNOWN1]]) ; CHECK-NEXT: ret float [[RESULT]] ; %always.nan = call float @returns_nan() @@ -1225,8 +1211,7 @@ define nofpclass(nan) float @ret_nonan__unknown__minimum__select_nan_or_unknown( ; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__unknown__minimum__select_nan_or_unknown( ; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) { ; CHECK-NEXT: [[ALWAYS_NAN:%.*]] = call float @returns_nan() -; CHECK-NEXT: [[SELECT_RHS:%.*]] = select i1 [[COND]], float [[UNKNOWN0]], float [[ALWAYS_NAN]] -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN1]], float [[SELECT_RHS]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[UNKNOWN1]], float [[UNKNOWN0]]) ; CHECK-NEXT: ret float [[RESULT]] ; %always.nan = call float @returns_nan() @@ -1259,8 +1244,7 @@ define nofpclass(snan) float @known_always_positive__minimum__known_always_negat ; CHECK-LABEL: define nofpclass(snan) float @known_always_positive__minimum__known_always_negative_or_nan() { ; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive() ; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_NEGATIVE_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_NEGATIVE_OR_NAN]] ; %known.positive = call float @returns_positive() %known.negative.or.nan = call float @returns_negative_or_nan() @@ -1272,8 +1256,7 @@ define nofpclass(snan) float @known_always_negative_or_nan__minimum__known_alway ; CHECK-LABEL: define nofpclass(snan) float @known_always_negative_or_nan__minimum__known_always_positive() { ; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan() ; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_NEGATIVE_OR_NAN]], float [[KNOWN_POSITIVE]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_NEGATIVE_OR_NAN]] ; %known.negative.or.nan = call float @returns_negative_or_nan() %known.positive = call float @returns_positive() @@ -1311,8 +1294,7 @@ define nofpclass(nan) float @ret_no_nan__known_always_positive_or_nan__minimum__ ; CHECK-LABEL: define nofpclass(nan) float @ret_no_nan__known_always_positive_or_nan__minimum__known_always_negative_or_nan() { ; CHECK-NEXT: [[KNOWN_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan() ; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_POSITIVE_OR_NAN]], float [[KNOWN_NEGATIVE_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_NEGATIVE_OR_NAN]] ; %known.positive.or.nan = call float @returns_positive_or_nan() %known.negative.or.nan = call float @returns_negative_or_nan() @@ -1324,8 +1306,7 @@ define nofpclass(nan) float @ret_no_nan__known_always_negative_or_nan__minimum__ ; CHECK-LABEL: define nofpclass(nan) float @ret_no_nan__known_always_negative_or_nan__minimum__known_always_positive_or_nan() { ; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan() ; CHECK-NEXT: [[KNOWN_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[KNOWN_NEGATIVE_OR_NAN]], float [[KNOWN_POSITIVE_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_NEGATIVE_OR_NAN]] ; %known.negative.or.nan = call float @returns_negative_or_nan() %known.positive.or.nan = call float @returns_positive_or_nan() @@ -1337,8 +1318,7 @@ define nofpclass(snan) float @pinf__minimum__unknown(float %unknown) { ; CHECK-LABEL: define nofpclass(snan) float @pinf__minimum__unknown( ; CHECK-SAME: float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[PINF]], float [[UNKNOWN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[UNKNOWN]] ; %pinf = call float @returns_pinf() %result = call float @llvm.minimum.f32(float %pinf, float %unknown) @@ -1349,8 +1329,7 @@ define nofpclass(snan) float @unknown__minimum__pinf(float %unknown) { ; CHECK-LABEL: define nofpclass(snan) float @unknown__minimum__pinf( ; CHECK-SAME: float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[PINF:%.*]] = call float @returns_pinf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN]], float [[PINF]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[UNKNOWN]] ; %pinf = call float @returns_pinf() %result = call float @llvm.minimum.f32(float %unknown, float %pinf) @@ -1385,7 +1364,7 @@ define nofpclass(snan) float @ninf__minimum__unknown(float %unknown) { ; CHECK-LABEL: define nofpclass(snan) float @ninf__minimum__unknown( ; CHECK-SAME: float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NINF]], float [[UNKNOWN]]) +; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN]], float 0xFFF0000000000000) ; CHECK-NEXT: ret float [[RESULT]] ; %ninf = call float @returns_ninf() @@ -1397,7 +1376,7 @@ define nofpclass(snan) float @unknown__minimum__ninf(float %unknown) { ; CHECK-LABEL: define nofpclass(snan) float @unknown__minimum__ninf( ; CHECK-SAME: float [[UNKNOWN:%.*]]) { ; CHECK-NEXT: [[NINF:%.*]] = call float @returns_ninf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN]], float [[NINF]]) +; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[UNKNOWN]], float 0xFFF0000000000000) ; CHECK-NEXT: ret float [[RESULT]] ; %ninf = call float @returns_ninf() @@ -1481,8 +1460,7 @@ define nofpclass(snan) float @ninf_or_nan__minimum__not_nan(float nofpclass(nan) ; CHECK-LABEL: define nofpclass(snan) float @ninf_or_nan__minimum__not_nan( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NINF_OR_NAN]], float [[NOT_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[NINF_OR_NAN]] ; %ninf.or.nan = call float @returns_ninf_or_nan() %result = call float @llvm.minimum.f32(float %ninf.or.nan, float %not.nan) @@ -1493,8 +1471,7 @@ define nofpclass(snan) float @not_nan__minimum__ninf_or_nan(float nofpclass(nan) ; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimum__ninf_or_nan( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NOT_NAN]], float [[NINF_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[NINF_OR_NAN]] ; %ninf.or.nan = call float @returns_ninf_or_nan() %result = call float @llvm.minimum.f32(float %not.nan, float %ninf.or.nan) @@ -1553,8 +1530,7 @@ define nofpclass(snan) float @ninf__minimum__not_nan(float nofpclass(nan) %not.n ; CHECK-LABEL: define nofpclass(snan) float @ninf__minimum__not_nan( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NINF_OR_NAN]], float [[NOT_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float 0xFFF0000000000000 ; %ninf.or.nan = call float @returns_ninf() %result = call float @llvm.minimum.f32(float %ninf.or.nan, float %not.nan) @@ -1565,8 +1541,7 @@ define nofpclass(snan) float @not_nan__minimum__ninf(float nofpclass(nan) %not.n ; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimum__ninf( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[NINF_OR_NAN:%.*]] = call float @returns_ninf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NOT_NAN]], float [[NINF_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float 0xFFF0000000000000 ; %ninf.or.nan = call float @returns_ninf() %result = call float @llvm.minimum.f32(float %not.nan, float %ninf.or.nan) @@ -1577,8 +1552,7 @@ define nofpclass(snan) float @pinf__minimum__not_nan(float nofpclass(nan) %not.n ; CHECK-LABEL: define nofpclass(snan) float @pinf__minimum__not_nan( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[PINF_OR_NAN]], float [[NOT_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[NOT_NAN]] ; %pinf.or.nan = call float @returns_pinf() %result = call float @llvm.minimum.f32(float %pinf.or.nan, float %not.nan) @@ -1589,8 +1563,7 @@ define nofpclass(snan) float @not_nan__minimum__pinf(float nofpclass(nan) %not.n ; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimum__pinf( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[PINF_OR_NAN:%.*]] = call float @returns_pinf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NOT_NAN]], float [[PINF_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[NOT_NAN]] ; %pinf.or.nan = call float @returns_pinf() %result = call float @llvm.minimum.f32(float %not.nan, float %pinf.or.nan) @@ -1601,7 +1574,7 @@ define nofpclass(snan) float @inf__minimum__not_nan(float nofpclass(nan) %not.na ; CHECK-LABEL: define nofpclass(snan) float @inf__minimum__not_nan( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call float @returns_inf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[INF_OR_NAN]], float [[NOT_NAN]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[INF_OR_NAN]], float [[NOT_NAN]]) ; CHECK-NEXT: ret float [[RESULT]] ; %inf.or.nan = call float @returns_inf() @@ -1613,7 +1586,7 @@ define nofpclass(snan) float @not_nan__minimum__inf(float nofpclass(nan) %not.na ; CHECK-LABEL: define nofpclass(snan) float @not_nan__minimum__inf( ; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]]) { ; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call float @returns_inf() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.minimum.f32(float [[NOT_NAN]], float [[INF_OR_NAN]]) +; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.minimum.f32(float [[NOT_NAN]], float [[INF_OR_NAN]]) ; CHECK-NEXT: ret float [[RESULT]] ; %inf.or.nan = call float @returns_inf() _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
