[COMMITTED] [frange] Handle relations in LTGT_EXPR.

[Aldy Hernandez <aldyh@redhat.com>]

LTGT_EXPR hasn't been handling relations, especially with NANs as a
possibility.  This handles them while documenting how relations work
in a world with NANs.

Basically we need to special case VREL_EQ before calling
frelop_early_resolve.  Note that VREL_EQ on entry to a range-op entry
is really VREL_EQ U NAN, but to make sure about the NAN possibility,
one must look at the operands.  However, even VREL_EQ U NAN is false
for LTGT_EXPR since the latter is just NE_EXPR without a NAN.

After we handle VREL_EQ, we drop down to frelop_early_resolve
pretending to be a NE_EXPR, and everything should just map correctly.

2023-08-28  Aldy Hernandez  <aldyh@redhat.com>

	* range-op-float.cc (fold_range): Handle relations.
---
 gcc/range-op-float.cc | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/gcc/range-op-float.cc b/gcc/range-op-float.cc
index 14199647744..eebc73f9918 100644
--- a/gcc/range-op-float.cc
+++ b/gcc/range-op-float.cc
@@ -2204,8 +2204,23 @@ class foperator_ltgt : public range_operator
 public:
   bool fold_range (irange &r, tree type,
 		   const frange &op1, const frange &op2,
-		   relation_trio rel = TRIO_VARYING) const final override
+		   relation_trio trio = TRIO_VARYING) const final override
   {
+    relation_kind rel = trio.op1_op2 ();
+
+    // VREL_EQ is really VREL_(UN)EQ because we could have a NAN in
+    // the operands, but since LTGT_EXPR is really a NE_EXPR without
+    // the NAN, VREL_EQ & LTGT_EXPR is an impossibility.
+    if (rel == VREL_EQ)
+      {
+	r = range_false (type);
+	return true;
+      }
+    // ...otherwise pretend we're trying to resolve a NE_EXPR and
+    // everything will "just work".
+    if (frelop_early_resolve (r, type, op1, op2, trio, VREL_NE))
+      return true;
+
     if (op1.known_isnan () || op2.known_isnan ())
       {
 	r = range_false (type);
@@ -2218,7 +2233,7 @@ public:
     if (op2.maybe_isnan ())
       op2_no_nan.clear_nan ();
     if (!range_op_handler (NE_EXPR).fold_range (r, type, op1_no_nan,
-						op2_no_nan, rel))
+						op2_no_nan, trio))
       return false;
     // The result is the same as the ordered version when the
     // comparison is true or when the operands cannot be NANs.
-- 
2.41.0