InstCombine: Handle minimumnum/maximumnum in SimplifyDemandedFPClass #173977
+152
−136
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Contributor
Author
This stack of pull requests is managed by Graphite. Learn more about stacking. |
arsenm
added
floating-point
Graphite App
arsenm
requested review from
andykaylor,
dtcxzyw,
jayfoad,
jcranmer-intel,
nikic and
spavloff
Member
|
@llvm/pr-subscribers-llvm-transforms @llvm/pr-subscribers-llvm-analysis Author: Matt Arsenault (arsenm) ChangesPatch is 51.79 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/173977.diff 3 Files Affected:
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]
|
Member
|
@llvm/pr-subscribers-llvm-support Author: Matt Arsenault (arsenm) ChangesPatch is 51.79 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/173977.diff 3 Files Affected:
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]
|
arsenm
force-pushed
the
users/arsenm/instcombine/simplify-demanded-fpclass-minimumnum-maximumnum
branch
from
86aace1 to
c843519
Compare
arsenm
force-pushed
the
users/arsenm/instcombine/add-baseline-tests-simplifydemandedfpclass-minimumnum-maximumnum
branch
2 times, most recently
from
2118850 to
ba38a1e
Compare
arsenm
force-pushed
the
users/arsenm/instcombine/simplify-demanded-fpclass-minimumnum-maximumnum
branch
2 times, most recently
from
13aa5d0 to
c16480d
Compare
arsenm
force-pushed
the
users/arsenm/instcombine/add-baseline-tests-simplifydemandedfpclass-minimumnum-maximumnum
branch
2 times, most recently
from
731dc7d to
e812bfa
Compare
arsenm
force-pushed
the
users/arsenm/instcombine/simplify-demanded-fpclass-minimumnum-maximumnum
branch
from
c16480d to
5faaa86
Compare
arsenm
force-pushed
the
users/arsenm/instcombine/add-baseline-tests-simplifydemandedfpclass-minimumnum-maximumnum
branch
from
e812bfa to
f746146
Compare
arsenm
force-pushed
the
users/arsenm/instcombine/simplify-demanded-fpclass-minimumnum-maximumnum
branch
from
5faaa86 to
f8ecc3c
Compare
arsenm
force-pushed
the
users/arsenm/instcombine/add-baseline-tests-simplifydemandedfpclass-minimumnum-maximumnum
branch
from
f746146 to
89d4b37
Compare
arsenm
force-pushed
the
users/arsenm/instcombine/simplify-demanded-fpclass-minimumnum-maximumnum
branch
from
f8ecc3c to
8a5f218
Compare
🪟 Windows x64 Test Results
✅ The build succeeded and all tests passed. |
arsenm
force-pushed
the
users/arsenm/instcombine/simplify-demanded-fpclass-minimumnum-maximumnum
branch
from
8a5f218 to
ce99f7b
Compare
arsenm
force-pushed
the
users/arsenm/instcombine/add-baseline-tests-simplifydemandedfpclass-minimumnum-maximumnum
branch
from
89d4b37 to
1612f5d
Compare
arsenm
force-pushed
the
users/arsenm/instcombine/simplify-demanded-fpclass-minimumnum-maximumnum
branch
from
ce99f7b to
a691454
Compare
arsenm
force-pushed
the
users/arsenm/instcombine/add-baseline-tests-simplifydemandedfpclass-minimumnum-maximumnum
branch
from
1612f5d to
079133f
Compare
Base automatically changed from
users/arsenm/instcombine/add-baseline-tests-simplifydemandedfpclass-minimumnum-maximumnum
to
users/arsenm/instcombine/simplify-demanded-fpclass-minimum-maximum
January 7, 2026 17:43
Base automatically changed from
users/arsenm/instcombine/simplify-demanded-fpclass-minimum-maximum
to
main
January 7, 2026 18:35
arsenm
force-pushed
the
users/arsenm/instcombine/simplify-demanded-fpclass-minimumnum-maximumnum
branch
from
a691454 to
c7a3440
Compare
🐧 Linux x64 Test Results
Failed Tests(click on a test name to see its output) lldlld.COFF/linkreprofullpathrsp.testIf these failures are unrelated to your changes (for example tests are broken or flaky at HEAD), please open an issue at https://github.com/llvm/llvm-project/issues and add the |
arsenm
force-pushed
the
users/arsenm/instcombine/simplify-demanded-fpclass-minimumnum-maximumnum
branch
from
c7a3440 to
ed7c9e4
Compare
arsenm
deleted the
users/arsenm/instcombine/simplify-demanded-fpclass-minimumnum-maximumnum
branch
Collaborator
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/169/builds/18830 Here is the relevant piece of the build log for the reference |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
No description provided.