llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-llvm-transforms Author: Matt Arsenault (arsenm) <details> <summary>Changes</summary> Refine handling of minimum/maximum and minimumnum/maximumnum. The previous folds to input were based on sign bit checks. This was too conservative with 0s. This can now consider -0 as less than or equal to +0 as appropriate, account for nsz. It additionally can handle cases like one half is known positive normal and the other subnormal. --- Patch is 65.87 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/175382.diff 5 Files Affected: - (modified) llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp (+28-57) - (modified) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll (+22-44) - (modified) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll (+23-46) - (modified) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimum.ll (+23-58) - (modified) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll (+22-52) ``````````diff diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp index f4f7450e69c29..b1537530dd91a 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp @@ -2307,29 +2307,23 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I, KnownRHS.knownNot(fcNan); } - KnownFPClass::MinMaxKind OpKind; + bool OrderedZeroSign = !FMF.noSignedZeros(); + KnownFPClass::MinMaxKind OpKind; switch (IID) { case Intrinsic::maximum: { OpKind = KnownFPClass::MinMaxKind::maximum; - // If at least one operand is known to be positive and the other - // negative, the result must be the positive (unless the other operand - // may be propagating a nan). - if (KnownLHS.isKnownNever(fcNegative) && - KnownRHS.isKnownNever(fcPositive | fcNan)) - return CI->getArgOperand(0); - - if (KnownRHS.isKnownNever(fcNegative) && - KnownLHS.isKnownNever(fcPositive | fcNan)) - return CI->getArgOperand(1); - - // If one value must be pinf, the result is pinf or a propagated nan. - if (KnownLHS.isKnownAlways(fcPosInf | fcNan) && + // If one operand is known greater than the other, it must be that + // operand unless the other is a nan. + if (cannotOrderStrictlyLess(KnownLHS.KnownFPClasses, + KnownRHS.KnownFPClasses, OrderedZeroSign) && KnownRHS.isKnownNever(fcNan)) return CI->getArgOperand(0); - if (KnownRHS.isKnownAlways(fcPosInf | fcNan) && + if (cannotOrderStrictlyGreater(KnownLHS.KnownFPClasses, + KnownRHS.KnownFPClasses, + OrderedZeroSign) && KnownLHS.isKnownNever(fcNan)) return CI->getArgOperand(1); @@ -2338,23 +2332,16 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I, case Intrinsic::minimum: { OpKind = KnownFPClass::MinMaxKind::minimum; - // If one operand is known to be negative, and the other positive, the - // result must be the negative (unless the other operand may be - // propagating a nan). - if (KnownLHS.isKnownNever(fcPositive) && - KnownRHS.isKnownNever(fcNegative | fcNan)) - return CI->getArgOperand(0); - - if (KnownRHS.isKnownNever(fcPositive) && - KnownLHS.isKnownNever(fcNegative | fcNan)) - return CI->getArgOperand(1); - - // If one value must be ninf, the result is ninf or a propagated nan. - if (KnownLHS.isKnownAlways(fcNegInf | fcNan) && + // If one operand is known less than the other, it must be that operand + // unless the other is a nan. + if (cannotOrderStrictlyGreater(KnownLHS.KnownFPClasses, + KnownRHS.KnownFPClasses, + OrderedZeroSign) && KnownRHS.isKnownNever(fcNan)) return CI->getArgOperand(0); - if (KnownRHS.isKnownAlways(fcNegInf | fcNan) && + if (cannotOrderStrictlyLess(KnownLHS.KnownFPClasses, + KnownRHS.KnownFPClasses, OrderedZeroSign) && KnownLHS.isKnownNever(fcNan)) return CI->getArgOperand(1); @@ -2363,49 +2350,33 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I, case Intrinsic::maximumnum: { OpKind = KnownFPClass::MinMaxKind::maximumnum; - // If at least one operand is known to be positive and the other - // negative, the result must be the positive. - if (KnownLHS.isKnownNever(fcNegative | fcNan) && - KnownRHS.isKnownNever(fcPositive)) + if (cannotOrderStrictlyLess(KnownLHS.KnownFPClasses, + KnownRHS.KnownFPClasses, OrderedZeroSign) && + KnownLHS.isKnownNever(fcNan)) return CI->getArgOperand(0); - if (KnownRHS.isKnownNever(fcNegative | fcNan) && - KnownLHS.isKnownNever(fcPositive)) - return CI->getArgOperand(1); - - // If one value must be ninf or nan, the other value must be returned - if (KnownLHS.isKnownAlways(fcNegInf | fcNan) && + if (cannotOrderStrictlyGreater(KnownLHS.KnownFPClasses, + KnownRHS.KnownFPClasses, + OrderedZeroSign) && KnownRHS.isKnownNever(fcNan)) return CI->getArgOperand(1); - if (KnownRHS.isKnownAlways(fcNegInf | fcNan) && - KnownLHS.isKnownNever(fcNan)) - return CI->getArgOperand(0); - break; } case Intrinsic::minimumnum: { OpKind = KnownFPClass::MinMaxKind::minimumnum; - // If at least one operand is known to be negative and the other - // positive, the result must be the negative - if (KnownLHS.isKnownNever(fcPositive | fcNan) && - KnownRHS.isKnownNever(fcNegative)) + if (cannotOrderStrictlyGreater(KnownLHS.KnownFPClasses, + KnownRHS.KnownFPClasses, + OrderedZeroSign) && + KnownLHS.isKnownNever(fcNan)) return CI->getArgOperand(0); - if (KnownRHS.isKnownNever(fcPositive | fcNan) && - KnownLHS.isKnownNever(fcNegative)) - return CI->getArgOperand(1); - - // If one value must be pinf or nan, the other value must be returned - if (KnownLHS.isKnownAlways(fcPosInf | fcNan) && + if (cannotOrderStrictlyLess(KnownLHS.KnownFPClasses, + KnownRHS.KnownFPClasses, OrderedZeroSign) && KnownRHS.isKnownNever(fcNan)) return CI->getArgOperand(1); - if (KnownRHS.isKnownAlways(fcPosInf | fcNan) && - KnownLHS.isKnownNever(fcNan)) - return CI->getArgOperand(0); - break; } default: diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll index 4ebbc064c16f3..8d11ce6bfccc9 100644 --- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll +++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll @@ -389,8 +389,7 @@ define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_0() { ; CHECK-LABEL: define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_0() { ; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero() ; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero() -; CHECK-NEXT: [[RESULT:%.*]] = call nnan nsz float @llvm.maximum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[MUST_BE_NEGATIVE_OR_ZERO]] ; %must.be.negative.or.zero = call float @returns_positive_or_zero() %must.be.positive.or.zero = call float @returns_negative_or_zero() @@ -402,8 +401,7 @@ define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_1() { ; CHECK-LABEL: define nofpclass(snan) float @nsz_fold_negative_or_zero__positive_or_zero_1() { ; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero() ; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero() -; CHECK-NEXT: [[RESULT:%.*]] = call nnan nsz float @llvm.maximum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[MUST_BE_NEGATIVE_OR_ZERO]] ; %must.be.negative.or.zero = call float @returns_positive_or_zero() %must.be.positive.or.zero = call float @returns_negative_or_zero() @@ -864,8 +862,7 @@ define nofpclass(snan) float @known_positive__maximum__only_zero() { ; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximum__only_zero() { ; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive() ; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero() -; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_ZERO]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_POSITIVE]] ; %known.positive = call float @returns_positive() %known.zero = call float @returns_zero() @@ -877,8 +874,7 @@ define nofpclass(snan) float @only_zero__maximum__known_positive() { ; CHECK-LABEL: define nofpclass(snan) float @only_zero__maximum__known_positive() { ; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero() ; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive() -; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_POSITIVE]] ; %known.zero = call float @returns_zero() %known.positive = call float @returns_positive() @@ -916,8 +912,7 @@ define nofpclass(snan) float @known_positive_or_nan__maximum__only_zero() { ; CHECK-LABEL: define nofpclass(snan) float @known_positive_or_nan__maximum__only_zero() { ; CHECK-NEXT: [[KNOWN_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan() ; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_POSITIVE_OR_NAN]], float [[KNOWN_ZERO]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_POSITIVE_OR_NAN]] ; %known.positive.or.nan = call float @returns_positive_or_nan() %known.zero = call float @returns_zero() @@ -929,8 +924,7 @@ define nofpclass(snan) float @only_zero__maximum__known_positive_or_nan() { ; CHECK-LABEL: define nofpclass(snan) float @only_zero__maximum__known_positive_or_nan() { ; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero() ; CHECK-NEXT: [[KNOWN_POSITIVE_OR_NAN:%.*]] = call float @returns_positive_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_POSITIVE_OR_NAN]] ; %known.zero = call float @returns_zero() %known.positive.or.nan = call float @returns_positive_or_nan() @@ -966,8 +960,7 @@ define nofpclass(snan) float @known_positive__maximum__only_pzero() { ; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximum__only_pzero() { ; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive() ; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero() -; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[KNOWN_POSITIVE]], float 0.000000e+00) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_POSITIVE]] ; %known.positive = call float @returns_positive() %known.pzero = call float @returns_pzero() @@ -979,8 +972,7 @@ define nofpclass(snan) float @only_pzero__maximum__known_positive() { ; CHECK-LABEL: define nofpclass(snan) float @only_pzero__maximum__known_positive() { ; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero() ; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive() -; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[KNOWN_POSITIVE]], float 0.000000e+00) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_POSITIVE]] ; %known.pzero = call float @returns_pzero() %known.positive = call float @returns_positive() @@ -992,8 +984,7 @@ define nofpclass(snan) float @known_negative__maximum__only_zero_or_nan() { ; CHECK-LABEL: define nofpclass(snan) float @known_negative__maximum__only_zero_or_nan() { ; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[KNOWN_ZERO_OR_NAN:%.*]] = call float @returns_zero_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_NEGATIVE]], float [[KNOWN_ZERO_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_ZERO_OR_NAN]] ; %known.negative = call float @returns_negative() %known.zero.or.nan = call float @returns_zero_or_nan() @@ -1005,8 +996,7 @@ define nofpclass(snan) float @only_zero_or_nan__maximum__known_negative() { ; CHECK-LABEL: define nofpclass(snan) float @only_zero_or_nan__maximum__known_negative() { ; CHECK-NEXT: [[KNOWN_ZERO_OR_NAN:%.*]] = call float @returns_zero_or_nan() ; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_ZERO_OR_NAN]], float [[KNOWN_NEGATIVE]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_ZERO_OR_NAN]] ; %known.zero.or.nan = call float @returns_zero_or_nan() %known.negative = call float @returns_negative() @@ -1068,8 +1058,7 @@ define nofpclass(snan) float @known_negative__maximum__only_nzero_or_nan() { ; CHECK-LABEL: define nofpclass(snan) float @known_negative__maximum__only_nzero_or_nan() { ; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[KNOWN_NZERO_OR_NAN:%.*]] = call float @returns_nzero_or_nan() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_NEGATIVE]], float [[KNOWN_NZERO_OR_NAN]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_NZERO_OR_NAN]] ; %known.negative = call float @returns_negative() %known.nzero.or.nan = call float @returns_nzero_or_nan() @@ -1081,8 +1070,7 @@ define nofpclass(snan) float @only_nzero_or_nan__maximum__known_negative() { ; CHECK-LABEL: define nofpclass(snan) float @only_nzero_or_nan__maximum__known_negative() { ; CHECK-NEXT: [[KNOWN_NZERO_OR_NAN:%.*]] = call float @returns_nzero_or_nan() ; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = call float @returns_negative() -; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[KNOWN_NZERO_OR_NAN]], float [[KNOWN_NEGATIVE]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[KNOWN_NZERO_OR_NAN]] ; %known.nzero.or.nan = call float @returns_nzero_or_nan() %known.negative = call float @returns_negative() @@ -1740,8 +1728,7 @@ define nofpclass(snan) float @select_is_positive_or_0__maximum__nnorm_0(float no ; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00 ; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm() -; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[SELECT]], float [[NNORM]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[SELECT]] ; %is.pos.or.zero = fcmp oge float %arg, 0.0 %select = select i1 %is.pos.or.zero, float %arg, float 0.0 @@ -1756,8 +1743,7 @@ define nofpclass(snan) float @select_is_positive_or_0__maximum__nnorm_1(float no ; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm() ; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00 -; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[NNORM]], float [[SELECT]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[SELECT]] ; %nnorm = call float @returns_nnorm() %is.pos.or.zero = fcmp oge float %arg, 0.0 @@ -1804,8 +1790,7 @@ define nofpclass(snan) float @select_is_positive_or_0__maximum__negative(float n ; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00 ; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative() -; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[SELECT]], float [[NEGATIVE]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[SELECT]] ; %is.pos.or.zero = fcmp oge float %arg, 0.0 %select = select i1 %is.pos.or.zero, float %arg, float 0.0 @@ -1820,8 +1805,7 @@ define nofpclass(snan) float @negative__maximum__select_is_positive_or_0(float n ; CHECK-NEXT: [[NEGATIVE:%.*]] = call float @returns_negative() ; CHECK-NEXT: [[IS_POS_OR_ZERO:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 ; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_POS_OR_ZERO]], float [[ARG]], float 0.000000e+00 -; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[NEGATIVE]], float [[SELECT]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[SELECT]] ; %negative = call float @returns_negative() %is.pos.or.zero = fcmp oge float %arg, 0.0 @@ -1890,8 +1874,7 @@ define nofpclass(snan) float @negative_or_zero__maximum__positive_or_zero() { ; CHECK-LABEL: define nofpclass(snan) float @negative_or_zero__maximum__positive_or_zero() { ; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero() ; CHECK-NEXT: [[POSITIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero() -; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[NEG_NONZERO]], float [[POSITIVE_OR_ZERO]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[POSITIVE_OR_ZERO]] ; %neg.nonzero = call float @returns_negative_nonzero() %positive.or.zero = call float @returns_positive_or_zero() @@ -1903,8 +1886,7 @@ define nofpclass(snan) float @positive_or_zero__maximum__negative_or_zero() { ; CHECK-LABEL: define nofpclass(snan) float @positive_or_zero__maximum__negative_or_zero() { ; CHECK-NEXT: [[POSITIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero() ; CHECK-NEXT: [[NEG_NONZERO:%.*]] = call float @returns_negative_nonzero() -; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[POSITIVE_OR_ZERO]], float [[NEG_NONZERO]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[POSITIVE_OR_ZERO]] ; %positive.or.zero = call float @returns_positive_or_zero() %neg.nonzero = call float @returns_negative_nonzero() @@ -1990,8 +1972,7 @@ define nofpclass(snan) float @known_pnorm__maximum__known_psub() { ; CHECK-LABEL: define nofpclass(snan) float @known_pnorm__maximum__known_psub() { ; CHECK-NEXT: [[PNORM:%.*]] = call float @returns_pnorm() ; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub() -; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[PNORM]], float [[PSUB]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[PNORM]] ; %pnorm = call float @returns_pnorm() %psub = call float @returns_psub() @@ -2003,8 +1984,7 @@ define nofpclass(snan) float @known_psub__maximum__known_pnorm() { ; CHECK-LABEL: define nofpclass(snan) float @known_psub__maximum__known_pnorm() { ; CHECK-NEXT: [[PSUB:%.*]] = call float @returns_psub() ; CHECK-NEXT: [[PNORM:%.*]] = call float @returns_pnorm() -; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[PSUB]], float [[PNORM]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[PNORM]] ; %psub = call float @returns_psub() %pnorm = call float @returns_pnorm() @@ -2040,8 +2020,7 @@ define nofpclass(snan) float @known_nnorm__maximum__known_nsub() { ; CHECK-LABEL: define nofpclass(snan) float @known_nnorm__maximum__known_nsub() { ; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm() ; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub() -; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[NNORM]], float [[NSUB]]) -; CHECK-NEXT: ret float [[RESULT]] +; CHECK-NEXT: ret float [[NSUB]] ; %nnorm = call float @returns_nnorm() %nsub = call float @returns_nsub() @@ -2053,8 +2032,7 @@ define nofpclass(snan) float @known_nsub__maximum__known_nnorm() { ; CHECK-LABEL: define nofpclass(snan) float @known_nsub__maximum__known_nnorm() { ; CHECK-NEXT: [[NSUB:%.*]] = call float @returns_nsub() ; CHECK-NEXT: [[NNORM:%.*]] = call float @returns_nnorm() -; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximum.f32(float [[NSUB]], float [[N... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/175382 _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
