[llvm-branch-commits] [llvm] InstCombine: Handle minimumnum/maximumnum in SimplifyDemandedFPClass (PR #173977)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Tue Dec 30 03:12:52 PST 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-support
Author: Matt Arsenault (arsenm)
<details>
<summary>Changes</summary>
---
Patch is 51.79 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/173977.diff
3 Files Affected:
- (modified) llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp (+64-12)
- (modified) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll (+34-55)
- (modified) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimumnum.ll (+36-59)
``````````diff
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
index 2ae9221a00cbd..3cf5615ecb43f 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
@@ -2113,26 +2113,35 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Value *V,
break;
}
case Intrinsic::maximum:
- case Intrinsic::minimum: {
- KnownFPClass KnownLHS, KnownRHS;
+ case Intrinsic::minimum:
+ case Intrinsic::maximumnum:
+ case Intrinsic::minimumnum: {
+ const bool PropagateNaN =
+ IID == Intrinsic::maximum || IID == Intrinsic::minimum;
// We can't tell much based on the demanded result without inspecting the
// operands (e.g., a known-positive result could have been clamped), but
// we can still prune known-nan inputs.
- FPClassTest SrcDemandedMask = DemandedMask | ~fcNan;
+ FPClassTest SrcDemandedMask =
+ PropagateNaN ? DemandedMask | ~fcNan : fcAllFlags;
+ KnownFPClass KnownLHS, KnownRHS;
if (SimplifyDemandedFPClass(CI, 1, SrcDemandedMask, KnownRHS,
Depth + 1) ||
SimplifyDemandedFPClass(CI, 0, SrcDemandedMask, KnownLHS, Depth + 1))
return I;
/// Propagate nnan-ness to simplify edge case checks.
- if ((DemandedMask & fcNan) == fcNone) {
+ if (PropagateNaN && (DemandedMask & fcNan) == fcNone) {
KnownLHS.knownNot(fcNan);
KnownRHS.knownNot(fcNan);
}
+ KnownFPClass::MinMaxKind OpKind;
+
if (IID == Intrinsic::maximum) {
+ OpKind = KnownFPClass::MinMaxKind::maximum;
+
// If at least one operand is known to be positive and the other
// negative, the result must be the positive (unless the other operand
// may be propagating a nan).
@@ -2152,7 +2161,9 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Value *V,
if (KnownRHS.isKnownAlways(fcPosInf | fcNan) &&
KnownLHS.isKnownNever(fcNan))
return CI->getArgOperand(1);
- } else {
+ } else if (IID == Intrinsic::minimum) {
+ OpKind = KnownFPClass::MinMaxKind::minimum;
+
// If one operand is known to be negative, and the other positive, the
// result must be the negative (unless the other operand may be
// propagating a nan).
@@ -2172,15 +2183,54 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Value *V,
if (KnownRHS.isKnownAlways(fcNegInf | fcNan) &&
KnownLHS.isKnownNever(fcNan))
return CI->getArgOperand(1);
- }
+ } else if (IID == Intrinsic::maximumnum) {
+ OpKind = KnownFPClass::MinMaxKind::maximumnum;
+
+ // If at least one operand is known to be positive and the other
+ // negative, the result must be the positive.
+ if (KnownLHS.isKnownNever(fcNegative | fcNan) &&
+ KnownRHS.isKnownNever(fcPositive))
+ return CI->getArgOperand(0);
+
+ if (KnownRHS.isKnownNever(fcNegative | fcNan) &&
+ KnownLHS.isKnownNever(fcPositive))
+ return CI->getArgOperand(1);
+
+ // If one value must be ninf or nan, the other value must be returned
+ if (KnownLHS.isKnownAlways(fcNegInf | fcNan) &&
+ KnownRHS.isKnownNever(fcNan))
+ return CI->getArgOperand(1);
+
+ if (KnownRHS.isKnownAlways(fcNegInf | fcNan) &&
+ KnownLHS.isKnownNever(fcNan))
+ return CI->getArgOperand(0);
+ } else if (IID == Intrinsic::minimumnum) {
+ OpKind = KnownFPClass::MinMaxKind::minimumnum;
+
+ // If at least one operand is known to be negative and the other
+ // positive, the result must be the negative
+ if (KnownLHS.isKnownNever(fcPositive | fcNan) &&
+ KnownRHS.isKnownNever(fcNegative))
+ return CI->getArgOperand(0);
+
+ if (KnownRHS.isKnownNever(fcPositive | fcNan) &&
+ KnownLHS.isKnownNever(fcNegative))
+ return CI->getArgOperand(1);
+
+ // If one value must be pinf or nan, the other value must be returned
+ if (KnownLHS.isKnownAlways(fcPosInf | fcNan) &&
+ KnownRHS.isKnownNever(fcNan))
+ return CI->getArgOperand(1);
+
+ if (KnownRHS.isKnownAlways(fcPosInf | fcNan) &&
+ KnownLHS.isKnownNever(fcNan))
+ return CI->getArgOperand(0);
+ } else
+ llvm_unreachable("not a min/max intrinsic");
Type *EltTy = VTy->getScalarType();
DenormalMode Mode = F.getDenormalMode(EltTy->getFltSemantics());
- Known = KnownFPClass::minMaxLike(KnownLHS, KnownRHS,
- IID == Intrinsic::maximum
- ? KnownFPClass::MinMaxKind::maximum
- : KnownFPClass::MinMaxKind::minimum,
- Mode);
+ Known = KnownFPClass::minMaxLike(KnownLHS, KnownRHS, OpKind, Mode);
FPClassTest ValidResults = DemandedMask & Known.KnownFPClasses;
@@ -2194,7 +2244,9 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Value *V,
// TODO: Add NSZ flag if we know the result will not be sensitive on the
// sign of 0.
- if (!FPOp->hasNoNaNs() && (ValidResults & fcNan) == fcNone) {
+ if (!FPOp->hasNoNaNs() &&
+ ((PropagateNaN && (ValidResults & fcNan) == fcNone) ||
+ (KnownLHS.isKnownNeverNaN() && KnownRHS.isKnownNeverNaN()))) {
CI->setHasNoNaNs(true);
ChangedFlags = true;
}
diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll
index fcbe2df985ea5..4c3769db721a4 100644
--- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll
+++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximumnum.ll
@@ -34,8 +34,7 @@ declare nofpclass(norm sub zero) float @returns_inf_or_nan()
define nofpclass(inf norm sub zero) float @ret_only_nan(float %x, float %y) {
; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_only_nan(
; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[X]], float [[Y]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF8000000000000
;
%result = call float @llvm.maximumnum.f32(float %x, float %y)
ret float %result
@@ -152,8 +151,7 @@ define nofpclass(ninf nnorm nsub nzero) float @ret_known_positive_or_nan__maximu
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_known_positive_or_nan__maximumnum__negative_or_nan___negative_or_nan() {
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN0:%.*]] = call float @returns_negative_or_nan()
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_NAN1:%.*]] = call float @returns_negative_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_NEGATIVE_OR_NAN0]], float [[MUST_BE_NEGATIVE_OR_NAN1]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF8000000000000
;
%must.be.negative.or.nan0 = call float @returns_negative_or_nan()
%must.be.negative.or.nan1 = call float @returns_negative_or_nan()
@@ -166,8 +164,7 @@ define nofpclass(pinf pnorm psub pzero) float @ret_known_negative_or_nan__maximu
; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @ret_known_negative_or_nan__maximumnum__positive_or_nan___positive_or_nan() {
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN0:%.*]] = call float @returns_positive_or_nan()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_NAN1:%.*]] = call float @returns_positive_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_POSITIVE_OR_NAN0]], float [[MUST_BE_POSITIVE_OR_NAN1]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF8000000000000
;
%must.be.positive.or.nan0 = call float @returns_positive_or_nan()
%must.be.positive.or.nan1 = call float @returns_positive_or_nan()
@@ -352,7 +349,7 @@ define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_0()
; CHECK-LABEL: define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_0() {
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[MUST_BE_NEGATIVE_OR_ZERO]], float [[MUST_BE_POSITIVE_OR_ZERO]])
; CHECK-NEXT: ret float [[RESULT]]
;
%must.be.negative.or.zero = call float @returns_positive_or_zero()
@@ -366,7 +363,7 @@ define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_1()
; CHECK-LABEL: define nofpclass(snan) float @cannot_fold_negative_or_zero__positive_or_zero_1() {
; CHECK-NEXT: [[MUST_BE_NEGATIVE_OR_ZERO:%.*]] = call float @returns_positive_or_zero()
; CHECK-NEXT: [[MUST_BE_POSITIVE_OR_ZERO:%.*]] = call float @returns_negative_or_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[MUST_BE_POSITIVE_OR_ZERO]], float [[MUST_BE_NEGATIVE_OR_ZERO]])
; CHECK-NEXT: ret float [[RESULT]]
;
%must.be.negative.or.zero = call float @returns_positive_or_zero()
@@ -398,8 +395,7 @@ define nofpclass(nsub) float @rhs_must_be_pinf_or_nan(float nofpclass(ninf norm
define nofpclass(nsub) float @lhs_must_be_pinf(float %unknown, float nofpclass(nan ninf norm zero sub) %must.be.pinf) {
; CHECK-LABEL: define nofpclass(nsub) float @lhs_must_be_pinf(
; CHECK-SAME: float [[UNKNOWN:%.*]], float nofpclass(nan ninf zero sub norm) [[MUST_BE_PINF:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_PINF]], float [[UNKNOWN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%result = call float @llvm.maximumnum.f32(float %must.be.pinf, float %unknown)
ret float %result
@@ -408,8 +404,7 @@ define nofpclass(nsub) float @lhs_must_be_pinf(float %unknown, float nofpclass(n
define nofpclass(nsub) float @rhs_must_be_pinf(float nofpclass(nan ninf norm zero sub) %must.be.pinf, float %unknown) {
; CHECK-LABEL: define nofpclass(nsub) float @rhs_must_be_pinf(
; CHECK-SAME: float nofpclass(nan ninf zero sub norm) [[MUST_BE_PINF:%.*]], float [[UNKNOWN:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[UNKNOWN]], float [[MUST_BE_PINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%result = call float @llvm.maximumnum.f32(float %unknown, float %must.be.pinf)
ret float %result
@@ -419,8 +414,7 @@ define nofpclass(nsub) float @rhs_must_be_pinf(float nofpclass(nan ninf norm zer
define nofpclass(nsub) float @lhs_must_be_pinf_rhs_non_nan(float nofpclass(nan) %not.nan, float nofpclass(nan ninf norm zero sub) %must.be.pinf) {
; CHECK-LABEL: define nofpclass(nsub) float @lhs_must_be_pinf_rhs_non_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]], float nofpclass(nan ninf zero sub norm) [[MUST_BE_PINF:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_PINF]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%result = call float @llvm.maximumnum.f32(float %must.be.pinf, float %not.nan)
ret float %result
@@ -430,8 +424,7 @@ define nofpclass(nsub) float @lhs_must_be_pinf_rhs_non_nan(float nofpclass(nan)
define nofpclass(nsub) float @rhs_must_be_pinf_lhs_non_nan(float nofpclass(nan ninf norm zero sub) %must.be.pinf, float nofpclass(nan) %not.nan) {
; CHECK-LABEL: define nofpclass(nsub) float @rhs_must_be_pinf_lhs_non_nan(
; CHECK-SAME: float nofpclass(nan ninf zero sub norm) [[MUST_BE_PINF:%.*]], float nofpclass(nan) [[NOT_NAN:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NOT_NAN]], float [[MUST_BE_PINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float 0x7FF0000000000000
;
%result = call float @llvm.maximumnum.f32(float %not.nan, float %must.be.pinf)
ret float %result
@@ -460,7 +453,7 @@ define nofpclass(nsub) float @rhs_must_be_ninf_or_nan(float nofpclass(pinf norm
define nofpclass(nsub) float @lhs_must_be_ninf(float %unknown, float nofpclass(nan pinf norm zero sub) %must.be.ninf) {
; CHECK-LABEL: define nofpclass(nsub) float @lhs_must_be_ninf(
; CHECK-SAME: float [[UNKNOWN:%.*]], float nofpclass(nan pinf zero sub norm) [[MUST_BE_NINF:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_NINF]], float [[UNKNOWN]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[UNKNOWN]], float 0xFFF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximumnum.f32(float %must.be.ninf, float %unknown)
@@ -470,7 +463,7 @@ define nofpclass(nsub) float @lhs_must_be_ninf(float %unknown, float nofpclass(n
define nofpclass(nsub) float @rhs_must_be_ninf(float nofpclass(nan pinf norm zero sub) %must.be.ninf, float %unknown) {
; CHECK-LABEL: define nofpclass(nsub) float @rhs_must_be_ninf(
; CHECK-SAME: float nofpclass(nan pinf zero sub norm) [[MUST_BE_NINF:%.*]], float [[UNKNOWN:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[UNKNOWN]], float [[MUST_BE_NINF]])
+; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[UNKNOWN]], float 0xFFF0000000000000)
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximumnum.f32(float %unknown, float %must.be.ninf)
@@ -482,8 +475,7 @@ define nofpclass(nsub) float @rhs_must_be_ninf(float nofpclass(nan pinf norm zer
define nofpclass(nsub) float @lhs_must_be_ninf_rhs_non_nan(float nofpclass(nan) %not.nan, float nofpclass(nan pinf norm zero sub) %must.be.ninf) {
; CHECK-LABEL: define nofpclass(nsub) float @lhs_must_be_ninf_rhs_non_nan(
; CHECK-SAME: float nofpclass(nan) [[NOT_NAN:%.*]], float nofpclass(nan pinf zero sub norm) [[MUST_BE_NINF:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[MUST_BE_NINF]], float [[NOT_NAN]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%result = call float @llvm.maximumnum.f32(float %must.be.ninf, float %not.nan)
ret float %result
@@ -493,8 +485,7 @@ define nofpclass(nsub) float @lhs_must_be_ninf_rhs_non_nan(float nofpclass(nan)
define nofpclass(nsub) float @rhs_must_be_ninf_lhs_non_nan(float nofpclass(nan pinf norm zero sub) %must.be.ninf, float nofpclass(nan) %not.nan) {
; CHECK-LABEL: define nofpclass(nsub) float @rhs_must_be_ninf_lhs_non_nan(
; CHECK-SAME: float nofpclass(nan pinf zero sub norm) [[MUST_BE_NINF:%.*]], float nofpclass(nan) [[NOT_NAN:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[NOT_NAN]], float [[MUST_BE_NINF]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[NOT_NAN]]
;
%result = call float @llvm.maximumnum.f32(float %not.nan, float %must.be.ninf)
ret float %result
@@ -803,7 +794,7 @@ define nofpclass(snan) float @unknown__maximumnum__not_nan(float %x, float nofpc
define nofpclass(snan) float @not_nan__maximumnum__not_nan(float nofpclass(nan) %x, float nofpclass(nan) %y) {
; CHECK-LABEL: define nofpclass(snan) float @not_nan__maximumnum__not_nan(
; CHECK-SAME: float nofpclass(nan) [[X:%.*]], float nofpclass(nan) [[Y:%.*]]) {
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[X]], float [[Y]])
; CHECK-NEXT: ret float [[RESULT]]
;
%result = call float @llvm.maximumnum.f32(float %x, float %y)
@@ -834,7 +825,7 @@ define nofpclass(snan) float @known_positive__maximumnum__only_zero() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximumnum__only_zero() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_ZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_ZERO]])
; CHECK-NEXT: ret float [[RESULT]]
;
%known.positive = call float @returns_positive()
@@ -847,7 +838,7 @@ define nofpclass(snan) float @only_zero__maximumnum__known_positive() {
; CHECK-LABEL: define nofpclass(snan) float @only_zero__maximumnum__known_positive() {
; CHECK-NEXT: [[KNOWN_ZERO:%.*]] = call float @returns_zero()
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[KNOWN_ZERO]], float [[KNOWN_POSITIVE]])
; CHECK-NEXT: ret float [[RESULT]]
;
%known.zero = call float @returns_zero()
@@ -912,8 +903,7 @@ define nofpclass(snan) float @known_positive__maximumnum__only_nzero() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximumnum__only_nzero() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_NZERO:%.*]] = call float @returns_nzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_NZERO]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.positive = call float @returns_positive()
%known.nzero = call float @returns_nzero()
@@ -925,8 +915,7 @@ define nofpclass(snan) float @only_nzero__maximumnum__known_positive() {
; CHECK-LABEL: define nofpclass(snan) float @only_nzero__maximumnum__known_positive() {
; CHECK-NEXT: [[KNOWN_NZERO:%.*]] = call float @returns_nzero()
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_NZERO]], float [[KNOWN_POSITIVE]])
-; CHECK-NEXT: ret float [[RESULT]]
+; CHECK-NEXT: ret float [[KNOWN_POSITIVE]]
;
%known.nzero = call float @returns_nzero()
%known.positive = call float @returns_positive()
@@ -938,7 +927,7 @@ define nofpclass(snan) float @known_positive__maximumnum__only_pzero() {
; CHECK-LABEL: define nofpclass(snan) float @known_positive__maximumnum__only_pzero() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float [[KNOWN_PZERO]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float 0.000000e+00)
; CHECK-NEXT: ret float [[RESULT]]
;
%known.positive = call float @returns_positive()
@@ -951,7 +940,7 @@ define nofpclass(snan) float @only_pzero__maximumnum__known_positive() {
; CHECK-LABEL: define nofpclass(snan) float @only_pzero__maximumnum__known_positive() {
; CHECK-NEXT: [[KNOWN_PZERO:%.*]] = call float @returns_pzero()
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float [[KNOWN_PZERO]], float [[KNOWN_POSITIVE]])
+; CHECK-NEXT: [[RESULT:%.*]] = call nnan float @llvm.maximumnum.f32(float [[KNOWN_POSITIVE]], float 0.000000e+00)
; CHECK-NEXT: ret float [[RESULT]]
;
%known.pzero = call float @returns_pzero()
@@ -1259,8 +1248,7 @@ define nofpclass(snan) float @known_always_positive__maximumnum__known_always_ne
; CHECK-LABEL: define nofpclass(snan) float @known_always_positive__maximumnum__known_always_negative_or_nan() {
; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @returns_positive()
; CHECK-NEXT: [[KNOWN_NEGATIVE_OR_NAN:%.*]] = call float @returns_negative_or_nan()
-; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximumnum.f32(float ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/173977
More information about the llvm-branch-commits
mailing list