[PATCH] [PR106831] Avoid propagating long doubles that may have multiple representations.

[PATCH] [PR106831] Avoid propagating long doubles that may have multiple representations.

[Aldy Hernandez]

Long doubles are tricky when it comes to considering singletons
because small numbers and +-INF can have multiple representations for
the same number.  So we need to be very careful not to treat those as
singletons, lest they be incorrectly propagated by VRP.  This is
similar to the -0.0 and +0.0 duality.

In long doubles +INF can be represented with +INF in the MSB and
either -0.0 or +0.0 in the LSB.  Similarly for numbers that are exactly
representable in DF.  For example, 1.0 can be represented as either
(1.0, +0.0) or (1.0, -0.0).

This patch avoids treating these numbers as singletons.

Note that NANs in long double format have a LSB of don't care, but
this is irrelevant for singleton_p, because NANs are never considered
singletons.  Also, internally in the frange we store NANs as a pair of
boolean flags indicating whether they are +NAN or -NAN, so we don't need
any special treatment here for comparing range equality etc.  We never
see anything but the boolean flags.  (Errr, the boolean flags are not
yet in trunk, but should go in shortly).

I will push this patch after tests complete.

Thank you Jakub for providing this patch.

	PR middle-end/106831

gcc/ChangeLog:

	* value-range.cc (frange::singleton_p): Avoid propagating long
	doubles that may have multiple representations.
---
 gcc/value-range.cc | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index 55a216efd8b..67d5d7fa90f 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -639,6 +639,21 @@ frange::singleton_p (tree *result) const
       if (HONOR_NANS (m_type) && maybe_isnan ())
 	return false;
 
+      if (MODE_COMPOSITE_P (TYPE_MODE (m_type)))
+	{
+	  // For IBM long doubles, if the value is +-Inf or is exactly
+	  // representable in double, the other double could be +0.0
+	  // or -0.0.  Since this means there is more than one way to
+	  // represent a value, return false to avoid propagating it.
+	  // See libgcc/config/rs6000/ibm-ldouble-format for details.
+	  if (real_isinf (&m_min))
+	    return false;
+	  REAL_VALUE_TYPE r;
+	  real_convert (&r, DFmode, &m_min);
+	  if (real_identical (&r, &m_min))
+	    return false;
+	}
+
       if (result)
 	*result = build_real (m_type, m_min);
       return true;
-- 
2.37.1