Re: [PATCH] range-op-float, v2: frange_arithmetic tweaks for MODE_COMPOSITE_P

[Aldy Hernandez via Gcc-patches]

OK, thanks.
Aldy

On 12/7/22 17:05, Jakub Jelinek wrote:

On Wed, Dec 07, 2022 at 04:38:14PM +0100, Aldy Hernandez wrote:

So, perhaps a combination of that, change frange_nextafter to do the above
and change frange_arithmetic for the initial inexact rounding only to
do it by hand using range_nextafter and starting from value.

Either way is fine.  Whatever is cleaner.

Now in patch form:

2022-12-07  Jakub Jelinek  <ja...@redhat.com>

        * range-op-float.cc (frange_nextafter): For MODE_COMPOSITE_P from
        denormal or zero, use real_nextafter on DFmode with conversions
        around it.
        (frange_arithmetic): For mode_composite, on top of rounding in the
        right direction accept extra 1ulp error for PLUS/MINUS_EXPR, extra
        2ulps error for MULT_EXPR and extra 3ulps error for RDIV_EXPR.

--- gcc/range-op-float.cc.jj    2022-12-07 12:46:01.536123757 +0100
+++ gcc/range-op-float.cc       2022-12-07 16:58:02.406062286 +0100
@@ -254,10 +254,21 @@ frange_nextafter (enum machine_mode mode
                  REAL_VALUE_TYPE &value,
                  const REAL_VALUE_TYPE &inf)
  {
-  const real_format *fmt = REAL_MODE_FORMAT (mode);
-  REAL_VALUE_TYPE tmp;
-  real_nextafter (&tmp, fmt, &value, &inf);
-  value = tmp;
+  if (MODE_COMPOSITE_P (mode)
+      && (real_isdenormal (&value, mode) || real_iszero (&value)))
+    {
+      // IBM extended denormals only have DFmode precision.
+      REAL_VALUE_TYPE tmp, tmp2;
+      real_convert (&tmp2, DFmode, &value);
+      real_nextafter (&tmp, REAL_MODE_FORMAT (DFmode), &tmp2, &inf);
+      real_convert (&value, mode, &tmp);
+    }
+  else
+    {
+      REAL_VALUE_TYPE tmp;
+      real_nextafter (&tmp, REAL_MODE_FORMAT (mode), &value, &inf);
+      value = tmp;
+    }
  }

// Like real_arithmetic, but round the result to INF if the operation

@@ -324,21 +335,40 @@ frange_arithmetic (enum tree_code code,
      }
    if (round && (inexact || !real_identical (&result, &value)))
      {
-      if (mode_composite)
+      if (mode_composite
+         && (real_isdenormal (&result, mode) || real_iszero (&result)))
        {
-         if (real_isdenormal (&result, mode)
-             || real_iszero (&result))
-           {
-             // IBM extended denormals only have DFmode precision.
-             REAL_VALUE_TYPE tmp;
-             real_convert (&tmp, DFmode, &value);
-             frange_nextafter (DFmode, tmp, inf);
-             real_convert (&result, mode, &tmp);
-             return;
-           }
+         // IBM extended denormals only have DFmode precision.
+         REAL_VALUE_TYPE tmp, tmp2;
+         real_convert (&tmp2, DFmode, &value);
+         real_nextafter (&tmp, REAL_MODE_FORMAT (DFmode), &tmp2, &inf);
+         real_convert (&result, mode, &tmp);
        }
-      frange_nextafter (mode, result, inf);
+      else
+       frange_nextafter (mode, result, inf);
      }
+  if (mode_composite)
+    switch (code)
+      {
+      case PLUS_EXPR:
+      case MINUS_EXPR:
+       // ibm-ldouble-format documents 1ulp for + and -.
+       frange_nextafter (mode, result, inf);
+       break;
+      case MULT_EXPR:
+       // ibm-ldouble-format documents 2ulps for *.
+       frange_nextafter (mode, result, inf);
+       frange_nextafter (mode, result, inf);
+       break;
+      case RDIV_EXPR:
+       // ibm-ldouble-format documents 3ulps for /.
+       frange_nextafter (mode, result, inf);
+       frange_nextafter (mode, result, inf);
+       frange_nextafter (mode, result, inf);
+       break;
+      default:
+       break;
+      }
  }

// Crop R to [-INF, MAX] where MAX is the maximum representable number

        Jakub