real: Fix roundeven on inf/nan [PR93663]
diff mbox series

Message ID 20200212061901.GV17695@tucnak
State New
Headers show
Series
  • real: Fix roundeven on inf/nan [PR93663]
Related show

Commit Message

Jakub Jelinek Feb. 12, 2020, 6:19 a.m. UTC
On Fri, Aug 23, 2019 at 08:38:43PM +0000, Joseph Myers wrote:
> > +/* Return true if R is halfway between two integers, else return
> > +   false.  The function is not valid for rvc_inf and rvc_nan classes.  */
> > +
> > +bool
> > +is_halfway_below (const REAL_VALUE_TYPE *r)
> > +{
> > +  gcc_assert (r->cl != rvc_inf);
> > +  gcc_assert (r->cl != rvc_nan);
> > +  int i;
> 
> Explicitly check for rvc_zero and return false in that case (that seems to 
> be the convention in real.c, rather than relying on code using REAL_EXP to 
> do something sensible for zero, which has REAL_EXP of 0).

As can be seen in the testcase, roundeven with inf or nan arguments
ICE because of those asserts where nothing prevents from is_halfway_below
being called with those arguments.

The following patch fixes that by just returning false for rvc_inf/rvc_nan
like it returns for rvc_zero, so that we handle roundeven with all those
values as round.  Inf/NaN are not halfway in between two integers...

Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?

2020-02-12  Jakub Jelinek  <jakub@redhat.com>

	PR middle-end/93663
	* real.c (is_even): Make static.  Function comment fix.
	(is_halfway_below): Make static, don't assert R is not inf/nan,
	instead return false for those.  Small formatting fixes.

	* gcc.dg/torture/builtin-round-roundeven.c (main): Add tests
	for DBL_MAX, inf, their negations and nan.



	Jakub

Comments

Joseph Myers Feb. 12, 2020, 8:56 p.m. UTC | #1
On Wed, 12 Feb 2020, Jakub Jelinek wrote:

> As can be seen in the testcase, roundeven with inf or nan arguments
> ICE because of those asserts where nothing prevents from is_halfway_below
> being called with those arguments.
> 
> The following patch fixes that by just returning false for rvc_inf/rvc_nan
> like it returns for rvc_zero, so that we handle roundeven with all those
> values as round.  Inf/NaN are not halfway in between two integers...
> 
> Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?

OK.

Patch
diff mbox series

--- gcc/real.c.jj	2020-01-23 16:16:16.456601333 +0100
+++ gcc/real.c	2020-02-11 12:40:06.571398420 +0100
@@ -5150,10 +5150,10 @@  real_round (REAL_VALUE_TYPE *r, format_h
     real_convert (r, fmt, r);
 }
 
-/* Return true including 0 if integer part of R is even, else return
+/* Return true (including 0) if integer part of R is even, else return
    false.  The function is not valid for rvc_inf and rvc_nan classes.  */
 
-bool
+static bool
 is_even (REAL_VALUE_TYPE *r)
 {
   gcc_assert (r->cl != rvc_inf);
@@ -5184,16 +5184,12 @@  is_even (REAL_VALUE_TYPE *r)
 }
 
 /* Return true if R is halfway between two integers, else return
-   false.  The function is not valid for rvc_inf and rvc_nan classes.  */
+   false.  */
 
-bool
+static bool
 is_halfway_below (const REAL_VALUE_TYPE *r)
 {
-  gcc_assert (r->cl != rvc_inf);
-  gcc_assert (r->cl != rvc_nan);
-  int i;
-
-  if (r->cl == rvc_zero)
+  if (r->cl != rvc_normal)
     return false;
 
   /* For numbers (-0.5,0) and (0,0.5).  */
@@ -5205,13 +5201,13 @@  is_halfway_below (const REAL_VALUE_TYPE
       unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r) - 1;
       int w = n / HOST_BITS_PER_LONG;
 
-      for (i = 0; i < w; ++i)
+      for (int i = 0; i < w; ++i)
 	if (r->sig[i] != 0)
 	  return false;
 
-      unsigned long num = ((unsigned long)1 << (n % HOST_BITS_PER_LONG));
+      unsigned long num = 1UL << (n % HOST_BITS_PER_LONG);
 
-      if (((r->sig[w] & num) != 0) && ((r->sig[w] & (num-1)) == 0))
+      if ((r->sig[w] & num) != 0 && (r->sig[w] & (num - 1)) == 0)
 	return true;
     }
   return false;
--- gcc/testsuite/gcc.dg/torture/builtin-round-roundeven.c.jj	2020-01-12 11:54:37.547396300 +0100
+++ gcc/testsuite/gcc.dg/torture/builtin-round-roundeven.c	2020-02-11 12:47:55.346354893 +0100
@@ -18,6 +18,13 @@  main (void)
   TEST(roundeven,  -1.5, -2);
   TEST(roundeven,  3.499, 3);
   TEST(roundeven,  3.501, 4);
+  TEST(roundeven,  __DBL_MAX__, __DBL_MAX__);
+  TEST(roundeven,  -__DBL_MAX__, -__DBL_MAX__);
+  TEST(roundeven,  __builtin_inf (), __builtin_inf ());
+  TEST(roundeven,  -__builtin_inf (), -__builtin_inf ());
+
+  if (!__builtin_isnan (__builtin_roundeven (__builtin_nan (""))))
+    link_error (__LINE__);
 
   if (__builtin_copysign (1, __builtin_roundeven (-0.5)) != -1)
     link_error (__LINE__);
@@ -31,6 +38,5 @@  main (void)
     link_error (__LINE__);
   if (__builtin_copysign (-1, __builtin_roundeven (0.25)) != 1)
     link_error (__LINE__);
- return 0;
+  return 0;
 }
-