From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2136) id 5D2B03858C62; Wed, 21 Sep 2022 09:08:40 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 5D2B03858C62 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1663751320; bh=5dX28cFLwHk+dR/nV1qlmBLoEEQmcfWMiZr/N1Z9Io0=; h=From:To:Subject:Date:From; b=bREf/7oVZQwbnHSdGABZ+gs5RWU28hhTvkc4lAFL+ukt8cKbcnpmlBoAwUxLb1vYs T2GnbXg4Os5WSo3kt7gBytc8ods3eDUktWD7ThNyzM72VN8T6DPhm3tgc4XqAvLV0U MuBHY9ntIfWZfA9COeFwpTAl49zeijRUlqCerxj4= MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Aldy Hernandez To: gcc-cvs@gcc.gnu.org Subject: [gcc r13-2756] [PR106967] frange: revamp relational operators for NANs. X-Act-Checkin: gcc X-Git-Author: Aldy Hernandez X-Git-Refname: refs/heads/master X-Git-Oldrev: ce8aed75a38b468490ecab4c318e3eb08d468608 X-Git-Newrev: d2278da1c3cb7bf8b3d96c86dbef2982bf4cc54a Message-Id: <20220921090840.5D2B03858C62@sourceware.org> Date: Wed, 21 Sep 2022 09:08:40 +0000 (GMT) List-Id: https://gcc.gnu.org/g:d2278da1c3cb7bf8b3d96c86dbef2982bf4cc54a commit r13-2756-gd2278da1c3cb7bf8b3d96c86dbef2982bf4cc54a Author: Aldy Hernandez Date: Tue Sep 20 16:19:14 2022 +0200 [PR106967] frange: revamp relational operators for NANs. Since NANs can be inserted by other passes even for -ffinite-math-only, we can't depend on the flag to determine if a NAN is a possiblity. Instead, we must explicitly check for them. In the case of -ffinite-math-only, paths leading up to a NAN are undefined and can be considered unreachable. I have audited all the relational code and made sure we're handling the known NAN case before anything else, setting undefined when appropriate. In the process, I revamped all the relational code handling NANs to correctly notice paths that are unreachable. The basic structure for ordered relational operators (except != of course) is this: If either operand is a known NAN, return FALSE. The true side of a relop when one operand is a NAN is unreachable. On the false side of a relop when one operand is a NAN, we know nothing about the other operand. Regstrapped on x86-64 and ppc64le Linux. lapack testing on x86-64 with and without -ffinite-math-only. PR tree-optimization/106967 gcc/ChangeLog: * range-op-float.cc (foperator_equal::fold_range): Adjust for NAN. (foperator_equal::op1_range): Same. (foperator_not_equal::fold_range): Same. (foperator_not_equal::op1_range): Same. (foperator_lt::fold_range): Same. (foperator_lt::op1_range): Same. (foperator_lt::op2_range): Same. (foperator_le::fold_range): Same. (foperator_le::op1_range): Same. (foperator_le::op2_range): Same. (foperator_gt::fold_range): Same. (foperator_gt::op1_range): Same. (foperator_gt::op2_range): Same. (foperator_ge::fold_range): Same. (foperator_ge::op1_range): Same. (foperator_ge::op2_range): Same. (foperator_unordered::op1_range): Same. (foperator_ordered::fold_range): Same. (foperator_ordered::op1_range): Same. (build_le): Assert that we don't have a NAN. (build_lt): Same. (build_gt): Same. (build_ge): Same. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/pr106967.c: New test. Diff: --- gcc/range-op-float.cc | 270 ++++++++++++++++++++----------- gcc/testsuite/gcc.dg/tree-ssa/pr106967.c | 16 ++ 2 files changed, 193 insertions(+), 93 deletions(-) diff --git a/gcc/range-op-float.cc b/gcc/range-op-float.cc index 1e39a07ab97..2bd3dc9253f 100644 --- a/gcc/range-op-float.cc +++ b/gcc/range-op-float.cc @@ -230,11 +230,8 @@ frange_add_zeros (frange &r, tree type) static bool build_le (frange &r, tree type, const frange &val) { - if (val.known_isnan ()) - { - r.set_undefined (); - return false; - } + gcc_checking_assert (!val.known_isnan ()); + r.set (type, dconstninf, val.upper_bound ()); // Add both zeros if there's the possibility of zero equality. @@ -248,11 +245,8 @@ build_le (frange &r, tree type, const frange &val) static bool build_lt (frange &r, tree type, const frange &val) { - if (val.known_isnan ()) - { - r.set_undefined (); - return false; - } + gcc_checking_assert (!val.known_isnan ()); + // < -INF is outside the range. if (real_isinf (&val.upper_bound (), 1)) { @@ -272,11 +266,8 @@ build_lt (frange &r, tree type, const frange &val) static bool build_ge (frange &r, tree type, const frange &val) { - if (val.known_isnan ()) - { - r.set_undefined (); - return false; - } + gcc_checking_assert (!val.known_isnan ()); + r.set (type, val.lower_bound (), dconstinf); // Add both zeros if there's the possibility of zero equality. @@ -290,11 +281,8 @@ build_ge (frange &r, tree type, const frange &val) static bool build_gt (frange &r, tree type, const frange &val) { - if (val.known_isnan ()) - { - r.set_undefined (); - return false; - } + gcc_checking_assert (!val.known_isnan ()); + // > +INF is outside the range. if (real_isinf (&val.lower_bound (), 0)) { @@ -365,9 +353,11 @@ foperator_equal::fold_range (irange &r, tree type, if (frelop_early_resolve (r, type, op1, op2, rel, VREL_EQ)) return true; + if (op1.known_isnan () || op2.known_isnan ()) + r = range_false (type); // We can be sure the values are always equal or not if both ranges // consist of a single value, and then compare them. - if (op1.singleton_p () && op2.singleton_p ()) + else if (op1.singleton_p () && op2.singleton_p ()) { if (op1 == op2) r = range_true (type); @@ -393,25 +383,33 @@ foperator_equal::fold_range (irange &r, tree type, bool foperator_equal::op1_range (frange &r, tree type, const irange &lhs, - const frange &op2 ATTRIBUTE_UNUSED, + const frange &op2, relation_kind rel) const { switch (get_bool_state (r, lhs, type)) { case BRS_TRUE: - // If it's true, the result is the same as OP2. - r = op2; - // Add both zeros if there's the possibility of zero equality. - frange_add_zeros (r, type); - // The TRUE side of op1 == op2 implies op1 is !NAN. - r.clear_nan (); + // The TRUE side of x == NAN is unreachable. + if (op2.known_isnan ()) + r.set_undefined (); + else + { + // If it's true, the result is the same as OP2. + r = op2; + // Add both zeros if there's the possibility of zero equality. + frange_add_zeros (r, type); + // The TRUE side of op1 == op2 implies op1 is !NAN. + r.clear_nan (); + } break; case BRS_FALSE: - r.set_varying (type); // The FALSE side of op1 == op1 implies op1 is a NAN. if (rel == VREL_EQ) r.set_nan (type); + // On the FALSE side of x == NAN, we know nothing about x. + else if (op2.known_isnan ()) + r.set_varying (type); // If the result is false, the only time we know anything is // if OP2 is a constant. else if (op2.singleton_p () @@ -420,6 +418,8 @@ foperator_equal::op1_range (frange &r, tree type, REAL_VALUE_TYPE tmp = op2.lower_bound (); r.set (type, tmp, tmp, VR_ANTI_RANGE); } + else + r.set_varying (type); break; default: @@ -453,9 +453,12 @@ foperator_not_equal::fold_range (irange &r, tree type, if (frelop_early_resolve (r, type, op1, op2, rel, VREL_NE)) return true; + // x != NAN is always TRUE. + if (op1.known_isnan () || op2.known_isnan ()) + r = range_true (type); // We can be sure the values are always equal or not if both ranges // consist of a single value, and then compare them. - if (op1.singleton_p () && op2.singleton_p ()) + else if (op1.singleton_p () && op2.singleton_p ()) { if (op1 != op2) r = range_true (type); @@ -481,7 +484,7 @@ foperator_not_equal::fold_range (irange &r, tree type, bool foperator_not_equal::op1_range (frange &r, tree type, const irange &lhs, - const frange &op2 ATTRIBUTE_UNUSED, + const frange &op2, relation_kind) const { switch (get_bool_state (r, lhs, type)) @@ -502,12 +505,18 @@ foperator_not_equal::op1_range (frange &r, tree type, break; case BRS_FALSE: - // If it's false, the result is the same as OP2. - r = op2; - // Add both zeros if there's the possibility of zero equality. - frange_add_zeros (r, type); - // The FALSE side of op1 != op2 implies op1 is !NAN. - r.clear_nan (); + // The FALSE side of x != NAN is impossible. + if (op2.known_isnan ()) + r.set_undefined (); + else + { + // If it's false, the result is the same as OP2. + r = op2; + // Add both zeros if there's the possibility of zero equality. + frange_add_zeros (r, type); + // The FALSE side of op1 != op2 implies op1 is !NAN. + r.clear_nan (); + } break; default: @@ -545,7 +554,9 @@ foperator_lt::fold_range (irange &r, tree type, if (frelop_early_resolve (r, type, op1, op2, rel, VREL_LT)) return true; - if (finite_operands_p (op1, op2)) + if (op1.known_isnan () || op2.known_isnan ()) + r = range_false (type); + else if (finite_operands_p (op1, op2)) { if (real_less (&op1.upper_bound (), &op2.lower_bound ())) r = range_true (type); @@ -555,8 +566,6 @@ foperator_lt::fold_range (irange &r, tree type, else r = range_true_and_false (type); } - else if (op1.known_isnan () || op2.known_isnan ()) - r = range_false (type); else r = range_true_and_false (type); return true; @@ -566,13 +575,16 @@ bool foperator_lt::op1_range (frange &r, tree type, const irange &lhs, - const frange &op2 ATTRIBUTE_UNUSED, + const frange &op2, relation_kind) const { switch (get_bool_state (r, lhs, type)) { case BRS_TRUE: - if (build_lt (r, type, op2)) + // The TRUE side of x < NAN is unreachable. + if (op2.known_isnan ()) + r.set_undefined (); + else if (build_lt (r, type, op2)) { r.clear_nan (); // x < y implies x is not +INF. @@ -581,7 +593,11 @@ foperator_lt::op1_range (frange &r, break; case BRS_FALSE: - build_ge (r, type, op2); + // On the FALSE side of x < NAN, we know nothing about x. + if (op2.known_isnan ()) + r.set_varying (type); + else + build_ge (r, type, op2); break; default: @@ -594,13 +610,16 @@ bool foperator_lt::op2_range (frange &r, tree type, const irange &lhs, - const frange &op1 ATTRIBUTE_UNUSED, + const frange &op1, relation_kind) const { switch (get_bool_state (r, lhs, type)) { case BRS_TRUE: - if (build_gt (r, type, op1)) + // The TRUE side of NAN < x is unreachable. + if (op1.known_isnan ()) + r.set_undefined (); + else if (build_gt (r, type, op1)) { r.clear_nan (); // x < y implies y is not -INF. @@ -609,7 +628,11 @@ foperator_lt::op2_range (frange &r, break; case BRS_FALSE: - build_le (r, type, op1); + // On the FALSE side of NAN < x, we know nothing about x. + if (op1.known_isnan ()) + r.set_varying (type); + else + build_le (r, type, op1); break; default: @@ -647,7 +670,9 @@ foperator_le::fold_range (irange &r, tree type, if (frelop_early_resolve (r, type, op1, op2, rel, VREL_LE)) return true; - if (finite_operands_p (op1, op2)) + if (op1.known_isnan () || op2.known_isnan ()) + r = range_false (type); + else if (finite_operands_p (op1, op2)) { if (real_compare (LE_EXPR, &op1.upper_bound (), &op2.lower_bound ())) r = range_true (type); @@ -657,8 +682,6 @@ foperator_le::fold_range (irange &r, tree type, else r = range_true_and_false (type); } - else if (op1.known_isnan () || op2.known_isnan ()) - r = range_false (type); else r = range_true_and_false (type); return true; @@ -674,12 +697,19 @@ foperator_le::op1_range (frange &r, switch (get_bool_state (r, lhs, type)) { case BRS_TRUE: - if (build_le (r, type, op2)) + // The TRUE side of x <= NAN is unreachable. + if (op2.known_isnan ()) + r.set_undefined (); + else if (build_le (r, type, op2)) r.clear_nan (); break; case BRS_FALSE: - build_gt (r, type, op2); + // On the FALSE side of x <= NAN, we know nothing about x. + if (op2.known_isnan ()) + r.set_varying (type); + else + build_gt (r, type, op2); break; default: @@ -698,12 +728,19 @@ foperator_le::op2_range (frange &r, switch (get_bool_state (r, lhs, type)) { case BRS_TRUE: - if (build_ge (r, type, op1)) + // The TRUE side of NAN <= x is unreachable. + if (op1.known_isnan ()) + r.set_undefined (); + else if (build_ge (r, type, op1)) r.clear_nan (); break; case BRS_FALSE: - build_lt (r, type, op1); + // On the FALSE side of NAN <= x, we know nothing about x. + if (op1.known_isnan ()) + r.set_varying (type); + else + build_lt (r, type, op1); break; default: @@ -741,7 +778,9 @@ foperator_gt::fold_range (irange &r, tree type, if (frelop_early_resolve (r, type, op1, op2, rel, VREL_GT)) return true; - if (finite_operands_p (op1, op2)) + if (op1.known_isnan () || op2.known_isnan ()) + r = range_false (type); + else if (finite_operands_p (op1, op2)) { if (real_compare (GT_EXPR, &op1.lower_bound (), &op2.upper_bound ())) r = range_true (type); @@ -751,8 +790,6 @@ foperator_gt::fold_range (irange &r, tree type, else r = range_true_and_false (type); } - else if (op1.known_isnan () || op2.known_isnan ()) - r = range_false (type); else r = range_true_and_false (type); return true; @@ -762,13 +799,16 @@ bool foperator_gt::op1_range (frange &r, tree type, const irange &lhs, - const frange &op2 ATTRIBUTE_UNUSED, + const frange &op2, relation_kind) const { switch (get_bool_state (r, lhs, type)) { case BRS_TRUE: - if (build_gt (r, type, op2)) + // The TRUE side of x > NAN is unreachable. + if (op2.known_isnan ()) + r.set_undefined (); + else if (build_gt (r, type, op2)) { r.clear_nan (); // x > y implies x is not -INF. @@ -777,7 +817,11 @@ foperator_gt::op1_range (frange &r, break; case BRS_FALSE: - build_le (r, type, op2); + // On the FALSE side of x > NAN, we know nothing about x. + if (op2.known_isnan ()) + r.set_varying (type); + else + build_le (r, type, op2); break; default: @@ -790,13 +834,16 @@ bool foperator_gt::op2_range (frange &r, tree type, const irange &lhs, - const frange &op1 ATTRIBUTE_UNUSED, + const frange &op1, relation_kind) const { switch (get_bool_state (r, lhs, type)) { case BRS_TRUE: - if (build_lt (r, type, op1)) + // The TRUE side of NAN > x is unreachable. + if (op1.known_isnan ()) + r.set_undefined (); + else if (build_lt (r, type, op1)) { r.clear_nan (); // x > y implies y is not +INF. @@ -805,7 +852,11 @@ foperator_gt::op2_range (frange &r, break; case BRS_FALSE: - build_ge (r, type, op1); + // On The FALSE side of NAN > x, we know nothing about x. + if (op1.known_isnan ()) + r.set_varying (type); + else + build_ge (r, type, op1); break; default: @@ -843,7 +894,9 @@ foperator_ge::fold_range (irange &r, tree type, if (frelop_early_resolve (r, type, op1, op2, rel, VREL_GE)) return true; - if (finite_operands_p (op1, op2)) + if (op1.known_isnan () || op2.known_isnan ()) + r = range_false (type); + else if (finite_operands_p (op1, op2)) { if (real_compare (GE_EXPR, &op1.lower_bound (), &op2.upper_bound ())) r = range_true (type); @@ -853,8 +906,6 @@ foperator_ge::fold_range (irange &r, tree type, else r = range_true_and_false (type); } - else if (op1.known_isnan () || op2.known_isnan ()) - r = range_false (type); else r = range_true_and_false (type); return true; @@ -870,12 +921,19 @@ foperator_ge::op1_range (frange &r, switch (get_bool_state (r, lhs, type)) { case BRS_TRUE: - build_ge (r, type, op2); - r.clear_nan (); + // The TRUE side of x >= NAN is unreachable. + if (op2.known_isnan ()) + r.set_undefined (); + else if (build_ge (r, type, op2)) + r.clear_nan (); break; case BRS_FALSE: - build_lt (r, type, op2); + // On the FALSE side of x >= NAN, we know nothing about x. + if (op2.known_isnan ()) + r.set_varying (type); + else + build_lt (r, type, op2); break; default: @@ -892,13 +950,23 @@ foperator_ge::op2_range (frange &r, tree type, { switch (get_bool_state (r, lhs, type)) { - case BRS_FALSE: - build_gt (r, type, op1); + case BRS_TRUE: + // The TRUE side of NAN >= x is unreachable. + if (op1.known_isnan ()) + r.set_undefined (); + else + { + build_le (r, type, op1); + r.clear_nan (); + } break; - case BRS_TRUE: - build_le (r, type, op1); - r.clear_nan (); + case BRS_FALSE: + // On the FALSE side of NAN >= x, we know nothing about x. + if (op1.known_isnan ()) + r.set_varying (type); + else + build_gt (r, type, op1); break; default: @@ -949,23 +1017,30 @@ foperator_unordered::fold_range (irange &r, tree type, bool foperator_unordered::op1_range (frange &r, tree type, const irange &lhs, - const frange &op2 ATTRIBUTE_UNUSED, + const frange &op2, relation_kind) const { switch (get_bool_state (r, lhs, type)) { case BRS_TRUE: - r.set_varying (type); // Since at least one operand must be NAN, if one of them is // not, the other must be. if (!op2.maybe_isnan ()) r.set_nan (type); + else + r.set_varying (type); break; case BRS_FALSE: - r.set_varying (type); - // A false UNORDERED means both operands are !NAN. - r.clear_nan (); + // A false UNORDERED means both operands are !NAN, so it's + // impossible for op2 to be a NAN. + if (op2.known_isnan ()) + r.set_undefined (); + else + { + r.set_varying (type); + r.clear_nan (); + } break; default: @@ -1002,10 +1077,10 @@ foperator_ordered::fold_range (irange &r, tree type, const frange &op1, const frange &op2, relation_kind) const { - if (!op1.maybe_isnan () && !op2.maybe_isnan ()) - r = range_true (type); - else if (op1.known_isnan () || op2.known_isnan ()) + if (op1.known_isnan () || op2.known_isnan ()) r = range_false (type); + else if (!op1.maybe_isnan () && !op2.maybe_isnan ()) + r = range_true (type); else r = range_true_and_false (type); return true; @@ -1014,15 +1089,21 @@ foperator_ordered::fold_range (irange &r, tree type, bool foperator_ordered::op1_range (frange &r, tree type, const irange &lhs, - const frange &op2 ATTRIBUTE_UNUSED, + const frange &op2, relation_kind rel) const { switch (get_bool_state (r, lhs, type)) { case BRS_TRUE: - r.set_varying (type); - // The TRUE side of op1 ORDERED op2 implies op1 is !NAN. - r.clear_nan (); + // The TRUE side of ORDERED means both operands are !NAN, so + // it's impossible for op2 to be a NAN. + if (op2.known_isnan ()) + r.set_undefined (); + else + { + r.set_varying (type); + r.clear_nan (); + } break; case BRS_FALSE: @@ -1046,13 +1127,16 @@ class foperator_relop_unknown : public range_operator_float public: bool fold_range (irange &r, tree type, - const frange &, const frange &, + const frange &op1, const frange &op2, relation_kind) const final override { - r.set_varying (type); + if (op1.known_isnan () || op2.known_isnan ()) + r = range_true (type); + else + r.set_varying (type); return true; } -} fop_relop_unknown; +} fop_unordered_relop_unknown; // Instantiate a range_op_table for floating point operations. @@ -1077,11 +1161,11 @@ floating_op_table::floating_op_table () set (LE_EXPR, fop_le); set (GT_EXPR, fop_gt); set (GE_EXPR, fop_ge); - set (UNLE_EXPR, fop_relop_unknown); - set (UNLT_EXPR, fop_relop_unknown); - set (UNGE_EXPR, fop_relop_unknown); - set (UNGT_EXPR, fop_relop_unknown); - set (UNEQ_EXPR, fop_relop_unknown); + set (UNLE_EXPR, fop_unordered_relop_unknown); + set (UNLT_EXPR, fop_unordered_relop_unknown); + set (UNGE_EXPR, fop_unordered_relop_unknown); + set (UNGT_EXPR, fop_unordered_relop_unknown); + set (UNEQ_EXPR, fop_unordered_relop_unknown); set (ORDERED_EXPR, fop_ordered); set (UNORDERED_EXPR, fop_unordered); } diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr106967.c b/gcc/testsuite/gcc.dg/tree-ssa/pr106967.c new file mode 100644 index 00000000000..bff27956f60 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr106967.c @@ -0,0 +1,16 @@ +// { dg-do compile } +// { dg-options "-O2 -ffinite-math-only -fno-trapping-math -fno-tree-dominator-opts" } + +void +foo (float x, int *y) +{ + int i; + float sum2 = 0.0; + + for (i = 0; i < *y; ++i) + sum2 += x; + + sum2 = 1.0 / sum2; + if (sum2 * 0.0 < 5.E-5) + *y = 0; +}