diff mbox series

range-op-float, v2: frange_arithmetic tweaks for MODE_COMPOSITE_P

Message ID Y5C54d2clIOm0hrr@tucnak
State Unresolved
Headers
Series range-op-float, v2: frange_arithmetic tweaks for MODE_COMPOSITE_P |

Checks

Context Check Description
snail/gcc-patch-check warning Git am fail log

Commit Message

Jakub Jelinek Dec. 7, 2022, 4:05 p.m. UTC 
  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  <jakub@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.



	Jakub

Comments

Aldy Hernandez Dec. 7, 2022, 5:41 p.m. UTC | #1 
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  <jakub@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
>
diff mbox series

Patch

--- 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