public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc r13-3229] Share common ordered comparison code with UN*_EXPR.
@ 2022-10-11 13:54 Aldy Hernandez
0 siblings, 0 replies; only message in thread
From: Aldy Hernandez @ 2022-10-11 13:54 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:4cbc312a31424ca4ff7cdd358fc47b9c9511a646
commit r13-3229-g4cbc312a31424ca4ff7cdd358fc47b9c9511a646
Author: Aldy Hernandez <aldyh@redhat.com>
Date: Mon Oct 10 14:56:01 2022 +0200
Share common ordered comparison code with UN*_EXPR.
Most unordered comparisons can use the result from the ordered
version, if the operands are known not to be NAN or if the result is
true.
gcc/ChangeLog:
* range-op-float.cc (class foperator_unordered_lt): New.
(class foperator_relop_unknown): Remove
(class foperator_unordered_le): New.
(class foperator_unordered_gt): New.
(class foperator_unordered_ge): New.
(class foperator_unordered_equal): New.
(floating_op_table::floating_op_table): Replace all UN_EXPR
entries with their appropriate fop_unordered_* counterpart.
Diff:
---
gcc/range-op-float.cc | 140 +++++++++++++++++++++++++++++++++++++++++++++-----
1 file changed, 128 insertions(+), 12 deletions(-)
diff --git a/gcc/range-op-float.cc b/gcc/range-op-float.cc
index 3cf117d8931..8dd4bcc70c0 100644
--- a/gcc/range-op-float.cc
+++ b/gcc/range-op-float.cc
@@ -1132,24 +1132,140 @@ foperator_ordered::op1_range (frange &r, tree type,
return true;
}
-// Placeholder for unimplemented relational operators.
+class foperator_unordered_lt : public range_operator_float
+{
+ using range_operator_float::fold_range;
+public:
+ bool fold_range (irange &r, tree type,
+ const frange &op1, const frange &op2,
+ relation_kind rel) const final override
+ {
+ if (op1.known_isnan () || op2.known_isnan ())
+ {
+ r = range_true (type);
+ return true;
+ }
+ if (!fop_lt.fold_range (r, type, op1, op2, rel))
+ return false;
+ // The result is the same as the ordered version when the
+ // comparison is true or when the operands cannot be NANs.
+ if (finite_operands_p (op1, op2) || r == range_true (type))
+ return true;
+ else
+ {
+ r = range_true_and_false (type);
+ return true;
+ }
+ }
+} fop_unordered_lt;
-class foperator_relop_unknown : public range_operator_float
+class foperator_unordered_le : public range_operator_float
{
using range_operator_float::fold_range;
+public:
+ bool fold_range (irange &r, tree type,
+ const frange &op1, const frange &op2,
+ relation_kind rel) const final override
+ {
+ if (op1.known_isnan () || op2.known_isnan ())
+ {
+ r = range_true (type);
+ return true;
+ }
+ if (!fop_le.fold_range (r, type, op1, op2, rel))
+ return false;
+ // The result is the same as the ordered version when the
+ // comparison is true or when the operands cannot be NANs.
+ if (finite_operands_p (op1, op2) || r == range_true (type))
+ return true;
+ else
+ {
+ r = range_true_and_false (type);
+ return true;
+ }
+ }
+} fop_unordered_le;
+class foperator_unordered_gt : public range_operator_float
+{
+ using range_operator_float::fold_range;
public:
bool fold_range (irange &r, tree type,
const frange &op1, const frange &op2,
- relation_kind) const final override
+ relation_kind rel) const final override
{
if (op1.known_isnan () || op2.known_isnan ())
- r = range_true (type);
+ {
+ r = range_true (type);
+ return true;
+ }
+ if (!fop_gt.fold_range (r, type, op1, op2, rel))
+ return false;
+ // The result is the same as the ordered version when the
+ // comparison is true or when the operands cannot be NANs.
+ if (finite_operands_p (op1, op2) || r == range_true (type))
+ return true;
else
- r.set_varying (type);
- return true;
+ {
+ r = range_true_and_false (type);
+ return true;
+ }
+ }
+} fop_unordered_gt;
+
+class foperator_unordered_ge : public range_operator_float
+{
+ using range_operator_float::fold_range;
+public:
+ bool fold_range (irange &r, tree type,
+ const frange &op1, const frange &op2,
+ relation_kind rel) const final override
+ {
+ if (op1.known_isnan () || op2.known_isnan ())
+ {
+ r = range_true (type);
+ return true;
+ }
+ if (!fop_ge.fold_range (r, type, op1, op2, rel))
+ return false;
+ // The result is the same as the ordered version when the
+ // comparison is true or when the operands cannot be NANs.
+ if (finite_operands_p (op1, op2) || r == range_true (type))
+ return true;
+ else
+ {
+ r = range_true_and_false (type);
+ return true;
+ }
+ }
+} fop_unordered_ge;
+
+class foperator_unordered_equal : public range_operator_float
+{
+ using range_operator_float::fold_range;
+public:
+ bool fold_range (irange &r, tree type,
+ const frange &op1, const frange &op2,
+ relation_kind rel) const final override
+ {
+ if (op1.known_isnan () || op2.known_isnan ())
+ {
+ r = range_true (type);
+ return true;
+ }
+ if (!fop_equal.fold_range (r, type, op1, op2, rel))
+ return false;
+ // The result is the same as the ordered version when the
+ // comparison is true or when the operands cannot be NANs.
+ if (finite_operands_p (op1, op2) || r == range_true (type))
+ return true;
+ else
+ {
+ r = range_true_and_false (type);
+ return true;
+ }
}
-} fop_unordered_relop_unknown;
+} fop_unordered_equal;
// Instantiate a range_op_table for floating point operations.
@@ -1174,11 +1290,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_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 (UNLE_EXPR, fop_unordered_le);
+ set (UNLT_EXPR, fop_unordered_lt);
+ set (UNGE_EXPR, fop_unordered_ge);
+ set (UNGT_EXPR, fop_unordered_gt);
+ set (UNEQ_EXPR, fop_unordered_equal);
set (ORDERED_EXPR, fop_ordered);
set (UNORDERED_EXPR, fop_unordered);
}
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2022-10-11 13:54 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-10-11 13:54 [gcc r13-3229] Share common ordered comparison code with UN*_EXPR Aldy Hernandez
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).