[PATCH 3/4] alpha: fix rint on sNaN input [committed/2.23]

[PATCH 3/4] alpha: fix rint on sNaN input [committed/2.23]

[Mike Frysinger]

From: Aurelien Jarno <aurelien@aurel32.net>

The alpha version of rint wrongly return sNaN for sNaN input. Fix that
by checking for NaN and by returning the input value added with itself
in that case.

Changelog:
	* sysdeps/alpha/fpu/s_rint.c (__rint): Add argument with itself
	when it is a NaN.
	* sysdeps/alpha/fpu/s_rintf.c (__rintf): Likewise.

(cherry picked from commit cb7f9d63b921ea1a1cbb4ab377a8484fd5da9a2b)
---
 ChangeLog                   | 5 +++++
 sysdeps/alpha/fpu/s_rint.c  | 3 +++
 sysdeps/alpha/fpu/s_rintf.c | 3 +++
 3 files changed, 11 insertions(+)

diff --git a/ChangeLog b/ChangeLog
index 4f8dc172cc42..b4d4b6af2ae6 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,7 @@
 2016-08-02  Aurelien Jarno  <aurelien@aurel32.net>
 
+2016-08-02  Aurelien Jarno  <aurelien@aurel32.net>
+
 	* sysdeps/alpha/fpu/s_ceil.c (__ceil): Add argument with itself
 	when it is a NaN.
 	[_IEEE_FP_INEXACT] Remove.
@@ -8,6 +10,9 @@
 	when it is a NaN.
 	[_IEEE_FP_INEXACT] Remove.
 	* sysdeps/alpha/fpu/s_floorf.c (__floorf): Likewise.
+	* sysdeps/alpha/fpu/s_rint.c (__rint): Add argument with itself
+	when it is a NaN.
+	* sysdeps/alpha/fpu/s_rintf.c (__rintf): Likewise.
 
 2016-11-23  Matthew Fortune  <Matthew.Fortune@imgtec.com>
 	    Maciej W. Rozycki  <macro@imgtec.com>
diff --git a/sysdeps/alpha/fpu/s_rint.c b/sysdeps/alpha/fpu/s_rint.c
index f33fe72c116b..259348afc08d 100644
--- a/sysdeps/alpha/fpu/s_rint.c
+++ b/sysdeps/alpha/fpu/s_rint.c
@@ -23,6 +23,9 @@
 double
 __rint (double x)
 {
+  if (isnan (x))
+    return x + x;
+
   if (isless (fabs (x), 9007199254740992.0))	/* 1 << DBL_MANT_DIG */
     {
       double tmp1, new_x;
diff --git a/sysdeps/alpha/fpu/s_rintf.c b/sysdeps/alpha/fpu/s_rintf.c
index 1400dfe8d76b..645728ad5b02 100644
--- a/sysdeps/alpha/fpu/s_rintf.c
+++ b/sysdeps/alpha/fpu/s_rintf.c
@@ -22,6 +22,9 @@
 float
 __rintf (float x)
 {
+  if (isnanf (x))
+    return x + x;
+
   if (isless (fabsf (x), 16777216.0f))	/* 1 << FLT_MANT_DIG */
     {
       /* Note that Alpha S_Floating is stored in registers in a
-- 
2.11.0.rc2

[PATCH 1/4] alpha: fix ceil on sNaN input [committed/2.23]

[Mike Frysinger]

From: Aurelien Jarno <aurelien@aurel32.net>

The alpha version of ceil wrongly return sNaN for sNaN input. Fix that
by checking for NaN and by returning the input value added with itself
in that case.

Finally remove the code to handle inexact exception, ceil should never
generate such an exception.

Changelog:
	* sysdeps/alpha/fpu/s_ceil.c (__ceil): Add argument with itself
	when it is a NaN.
	[_IEEE_FP_INEXACT] Remove.
	* sysdeps/alpha/fpu/s_ceilf.c (__ceilf): Likewise.

(cherry picked from commit 062e53c195b4a87754632c7d51254867247698b4)
---
 ChangeLog                   | 7 +++++++
 sysdeps/alpha/fpu/s_ceil.c  | 7 +++----
 sysdeps/alpha/fpu/s_ceilf.c | 7 +++----
 3 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index 24ce4491dc80..ad8921af8858 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+2016-08-02  Aurelien Jarno  <aurelien@aurel32.net>
+
+	* sysdeps/alpha/fpu/s_ceil.c (__ceil): Add argument with itself
+	when it is a NaN.
+	[_IEEE_FP_INEXACT] Remove.
+	* sysdeps/alpha/fpu/s_ceilf.c (__ceilf): Likewise.
+
 2016-11-23  Matthew Fortune  <Matthew.Fortune@imgtec.com>
 	    Maciej W. Rozycki  <macro@imgtec.com>
 
diff --git a/sysdeps/alpha/fpu/s_ceil.c b/sysdeps/alpha/fpu/s_ceil.c
index c1ff864d4b86..e9c350af1cc0 100644
--- a/sysdeps/alpha/fpu/s_ceil.c
+++ b/sysdeps/alpha/fpu/s_ceil.c
@@ -26,17 +26,16 @@
 double
 __ceil (double x)
 {
+  if (isnan (x))
+    return x + x;
+
   if (isless (fabs (x), 9007199254740992.0))	/* 1 << DBL_MANT_DIG */
     {
       double tmp1, new_x;
 
       new_x = -x;
       __asm (
-#ifdef _IEEE_FP_INEXACT
-	     "cvttq/svim %2,%1\n\t"
-#else
 	     "cvttq/svm %2,%1\n\t"
-#endif
 	     "cvtqt/m %1,%0\n\t"
 	     : "=f"(new_x), "=&f"(tmp1)
 	     : "f"(new_x));
diff --git a/sysdeps/alpha/fpu/s_ceilf.c b/sysdeps/alpha/fpu/s_ceilf.c
index 7e63a6fe94e7..77e01a99f743 100644
--- a/sysdeps/alpha/fpu/s_ceilf.c
+++ b/sysdeps/alpha/fpu/s_ceilf.c
@@ -25,6 +25,9 @@
 float
 __ceilf (float x)
 {
+  if (isnanf (x))
+    return x + x;
+
   if (isless (fabsf (x), 16777216.0f))	/* 1 << FLT_MANT_DIG */
     {
       /* Note that Alpha S_Floating is stored in registers in a
@@ -36,11 +39,7 @@ __ceilf (float x)
 
       new_x = -x;
       __asm ("cvtst/s %3,%2\n\t"
-#ifdef _IEEE_FP_INEXACT
-	     "cvttq/svim %2,%1\n\t"
-#else
 	     "cvttq/svm %2,%1\n\t"
-#endif
 	     "cvtqt/m %1,%0\n\t"
 	     : "=f"(new_x), "=&f"(tmp1), "=&f"(tmp2)
 	     : "f"(new_x));
-- 
2.11.0.rc2

[PATCH 4/4] alpha: fix trunc for big input values [committed/2.23]

[Mike Frysinger]

From: Aurelien Jarno <aurelien@aurel32.net>

The alpha specific version of trunc and truncf always add and subtract
0x1.0p23 or 0x1.0p52 even for big values. This causes this kind of
errors in the testsuite:

  Failure: Test: trunc_towardzero (0x1p107)
  Result:
   is:          1.6225927682921334e+32   0x1.fffffffffffffp+106
   should be:   1.6225927682921336e+32   0x1.0000000000000p+107
   difference:  1.8014398509481984e+16   0x1.0000000000000p+54
   ulp       :  0.5000
   max.ulp   :  0.0000

Change this by returning the input value when its absolute value is
greater than 0x1.0p23 or 0x1.0p52. NaN have to go through the add and
subtract operations to get possibly silenced.

Finally remove the code to handle inexact exception, trunc should never
generate such an exception.

Changelog:
	* sysdeps/alpha/fpu/s_trunc.c (__trunc): Return the input value
	when its absolute value is greater than 0x1.0p52.
	[_IEEE_FP_INEXACT] Remove.
	* sysdeps/alpha/fpu/s_truncf.c (__truncf): Return the input value
	when its absolute value is greater than 0x1.0p23.
	[_IEEE_FP_INEXACT] Remove.

(cherry picked from commit b74d259fe793499134eb743222cd8dd7c74a31ce)
---
 ChangeLog                    | 6 ++++++
 sysdeps/alpha/fpu/s_trunc.c  | 7 +++----
 sysdeps/alpha/fpu/s_truncf.c | 7 +++----
 3 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index b4d4b6af2ae6..5a49870eb15b 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -13,6 +13,12 @@
 	* sysdeps/alpha/fpu/s_rint.c (__rint): Add argument with itself
 	when it is a NaN.
 	* sysdeps/alpha/fpu/s_rintf.c (__rintf): Likewise.
+	* sysdeps/alpha/fpu/s_trunc.c (__trunc): Return the input value
+	when its absolute value is greater than 0x1.0p52.
+	[_IEEE_FP_INEXACT] Remove.
+	* sysdeps/alpha/fpu/s_truncf.c (__truncf): Return the input value
+	when its absolute value is greater than 0x1.0p23.
+	[_IEEE_FP_INEXACT] Remove.
 
 2016-11-23  Matthew Fortune  <Matthew.Fortune@imgtec.com>
 	    Maciej W. Rozycki  <macro@imgtec.com>
diff --git a/sysdeps/alpha/fpu/s_trunc.c b/sysdeps/alpha/fpu/s_trunc.c
index 16cb114a72f5..4b986a6926eb 100644
--- a/sysdeps/alpha/fpu/s_trunc.c
+++ b/sysdeps/alpha/fpu/s_trunc.c
@@ -28,12 +28,11 @@ __trunc (double x)
   double two52 = copysign (0x1.0p52, x);
   double r, tmp;
 
+  if (isgreaterequal (fabs (x), 0x1.0p52))
+    return x;
+
   __asm (
-#ifdef _IEEE_FP_INEXACT
-	 "addt/suic %2, %3, %1\n\tsubt/suic %1, %3, %0"
-#else
 	 "addt/suc %2, %3, %1\n\tsubt/suc %1, %3, %0"
-#endif
 	 : "=&f"(r), "=&f"(tmp)
 	 : "f"(x), "f"(two52));
 
diff --git a/sysdeps/alpha/fpu/s_truncf.c b/sysdeps/alpha/fpu/s_truncf.c
index 2290f282954d..3e933561663b 100644
--- a/sysdeps/alpha/fpu/s_truncf.c
+++ b/sysdeps/alpha/fpu/s_truncf.c
@@ -27,12 +27,11 @@ __truncf (float x)
   float two23 = copysignf (0x1.0p23, x);
   float r, tmp;
 
+  if (isgreaterequal (fabsf (x), 0x1.0p23))
+    return x;
+
   __asm (
-#ifdef _IEEE_FP_INEXACT
-	 "adds/suic %2, %3, %1\n\tsubs/suic %1, %3, %0"
-#else
 	 "adds/suc %2, %3, %1\n\tsubs/suc %1, %3, %0"
-#endif
 	 : "=&f"(r), "=&f"(tmp)
 	 : "f"(x), "f"(two23));
 
-- 
2.11.0.rc2

[PATCH 2/4] alpha: fix floor on sNaN input [committed/2.23]

[Mike Frysinger]

From: Aurelien Jarno <aurelien@aurel32.net>

The alpha version of floor wrongly return sNaN for sNaN input. Fix that
by checking for NaN and by returning the input value added with itself
in that case.

Finally remove the code to handle inexact exception, floor should never
generate such an exception.

Changelog:
	* sysdeps/alpha/fpu/s_floor.c (__floor): Add argument with itself
	when it is a NaN.
	[_IEEE_FP_INEXACT] Remove.
	* sysdeps/alpha/fpu/s_floorf.c (__floorf): Likewise.

(cherry picked from commit 65cc568cf57156e5230db9a061645e54ff028a41)
---
 ChangeLog                    | 4 ++++
 sysdeps/alpha/fpu/s_floor.c  | 7 +++----
 sysdeps/alpha/fpu/s_floorf.c | 7 +++----
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index ad8921af8858..4f8dc172cc42 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -4,6 +4,10 @@
 	when it is a NaN.
 	[_IEEE_FP_INEXACT] Remove.
 	* sysdeps/alpha/fpu/s_ceilf.c (__ceilf): Likewise.
+	* sysdeps/alpha/fpu/s_floor.c (__floor): Add argument with itself
+	when it is a NaN.
+	[_IEEE_FP_INEXACT] Remove.
+	* sysdeps/alpha/fpu/s_floorf.c (__floorf): Likewise.
 
 2016-11-23  Matthew Fortune  <Matthew.Fortune@imgtec.com>
 	    Maciej W. Rozycki  <macro@imgtec.com>
diff --git a/sysdeps/alpha/fpu/s_floor.c b/sysdeps/alpha/fpu/s_floor.c
index 1a6f8c461756..9930f6be42af 100644
--- a/sysdeps/alpha/fpu/s_floor.c
+++ b/sysdeps/alpha/fpu/s_floor.c
@@ -27,16 +27,15 @@
 double
 __floor (double x)
 {
+  if (isnan (x))
+    return x + x;
+
   if (isless (fabs (x), 9007199254740992.0))	/* 1 << DBL_MANT_DIG */
     {
       double tmp1, new_x;
 
       __asm (
-#ifdef _IEEE_FP_INEXACT
-	     "cvttq/svim %2,%1\n\t"
-#else
 	     "cvttq/svm %2,%1\n\t"
-#endif
 	     "cvtqt/m %1,%0\n\t"
 	     : "=f"(new_x), "=&f"(tmp1)
 	     : "f"(x));
diff --git a/sysdeps/alpha/fpu/s_floorf.c b/sysdeps/alpha/fpu/s_floorf.c
index 8cd80e2b42d7..015c04f40d80 100644
--- a/sysdeps/alpha/fpu/s_floorf.c
+++ b/sysdeps/alpha/fpu/s_floorf.c
@@ -26,6 +26,9 @@
 float
 __floorf (float x)
 {
+  if (isnanf (x))
+    return x + x;
+
   if (isless (fabsf (x), 16777216.0f))	/* 1 << FLT_MANT_DIG */
     {
       /* Note that Alpha S_Floating is stored in registers in a
@@ -36,11 +39,7 @@ __floorf (float x)
       float tmp1, tmp2, new_x;
 
       __asm ("cvtst/s %3,%2\n\t"
-#ifdef _IEEE_FP_INEXACT
-	     "cvttq/svim %2,%1\n\t"
-#else
 	     "cvttq/svm %2,%1\n\t"
-#endif
 	     "cvtqt/m %1,%0\n\t"
 	     : "=f"(new_x), "=&f"(tmp1), "=&f"(tmp2)
 	     : "f"(x));
-- 
2.11.0.rc2

Re: [PATCH 1/4] alpha: fix ceil on sNaN input [committed/2.23]

[Richard Henderson]

On 12/08/2016 10:51 AM, Mike Frysinger wrote:
>  __ceil (double x)
>  {
> +  if (isnan (x))
> +    return x + x;
> +
>    if (isless (fabs (x), 9007199254740992.0))	/* 1 << DBL_MANT_DIG */
>      {
>        double tmp1, new_x;

Probably better to test for nan in the else of this if, since the isless is 
surely more likely than the nan.

That goes for all of the changes.


r~

Re: [PATCH 1/4] alpha: fix ceil on sNaN input [committed/2.23]

[Mike Frysinger]

[-- Attachment #1: Type: text/plain, Size: 595 bytes --]

On 08 Dec 2016 20:01, Richard Henderson wrote:
> On 12/08/2016 10:51 AM, Mike Frysinger wrote:
> >  __ceil (double x)
> >  {
> > +  if (isnan (x))
> > +    return x + x;
> > +
> >    if (isless (fabs (x), 9007199254740992.0))	/* 1 << DBL_MANT_DIG */
> >      {
> >        double tmp1, new_x;
> 
> Probably better to test for nan in the else of this if, since the isless is 
> surely more likely than the nan.
> 
> That goes for all of the changes.

i guess fabs(NaN) and isless(NaN, ...) isn't a problem ?

would it be equiv to do ?
	if (__glibc_unlikely (isnan (x)))
-mike

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

Re: [PATCH 1/4] alpha: fix ceil on sNaN input [committed/2.23]

[Richard Henderson]

On 12/08/2016 08:11 PM, Mike Frysinger wrote:
> On 08 Dec 2016 20:01, Richard Henderson wrote:
>> On 12/08/2016 10:51 AM, Mike Frysinger wrote:
>>>  __ceil (double x)
>>>  {
>>> +  if (isnan (x))
>>> +    return x + x;
>>> +
>>>    if (isless (fabs (x), 9007199254740992.0))	/* 1 << DBL_MANT_DIG */
>>>      {
>>>        double tmp1, new_x;
>>
>> Probably better to test for nan in the else of this if, since the isless is
>> surely more likely than the nan.
>>
>> That goes for all of the changes.
>
> i guess fabs(NaN) and isless(NaN, ...) isn't a problem ?

No, that's fine.

> would it be equiv to do ?
> 	if (__glibc_unlikely (isnan (x)))

No, since that test would still happen first.  I think that

   if (isless(...))
     ...
   else if (isnan(x))
     return x + x;

is better for the average case.


r~