llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-llvm-analysis Author: Matt Arsenault (arsenm) <details> <summary>Changes</summary> --- Patch is 135.89 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/173896.diff 2 Files Affected: - (added) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll (+1250) - (added) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-minimum.ll (+1250) ``````````diff diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll new file mode 100644 index 0000000000000..99e03f6b12e5c --- /dev/null +++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-maximum.ll @@ -0,0 +1,1250 @@ +; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6 +; RUN: opt -S -passes=instcombine < %s | FileCheck %s + +declare nofpclass(ninf nnorm nsub nzero nan) float @returns_positive() +declare nofpclass(ninf nnorm nsub nzero) float @returns_positive_or_nan() + +declare nofpclass(pinf pnorm psub pzero nan) float @returns_negative() +declare nofpclass(pinf pnorm psub pzero) float @returns_negative_or_nan() + +declare nofpclass(ninf nnorm nsub nan) float @returns_positive_or_zero() +declare nofpclass(pinf pnorm psub nan) float @returns_negative_or_zero() + +declare nofpclass(ninf nnorm nsub) float @returns_positive_or_zero_or_nan() +declare nofpclass(pinf pnorm psub) float @returns_negative_or_zero_or_nan() + +declare nofpclass(inf sub norm nan) float @returns_zero() +declare nofpclass(inf sub norm) float @returns_zero_or_nan() +declare nofpclass(inf sub norm nan pzero) float @returns_nzero() +declare nofpclass(inf sub norm pzero) float @returns_nzero_or_nan() +declare nofpclass(inf sub norm nan nzero) float @returns_pzero() +declare nofpclass(inf sub norm nzero) float @returns_pzero_or_nan() +declare nofpclass(inf norm sub zero) float @returns_nan() + +; -> qnan +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]] +; + %result = call float @llvm.maximum.f32(float %x, float %y) + ret float %result +} + +define nofpclass(inf norm sub zero qnan) float @ret_only_snan(float %x, float %y) { +; CHECK-LABEL: define nofpclass(qnan inf zero sub norm) float @ret_only_snan( +; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { +; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[X]], float [[Y]]) +; CHECK-NEXT: ret float [[RESULT]] +; + %result = call float @llvm.maximum.f32(float %x, float %y) + ret float %result +} + +define nofpclass(inf norm sub zero snan) float @ret_only_qnan(float %x, float %y) { +; CHECK-LABEL: define nofpclass(snan inf zero sub norm) float @ret_only_qnan( +; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { +; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[X]], float [[Y]]) +; CHECK-NEXT: ret float [[RESULT]] +; + %result = call float @llvm.maximum.f32(float %x, float %y) + ret float %result +} + +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: ret float [[RESULT]] +; + %result = call float @llvm.maximum.f32(float %x, float %y) + ret float %result +} + +define nofpclass(nan pinf norm sub zero) float @ret_only_ninf(float %x, float %y) { +; CHECK-LABEL: define nofpclass(nan pinf zero sub norm) float @ret_only_ninf( +; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { +; CHECK-NEXT: ret float 0xFFF0000000000000 +; + %result = call float @llvm.maximum.f32(float %x, float %y) + ret float %result +} + +define nofpclass(nan ninf norm sub zero) float @ret_only_pinf(float %x, float %y) { +; CHECK-LABEL: define nofpclass(nan ninf zero sub norm) float @ret_only_pinf( +; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { +; CHECK-NEXT: ret float 0x7FF0000000000000 +; + %result = call float @llvm.maximum.f32(float %x, float %y) + ret float %result +} + +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: ret float [[RESULT]] +; + %result = call float @llvm.maximum.f32(float %x, float %y) + ret float %result +} + +define nofpclass(inf nan norm sub nzero) float @ret_only_pzero(float %x, float %y) { +; CHECK-LABEL: define nofpclass(nan inf nzero sub norm) float @ret_only_pzero( +; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { +; CHECK-NEXT: ret float 0.000000e+00 +; + %result = call float @llvm.maximum.f32(float %x, float %y) + ret float %result +} + +define nofpclass(inf nan norm sub pzero) float @ret_only_nzero(float %x, float %y) { +; CHECK-LABEL: define nofpclass(nan inf pzero sub norm) float @ret_only_nzero( +; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { +; CHECK-NEXT: ret float -0.000000e+00 +; + %result = call float @llvm.maximum.f32(float %x, float %y) + ret float %result +} + +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: ret float [[RESULT]] +; + %result = call float @llvm.maximum.f32(float %x, float %y) + ret float %result +} + +define nofpclass(inf) float @ret_no_infs(float %x, float %y) { +; CHECK-LABEL: define nofpclass(inf) float @ret_no_infs( +; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) { +; CHECK-NEXT: [[RESULT:%.*]] = call float @llvm.maximum.f32(float [[X]], float [[Y]]) +; CHECK-NEXT: ret float [[RESULT]] +; + %result = call float @llvm.maximum.f32(float %x, float %y) + ret float %result +} + +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: ret float [[RESULT]] +; + %result = call float @llvm.maximum.f32(float %x, float %y) + ret float %result +} + +; -> qnan +define nofpclass(ninf nnorm nsub nzero) float @ret_known_positive_or_nan__maximum__negative_or_nan___negative_or_nan() { +; 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]] +; + %must.be.negative.or.nan0 = call float @returns_negative_or_nan() + %must.be.negative.or.nan1 = call float @returns_negative_or_nan() + %result = call float @llvm.maximum.f32(float %must.be.negative.or.nan0, float %must.be.negative.or.nan1) + ret float %result +} + +; -> qnan +define nofpclass(pinf pnorm psub pzero) float @ret_known_negative_or_nan__maximum__positive_or_nan___positive_or_nan() { +; 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]] +; + %must.be.positive.or.nan0 = call float @returns_positive_or_nan() + %must.be.positive.or.nan1 = call float @returns_positive_or_nan() + %result = call float @llvm.maximum.f32(float %must.be.positive.or.nan0, float %must.be.positive.or.nan1) + ret float %result +} + +define nofpclass(snan) float @known_positive_or_nan__maximum__known_negative_or_nan() { +; CHECK-LABEL: define nofpclass(snan) float @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]] +; + %must.be.positive.or.nan = call float @returns_positive_or_nan() + %must.be.negative.or.nan = call float @returns_negative_or_nan() + %result = call float @llvm.maximum.f32(float %must.be.positive.or.nan, float %must.be.negative.or.nan) + ret float %result +} + +define nofpclass(snan) float @known_negative_or_nan__maximum__known_positive_or_nan() { +; CHECK-LABEL: define nofpclass(snan) float @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]] +; + %must.be.negative.or.nan = call float @returns_negative_or_nan() + %must.be.positive.or.nan = call float @returns_positive_or_nan() + %result = call float @llvm.maximum.f32(float %must.be.negative.or.nan, float %must.be.positive.or.nan) + ret float %result +} + +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]] +; + %must.be.positive.or.nan = call float @returns_positive_or_nan() + %must.be.negative = call float @returns_negative() + %result = call float @llvm.maximum.f32(float %must.be.positive.or.nan, float %must.be.negative) + ret float %result +} + +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]] +; + %must.be.negative = call float @returns_negative() + %must.be.positive.or.nan = call float @returns_positive_or_nan() + %result = call float @llvm.maximum.f32(float %must.be.negative, float %must.be.positive.or.nan) + ret float %result +} + +define nofpclass(ninf nnorm nsub nzero) float @ret_always_positive_or_nan__select_always_negative_or_unknown__maximum__unknown(i1 %cond, float %unknown0, float %unknown1) { +; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_always_positive_or_nan__select_always_negative_or_unknown__maximum__unknown( +; 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: ret float [[RESULT]] +; + %always.negative = call float @returns_negative() + %select.lhs = select i1 %cond, float %always.negative, float %unknown0 + %result = call float @llvm.maximum.f32(float %select.lhs, float %unknown1) + ret float %result +} + +define nofpclass(ninf nnorm nsub nzero) float @ret_always_positive_or_nan__unknown__maximum__select_always_negative_or_unknown(i1 %cond, float %unknown0, float %unknown1) { +; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_always_positive_or_nan__unknown__maximum__select_always_negative_or_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: ret float [[RESULT]] +; + %always.negative = call float @returns_negative() + %select.rhs = select i1 %cond, float %always.negative, float %unknown0 + %result = call float @llvm.maximum.f32(float %unknown1, float %select.rhs) + ret float %result +} + +define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_positive__select_always_negative_or_unknown__maximum__unknown(i1 %cond, float %unknown0, float %unknown1) { +; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_always_positive__select_always_negative_or_unknown__maximum__unknown( +; 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: ret float [[RESULT]] +; + %always.negative = call float @returns_negative() + %select.lhs = select i1 %cond, float %always.negative, float %unknown0 + %result = call float @llvm.maximum.f32(float %select.lhs, float %unknown1) + ret float %result +} + +define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_positive__unknown__maximum__select_always_negative_or_unknown(i1 %cond, float %unknown0, float %unknown1) { +; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_always_positive__unknown__maximum__select_always_negative_or_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: ret float [[RESULT]] +; + %always.negative = call float @returns_negative() + %select.rhs = select i1 %cond, float %always.negative, float %unknown0 + %result = call float @llvm.maximum.f32(float %unknown1, float %select.rhs) + ret float %result +} + +define nofpclass(ninf nnorm nsub nzero) float @ret_always_negative_or_nan__simplify_unneeded_lhs_rhs(i1 %cond, float %unknown0, float %unknown1) { +; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_always_negative_or_nan__simplify_unneeded_lhs_rhs( +; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) { +; CHECK-NEXT: [[ALWAYS_NEGATIVE0:%.*]] = call float @returns_negative() +; 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: ret float [[RESULT]] +; + %always.negative0 = call float @returns_negative() + %always.negative1 = call float @returns_negative() + %select.lhs = select i1 %cond, float %always.negative0, float %unknown0 + %select.rhs = select i1 %cond, float %unknown1, float %always.negative1 + %result = call float @llvm.maximum.f32(float %select.lhs, float %select.rhs) + ret float %result +} + +define nofpclass(ninf nnorm nsub nzero nan) float @ret_always_negative__simplify_unneeded_lhs_rhs(i1 %cond, float %unknown0, float %unknown1) { +; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_always_negative__simplify_unneeded_lhs_rhs( +; CHECK-SAME: i1 [[COND:%.*]], float [[UNKNOWN0:%.*]], float [[UNKNOWN1:%.*]]) { +; CHECK-NEXT: [[ALWAYS_NEGATIVE0:%.*]] = call float @returns_negative() +; 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: ret float [[RESULT]] +; + %always.negative0 = call float @returns_negative() + %always.negative1 = call float @returns_negative() + %select.lhs = select i1 %cond, float %always.negative0, float %unknown0 + %select.rhs = select i1 %cond, float %unknown1, float %always.negative1 + %result = call float @llvm.maximum.f32(float %select.lhs, float %select.rhs) + ret float %result +} + +define nofpclass(nan) float @no_fold_select_always_negative_0(i1 %cond, float %unknown0, float %unknown1) { +; CHECK-LABEL: define nofpclass(nan) float @no_fold_select_always_negative_0( +; 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: ret float [[RESULT]] +; + %always.negative = call float @returns_negative() + %select.lhs = select i1 %cond, float %always.negative, float %unknown0 + %result = call float @llvm.maximum.f32(float %select.lhs, float %unknown1) + ret float %result +} + +define nofpclass(nan) float @no_fold_select_always_negative_1(i1 %cond, float %unknown0, float %unknown1) { +; CHECK-LABEL: define nofpclass(nan) float @no_fold_select_always_negative_1( +; 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: ret float [[RESULT]] +; + %always.negative = call float @returns_negative() + %select.rhs = select i1 %cond, float %always.negative, float %unknown0 + %result = call float @llvm.maximum.f32(float %unknown1, float %select.rhs) + ret float %result +} + +; Cannot fold out due to possible -0 +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: ret float [[RESULT]] +; + %must.be.negative.or.zero = call float @returns_positive_or_zero() + %must.be.positive.or.zero = call float @returns_negative_or_zero() + %result = call float @llvm.maximum.f32(float %must.be.negative.or.zero, float %must.be.positive.or.zero) + ret float %result +} + +; Cannot fold out due to possible -0 +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 fl... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/173896 _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
