[gcc r13-3823] [range-op-float] Set NAN possibility for INF + (-INF) and vice versa.

[Aldy Hernandez <aldyh@gcc.gnu.org>]

https://gcc.gnu.org/g:68b0615be2aaff3a8ce91ba7cd0f69ebbd93702c

commit r13-3823-g68b0615be2aaff3a8ce91ba7cd0f69ebbd93702c
Author: Aldy Hernandez <aldyh@redhat.com>
Date:   Tue Nov 8 23:42:04 2022 +0100

    [range-op-float] Set NAN possibility for INF + (-INF) and vice versa.
    
    Some combinations of operations can yield a NAN even if no operands
    have the possiblity of a NAN.  For example, [-INF] + [+INF] = NAN and
    vice versa.
    
    For [-INF,+INF] + [-INF,+INF], frange_arithmetic will not return a
    NAN, and since the operands have no possibility of a NAN, we will
    mistakenly assume the result cannot have a NAN.  This fixes the
    oversight.
    
    gcc/ChangeLog:
    
            * range-op-float.cc (foperator_plus::fold_range): Set NAN for
            addition of different signed infinities.
            (range_op_float_tests): New test.

Diff:
---
 gcc/range-op-float.cc | 26 +++++++++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/gcc/range-op-float.cc b/gcc/range-op-float.cc
index 3bc6cc8849d..8282c912fc4 100644
--- a/gcc/range-op-float.cc
+++ b/gcc/range-op-float.cc
@@ -1863,7 +1863,21 @@ foperator_plus::fold_range (frange &r, tree type,
 
   r.set (type, lb, ub);
 
-  if (lb_nan || ub_nan)
+  // Some combinations can yield a NAN even if no operands have the
+  // possibility of a NAN.
+  bool maybe_nan;
+  // [-INF] + [+INF] = NAN
+  if (real_isinf (&op1.lower_bound (), true)
+      && real_isinf (&op2.upper_bound (), false))
+    maybe_nan = true;
+  // [+INF] + [-INF] = NAN
+  else if (real_isinf (&op1.upper_bound (), false)
+	   && real_isinf (&op2.lower_bound (), true))
+    maybe_nan = true;
+  else
+    maybe_nan = false;
+
+  if (lb_nan || ub_nan || maybe_nan)
     // Keep the default NAN (with a varying sign) set by the setter.
     ;
   else if (!op1.maybe_isnan () && !op2.maybe_isnan ())
@@ -1960,6 +1974,16 @@ range_op_float_tests ()
   r1 = frange_float ("-1", "-0");
   r1.update_nan (false);
   ASSERT_EQ (r, r1);
+
+  // [-INF,+INF] + [-INF,+INF] could be a NAN.
+  range_op_handler plus (PLUS_EXPR, float_type_node);
+  r0.set_varying (float_type_node);
+  r1.set_varying (float_type_node);
+  r0.clear_nan ();
+  r1.clear_nan ();
+  plus.fold_range (r, float_type_node, r0, r1);
+  if (HONOR_NANS (float_type_node))
+    ASSERT_TRUE (r.maybe_isnan ());
 }
 
 } // namespace selftest