[PATCH v2 00/18] Use GCC builtins for some math functions if desired.

[PATCH v2 00/18] Use GCC builtins for some math functions if desired.

[Stefan Liebler]

Hi,

this patch-series moves the nearbyint, rint, floor, ceil, trunc and round implementation from sysdeps/ieee754/dbl-64/wordsize-64 to sysdeps/ieee754/dbl-64/ as proposed by Adhemerval:
ttps://www.sourceware.org/ml/libc-alpha/2019-11/msg00085.html

It also introduces the math-use-builtins.h header with __USE_<SYMBOL>_BUILTIN macros which allows to just use GCC __builtin_<SYMBOL> instead of the current common-code implementation.  There is a float, double, long double and _Float128 version of this macro for each <SYMBOL>.

The generic math-use-builtins.h header is defining all those macros to 0 in order to use the current common-code implenetation.  If an architecture wants to use the builtins, an architecture specific math-use-builtins.h needs to be created (e.g. done for s390) where those macros are defined to 1.

Changes compared to first version (see https://www.sourceware.org/ml/libc-alpha/2019-12/msg00029.html) due to review from:
Joseph Myers:
* The copysign builtins are now used unconditionally for float, double and long double.  For _Float128 the macro is defined to 1 if build with GCC >= 7.

Adhemerval Zanella:
* Some static array definitions like TWO52 in s_nearbyint.c are moved inside the !USE_NEARBYINT_BUILTIN within the function.
* The s390 math-use-builtins.h header is now replicating the USE_XYZ* macros for !HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT instead of just including the generic header file.
* The changes regarding code style in the "Use GCC builtins for xyz functions if desired" patches are splitted out into the new patches "Adjust s_XYZ.c regarding code style."

Bye,
Stefan

Stefan Liebler (18):
  Always use wordsize-64 version of s_nearbyint.c.
  Always use wordsize-64 version of s_rint.c.
  Always use wordsize-64 version of s_floor.c.
  Always use wordsize-64 version of s_ceil.c.
  Always use wordsize-64 version of s_trunc.c.
  Always use wordsize-64 version of s_round.c.
  Use GCC builtins for nearbyint functions if desired.
  Use GCC builtins for rint functions if desired.
  Use GCC builtins for floor functions if desired.
  Use GCC builtins for ceil functions if desired.
  Use GCC builtins for trunc functions if desired.
  Use GCC builtins for round functions if desired.
  Use GCC builtins for copysign functions if desired.
  Adjust s_nearbyintf.c and s_nearbyintl.c regarding code style.
  Adjust s_rintf.c and s_rintl.c regarding code style.
  Adjust s_floorf.c and s_floorl.c regarding code style.
  Adjust s_ceilf.c and s_ceill.c regarding code style.
  Adjust s_copysignl.c regarding code style.

 sysdeps/generic/math-use-builtins.h           |  63 ++++++++++
 sysdeps/ieee754/dbl-64/s_ceil.c               |  65 ++++------
 sysdeps/ieee754/dbl-64/s_copysign.c           |   9 +-
 sysdeps/ieee754/dbl-64/s_floor.c              |  99 ++++++++--------
 sysdeps/ieee754/dbl-64/s_nearbyint.c          |  49 ++++----
 sysdeps/ieee754/dbl-64/s_rint.c               |  43 ++++---
 sysdeps/ieee754/dbl-64/s_round.c              |  45 +++----
 sysdeps/ieee754/dbl-64/s_trunc.c              |  31 ++---
 sysdeps/ieee754/dbl-64/wordsize-64/s_ceil.c   |  52 --------
 sysdeps/ieee754/dbl-64/wordsize-64/s_floor.c  |  72 ------------
 .../ieee754/dbl-64/wordsize-64/s_nearbyint.c  |  65 ----------
 sysdeps/ieee754/dbl-64/wordsize-64/s_rint.c   |  58 ---------
 sysdeps/ieee754/dbl-64/wordsize-64/s_round.c  |  66 -----------
 sysdeps/ieee754/dbl-64/wordsize-64/s_trunc.c  |  55 ---------
 sysdeps/ieee754/float128/float128_private.h   |  22 ++++
 sysdeps/ieee754/flt-32/s_ceilf.c              |  61 ++++++----
 sysdeps/ieee754/flt-32/s_copysignf.c          |  12 +-
 sysdeps/ieee754/flt-32/s_floorf.c             |  61 ++++++----
 sysdeps/ieee754/flt-32/s_nearbyintf.c         |  77 ++++++------
 sysdeps/ieee754/flt-32/s_rintf.c              |  61 ++++++----
 sysdeps/ieee754/flt-32/s_roundf.c             |   6 +
 sysdeps/ieee754/flt-32/s_truncf.c             |   6 +
 sysdeps/ieee754/ldbl-128/s_ceill.c            |  97 ++++++++++-----
 sysdeps/ieee754/ldbl-128/s_copysignl.c        |  23 ++--
 sysdeps/ieee754/ldbl-128/s_floorl.c           |  95 ++++++++++-----
 sysdeps/ieee754/ldbl-128/s_nearbyintl.c       |  80 +++++++------
 sysdeps/ieee754/ldbl-128/s_rintl.c            |  66 ++++++-----
 sysdeps/ieee754/ldbl-128/s_roundl.c           |   6 +
 sysdeps/ieee754/ldbl-128/s_truncl.c           |   6 +
 sysdeps/s390/fpu/math-use-builtins.h          | 111 ++++++++++++++++++
 .../sparc64/fpu/multiarch/s_ceil-generic.c    |   2 +-
 .../sparc/sparc64/fpu/multiarch/s_ceil-vis3.c |   2 +-
 .../sparc64/fpu/multiarch/s_floor-generic.c   |   2 +-
 .../sparc64/fpu/multiarch/s_floor-vis3.c      |   2 +-
 .../sparc64/fpu/multiarch/s_trunc-generic.c   |   2 +-
 .../sparc64/fpu/multiarch/s_trunc-vis3.c      |   2 +-
 sysdeps/x86_64/fpu/multiarch/s_ceil-c.c       |   2 +-
 sysdeps/x86_64/fpu/multiarch/s_floor-c.c      |   2 +-
 sysdeps/x86_64/fpu/multiarch/s_nearbyint-c.c  |   2 +-
 sysdeps/x86_64/fpu/multiarch/s_rint-c.c       |   2 +-
 sysdeps/x86_64/fpu/multiarch/s_trunc-c.c      |   2 +-
 41 files changed, 778 insertions(+), 806 deletions(-)
 create mode 100644 sysdeps/generic/math-use-builtins.h
 delete mode 100644 sysdeps/ieee754/dbl-64/wordsize-64/s_ceil.c
 delete mode 100644 sysdeps/ieee754/dbl-64/wordsize-64/s_floor.c
 delete mode 100644 sysdeps/ieee754/dbl-64/wordsize-64/s_nearbyint.c
 delete mode 100644 sysdeps/ieee754/dbl-64/wordsize-64/s_rint.c
 delete mode 100644 sysdeps/ieee754/dbl-64/wordsize-64/s_round.c
 delete mode 100644 sysdeps/ieee754/dbl-64/wordsize-64/s_trunc.c
 create mode 100644 sysdeps/s390/fpu/math-use-builtins.h

-- 
2.19.1

[PATCH v2 01/18] Always use wordsize-64 version of s_nearbyint.c.

[Stefan Liebler]

This patch replaces s_nearbyint.c in sysdeps/dbl-64 with the one in
sysdeps/dbl-64/wordsize-64 and removes the latter one.
The code is not changed except changes in code style.

Also adjusted the include path in x86_64 file.
---
 sysdeps/ieee754/dbl-64/s_nearbyint.c          | 38 +++++------
 .../ieee754/dbl-64/wordsize-64/s_nearbyint.c  | 65 -------------------
 sysdeps/x86_64/fpu/multiarch/s_nearbyint-c.c  |  2 +-
 3 files changed, 17 insertions(+), 88 deletions(-)
 delete mode 100644 sysdeps/ieee754/dbl-64/wordsize-64/s_nearbyint.c

diff --git a/sysdeps/ieee754/dbl-64/s_nearbyint.c b/sysdeps/ieee754/dbl-64/s_nearbyint.c
index 4ce570ac7f..c261885c5a 100644
--- a/sysdeps/ieee754/dbl-64/s_nearbyint.c
+++ b/sysdeps/ieee754/dbl-64/s_nearbyint.c
@@ -10,10 +10,6 @@
  * ====================================================
  */
 
-#if defined(LIBM_SCCS) && !defined(lint)
-static char rcsid[] = "$NetBSD: s_rint.c,v 1.8 1995/05/10 20:48:04 jtc Exp $";
-#endif
-
 /*
  * rint(x)
  * Return x rounded to integral value according to the prevailing
@@ -32,44 +28,42 @@ static char rcsid[] = "$NetBSD: s_rint.c,v 1.8 1995/05/10 20:48:04 jtc Exp $";
 #include <libm-alias-double.h>
 
 static const double
-  TWO52[2] = {
-  4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
- -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
+TWO52[2] = {
+	    4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
+	    -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
 };
 
 double
 __nearbyint (double x)
 {
   fenv_t env;
-  int32_t i0, j0, sx;
-  double w, t;
-  GET_HIGH_WORD (i0, x);
-  sx = (i0 >> 31) & 1;
-  j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
-  if (j0 < 52)
+  int64_t i0, sx;
+  int32_t j0;
+  EXTRACT_WORDS64 (i0, x);
+  sx = (i0 >> 63) & 1;
+  j0 = ((i0 >> 52) & 0x7ff) - 0x3ff;
+  if (__glibc_likely (j0 < 52))
     {
       if (j0 < 0)
 	{
 	  libc_feholdexcept (&env);
-	  w = TWO52[sx] + math_opt_barrier (x);
-	  t = w - TWO52[sx];
+	  double w = TWO52[sx] + math_opt_barrier (x);
+	  double t =  w - TWO52[sx];
 	  math_force_eval (t);
 	  libc_fesetenv (&env);
-	  GET_HIGH_WORD (i0, t);
-	  SET_HIGH_WORD (t, (i0 & 0x7fffffff) | (sx << 31));
-	  return t;
+	  return copysign (t, x);
 	}
     }
   else
     {
       if (j0 == 0x400)
-	return x + x;                   /* inf or NaN */
+	return x + x;			/* inf or NaN  */
       else
-	return x;                       /* x is integral */
+	return x;			/* x is integral  */
     }
   libc_feholdexcept (&env);
-  w = TWO52[sx] + math_opt_barrier (x);
-  t = w - TWO52[sx];
+  double w = TWO52[sx] + math_opt_barrier (x);
+  double t = w - TWO52[sx];
   math_force_eval (t);
   libc_fesetenv (&env);
   return t;
diff --git a/sysdeps/ieee754/dbl-64/wordsize-64/s_nearbyint.c b/sysdeps/ieee754/dbl-64/wordsize-64/s_nearbyint.c
deleted file mode 100644
index 92fa72af59..0000000000
--- a/sysdeps/ieee754/dbl-64/wordsize-64/s_nearbyint.c
+++ /dev/null
@@ -1,65 +0,0 @@
-/* Adapted for use as nearbyint by Ulrich Drepper <drepper@cygnus.com>.  */
-/*
- * ====================================================
- * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
- *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
- * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
- * is preserved.
- * ====================================================
- */
-
-/*
- * rint(x)
- * Return x rounded to integral value according to the prevailing
- * rounding mode.
- * Method:
- *	Using floating addition.
- * Exception:
- *	Inexact flag raised if x not equal to rint(x).
- */
-
-#include <fenv.h>
-#include <math.h>
-#include <math-barriers.h>
-#include <math_private.h>
-#include <fenv_private.h>
-#include <libm-alias-double.h>
-
-static const double
-TWO52[2]={
-  4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
- -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
-};
-
-double
-__nearbyint(double x)
-{
-	fenv_t env;
-	int64_t i0,sx;
-	int32_t j0;
-	EXTRACT_WORDS64(i0,x);
-	sx = (i0>>63)&1;
-	j0 = ((i0>>52)&0x7ff)-0x3ff;
-	if(__builtin_expect(j0<52, 1)) {
-	    if(j0<0) {
-		libc_feholdexcept (&env);
-		double w = TWO52[sx] + math_opt_barrier (x);
-		double t =  w-TWO52[sx];
-		math_force_eval (t);
-		libc_fesetenv (&env);
-		return copysign (t, x);
-	    }
-	} else {
-	    if(j0==0x400) return x+x;	/* inf or NaN */
-	    else return x;		/* x is integral */
-	}
-	libc_feholdexcept (&env);
-	double w = TWO52[sx] + math_opt_barrier (x);
-	double t = w-TWO52[sx];
-	math_force_eval (t);
-	libc_fesetenv (&env);
-	return t;
-}
-libm_alias_double (__nearbyint, nearbyint)
diff --git a/sysdeps/x86_64/fpu/multiarch/s_nearbyint-c.c b/sysdeps/x86_64/fpu/multiarch/s_nearbyint-c.c
index f897a2a6a6..4fdeb11291 100644
--- a/sysdeps/x86_64/fpu/multiarch/s_nearbyint-c.c
+++ b/sysdeps/x86_64/fpu/multiarch/s_nearbyint-c.c
@@ -1,3 +1,3 @@
 #undef __nearbyint
 #define __nearbyint __nearbyint_c
-#include <sysdeps/ieee754/dbl-64/wordsize-64/s_nearbyint.c>
+#include <sysdeps/ieee754/dbl-64/s_nearbyint.c>
-- 
2.19.1

[PATCH v2 02/18] Always use wordsize-64 version of s_rint.c.

[Stefan Liebler]

This patch replaces s_rint.c in sysdeps/dbl-64 with the one in
sysdeps/dbl-64/wordsize-64 and removes the latter one.
The code is not changed except changes in code style.

Also adjusted the include path in x86_64 file.
---
 sysdeps/ieee754/dbl-64/s_rint.c             | 32 ++++++------
 sysdeps/ieee754/dbl-64/wordsize-64/s_rint.c | 58 ---------------------
 sysdeps/x86_64/fpu/multiarch/s_rint-c.c     |  2 +-
 3 files changed, 17 insertions(+), 75 deletions(-)
 delete mode 100644 sysdeps/ieee754/dbl-64/wordsize-64/s_rint.c

diff --git a/sysdeps/ieee754/dbl-64/s_rint.c b/sysdeps/ieee754/dbl-64/s_rint.c
index dd01a84176..66c9196473 100644
--- a/sysdeps/ieee754/dbl-64/s_rint.c
+++ b/sysdeps/ieee754/dbl-64/s_rint.c
@@ -1,4 +1,3 @@
-/* @(#)s_rint.c 5.1 93/09/24 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
@@ -26,38 +25,39 @@
 #include <libm-alias-double.h>
 
 static const double
-  TWO52[2] = {
-  4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
- -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
+TWO52[2] = {
+	    4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
+	    -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
 };
 
 double
 __rint (double x)
 {
-  int32_t i0, j0, sx;
-  double w, t;
-  GET_HIGH_WORD (i0, x);
-  sx = (i0 >> 31) & 1;
-  j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
+  int64_t i0, sx;
+  int32_t j0;
+  EXTRACT_WORDS64 (i0, x);
+  sx = (i0 >> 63) & 1;
+  j0 = ((i0 >> 52) & 0x7ff) - 0x3ff;
   if (j0 < 52)
     {
       if (j0 < 0)
 	{
-	  w = TWO52[sx] + x;
-	  t = w - TWO52[sx];
-	  GET_HIGH_WORD (i0, t);
-	  SET_HIGH_WORD (t, (i0 & 0x7fffffff) | (sx << 31));
+	  double w = TWO52[sx] + x;
+	  double t =  w - TWO52[sx];
+	  EXTRACT_WORDS64 (i0, t);
+	  INSERT_WORDS64 (t, (i0 & UINT64_C (0x7fffffffffffffff))
+			  | (sx << 63));
 	  return t;
 	}
     }
   else
     {
       if (j0 == 0x400)
-	return x + x;                   /* inf or NaN */
+	return x + x;			/* inf or NaN  */
       else
-	return x;                       /* x is integral */
+	return x;			/* x is integral  */
     }
-  w = TWO52[sx] + x;
+  double w = TWO52[sx] + x;
   return w - TWO52[sx];
 }
 #ifndef __rint
diff --git a/sysdeps/ieee754/dbl-64/wordsize-64/s_rint.c b/sysdeps/ieee754/dbl-64/wordsize-64/s_rint.c
deleted file mode 100644
index 378b73a544..0000000000
--- a/sysdeps/ieee754/dbl-64/wordsize-64/s_rint.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * ====================================================
- * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
- *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
- * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
- * is preserved.
- * ====================================================
- */
-
-/*
- * rint(x)
- * Return x rounded to integral value according to the prevailing
- * rounding mode.
- * Method:
- *	Using floating addition.
- * Exception:
- *	Inexact flag raised if x not equal to rint(x).
- */
-
-#define NO_MATH_REDIRECT
-#include <math.h>
-#include <math_private.h>
-#include <libm-alias-double.h>
-
-static const double
-TWO52[2]={
-  4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
- -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
-};
-
-double
-__rint(double x)
-{
-	int64_t i0,sx;
-	int32_t j0;
-	EXTRACT_WORDS64(i0,x);
-	sx = (i0>>63)&1;
-	j0 = ((i0>>52)&0x7ff)-0x3ff;
-	if(j0<52) {
-	    if(j0<0) {
-		double w = TWO52[sx]+x;
-		double t =  w-TWO52[sx];
-		EXTRACT_WORDS64(i0,t);
-		INSERT_WORDS64(t,(i0&UINT64_C(0x7fffffffffffffff))|(sx<<63));
-		return t;
-	    }
-	} else {
-	    if(j0==0x400) return x+x;	/* inf or NaN */
-	    else return x;		/* x is integral */
-	}
-	double w = TWO52[sx]+x;
-	return w-TWO52[sx];
-}
-#ifndef __rint
-libm_alias_double (__rint, rint)
-#endif
diff --git a/sysdeps/x86_64/fpu/multiarch/s_rint-c.c b/sysdeps/x86_64/fpu/multiarch/s_rint-c.c
index 162a630ff9..b010150f52 100644
--- a/sysdeps/x86_64/fpu/multiarch/s_rint-c.c
+++ b/sysdeps/x86_64/fpu/multiarch/s_rint-c.c
@@ -1,3 +1,3 @@
 #undef __rint
 #define __rint __rint_c
-#include <sysdeps/ieee754/dbl-64/wordsize-64/s_rint.c>
+#include <sysdeps/ieee754/dbl-64/s_rint.c>
-- 
2.19.1

[PATCH v2 04/18] Always use wordsize-64 version of s_ceil.c.

[Stefan Liebler]

This patch replaces s_ceil.c in sysdeps/dbl-64 with the one in
sysdeps/dbl-64/wordsize-64 and removes the latter one.
The code is not changed except changes in code style.

Also adjusted the include path in x86_64 and sparc64 files.
---
 sysdeps/ieee754/dbl-64/s_ceil.c               | 59 ++++++-------------
 sysdeps/ieee754/dbl-64/wordsize-64/s_ceil.c   | 52 ----------------
 .../sparc64/fpu/multiarch/s_ceil-generic.c    |  2 +-
 .../sparc/sparc64/fpu/multiarch/s_ceil-vis3.c |  2 +-
 sysdeps/x86_64/fpu/multiarch/s_ceil-c.c       |  2 +-
 5 files changed, 21 insertions(+), 96 deletions(-)
 delete mode 100644 sysdeps/ieee754/dbl-64/wordsize-64/s_ceil.c

diff --git a/sysdeps/ieee754/dbl-64/s_ceil.c b/sysdeps/ieee754/dbl-64/s_ceil.c
index 4c96286c69..8d66f027e7 100644
--- a/sysdeps/ieee754/dbl-64/s_ceil.c
+++ b/sysdeps/ieee754/dbl-64/s_ceil.c
@@ -25,61 +25,38 @@
 double
 __ceil (double x)
 {
-  int32_t i0, i1, j0;
-  uint32_t i, j;
-  EXTRACT_WORDS (i0, i1, x);
-  j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
-  if (j0 < 20)
+  int64_t i0, i;
+  int32_t j0;
+  EXTRACT_WORDS64 (i0, x);
+  j0 = ((i0 >> 52) & 0x7ff) - 0x3ff;
+  if (j0 <= 51)
     {
       if (j0 < 0)
 	{
-	  /* return 0*sign(x) if |x|<1 */
+	  /* return 0 * sign(x) if |x| < 1  */
 	  if (i0 < 0)
-	    {
-	      i0 = 0x80000000; i1 = 0;
-	    }
-	  else if ((i0 | i1) != 0)
-	    {
-	      i0 = 0x3ff00000; i1 = 0;
-	    }
+	    i0 = INT64_C (0x8000000000000000);
+	  else if (i0 != 0)
+	    i0 = INT64_C (0x3ff0000000000000);
 	}
       else
 	{
-	  i = (0x000fffff) >> j0;
-	  if (((i0 & i) | i1) == 0)
-	    return x;                        /* x is integral */
+	  i = INT64_C (0x000fffffffffffff) >> j0;
+	  if ((i0 & i) == 0)
+	    return x;			/* x is integral  */
 	  if (i0 > 0)
-	    i0 += (0x00100000) >> j0;
-	  i0 &= (~i); i1 = 0;
+	    i0 += UINT64_C (0x0010000000000000) >> j0;
+	  i0 &= ~i;
 	}
     }
-  else if (j0 > 51)
+  else
     {
       if (j0 == 0x400)
-	return x + x;                   /* inf or NaN */
+	return x + x;			/* inf or NaN  */
       else
-	return x;                       /* x is integral */
-    }
-  else
-    {
-      i = ((uint32_t) (0xffffffff)) >> (j0 - 20);
-      if ((i1 & i) == 0)
-	return x;                       /* x is integral */
-      if (i0 > 0)
-	{
-	  if (j0 == 20)
-	    i0 += 1;
-	  else
-	    {
-	      j = i1 + (1 << (52 - j0));
-	      if (j < i1)
-		i0 += 1;                /* got a carry */
-	      i1 = j;
-	    }
-	}
-      i1 &= (~i);
+	return x;			/* x is integral  */
     }
-  INSERT_WORDS (x, i0, i1);
+  INSERT_WORDS64 (x, i0);
   return x;
 }
 #ifndef __ceil
diff --git a/sysdeps/ieee754/dbl-64/wordsize-64/s_ceil.c b/sysdeps/ieee754/dbl-64/wordsize-64/s_ceil.c
deleted file mode 100644
index 4bb93d0633..0000000000
--- a/sysdeps/ieee754/dbl-64/wordsize-64/s_ceil.c
+++ /dev/null
@@ -1,52 +0,0 @@
-/* @(#)s_ceil.c 5.1 93/09/24 */
-/*
- * ====================================================
- * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
- *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
- * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
- * is preserved.
- * ====================================================
- */
-
-/*
- * ceil(x)
- * Return x rounded toward -inf to integral value
- * Method:
- *	Bit twiddling.
- */
-
-#define NO_MATH_REDIRECT
-#include <math.h>
-#include <math_private.h>
-#include <libm-alias-double.h>
-
-double
-__ceil(double x)
-{
-	int64_t i0,i;
-	int32_t j0;
-	EXTRACT_WORDS64(i0,x);
-	j0 = ((i0>>52)&0x7ff)-0x3ff;
-	if(j0<=51) {
-	    if(j0<0) {
-	      /* return 0*sign(x) if |x|<1 */
-	      if(i0<0) {i0=INT64_C(0x8000000000000000);}
-	      else if(i0!=0) { i0=INT64_C(0x3ff0000000000000);}
-	    } else {
-		i = INT64_C(0x000fffffffffffff)>>j0;
-		if((i0&i)==0) return x; /* x is integral */
-		if(i0>0) i0 += UINT64_C(0x0010000000000000)>>j0;
-		i0 &= (~i);
-	    }
-	} else {
-	    if(j0==0x400) return x+x;	/* inf or NaN */
-	    else return x;		/* x is integral */
-	}
-	INSERT_WORDS64(x,i0);
-	return x;
-}
-#ifndef __ceil
-libm_alias_double (__ceil, ceil)
-#endif
diff --git a/sysdeps/sparc/sparc64/fpu/multiarch/s_ceil-generic.c b/sysdeps/sparc/sparc64/fpu/multiarch/s_ceil-generic.c
index febea745e1..80f68b6766 100644
--- a/sysdeps/sparc/sparc64/fpu/multiarch/s_ceil-generic.c
+++ b/sysdeps/sparc/sparc64/fpu/multiarch/s_ceil-generic.c
@@ -1,2 +1,2 @@
 #define __ceil __ceil_generic
-#include <sysdeps/ieee754/dbl-64/wordsize-64/s_ceil.c>
+#include <sysdeps/ieee754/dbl-64/s_ceil.c>
diff --git a/sysdeps/sparc/sparc64/fpu/multiarch/s_ceil-vis3.c b/sysdeps/sparc/sparc64/fpu/multiarch/s_ceil-vis3.c
index 9c17809da4..2b89199c62 100644
--- a/sysdeps/sparc/sparc64/fpu/multiarch/s_ceil-vis3.c
+++ b/sysdeps/sparc/sparc64/fpu/multiarch/s_ceil-vis3.c
@@ -20,4 +20,4 @@
 
 #define __ceil __ceil_vis3
 
-#include <sysdeps/ieee754/dbl-64/wordsize-64/s_ceil.c>
+#include <sysdeps/ieee754/dbl-64/s_ceil.c>
diff --git a/sysdeps/x86_64/fpu/multiarch/s_ceil-c.c b/sysdeps/x86_64/fpu/multiarch/s_ceil-c.c
index 6a5ea3ff27..ada28baa1a 100644
--- a/sysdeps/x86_64/fpu/multiarch/s_ceil-c.c
+++ b/sysdeps/x86_64/fpu/multiarch/s_ceil-c.c
@@ -1,2 +1,2 @@
 #define __ceil __ceil_c
-#include <sysdeps/ieee754/dbl-64/wordsize-64/s_ceil.c>
+#include <sysdeps/ieee754/dbl-64/s_ceil.c>
-- 
2.19.1

[PATCH v2 03/18] Always use wordsize-64 version of s_floor.c.

[Stefan Liebler]

This patch replaces s_floor.c in sysdeps/dbl-64 with the one in
sysdeps/dbl-64/wordsize-64 and removes the latter one.
The code is not changed except changes in code style.

Also adjusted the include path in x86_64 and sparc64 files.
---
 sysdeps/ieee754/dbl-64/s_floor.c              | 93 +++++++++----------
 sysdeps/ieee754/dbl-64/wordsize-64/s_floor.c  | 72 --------------
 .../sparc64/fpu/multiarch/s_floor-generic.c   |  2 +-
 .../sparc64/fpu/multiarch/s_floor-vis3.c      |  2 +-
 sysdeps/x86_64/fpu/multiarch/s_floor-c.c      |  2 +-
 5 files changed, 46 insertions(+), 125 deletions(-)
 delete mode 100644 sysdeps/ieee754/dbl-64/wordsize-64/s_floor.c

diff --git a/sysdeps/ieee754/dbl-64/s_floor.c b/sysdeps/ieee754/dbl-64/s_floor.c
index bebc018658..ce0c42bdb6 100644
--- a/sysdeps/ieee754/dbl-64/s_floor.c
+++ b/sysdeps/ieee754/dbl-64/s_floor.c
@@ -1,4 +1,24 @@
-/* @(#)s_floor.c 5.1 93/09/24 */
+/* Round double to integer away from zero.
+   Copyright (C) 2011-2019 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 2011.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+/* Based on a version which carries the following copyright:  */
+
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
@@ -10,6 +30,12 @@
  * ====================================================
  */
 
+#define NO_MATH_REDIRECT
+#include <math.h>
+#include <math_private.h>
+#include <stdint.h>
+#include <libm-alias-double.h>
+
 /*
  * floor(x)
  * Return x rounded toward -inf to integral value
@@ -17,69 +43,36 @@
  *	Bit twiddling.
  */
 
-#define NO_MATH_REDIRECT
-#include <math.h>
-#include <math_private.h>
-#include <libm-alias-double.h>
 
 double
 __floor (double x)
 {
-  int32_t i0, i1, j0;
-  uint32_t i, j;
-  EXTRACT_WORDS (i0, i1, x);
-  j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
-  if (j0 < 20)
+  int64_t i0;
+  EXTRACT_WORDS64 (i0, x);
+  int32_t j0 = ((i0 >> 52) & 0x7ff) - 0x3ff;
+  if (__glibc_likely (j0 < 52))
     {
       if (j0 < 0)
 	{
-	  /* return 0*sign(x) if |x|<1 */
+	  /* return 0 * sign (x) if |x| < 1  */
 	  if (i0 >= 0)
-	    {
-	      i0 = i1 = 0;
-	    }
-	  else if (((i0 & 0x7fffffff) | i1) != 0)
-	    {
-	      i0 = 0xbff00000; i1 = 0;
-	    }
+	    i0 = 0;
+	  else if ((i0 & 0x7fffffffffffffffl) != 0)
+	    i0 = 0xbff0000000000000l;
 	}
       else
 	{
-	  i = (0x000fffff) >> j0;
-	  if (((i0 & i) | i1) == 0)
-	    return x;                        /* x is integral */
+	  uint64_t i = 0x000fffffffffffffl >> j0;
+	  if ((i0 & i) == 0)
+	    return x;			 /* x is integral */
 	  if (i0 < 0)
-	    i0 += (0x00100000) >> j0;
-	  i0 &= (~i); i1 = 0;
-	}
-    }
-  else if (j0 > 51)
-    {
-      if (j0 == 0x400)
-	return x + x;                   /* inf or NaN */
-      else
-	return x;                       /* x is integral */
-    }
-  else
-    {
-      i = ((uint32_t) (0xffffffff)) >> (j0 - 20);
-      if ((i1 & i) == 0)
-	return x;                       /* x is integral */
-      if (i0 < 0)
-	{
-	  if (j0 == 20)
-	    i0 += 1;
-	  else
-	    {
-	      j = i1 + (1 << (52 - j0));
-	      if (j < i1)
-		i0 += 1;                /* got a carry */
-	      i1 = j;
-	    }
+	    i0 += 0x0010000000000000l >> j0;
+	  i0 &= ~i;
 	}
-      i1 &= (~i);
+      INSERT_WORDS64 (x, i0);
     }
-  INSERT_WORDS (x, i0, i1);
+  else if (j0 == 0x400)
+    return x + x;			/* inf or NaN */
   return x;
 }
 #ifndef __floor
diff --git a/sysdeps/ieee754/dbl-64/wordsize-64/s_floor.c b/sysdeps/ieee754/dbl-64/wordsize-64/s_floor.c
deleted file mode 100644
index b60f15bf00..0000000000
--- a/sysdeps/ieee754/dbl-64/wordsize-64/s_floor.c
+++ /dev/null
@@ -1,72 +0,0 @@
-/* Round double to integer away from zero.
-   Copyright (C) 2011-2019 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Contributed by Ulrich Drepper <drepper@cygnus.com>, 2011.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   The GNU C Library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library; if not, see
-   <https://www.gnu.org/licenses/>.  */
-
-/* Based on a version which carries the following copyright:  */
-
-/*
- * ====================================================
- * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
- *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
- * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
- * is preserved.
- * ====================================================
- */
-
-#define NO_MATH_REDIRECT
-#include <math.h>
-#include <math_private.h>
-#include <stdint.h>
-#include <libm-alias-double.h>
-
-/*
- * floor(x)
- * Return x rounded toward -inf to integral value
- * Method:
- *	Bit twiddling.
- */
-
-
-double
-__floor (double x)
-{
-	int64_t i0;
-	EXTRACT_WORDS64(i0,x);
-	int32_t j0 = ((i0>>52)&0x7ff)-0x3ff;
-	if(__builtin_expect(j0<52, 1)) {
-	    if(j0<0) {
-		/* return 0*sign(x) if |x|<1 */
-		if(i0>=0) {i0=0;}
-		else if((i0&0x7fffffffffffffffl)!=0)
-		  { i0=0xbff0000000000000l;}
-	    } else {
-		uint64_t i = (0x000fffffffffffffl)>>j0;
-		if((i0&i)==0) return x; /* x is integral */
-		if(i0<0) i0 += (0x0010000000000000l)>>j0;
-		i0 &= (~i);
-	    }
-	    INSERT_WORDS64(x,i0);
-	} else if (j0==0x400)
-	    return x+x;	/* inf or NaN */
-	return x;
-}
-#ifndef __floor
-libm_alias_double (__floor, floor)
-#endif
diff --git a/sysdeps/sparc/sparc64/fpu/multiarch/s_floor-generic.c b/sysdeps/sparc/sparc64/fpu/multiarch/s_floor-generic.c
index 0f3361a9fb..c92b600df1 100644
--- a/sysdeps/sparc/sparc64/fpu/multiarch/s_floor-generic.c
+++ b/sysdeps/sparc/sparc64/fpu/multiarch/s_floor-generic.c
@@ -1,2 +1,2 @@
 #define __floor __floor_generic
-#include <sysdeps/ieee754/dbl-64/wordsize-64/s_floor.c>
+#include <sysdeps/ieee754/dbl-64/s_floor.c>
diff --git a/sysdeps/sparc/sparc64/fpu/multiarch/s_floor-vis3.c b/sysdeps/sparc/sparc64/fpu/multiarch/s_floor-vis3.c
index ccac0e46af..4f3d53c0e3 100644
--- a/sysdeps/sparc/sparc64/fpu/multiarch/s_floor-vis3.c
+++ b/sysdeps/sparc/sparc64/fpu/multiarch/s_floor-vis3.c
@@ -20,4 +20,4 @@
 
 #define __floor __floor_vis3
 
-#include <sysdeps/ieee754/dbl-64/wordsize-64/s_floor.c>
+#include <sysdeps/ieee754/dbl-64/s_floor.c>
diff --git a/sysdeps/x86_64/fpu/multiarch/s_floor-c.c b/sysdeps/x86_64/fpu/multiarch/s_floor-c.c
index 68733b69ef..002d12247e 100644
--- a/sysdeps/x86_64/fpu/multiarch/s_floor-c.c
+++ b/sysdeps/x86_64/fpu/multiarch/s_floor-c.c
@@ -1,3 +1,3 @@
 #undef __floor
 #define __floor __floor_c
-#include <sysdeps/ieee754/dbl-64/wordsize-64/s_floor.c>
+#include <sysdeps/ieee754/dbl-64/s_floor.c>
-- 
2.19.1

[PATCH v2 05/18] Always use wordsize-64 version of s_trunc.c.

[Stefan Liebler]

This patch replaces s_trunc.c in sysdeps/dbl-64 with the one in
sysdeps/dbl-64/wordsize-64 and removes the latter one.
The code is not changed except changes in code style.

Also adjusted the include path in x86_64 and sparc64 files.
---
 sysdeps/ieee754/dbl-64/s_trunc.c              | 25 ++++-----
 sysdeps/ieee754/dbl-64/wordsize-64/s_trunc.c  | 55 -------------------
 .../sparc64/fpu/multiarch/s_trunc-generic.c   |  2 +-
 .../sparc64/fpu/multiarch/s_trunc-vis3.c      |  2 +-
 sysdeps/x86_64/fpu/multiarch/s_trunc-c.c      |  2 +-
 5 files changed, 13 insertions(+), 73 deletions(-)
 delete mode 100644 sysdeps/ieee754/dbl-64/wordsize-64/s_trunc.c

diff --git a/sysdeps/ieee754/dbl-64/s_trunc.c b/sysdeps/ieee754/dbl-64/s_trunc.c
index 154feb9aa3..0de68ce298 100644
--- a/sysdeps/ieee754/dbl-64/s_trunc.c
+++ b/sysdeps/ieee754/dbl-64/s_trunc.c
@@ -27,31 +27,26 @@
 double
 __trunc (double x)
 {
-  int32_t i0, j0;
-  uint32_t i1;
-  int sx;
-
-  EXTRACT_WORDS (i0, i1, x);
-  sx = i0 & 0x80000000;
-  j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
-  if (j0 < 20)
+  int64_t i0, j0;
+  int64_t sx;
+
+  EXTRACT_WORDS64 (i0, x);
+  sx = i0 & UINT64_C (0x8000000000000000);
+  j0 = ((i0 >> 52) & 0x7ff) - 0x3ff;
+  if (j0 < 52)
     {
       if (j0 < 0)
 	/* The magnitude of the number is < 1 so the result is +-0.  */
-	INSERT_WORDS (x, sx, 0);
+	INSERT_WORDS64 (x, sx);
       else
-	INSERT_WORDS (x, sx | (i0 & ~(0x000fffff >> j0)), 0);
+	INSERT_WORDS64 (x, sx | (i0 & ~(UINT64_C (0x000fffffffffffff) >> j0)));
     }
-  else if (j0 > 51)
+  else
     {
       if (j0 == 0x400)
 	/* x is inf or NaN.  */
 	return x + x;
     }
-  else
-    {
-      INSERT_WORDS (x, i0, i1 & ~(0xffffffffu >> (j0 - 20)));
-    }
 
   return x;
 }
diff --git a/sysdeps/ieee754/dbl-64/wordsize-64/s_trunc.c b/sysdeps/ieee754/dbl-64/wordsize-64/s_trunc.c
deleted file mode 100644
index 3f040bbf83..0000000000
--- a/sysdeps/ieee754/dbl-64/wordsize-64/s_trunc.c
+++ /dev/null
@@ -1,55 +0,0 @@
-/* Truncate argument to nearest integral value not larger than the argument.
-   Copyright (C) 1997-2019 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   The GNU C Library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library; if not, see
-   <https://www.gnu.org/licenses/>.  */
-
-#define NO_MATH_REDIRECT
-#include <math.h>
-
-#include <math_private.h>
-#include <libm-alias-double.h>
-
-
-double
-__trunc (double x)
-{
-  int64_t i0, j0;
-  int64_t sx;
-
-  EXTRACT_WORDS64 (i0, x);
-  sx = i0 & UINT64_C(0x8000000000000000);
-  j0 = ((i0 >> 52) & 0x7ff) - 0x3ff;
-  if (j0 < 52)
-    {
-      if (j0 < 0)
-	/* The magnitude of the number is < 1 so the result is +-0.  */
-	INSERT_WORDS64 (x, sx);
-      else
-	INSERT_WORDS64 (x, sx | (i0 & ~(UINT64_C(0x000fffffffffffff) >> j0)));
-    }
-  else
-    {
-      if (j0 == 0x400)
-	/* x is inf or NaN.  */
-	return x + x;
-    }
-
-  return x;
-}
-#ifndef __trunc
-libm_alias_double (__trunc, trunc)
-#endif
diff --git a/sysdeps/sparc/sparc64/fpu/multiarch/s_trunc-generic.c b/sysdeps/sparc/sparc64/fpu/multiarch/s_trunc-generic.c
index 00abd2a643..c198ebb3d5 100644
--- a/sysdeps/sparc/sparc64/fpu/multiarch/s_trunc-generic.c
+++ b/sysdeps/sparc/sparc64/fpu/multiarch/s_trunc-generic.c
@@ -1,2 +1,2 @@
 #define __trunc __trunc_generic
-#include <sysdeps/ieee754/dbl-64/wordsize-64/s_trunc.c>
+#include <sysdeps/ieee754/dbl-64/s_trunc.c>
diff --git a/sysdeps/sparc/sparc64/fpu/multiarch/s_trunc-vis3.c b/sysdeps/sparc/sparc64/fpu/multiarch/s_trunc-vis3.c
index 45646c5d66..321a9eded6 100644
--- a/sysdeps/sparc/sparc64/fpu/multiarch/s_trunc-vis3.c
+++ b/sysdeps/sparc/sparc64/fpu/multiarch/s_trunc-vis3.c
@@ -20,4 +20,4 @@
 
 #define __trunc __trunc_vis3
 
-#include <sysdeps/ieee754/dbl-64/wordsize-64/s_trunc.c>
+#include <sysdeps/ieee754/dbl-64/s_trunc.c>
diff --git a/sysdeps/x86_64/fpu/multiarch/s_trunc-c.c b/sysdeps/x86_64/fpu/multiarch/s_trunc-c.c
index 6204ae3c77..8aa499fbb8 100644
--- a/sysdeps/x86_64/fpu/multiarch/s_trunc-c.c
+++ b/sysdeps/x86_64/fpu/multiarch/s_trunc-c.c
@@ -1,2 +1,2 @@
 #define __trunc __trunc_c
-#include <sysdeps/ieee754/dbl-64/wordsize-64/s_trunc.c>
+#include <sysdeps/ieee754/dbl-64/s_trunc.c>
-- 
2.19.1

[PATCH v2 07/18] Use GCC builtins for nearbyint functions if desired.

[Stefan Liebler]

This patch is using the corresponding GCC builtin for nearbyintf, nearbyint,
nearbintl and nearbyintf128 if the USE_FUNCTION_BUILTIN macros are defined to one
in math-use-builtins.h.

This is the case for s390 if build with at least --march=z196 --mzarch.
Otherwise the generic implementation is used.  The code of the generic
implementation is not changed.
---
 sysdeps/generic/math-use-builtins.h         | 29 ++++++++++++
 sysdeps/ieee754/dbl-64/s_nearbyint.c        | 17 ++++---
 sysdeps/ieee754/float128/float128_private.h |  4 ++
 sysdeps/ieee754/flt-32/s_nearbyintf.c       | 17 ++++---
 sysdeps/ieee754/ldbl-128/s_nearbyintl.c     | 17 ++++---
 sysdeps/s390/fpu/math-use-builtins.h        | 49 +++++++++++++++++++++
 6 files changed, 115 insertions(+), 18 deletions(-)
 create mode 100644 sysdeps/generic/math-use-builtins.h
 create mode 100644 sysdeps/s390/fpu/math-use-builtins.h

diff --git a/sysdeps/generic/math-use-builtins.h b/sysdeps/generic/math-use-builtins.h
new file mode 100644
index 0000000000..e12490ed41
--- /dev/null
+++ b/sysdeps/generic/math-use-builtins.h
@@ -0,0 +1,29 @@
+/* Using math gcc builtins instead of generic implementation.  Generic version.
+   Copyright (C) 2019 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef MATH_USE_BUILTINS_H
+#define MATH_USE_BUILTINS_H	1
+
+/* Define these macros to 1 to use __builtin_xyz instead of the
+   generic implementation.  */
+#define USE_NEARBYINT_BUILTIN 0
+#define USE_NEARBYINTF_BUILTIN 0
+#define USE_NEARBYINTL_BUILTIN 0
+#define USE_NEARBYINTF128_BUILTIN 0
+
+#endif /* math-use-builtins.h */
diff --git a/sysdeps/ieee754/dbl-64/s_nearbyint.c b/sysdeps/ieee754/dbl-64/s_nearbyint.c
index c261885c5a..2deaeb2568 100644
--- a/sysdeps/ieee754/dbl-64/s_nearbyint.c
+++ b/sysdeps/ieee754/dbl-64/s_nearbyint.c
@@ -26,16 +26,20 @@
 #include <math_private.h>
 #include <fenv_private.h>
 #include <libm-alias-double.h>
-
-static const double
-TWO52[2] = {
-	    4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
-	    -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
-};
+#include <math-use-builtins.h>
 
 double
 __nearbyint (double x)
 {
+#if USE_NEARBYINT_BUILTIN
+  return __builtin_nearbyint (x);
+#else
+  /* Use generic implementation.  */
+  static const double
+    TWO52[2] = {
+		4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
+		-4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
+  };
   fenv_t env;
   int64_t i0, sx;
   int32_t j0;
@@ -67,5 +71,6 @@ __nearbyint (double x)
   math_force_eval (t);
   libc_fesetenv (&env);
   return t;
+#endif /* ! USE_NEARBYINT_BUILTIN  */
 }
 libm_alias_double (__nearbyint, nearbyint)
diff --git a/sysdeps/ieee754/float128/float128_private.h b/sysdeps/ieee754/float128/float128_private.h
index 4e31ef365b..e96986a968 100644
--- a/sysdeps/ieee754/float128/float128_private.h
+++ b/sysdeps/ieee754/float128/float128_private.h
@@ -139,6 +139,9 @@
 #undef libm_alias_double_ldouble
 #define libm_alias_double_ldouble(func) libm_alias_float64_float128 (func)
 
+#include <math-use-builtins.h>
+#undef USE_NEARBYINTL_BUILTIN
+#define USE_NEARBYINTL_BUILTIN USE_NEARBYINTF128_BUILTIN
 
 /* IEEE function renames.  */
 #define __ieee754_acoshl __ieee754_acoshf128
@@ -342,6 +345,7 @@
 /* Builtin renames.  */
 #define __builtin_copysignl __builtin_copysignf128
 #define __builtin_signbitl __builtin_signbit
+#define __builtin_nearbyintl __builtin_nearbyintf128
 
 /* Get the constant suffix from bits/floatn-compat.h.  */
 #define L(x) __f128 (x)
diff --git a/sysdeps/ieee754/flt-32/s_nearbyintf.c b/sysdeps/ieee754/flt-32/s_nearbyintf.c
index acedf34c90..b37e003e12 100644
--- a/sysdeps/ieee754/flt-32/s_nearbyintf.c
+++ b/sysdeps/ieee754/flt-32/s_nearbyintf.c
@@ -21,16 +21,20 @@
 #include <math_private.h>
 #include <fenv_private.h>
 #include <libm-alias-float.h>
-
-static const float
-TWO23[2]={
-  8.3886080000e+06, /* 0x4b000000 */
- -8.3886080000e+06, /* 0xcb000000 */
-};
+#include <math-use-builtins.h>
 
 float
 __nearbyintf(float x)
 {
+#if USE_NEARBYINTF_BUILTIN
+  return __builtin_nearbyintf (x);
+#else
+  /* Use generic implementation.  */
+  static const float
+    TWO23[2] = {
+		8.3886080000e+06, /* 0x4b000000 */
+		-8.3886080000e+06, /* 0xcb000000 */
+  };
 	fenv_t env;
 	int32_t i0,j0,sx;
 	float w,t;
@@ -58,5 +62,6 @@ __nearbyintf(float x)
 	math_force_eval (t);
 	libc_fesetenvf (&env);
 	return t;
+#endif /* ! USE_NEARBYINT_BUILTIN  */
 }
 libm_alias_float (__nearbyint, nearbyint)
diff --git a/sysdeps/ieee754/ldbl-128/s_nearbyintl.c b/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
index f044cb4334..a4ad8e82e5 100644
--- a/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
+++ b/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
@@ -28,15 +28,19 @@
 #include <math-barriers.h>
 #include <math_private.h>
 #include <libm-alias-ldouble.h>
-
-static const _Float128
-TWO112[2]={
-  L(5.19229685853482762853049632922009600E+33), /* 0x406F000000000000, 0 */
- L(-5.19229685853482762853049632922009600E+33)  /* 0xC06F000000000000, 0 */
-};
+#include <math-use-builtins.h>
 
 _Float128 __nearbyintl(_Float128 x)
 {
+#if USE_NEARBYINTL_BUILTIN
+  return __builtin_nearbyintl (x);
+#else
+  /* Use generic implementation.  */
+  static const _Float128
+    TWO112[2] = {
+		 L(5.19229685853482762853049632922009600E+33), /* 0x406F000000000000, 0 */
+		 L(-5.19229685853482762853049632922009600E+33)  /* 0xC06F000000000000, 0 */
+  };
 	fenv_t env;
 	int64_t i0,j0,sx;
 	uint64_t i1 __attribute__ ((unused));
@@ -65,5 +69,6 @@ _Float128 __nearbyintl(_Float128 x)
 	math_force_eval (t);
 	fesetenv (&env);
 	return t;
+#endif /* ! USE_NEARBYINTL_BUILTIN  */
 }
 libm_alias_ldouble (__nearbyint, nearbyint)
diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
new file mode 100644
index 0000000000..7abbfb3b50
--- /dev/null
+++ b/sysdeps/s390/fpu/math-use-builtins.h
@@ -0,0 +1,49 @@
+/* Using math gcc builtins instead of generic implementation.  s390/s390x version.
+   Copyright (C) 2019 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef MATH_USE_BUILTINS_S390_H
+#define MATH_USE_BUILTINS_S390_H	1
+
+#ifdef HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT
+
+# include <features.h> /* For __GNUC_PREREQ.  */
+
+/* GCC emits the z196 zarch "load fp integer" instructions for these
+   builtins if build with at least --march=z196 -mzarch.  Otherwise a
+   function call to libc is emitted.  */
+# define USE_NEARBYINT_BUILTIN 1
+# define USE_NEARBYINTF_BUILTIN 1
+# define USE_NEARBYINTL_BUILTIN 1
+
+# if __GNUC_PREREQ (8, 0)
+#  define USE_NEARBYINTF128_BUILTIN 1
+# else
+#  define USE_NEARBYINTF128_BUILTIN 0
+# endif
+
+#else
+
+/* Disable the builtins if we do not have the z196 zarch instructions.  */
+# define USE_NEARBYINT_BUILTIN 0
+# define USE_NEARBYINTF_BUILTIN 0
+# define USE_NEARBYINTL_BUILTIN 0
+# define USE_NEARBYINTF128_BUILTIN 0
+
+#endif /* ! HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT  */
+
+#endif /* math-use-builtins.h */
-- 
2.19.1

[PATCH v2 06/18] Always use wordsize-64 version of s_round.c.

[Stefan Liebler]

This patch replaces s_round.c in sysdeps/dbl-64 with the one in
sysdeps/dbl-64/wordsize-64 and removes the latter one.
---
 sysdeps/ieee754/dbl-64/s_round.c             | 39 ++++--------
 sysdeps/ieee754/dbl-64/wordsize-64/s_round.c | 66 --------------------
 2 files changed, 12 insertions(+), 93 deletions(-)
 delete mode 100644 sysdeps/ieee754/dbl-64/wordsize-64/s_round.c

diff --git a/sysdeps/ieee754/dbl-64/s_round.c b/sysdeps/ieee754/dbl-64/s_round.c
index 1793e575e9..8f4b7cff86 100644
--- a/sysdeps/ieee754/dbl-64/s_round.c
+++ b/sysdeps/ieee754/dbl-64/s_round.c
@@ -22,38 +22,36 @@
 
 #include <math_private.h>
 #include <libm-alias-double.h>
+#include <stdint.h>
 
 
 double
 __round (double x)
 {
-  int32_t i0, j0;
-  uint32_t i1;
+  int64_t i0, j0;
 
-  EXTRACT_WORDS (i0, i1, x);
-  j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
-  if (j0 < 20)
+  EXTRACT_WORDS64 (i0, x);
+  j0 = ((i0 >> 52) & 0x7ff) - 0x3ff;
+  if (__glibc_likely (j0 < 52))
     {
       if (j0 < 0)
 	{
-	  i0 &= 0x80000000;
+	  i0 &= UINT64_C (0x8000000000000000);
 	  if (j0 == -1)
-	    i0 |= 0x3ff00000;
-	  i1 = 0;
+	    i0 |= UINT64_C (0x3ff0000000000000);
 	}
       else
 	{
-	  uint32_t i = 0x000fffff >> j0;
-	  if (((i0 & i) | i1) == 0)
+	  uint64_t i = UINT64_C (0x000fffffffffffff) >> j0;
+	  if ((i0 & i) == 0)
 	    /* X is integral.  */
 	    return x;
 
-	  i0 += 0x00080000 >> j0;
+	  i0 += UINT64_C (0x0008000000000000) >> j0;
 	  i0 &= ~i;
-	  i1 = 0;
 	}
     }
-  else if (j0 > 51)
+  else
     {
       if (j0 == 0x400)
 	/* Inf or NaN.  */
@@ -61,21 +59,8 @@ __round (double x)
       else
 	return x;
     }
-  else
-    {
-      uint32_t i = 0xffffffff >> (j0 - 20);
-      if ((i1 & i) == 0)
-	/* X is integral.  */
-	return x;
-
-      uint32_t j = i1 + (1 << (51 - j0));
-      if (j < i1)
-	i0 += 1;
-      i1 = j;
-      i1 &= ~i;
-    }
 
-  INSERT_WORDS (x, i0, i1);
+  INSERT_WORDS64 (x, i0);
   return x;
 }
 libm_alias_double (__round, round)
diff --git a/sysdeps/ieee754/dbl-64/wordsize-64/s_round.c b/sysdeps/ieee754/dbl-64/wordsize-64/s_round.c
deleted file mode 100644
index 1c3fc7f50e..0000000000
--- a/sysdeps/ieee754/dbl-64/wordsize-64/s_round.c
+++ /dev/null
@@ -1,66 +0,0 @@
-/* Round double to integer away from zero.
-   Copyright (C) 1997-2019 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   The GNU C Library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library; if not, see
-   <https://www.gnu.org/licenses/>.  */
-
-#define NO_MATH_REDIRECT
-#include <math.h>
-
-#include <math_private.h>
-#include <libm-alias-double.h>
-#include <stdint.h>
-
-
-double
-__round (double x)
-{
-  int64_t i0, j0;
-
-  EXTRACT_WORDS64 (i0, x);
-  j0 = ((i0 >> 52) & 0x7ff) - 0x3ff;
-  if (__glibc_likely (j0 < 52))
-    {
-      if (j0 < 0)
-	{
-	  i0 &= UINT64_C(0x8000000000000000);
-	  if (j0 == -1)
-	    i0 |= UINT64_C(0x3ff0000000000000);
-	}
-      else
-	{
-	  uint64_t i = UINT64_C(0x000fffffffffffff) >> j0;
-	  if ((i0 & i) == 0)
-	    /* X is integral.  */
-	    return x;
-
-	  i0 += UINT64_C(0x0008000000000000) >> j0;
-	  i0 &= ~i;
-	}
-    }
-  else
-    {
-      if (j0 == 0x400)
-	/* Inf or NaN.  */
-	return x + x;
-      else
-	return x;
-    }
-
-  INSERT_WORDS64 (x, i0);
-  return x;
-}
-libm_alias_double (__round, round)
-- 
2.19.1

[PATCH v2 10/18] Use GCC builtins for ceil functions if desired.

[Stefan Liebler]

This patch is using the corresponding GCC builtin for ceilf, ceil,
ceill and ceilf128 if the USE_FUNCTION_BUILTIN macros are defined to one
in math-use-builtins.h.

This is the case for s390 if build with at least --march=z196 --mzarch.
Otherwise the generic implementation is used.  The code of the generic
implementation is not changed.
---
 sysdeps/generic/math-use-builtins.h         |  5 +++++
 sysdeps/ieee754/dbl-64/s_ceil.c             |  6 ++++++
 sysdeps/ieee754/float128/float128_private.h |  3 +++
 sysdeps/ieee754/flt-32/s_ceilf.c            |  7 ++++++-
 sysdeps/ieee754/ldbl-128/s_ceill.c          |  6 ++++++
 sysdeps/s390/fpu/math-use-builtins.h        | 11 +++++++++++
 6 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/sysdeps/generic/math-use-builtins.h b/sysdeps/generic/math-use-builtins.h
index e1c5df62e4..076ec661b0 100644
--- a/sysdeps/generic/math-use-builtins.h
+++ b/sysdeps/generic/math-use-builtins.h
@@ -36,4 +36,9 @@
 #define USE_FLOORL_BUILTIN 0
 #define USE_FLOORF128_BUILTIN 0
 
+#define USE_CEIL_BUILTIN 0
+#define USE_CEILF_BUILTIN 0
+#define USE_CEILL_BUILTIN 0
+#define USE_CEILF128_BUILTIN 0
+
 #endif /* math-use-builtins.h */
diff --git a/sysdeps/ieee754/dbl-64/s_ceil.c b/sysdeps/ieee754/dbl-64/s_ceil.c
index 8d66f027e7..3738211360 100644
--- a/sysdeps/ieee754/dbl-64/s_ceil.c
+++ b/sysdeps/ieee754/dbl-64/s_ceil.c
@@ -21,10 +21,15 @@
 #include <math.h>
 #include <math_private.h>
 #include <libm-alias-double.h>
+#include <math-use-builtins.h>
 
 double
 __ceil (double x)
 {
+#if USE_CEIL_BUILTIN
+  return __builtin_ceil (x);
+#else
+  /* Use generic implementation.  */
   int64_t i0, i;
   int32_t j0;
   EXTRACT_WORDS64 (i0, x);
@@ -58,6 +63,7 @@ __ceil (double x)
     }
   INSERT_WORDS64 (x, i0);
   return x;
+#endif /* ! USE_CEIL_BUILTIN  */
 }
 #ifndef __ceil
 libm_alias_double (__ceil, ceil)
diff --git a/sysdeps/ieee754/float128/float128_private.h b/sysdeps/ieee754/float128/float128_private.h
index 8c8a74a12c..01881b574a 100644
--- a/sysdeps/ieee754/float128/float128_private.h
+++ b/sysdeps/ieee754/float128/float128_private.h
@@ -146,6 +146,8 @@
 #define USE_RINTL_BUILTIN USE_RINTF128_BUILTIN
 #undef USE_FLOORL_BUILTIN
 #define USE_FLOORL_BUILTIN USE_FLOORF128_BUILTIN
+#undef USE_CEILL_BUILTIN
+#define USE_CEILL_BUILTIN USE_CEILF128_BUILTIN
 
 /* IEEE function renames.  */
 #define __ieee754_acoshl __ieee754_acoshf128
@@ -352,6 +354,7 @@
 #define __builtin_nearbyintl __builtin_nearbyintf128
 #define __builtin_rintl __builtin_rintf128
 #define __builtin_floorl __builtin_floorf128
+#define __builtin_ceill __builtin_ceilf128
 
 /* Get the constant suffix from bits/floatn-compat.h.  */
 #define L(x) __f128 (x)
diff --git a/sysdeps/ieee754/flt-32/s_ceilf.c b/sysdeps/ieee754/flt-32/s_ceilf.c
index 25cba0807c..7d4990f3ff 100644
--- a/sysdeps/ieee754/flt-32/s_ceilf.c
+++ b/sysdeps/ieee754/flt-32/s_ceilf.c
@@ -17,11 +17,15 @@
 #include <math.h>
 #include <math_private.h>
 #include <libm-alias-float.h>
-
+#include <math-use-builtins.h>
 
 float
 __ceilf(float x)
 {
+#if USE_CEILF_BUILTIN
+  return __builtin_ceilf (x);
+#else
+  /* Use generic implementation.  */
 	int32_t i0,j0;
 	uint32_t i;
 
@@ -44,6 +48,7 @@ __ceilf(float x)
 	}
 	SET_FLOAT_WORD(x,i0);
 	return x;
+#endif /* ! USE_CEILF_BUILTIN  */
 }
 #ifndef __ceilf
 libm_alias_float (__ceil, ceil)
diff --git a/sysdeps/ieee754/ldbl-128/s_ceill.c b/sysdeps/ieee754/ldbl-128/s_ceill.c
index 2ec55de25a..02ffa7af2b 100644
--- a/sysdeps/ieee754/ldbl-128/s_ceill.c
+++ b/sysdeps/ieee754/ldbl-128/s_ceill.c
@@ -28,9 +28,14 @@ static char rcsid[] = "$NetBSD: $";
 #include <math.h>
 #include <math_private.h>
 #include <libm-alias-ldouble.h>
+#include <math-use-builtins.h>
 
 _Float128 __ceill(_Float128 x)
 {
+#if USE_CEILL_BUILTIN
+  return __builtin_ceill (x);
+#else
+  /* Use generic implementation.  */
 	int64_t i0,i1,j0;
 	uint64_t i,j;
 	GET_LDOUBLE_WORDS64(i0,i1,x);
@@ -64,5 +69,6 @@ _Float128 __ceill(_Float128 x)
 	}
 	SET_LDOUBLE_WORDS64(x,i0,i1);
 	return x;
+#endif /* ! USE_CEILL_BUILTIN  */
 }
 libm_alias_ldouble (__ceil, ceil)
diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
index c213c16c6f..5435cbb65f 100644
--- a/sysdeps/s390/fpu/math-use-builtins.h
+++ b/sysdeps/s390/fpu/math-use-builtins.h
@@ -38,14 +38,20 @@
 # define USE_FLOORF_BUILTIN 1
 # define USE_FLOORL_BUILTIN 1
 
+# define USE_CEIL_BUILTIN 1
+# define USE_CEILF_BUILTIN 1
+# define USE_CEILL_BUILTIN 1
+
 # if __GNUC_PREREQ (8, 0)
 #  define USE_NEARBYINTF128_BUILTIN 1
 #  define USE_RINTF128_BUILTIN 1
 #  define USE_FLOORF128_BUILTIN 1
+#  define USE_CEILF128_BUILTIN 1
 # else
 #  define USE_NEARBYINTF128_BUILTIN 0
 #  define USE_RINTF128_BUILTIN 0
 #  define USE_FLOORF128_BUILTIN 0
+#  define USE_CEILF128_BUILTIN 0
 # endif
 
 #else
@@ -66,6 +72,11 @@
 # define USE_FLOORL_BUILTIN 0
 # define USE_FLOORF128_BUILTIN 0
 
+# define USE_CEIL_BUILTIN 0
+# define USE_CEILF_BUILTIN 0
+# define USE_CEILL_BUILTIN 0
+# define USE_CEILF128_BUILTIN 0
+
 #endif /* ! HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT  */
 
 #endif /* math-use-builtins.h */
-- 
2.19.1

[PATCH v2 11/18] Use GCC builtins for trunc functions if desired.

[Stefan Liebler]

This patch is using the corresponding GCC builtin for truncf, trunc,
truncl and truncf128 if the USE_FUNCTION_BUILTIN macros are defined to one
in math-use-builtins.h.

This is the case for s390 if build with at least --march=z196 --mzarch.
Otherwise the generic implementation is used.  The code of the generic
implementation is not changed.
---
 sysdeps/generic/math-use-builtins.h         |  5 +++++
 sysdeps/ieee754/dbl-64/s_trunc.c            |  6 ++++++
 sysdeps/ieee754/float128/float128_private.h |  3 +++
 sysdeps/ieee754/flt-32/s_truncf.c           |  6 ++++++
 sysdeps/ieee754/ldbl-128/s_truncl.c         |  6 ++++++
 sysdeps/s390/fpu/math-use-builtins.h        | 11 +++++++++++
 6 files changed, 37 insertions(+)

diff --git a/sysdeps/generic/math-use-builtins.h b/sysdeps/generic/math-use-builtins.h
index 076ec661b0..ab379f45ba 100644
--- a/sysdeps/generic/math-use-builtins.h
+++ b/sysdeps/generic/math-use-builtins.h
@@ -41,4 +41,9 @@
 #define USE_CEILL_BUILTIN 0
 #define USE_CEILF128_BUILTIN 0
 
+#define USE_TRUNC_BUILTIN 0
+#define USE_TRUNCF_BUILTIN 0
+#define USE_TRUNCL_BUILTIN 0
+#define USE_TRUNCF128_BUILTIN 0
+
 #endif /* math-use-builtins.h */
diff --git a/sysdeps/ieee754/dbl-64/s_trunc.c b/sysdeps/ieee754/dbl-64/s_trunc.c
index 0de68ce298..c3129fea7b 100644
--- a/sysdeps/ieee754/dbl-64/s_trunc.c
+++ b/sysdeps/ieee754/dbl-64/s_trunc.c
@@ -22,11 +22,16 @@
 
 #include <math_private.h>
 #include <libm-alias-double.h>
+#include <math-use-builtins.h>
 
 
 double
 __trunc (double x)
 {
+#if USE_TRUNC_BUILTIN
+  return __builtin_trunc (x);
+#else
+  /* Use generic implementation.  */
   int64_t i0, j0;
   int64_t sx;
 
@@ -49,6 +54,7 @@ __trunc (double x)
     }
 
   return x;
+#endif /* ! USE_TRUNC_BUILTIN  */
 }
 #ifndef __trunc
 libm_alias_double (__trunc, trunc)
diff --git a/sysdeps/ieee754/float128/float128_private.h b/sysdeps/ieee754/float128/float128_private.h
index 01881b574a..9cd3a63f11 100644
--- a/sysdeps/ieee754/float128/float128_private.h
+++ b/sysdeps/ieee754/float128/float128_private.h
@@ -148,6 +148,8 @@
 #define USE_FLOORL_BUILTIN USE_FLOORF128_BUILTIN
 #undef USE_CEILL_BUILTIN
 #define USE_CEILL_BUILTIN USE_CEILF128_BUILTIN
+#undef USE_TRUNCL_BUILTIN
+#define USE_TRUNCL_BUILTIN USE_TRUNCF128_BUILTIN
 
 /* IEEE function renames.  */
 #define __ieee754_acoshl __ieee754_acoshf128
@@ -355,6 +357,7 @@
 #define __builtin_rintl __builtin_rintf128
 #define __builtin_floorl __builtin_floorf128
 #define __builtin_ceill __builtin_ceilf128
+#define __builtin_truncl __builtin_truncf128
 
 /* Get the constant suffix from bits/floatn-compat.h.  */
 #define L(x) __f128 (x)
diff --git a/sysdeps/ieee754/flt-32/s_truncf.c b/sysdeps/ieee754/flt-32/s_truncf.c
index e587706b5b..274638820e 100644
--- a/sysdeps/ieee754/flt-32/s_truncf.c
+++ b/sysdeps/ieee754/flt-32/s_truncf.c
@@ -22,11 +22,16 @@
 
 #include <math_private.h>
 #include <libm-alias-float.h>
+#include <math-use-builtins.h>
 
 
 float
 __truncf (float x)
 {
+#if USE_TRUNCF_BUILTIN
+  return __builtin_truncf (x);
+#else
+  /* Use generic implementation.  */
   int32_t i0, j0;
   int sx;
 
@@ -49,6 +54,7 @@ __truncf (float x)
     }
 
   return x;
+#endif /* ! USE_TRUNCF_BUILTIN  */
 }
 #ifndef __truncf
 libm_alias_float (__trunc, trunc)
diff --git a/sysdeps/ieee754/ldbl-128/s_truncl.c b/sysdeps/ieee754/ldbl-128/s_truncl.c
index de4dd34d59..d11ab937e2 100644
--- a/sysdeps/ieee754/ldbl-128/s_truncl.c
+++ b/sysdeps/ieee754/ldbl-128/s_truncl.c
@@ -23,11 +23,16 @@
 
 #include <math_private.h>
 #include <libm-alias-ldouble.h>
+#include <math-use-builtins.h>
 
 
 _Float128
 __truncl (_Float128 x)
 {
+#if USE_TRUNCL_BUILTIN
+  return __builtin_truncl (x);
+#else
+  /* Use generic implementation.  */
   int32_t j0;
   uint64_t i0, i1, sx;
 
@@ -54,5 +59,6 @@ __truncl (_Float128 x)
     }
 
   return x;
+#endif /* ! USE_TRUNCL_BUILTIN  */
 }
 libm_alias_ldouble (__trunc, trunc)
diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
index 5435cbb65f..a39715c612 100644
--- a/sysdeps/s390/fpu/math-use-builtins.h
+++ b/sysdeps/s390/fpu/math-use-builtins.h
@@ -42,16 +42,22 @@
 # define USE_CEILF_BUILTIN 1
 # define USE_CEILL_BUILTIN 1
 
+# define USE_TRUNC_BUILTIN 1
+# define USE_TRUNCF_BUILTIN 1
+# define USE_TRUNCL_BUILTIN 1
+
 # if __GNUC_PREREQ (8, 0)
 #  define USE_NEARBYINTF128_BUILTIN 1
 #  define USE_RINTF128_BUILTIN 1
 #  define USE_FLOORF128_BUILTIN 1
 #  define USE_CEILF128_BUILTIN 1
+#  define USE_TRUNCF128_BUILTIN 1
 # else
 #  define USE_NEARBYINTF128_BUILTIN 0
 #  define USE_RINTF128_BUILTIN 0
 #  define USE_FLOORF128_BUILTIN 0
 #  define USE_CEILF128_BUILTIN 0
+#  define USE_TRUNCF128_BUILTIN 0
 # endif
 
 #else
@@ -77,6 +83,11 @@
 # define USE_CEILL_BUILTIN 0
 # define USE_CEILF128_BUILTIN 0
 
+# define USE_TRUNC_BUILTIN 0
+# define USE_TRUNCF_BUILTIN 0
+# define USE_TRUNCL_BUILTIN 0
+# define USE_TRUNCF128_BUILTIN 0
+
 #endif /* ! HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT  */
 
 #endif /* math-use-builtins.h */
-- 
2.19.1

[PATCH v2 09/18] Use GCC builtins for floor functions if desired.

[Stefan Liebler]

This patch is using the corresponding GCC builtin for floorf, floor,
floorl and floorf128 if the USE_FUNCTION_BUILTIN macros are defined to one
in math-use-builtins.h.

This is the case for s390 if build with at least --march=z196 --mzarch.
Otherwise the generic implementation is used.  The code of the generic
implementation is not changed.
---
 sysdeps/generic/math-use-builtins.h         |  5 +++++
 sysdeps/ieee754/dbl-64/s_floor.c            |  6 ++++++
 sysdeps/ieee754/float128/float128_private.h |  3 +++
 sysdeps/ieee754/flt-32/s_floorf.c           |  6 ++++++
 sysdeps/ieee754/ldbl-128/s_floorl.c         |  6 ++++++
 sysdeps/s390/fpu/math-use-builtins.h        | 11 +++++++++++
 6 files changed, 37 insertions(+)

diff --git a/sysdeps/generic/math-use-builtins.h b/sysdeps/generic/math-use-builtins.h
index 64b4a4bb5b..e1c5df62e4 100644
--- a/sysdeps/generic/math-use-builtins.h
+++ b/sysdeps/generic/math-use-builtins.h
@@ -31,4 +31,9 @@
 #define USE_RINTL_BUILTIN 0
 #define USE_RINTF128_BUILTIN 0
 
+#define USE_FLOOR_BUILTIN 0
+#define USE_FLOORF_BUILTIN 0
+#define USE_FLOORL_BUILTIN 0
+#define USE_FLOORF128_BUILTIN 0
+
 #endif /* math-use-builtins.h */
diff --git a/sysdeps/ieee754/dbl-64/s_floor.c b/sysdeps/ieee754/dbl-64/s_floor.c
index ce0c42bdb6..78325214f4 100644
--- a/sysdeps/ieee754/dbl-64/s_floor.c
+++ b/sysdeps/ieee754/dbl-64/s_floor.c
@@ -35,6 +35,7 @@
 #include <math_private.h>
 #include <stdint.h>
 #include <libm-alias-double.h>
+#include <math-use-builtins.h>
 
 /*
  * floor(x)
@@ -47,6 +48,10 @@
 double
 __floor (double x)
 {
+#if USE_FLOOR_BUILTIN
+  return __builtin_floor (x);
+#else
+  /* Use generic implementation.  */
   int64_t i0;
   EXTRACT_WORDS64 (i0, x);
   int32_t j0 = ((i0 >> 52) & 0x7ff) - 0x3ff;
@@ -74,6 +79,7 @@ __floor (double x)
   else if (j0 == 0x400)
     return x + x;			/* inf or NaN */
   return x;
+#endif /* ! USE_FLOOR_BUILTIN  */
 }
 #ifndef __floor
 libm_alias_double (__floor, floor)
diff --git a/sysdeps/ieee754/float128/float128_private.h b/sysdeps/ieee754/float128/float128_private.h
index f458e7b85f..8c8a74a12c 100644
--- a/sysdeps/ieee754/float128/float128_private.h
+++ b/sysdeps/ieee754/float128/float128_private.h
@@ -144,6 +144,8 @@
 #define USE_NEARBYINTL_BUILTIN USE_NEARBYINTF128_BUILTIN
 #undef USE_RINTL_BUILTIN
 #define USE_RINTL_BUILTIN USE_RINTF128_BUILTIN
+#undef USE_FLOORL_BUILTIN
+#define USE_FLOORL_BUILTIN USE_FLOORF128_BUILTIN
 
 /* IEEE function renames.  */
 #define __ieee754_acoshl __ieee754_acoshf128
@@ -349,6 +351,7 @@
 #define __builtin_signbitl __builtin_signbit
 #define __builtin_nearbyintl __builtin_nearbyintf128
 #define __builtin_rintl __builtin_rintf128
+#define __builtin_floorl __builtin_floorf128
 
 /* Get the constant suffix from bits/floatn-compat.h.  */
 #define L(x) __f128 (x)
diff --git a/sysdeps/ieee754/flt-32/s_floorf.c b/sysdeps/ieee754/flt-32/s_floorf.c
index b34d967f01..afe02a1693 100644
--- a/sysdeps/ieee754/flt-32/s_floorf.c
+++ b/sysdeps/ieee754/flt-32/s_floorf.c
@@ -24,10 +24,15 @@
 #include <math.h>
 #include <math_private.h>
 #include <libm-alias-float.h>
+#include <math-use-builtins.h>
 
 float
 __floorf(float x)
 {
+#if USE_FLOORF_BUILTIN
+  return __builtin_floorf (x);
+#else
+  /* Use generic implementation.  */
 	int32_t i0,j0;
 	uint32_t i;
 	GET_FLOAT_WORD(i0,x);
@@ -50,6 +55,7 @@ __floorf(float x)
 	}
 	SET_FLOAT_WORD(x,i0);
 	return x;
+#endif /* ! USE_FLOORF_BUILTIN  */
 }
 #ifndef __floorf
 libm_alias_float (__floor, floor)
diff --git a/sysdeps/ieee754/ldbl-128/s_floorl.c b/sysdeps/ieee754/ldbl-128/s_floorl.c
index f340a3fbca..cfe008392a 100644
--- a/sysdeps/ieee754/ldbl-128/s_floorl.c
+++ b/sysdeps/ieee754/ldbl-128/s_floorl.c
@@ -28,9 +28,14 @@ static char rcsid[] = "$NetBSD: $";
 #include <math.h>
 #include <math_private.h>
 #include <libm-alias-ldouble.h>
+#include <math-use-builtins.h>
 
 _Float128 __floorl(_Float128 x)
 {
+#if USE_FLOORL_BUILTIN
+  return __builtin_floorl (x);
+#else
+  /* Use generic implementation.  */
 	int64_t i0,i1,j0;
 	uint64_t i,j;
 	GET_LDOUBLE_WORDS64(i0,i1,x);
@@ -65,5 +70,6 @@ _Float128 __floorl(_Float128 x)
 	}
 	SET_LDOUBLE_WORDS64(x,i0,i1);
 	return x;
+#endif /* ! USE_FLOORL_BUILTIN  */
 }
 libm_alias_ldouble (__floor, floor)
diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
index 8b702a6a90..c213c16c6f 100644
--- a/sysdeps/s390/fpu/math-use-builtins.h
+++ b/sysdeps/s390/fpu/math-use-builtins.h
@@ -34,12 +34,18 @@
 # define USE_RINTF_BUILTIN 1
 # define USE_RINTL_BUILTIN 1
 
+# define USE_FLOOR_BUILTIN 1
+# define USE_FLOORF_BUILTIN 1
+# define USE_FLOORL_BUILTIN 1
+
 # if __GNUC_PREREQ (8, 0)
 #  define USE_NEARBYINTF128_BUILTIN 1
 #  define USE_RINTF128_BUILTIN 1
+#  define USE_FLOORF128_BUILTIN 1
 # else
 #  define USE_NEARBYINTF128_BUILTIN 0
 #  define USE_RINTF128_BUILTIN 0
+#  define USE_FLOORF128_BUILTIN 0
 # endif
 
 #else
@@ -55,6 +61,11 @@
 # define USE_RINTL_BUILTIN 0
 # define USE_RINTF128_BUILTIN 0
 
+# define USE_FLOOR_BUILTIN 0
+# define USE_FLOORF_BUILTIN 0
+# define USE_FLOORL_BUILTIN 0
+# define USE_FLOORF128_BUILTIN 0
+
 #endif /* ! HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT  */
 
 #endif /* math-use-builtins.h */
-- 
2.19.1

[PATCH v2 08/18] Use GCC builtins for rint functions if desired.

[Stefan Liebler]

This patch is using the corresponding GCC builtin for rintf, rint,
rintl and rintf128 if the USE_FUNCTION_BUILTIN macros are defined to one
in math-use-builtins.h.

This is the case for s390 if build with at least --march=z196 --mzarch.
Otherwise the generic implementation is used.  The code of the generic
implementation is not changed.
---
 sysdeps/generic/math-use-builtins.h         |  5 +++++
 sysdeps/ieee754/dbl-64/s_rint.c             | 17 +++++++++++------
 sysdeps/ieee754/float128/float128_private.h |  3 +++
 sysdeps/ieee754/flt-32/s_rintf.c            | 17 +++++++++++------
 sysdeps/ieee754/ldbl-128/s_rintl.c          | 17 +++++++++++------
 sysdeps/s390/fpu/math-use-builtins.h        | 11 +++++++++++
 6 files changed, 52 insertions(+), 18 deletions(-)

diff --git a/sysdeps/generic/math-use-builtins.h b/sysdeps/generic/math-use-builtins.h
index e12490ed41..64b4a4bb5b 100644
--- a/sysdeps/generic/math-use-builtins.h
+++ b/sysdeps/generic/math-use-builtins.h
@@ -26,4 +26,9 @@
 #define USE_NEARBYINTL_BUILTIN 0
 #define USE_NEARBYINTF128_BUILTIN 0
 
+#define USE_RINT_BUILTIN 0
+#define USE_RINTF_BUILTIN 0
+#define USE_RINTL_BUILTIN 0
+#define USE_RINTF128_BUILTIN 0
+
 #endif /* math-use-builtins.h */
diff --git a/sysdeps/ieee754/dbl-64/s_rint.c b/sysdeps/ieee754/dbl-64/s_rint.c
index 66c9196473..8604733ef9 100644
--- a/sysdeps/ieee754/dbl-64/s_rint.c
+++ b/sysdeps/ieee754/dbl-64/s_rint.c
@@ -23,16 +23,20 @@
 #include <math.h>
 #include <math_private.h>
 #include <libm-alias-double.h>
-
-static const double
-TWO52[2] = {
-	    4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
-	    -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
-};
+#include <math-use-builtins.h>
 
 double
 __rint (double x)
 {
+#if USE_RINT_BUILTIN
+  return __builtin_rint (x);
+#else
+  /* Use generic implementation.  */
+  static const double
+    TWO52[2] = {
+		4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
+		-4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
+  };
   int64_t i0, sx;
   int32_t j0;
   EXTRACT_WORDS64 (i0, x);
@@ -59,6 +63,7 @@ __rint (double x)
     }
   double w = TWO52[sx] + x;
   return w - TWO52[sx];
+#endif /* ! USE_RINT_BUILTIN  */
 }
 #ifndef __rint
 libm_alias_double (__rint, rint)
diff --git a/sysdeps/ieee754/float128/float128_private.h b/sysdeps/ieee754/float128/float128_private.h
index e96986a968..f458e7b85f 100644
--- a/sysdeps/ieee754/float128/float128_private.h
+++ b/sysdeps/ieee754/float128/float128_private.h
@@ -142,6 +142,8 @@
 #include <math-use-builtins.h>
 #undef USE_NEARBYINTL_BUILTIN
 #define USE_NEARBYINTL_BUILTIN USE_NEARBYINTF128_BUILTIN
+#undef USE_RINTL_BUILTIN
+#define USE_RINTL_BUILTIN USE_RINTF128_BUILTIN
 
 /* IEEE function renames.  */
 #define __ieee754_acoshl __ieee754_acoshf128
@@ -346,6 +348,7 @@
 #define __builtin_copysignl __builtin_copysignf128
 #define __builtin_signbitl __builtin_signbit
 #define __builtin_nearbyintl __builtin_nearbyintf128
+#define __builtin_rintl __builtin_rintf128
 
 /* Get the constant suffix from bits/floatn-compat.h.  */
 #define L(x) __f128 (x)
diff --git a/sysdeps/ieee754/flt-32/s_rintf.c b/sysdeps/ieee754/flt-32/s_rintf.c
index 0306dc21f4..34c16ea164 100644
--- a/sysdeps/ieee754/flt-32/s_rintf.c
+++ b/sysdeps/ieee754/flt-32/s_rintf.c
@@ -17,16 +17,20 @@
 #include <math.h>
 #include <math_private.h>
 #include <libm-alias-float.h>
-
-static const float
-TWO23[2]={
-  8.3886080000e+06, /* 0x4b000000 */
- -8.3886080000e+06, /* 0xcb000000 */
-};
+#include <math-use-builtins.h>
 
 float
 __rintf(float x)
 {
+#if USE_RINTF_BUILTIN
+  return __builtin_rintf (x);
+#else
+  /* Use generic implementation.  */
+  static const float
+    TWO23[2] = {
+		8.3886080000e+06, /* 0x4b000000 */
+		-8.3886080000e+06, /* 0xcb000000 */
+  };
 	int32_t i0,j0,sx;
 	float w,t;
 	GET_FLOAT_WORD(i0,x);
@@ -46,6 +50,7 @@ __rintf(float x)
 	}
 	w = TWO23[sx]+x;
 	return w-TWO23[sx];
+#endif /* ! USE_RINTF_BUILTIN  */
 }
 #ifndef __rintf
 libm_alias_float (__rint, rint)
diff --git a/sysdeps/ieee754/ldbl-128/s_rintl.c b/sysdeps/ieee754/ldbl-128/s_rintl.c
index b6337e1d8a..3340c35ee1 100644
--- a/sysdeps/ieee754/ldbl-128/s_rintl.c
+++ b/sysdeps/ieee754/ldbl-128/s_rintl.c
@@ -31,15 +31,19 @@ static char rcsid[] = "$NetBSD: $";
 #include <math.h>
 #include <math_private.h>
 #include <libm-alias-ldouble.h>
-
-static const _Float128
-TWO112[2]={
-  5.19229685853482762853049632922009600E+33L, /* 0x406F000000000000, 0 */
- -5.19229685853482762853049632922009600E+33L  /* 0xC06F000000000000, 0 */
-};
+#include <math-use-builtins.h>
 
 _Float128 __rintl(_Float128 x)
 {
+#if USE_RINTL_BUILTIN
+  return __builtin_rintl (x);
+#else
+  /* Use generic implementation.  */
+  static const _Float128
+    TWO112[2] = {
+		 5.19229685853482762853049632922009600E+33L, /* 0x406F000000000000, 0 */
+		 -5.19229685853482762853049632922009600E+33L  /* 0xC06F000000000000, 0 */
+  };
 	int64_t i0,j0,sx;
 	uint64_t i1 __attribute__ ((unused));
 	_Float128 w,t;
@@ -60,5 +64,6 @@ _Float128 __rintl(_Float128 x)
 	}
 	w = TWO112[sx]+x;
 	return w-TWO112[sx];
+#endif /* ! USE_RINTL_BUILTIN  */
 }
 libm_alias_ldouble (__rint, rint)
diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
index 7abbfb3b50..8b702a6a90 100644
--- a/sysdeps/s390/fpu/math-use-builtins.h
+++ b/sysdeps/s390/fpu/math-use-builtins.h
@@ -30,10 +30,16 @@
 # define USE_NEARBYINTF_BUILTIN 1
 # define USE_NEARBYINTL_BUILTIN 1
 
+# define USE_RINT_BUILTIN 1
+# define USE_RINTF_BUILTIN 1
+# define USE_RINTL_BUILTIN 1
+
 # if __GNUC_PREREQ (8, 0)
 #  define USE_NEARBYINTF128_BUILTIN 1
+#  define USE_RINTF128_BUILTIN 1
 # else
 #  define USE_NEARBYINTF128_BUILTIN 0
+#  define USE_RINTF128_BUILTIN 0
 # endif
 
 #else
@@ -44,6 +50,11 @@
 # define USE_NEARBYINTL_BUILTIN 0
 # define USE_NEARBYINTF128_BUILTIN 0
 
+# define USE_RINT_BUILTIN 0
+# define USE_RINTF_BUILTIN 0
+# define USE_RINTL_BUILTIN 0
+# define USE_RINTF128_BUILTIN 0
+
 #endif /* ! HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT  */
 
 #endif /* math-use-builtins.h */
-- 
2.19.1

[PATCH v2 13/18] Use GCC builtins for copysign functions if desired.

[Stefan Liebler]

This patch is always using the corresponding GCC builtin for copysignf, copysign,
and is using the builtin for copysignl, copysignf128 if the USE_FUNCTION_BUILTIN
macros are defined to one in math-use-builtins.h.

Altough the long double version is enabled by default we still need
the macro and the alternative implementation as the _Float128 version
of the builtin is not available with all supported GCC versions.
---
 sysdeps/generic/math-use-builtins.h         |  9 +++++++++
 sysdeps/ieee754/dbl-64/s_copysign.c         |  9 ++-------
 sysdeps/ieee754/float128/float128_private.h |  3 +++
 sysdeps/ieee754/flt-32/s_copysignf.c        | 12 ++++--------
 sysdeps/ieee754/ldbl-128/s_copysignl.c      |  6 ++++++
 sysdeps/s390/fpu/math-use-builtins.h        |  7 +++++++
 6 files changed, 31 insertions(+), 15 deletions(-)

diff --git a/sysdeps/generic/math-use-builtins.h b/sysdeps/generic/math-use-builtins.h
index 34ca438a8c..770b54ce61 100644
--- a/sysdeps/generic/math-use-builtins.h
+++ b/sysdeps/generic/math-use-builtins.h
@@ -19,6 +19,8 @@
 #ifndef MATH_USE_BUILTINS_H
 #define MATH_USE_BUILTINS_H	1
 
+#include <features.h> /* For __GNUC_PREREQ.  */
+
 /* Define these macros to 1 to use __builtin_xyz instead of the
    generic implementation.  */
 #define USE_NEARBYINT_BUILTIN 0
@@ -51,4 +53,11 @@
 #define USE_ROUNDL_BUILTIN 0
 #define USE_ROUNDF128_BUILTIN 0
 
+#define USE_COPYSIGNL_BUILTIN 1
+#if __GNUC_PREREQ (7, 0)
+# define USE_COPYSIGNF128_BUILTIN 1
+#else
+# define USE_COPYSIGNF128_BUILTIN 0
+#endif
+
 #endif /* math-use-builtins.h */
diff --git a/sysdeps/ieee754/dbl-64/s_copysign.c b/sysdeps/ieee754/dbl-64/s_copysign.c
index 589b088c95..94025b7854 100644
--- a/sysdeps/ieee754/dbl-64/s_copysign.c
+++ b/sysdeps/ieee754/dbl-64/s_copysign.c
@@ -10,7 +10,7 @@
  * ====================================================
  */
 
-#if defined(LIBM_SCCS) && !defined(lint)
+#if defined (LIBM_SCCS) && ! defined (lint)
 static char rcsid[] = "$NetBSD: s_copysign.c,v 1.8 1995/05/10 20:46:57 jtc Exp $";
 #endif
 
@@ -22,16 +22,11 @@ static char rcsid[] = "$NetBSD: s_copysign.c,v 1.8 1995/05/10 20:46:57 jtc Exp $
 
 #define NO_MATH_REDIRECT
 #include <math.h>
-#include <math_private.h>
 #include <libm-alias-double.h>
 
 double
 __copysign (double x, double y)
 {
-  uint32_t hx, hy;
-  GET_HIGH_WORD (hx, x);
-  GET_HIGH_WORD (hy, y);
-  SET_HIGH_WORD (x, (hx & 0x7fffffff) | (hy & 0x80000000));
-  return x;
+  return __builtin_copysign (x, y);
 }
 libm_alias_double (__copysign, copysign)
diff --git a/sysdeps/ieee754/float128/float128_private.h b/sysdeps/ieee754/float128/float128_private.h
index a6c76ce364..7f7f904152 100644
--- a/sysdeps/ieee754/float128/float128_private.h
+++ b/sysdeps/ieee754/float128/float128_private.h
@@ -152,6 +152,8 @@
 #define USE_TRUNCL_BUILTIN USE_TRUNCF128_BUILTIN
 #undef USE_ROUNDL_BUILTIN
 #define USE_ROUNDL_BUILTIN USE_ROUNDF128_BUILTIN
+#undef USE_COPYSIGNL_BUILTIN
+#define USE_COPYSIGNL_BUILTIN USE_COPYSIGNF128_BUILTIN
 
 /* IEEE function renames.  */
 #define __ieee754_acoshl __ieee754_acoshf128
@@ -361,6 +363,7 @@
 #define __builtin_ceill __builtin_ceilf128
 #define __builtin_truncl __builtin_truncf128
 #define __builtin_roundl __builtin_roundf128
+#define __builtin_copysignl __builtin_copysignf128
 
 /* Get the constant suffix from bits/floatn-compat.h.  */
 #define L(x) __f128 (x)
diff --git a/sysdeps/ieee754/flt-32/s_copysignf.c b/sysdeps/ieee754/flt-32/s_copysignf.c
index 77d1d90e92..1c097d313f 100644
--- a/sysdeps/ieee754/flt-32/s_copysignf.c
+++ b/sysdeps/ieee754/flt-32/s_copysignf.c
@@ -13,7 +13,7 @@
  * ====================================================
  */
 
-#if defined(LIBM_SCCS) && !defined(lint)
+#if defined (LIBM_SCCS) && ! defined (lint)
 static char rcsid[] = "$NetBSD: s_copysignf.c,v 1.4 1995/05/10 20:46:59 jtc Exp $";
 #endif
 
@@ -25,15 +25,11 @@ static char rcsid[] = "$NetBSD: s_copysignf.c,v 1.4 1995/05/10 20:46:59 jtc Exp
 
 #define NO_MATH_REDIRECT
 #include <math.h>
-#include <math_private.h>
 #include <libm-alias-float.h>
 
-float __copysignf(float x, float y)
+float
+__copysignf (float x, float y)
 {
-	uint32_t ix,iy;
-	GET_FLOAT_WORD(ix,x);
-	GET_FLOAT_WORD(iy,y);
-	SET_FLOAT_WORD(x,(ix&0x7fffffff)|(iy&0x80000000));
-        return x;
+  return __builtin_copysignf (x, y);
 }
 libm_alias_float (__copysign, copysign)
diff --git a/sysdeps/ieee754/ldbl-128/s_copysignl.c b/sysdeps/ieee754/ldbl-128/s_copysignl.c
index a501139f71..848a184524 100644
--- a/sysdeps/ieee754/ldbl-128/s_copysignl.c
+++ b/sysdeps/ieee754/ldbl-128/s_copysignl.c
@@ -27,14 +27,20 @@ static char rcsid[] = "$NetBSD: $";
 #include <math.h>
 #include <math_private.h>
 #include <libm-alias-ldouble.h>
+#include <math-use-builtins.h>
 
 _Float128 __copysignl(_Float128 x, _Float128 y)
 {
+#if USE_COPYSIGNL_BUILTIN
+  return __builtin_copysignl (x, y);
+#else
+  /* Use generic implementation.  */
 	uint64_t hx,hy;
 	GET_LDOUBLE_MSW64(hx,x);
 	GET_LDOUBLE_MSW64(hy,y);
 	SET_LDOUBLE_MSW64(x,(hx&0x7fffffffffffffffULL)
 			    |(hy&0x8000000000000000ULL));
         return x;
+#endif /* ! USE_COPYSIGNL_BUILTIN  */
 }
 libm_alias_ldouble (__copysign, copysign)
diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
index 51cb9f91ab..4c4aad2ab5 100644
--- a/sysdeps/s390/fpu/math-use-builtins.h
+++ b/sysdeps/s390/fpu/math-use-builtins.h
@@ -101,4 +101,11 @@
 
 #endif /* ! HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT  */
 
+#define USE_COPYSIGNL_BUILTIN 1
+#if __GNUC_PREREQ (7, 0)
+# define USE_COPYSIGNF128_BUILTIN 1
+#else
+# define USE_COPYSIGNF128_BUILTIN 0
+#endif
+
 #endif /* math-use-builtins.h */
-- 
2.19.1

[PATCH v2 12/18] Use GCC builtins for round functions if desired.

[Stefan Liebler]

This patch is using the corresponding GCC builtin for roundf, round,
roundl and roundf128 if the USE_FUNCTION_BUILTIN macros are defined to one
in math-use-builtins.h.

This is the case for s390 if build with at least --march=z196 --mzarch.
Otherwise the generic implementation is used.  The code of the generic
implementation is not changed.
---
 sysdeps/generic/math-use-builtins.h         |  5 +++++
 sysdeps/ieee754/dbl-64/s_round.c            |  6 ++++++
 sysdeps/ieee754/float128/float128_private.h |  3 +++
 sysdeps/ieee754/flt-32/s_roundf.c           |  6 ++++++
 sysdeps/ieee754/ldbl-128/s_roundl.c         |  6 ++++++
 sysdeps/s390/fpu/math-use-builtins.h        | 11 +++++++++++
 6 files changed, 37 insertions(+)

diff --git a/sysdeps/generic/math-use-builtins.h b/sysdeps/generic/math-use-builtins.h
index ab379f45ba..34ca438a8c 100644
--- a/sysdeps/generic/math-use-builtins.h
+++ b/sysdeps/generic/math-use-builtins.h
@@ -46,4 +46,9 @@
 #define USE_TRUNCL_BUILTIN 0
 #define USE_TRUNCF128_BUILTIN 0
 
+#define USE_ROUND_BUILTIN 0
+#define USE_ROUNDF_BUILTIN 0
+#define USE_ROUNDL_BUILTIN 0
+#define USE_ROUNDF128_BUILTIN 0
+
 #endif /* math-use-builtins.h */
diff --git a/sysdeps/ieee754/dbl-64/s_round.c b/sysdeps/ieee754/dbl-64/s_round.c
index 8f4b7cff86..7eb1ecb482 100644
--- a/sysdeps/ieee754/dbl-64/s_round.c
+++ b/sysdeps/ieee754/dbl-64/s_round.c
@@ -23,11 +23,16 @@
 #include <math_private.h>
 #include <libm-alias-double.h>
 #include <stdint.h>
+#include <math-use-builtins.h>
 
 
 double
 __round (double x)
 {
+#if USE_ROUND_BUILTIN
+  return __builtin_round (x);
+#else
+  /* Use generic implementation.  */
   int64_t i0, j0;
 
   EXTRACT_WORDS64 (i0, x);
@@ -62,5 +67,6 @@ __round (double x)
 
   INSERT_WORDS64 (x, i0);
   return x;
+#endif /* ! USE_ROUND_BUILTIN  */
 }
 libm_alias_double (__round, round)
diff --git a/sysdeps/ieee754/float128/float128_private.h b/sysdeps/ieee754/float128/float128_private.h
index 9cd3a63f11..a6c76ce364 100644
--- a/sysdeps/ieee754/float128/float128_private.h
+++ b/sysdeps/ieee754/float128/float128_private.h
@@ -150,6 +150,8 @@
 #define USE_CEILL_BUILTIN USE_CEILF128_BUILTIN
 #undef USE_TRUNCL_BUILTIN
 #define USE_TRUNCL_BUILTIN USE_TRUNCF128_BUILTIN
+#undef USE_ROUNDL_BUILTIN
+#define USE_ROUNDL_BUILTIN USE_ROUNDF128_BUILTIN
 
 /* IEEE function renames.  */
 #define __ieee754_acoshl __ieee754_acoshf128
@@ -358,6 +360,7 @@
 #define __builtin_floorl __builtin_floorf128
 #define __builtin_ceill __builtin_ceilf128
 #define __builtin_truncl __builtin_truncf128
+#define __builtin_roundl __builtin_roundf128
 
 /* Get the constant suffix from bits/floatn-compat.h.  */
 #define L(x) __f128 (x)
diff --git a/sysdeps/ieee754/flt-32/s_roundf.c b/sysdeps/ieee754/flt-32/s_roundf.c
index cddab7b505..5d91239d6e 100644
--- a/sysdeps/ieee754/flt-32/s_roundf.c
+++ b/sysdeps/ieee754/flt-32/s_roundf.c
@@ -22,11 +22,16 @@
 
 #include <math_private.h>
 #include <libm-alias-float.h>
+#include <math-use-builtins.h>
 
 
 float
 __roundf (float x)
 {
+#if USE_ROUNDF_BUILTIN
+  return __builtin_roundf (x);
+#else
+  /* Use generic implementation.  */
   int32_t i0, j0;
 
   GET_FLOAT_WORD (i0, x);
@@ -61,5 +66,6 @@ __roundf (float x)
 
   SET_FLOAT_WORD (x, i0);
   return x;
+#endif /* ! USE_ROUNDF_BUILTIN  */
 }
 libm_alias_float (__round, round)
diff --git a/sysdeps/ieee754/ldbl-128/s_roundl.c b/sysdeps/ieee754/ldbl-128/s_roundl.c
index d41c9a04dc..8c7ae82217 100644
--- a/sysdeps/ieee754/ldbl-128/s_roundl.c
+++ b/sysdeps/ieee754/ldbl-128/s_roundl.c
@@ -23,11 +23,16 @@
 
 #include <math_private.h>
 #include <libm-alias-ldouble.h>
+#include <math-use-builtins.h>
 
 
 _Float128
 __roundl (_Float128 x)
 {
+#if USE_ROUNDL_BUILTIN
+  return __builtin_roundl (x);
+#else
+  /* Use generic implementation.  */
   int32_t j0;
   uint64_t i1, i0;
 
@@ -78,5 +83,6 @@ __roundl (_Float128 x)
 
   SET_LDOUBLE_WORDS64 (x, i0, i1);
   return x;
+#endif /* ! USE_ROUNDL_BUILTIN  */
 }
 libm_alias_ldouble (__round, round)
diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
index a39715c612..51cb9f91ab 100644
--- a/sysdeps/s390/fpu/math-use-builtins.h
+++ b/sysdeps/s390/fpu/math-use-builtins.h
@@ -46,18 +46,24 @@
 # define USE_TRUNCF_BUILTIN 1
 # define USE_TRUNCL_BUILTIN 1
 
+# define USE_ROUND_BUILTIN 1
+# define USE_ROUNDF_BUILTIN 1
+# define USE_ROUNDL_BUILTIN 1
+
 # if __GNUC_PREREQ (8, 0)
 #  define USE_NEARBYINTF128_BUILTIN 1
 #  define USE_RINTF128_BUILTIN 1
 #  define USE_FLOORF128_BUILTIN 1
 #  define USE_CEILF128_BUILTIN 1
 #  define USE_TRUNCF128_BUILTIN 1
+#  define USE_ROUNDF128_BUILTIN 1
 # else
 #  define USE_NEARBYINTF128_BUILTIN 0
 #  define USE_RINTF128_BUILTIN 0
 #  define USE_FLOORF128_BUILTIN 0
 #  define USE_CEILF128_BUILTIN 0
 #  define USE_TRUNCF128_BUILTIN 0
+#  define USE_ROUNDF128_BUILTIN 0
 # endif
 
 #else
@@ -88,6 +94,11 @@
 # define USE_TRUNCL_BUILTIN 0
 # define USE_TRUNCF128_BUILTIN 0
 
+# define USE_ROUND_BUILTIN 0
+# define USE_ROUNDF_BUILTIN 0
+# define USE_ROUNDL_BUILTIN 0
+# define USE_ROUNDF128_BUILTIN 0
+
 #endif /* ! HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT  */
 
 #endif /* math-use-builtins.h */
-- 
2.19.1

[PATCH v2 16/18] Adjust s_floorf.c and s_floorl.c regarding code style.

[Stefan Liebler]

This patch just adjusts the generic implementation regarding code style.
No functional change.
---
 sysdeps/ieee754/flt-32/s_floorf.c   | 55 +++++++++++-------
 sysdeps/ieee754/ldbl-128/s_floorl.c | 89 ++++++++++++++++++-----------
 2 files changed, 90 insertions(+), 54 deletions(-)

diff --git a/sysdeps/ieee754/flt-32/s_floorf.c b/sysdeps/ieee754/flt-32/s_floorf.c
index afe02a1693..da6c6dfa8a 100644
--- a/sysdeps/ieee754/flt-32/s_floorf.c
+++ b/sysdeps/ieee754/flt-32/s_floorf.c
@@ -27,34 +27,45 @@
 #include <math-use-builtins.h>
 
 float
-__floorf(float x)
+__floorf (float x)
 {
 #if USE_FLOORF_BUILTIN
   return __builtin_floorf (x);
 #else
   /* Use generic implementation.  */
-	int32_t i0,j0;
-	uint32_t i;
-	GET_FLOAT_WORD(i0,x);
-	j0 = ((i0>>23)&0xff)-0x7f;
-	if(j0<23) {
-	    if(j0<0) {
-		/* return 0*sign(x) if |x|<1 */
-		if(i0>=0) {i0=0;}
-		else if((i0&0x7fffffff)!=0)
-		  { i0=0xbf800000;}
-	    } else {
-		i = (0x007fffff)>>j0;
-		if((i0&i)==0) return x; /* x is integral */
-		if(i0<0) i0 += (0x00800000)>>j0;
-		i0 &= (~i);
-	    }
-	} else {
-	    if(__builtin_expect(j0==0x80, 0)) return x+x; /* inf or NaN */
-	    else return x;		/* x is integral */
+  int32_t i0, j0;
+  uint32_t i;
+  GET_FLOAT_WORD (i0, x);
+  j0 = ((i0 >> 23) & 0xff) - 0x7f;
+  if (j0 < 23)
+    {
+      if (j0 < 0)
+	{
+	  /* return 0 * sign (x) if |x| < 1  */
+	  if (i0 >= 0)
+	    i0 = 0;
+	  else if ((i0 & 0x7fffffff) != 0)
+	    i0 = 0xbf800000;
 	}
-	SET_FLOAT_WORD(x,i0);
-	return x;
+      else
+	{
+	  i = (0x007fffff) >> j0;
+	  if ((i0 & i) == 0)
+	    return x;		/* x is integral  */
+	  if (i0 < 0)
+	    i0 += (0x00800000) >> j0;
+	  i0 &= (~i);
+	}
+    }
+  else
+    {
+      if (__glibc_unlikely (j0 == 0x80))
+	return x + x;		/* inf or NaN  */
+      else
+	return x;		/* x is integral  */
+    }
+  SET_FLOAT_WORD (x, i0);
+  return x;
 #endif /* ! USE_FLOORF_BUILTIN  */
 }
 #ifndef __floorf
diff --git a/sysdeps/ieee754/ldbl-128/s_floorl.c b/sysdeps/ieee754/ldbl-128/s_floorl.c
index cfe008392a..0475120d7e 100644
--- a/sysdeps/ieee754/ldbl-128/s_floorl.c
+++ b/sysdeps/ieee754/ldbl-128/s_floorl.c
@@ -30,46 +30,71 @@ static char rcsid[] = "$NetBSD: $";
 #include <libm-alias-ldouble.h>
 #include <math-use-builtins.h>
 
-_Float128 __floorl(_Float128 x)
+_Float128
+__floorl (_Float128 x)
 {
 #if USE_FLOORL_BUILTIN
   return __builtin_floorl (x);
 #else
   /* Use generic implementation.  */
-	int64_t i0,i1,j0;
-	uint64_t i,j;
-	GET_LDOUBLE_WORDS64(i0,i1,x);
-	j0 = ((i0>>48)&0x7fff)-0x3fff;
-	if(j0<48) {
-	    if(j0<0) {
-		/* return 0*sign(x) if |x|<1 */
-		if(i0>=0) {i0=i1=0;}
-		else if(((i0&0x7fffffffffffffffLL)|i1)!=0)
-		    { i0=0xbfff000000000000ULL;i1=0;}
-	    } else {
-		i = (0x0000ffffffffffffULL)>>j0;
-		if(((i0&i)|i1)==0) return x; /* x is integral */
-		if(i0<0) i0 += (0x0001000000000000LL)>>j0;
-		i0 &= (~i); i1=0;
+  int64_t i0, i1, j0;
+  uint64_t i, j;
+  GET_LDOUBLE_WORDS64 (i0, i1, x);
+  j0 = ((i0 >> 48) & 0x7fff) - 0x3fff;
+  if (j0 < 48)
+    {
+      if (j0 < 0)
+	{
+	  /* return 0 * sign (x) if |x| < 1 */
+	  if (i0 >= 0)
+	    {
+	      i0 = i1 = 0;
 	    }
-	} else if (j0>111) {
-	    if(j0==0x4000) return x+x;	/* inf or NaN */
-	    else return x;		/* x is integral */
-	} else {
-	    i = -1ULL>>(j0-48);
-	    if((i1&i)==0) return x;	/* x is integral */
-	    if(i0<0) {
-		if(j0==48) i0+=1;
-		else {
-		    j = i1+(1LL<<(112-j0));
-		    if(j<i1) i0 +=1 ; 	/* got a carry */
-		    i1=j;
-		}
+	  else if (((i0 & 0x7fffffffffffffffLL) | i1) != 0)
+	    {
+	      i0 = 0xbfff000000000000ULL;
+	      i1 = 0;
 	    }
-	    i1 &= (~i);
 	}
-	SET_LDOUBLE_WORDS64(x,i0,i1);
-	return x;
+      else
+	{
+	  i = (0x0000ffffffffffffULL) >> j0;
+	  if (((i0 & i) | i1) == 0)
+	    return x;		/* x is integral  */
+	  if (i0 < 0)
+	    i0 += (0x0001000000000000LL) >> j0;
+	  i0 &= (~i);
+	  i1 = 0;
+	}
+    }
+  else if (j0 > 111)
+    {
+      if (j0 == 0x4000)
+	return x + x;		/* inf or NaN  */
+      else
+	return x;		/* x is integral  */
+    }
+  else
+    {
+      i = -1ULL >> (j0 - 48);
+      if ((i1 & i) == 0)
+	return x;		/* x is integral  */
+      if (i0 < 0)
+	{
+	  if (j0 == 48)
+	    i0 += 1;
+	  else
+	    {
+	      j = i1 + (1LL << (112 - j0));
+	      if (j < i1)
+		i0 += 1 ;	/* got a carry */
+	      i1 = j;
+	    }
+	}
+      i1 &= (~i);
+    }
+  SET_LDOUBLE_WORDS64 (x, i0, i1);
+  return x;
 #endif /* ! USE_FLOORL_BUILTIN  */
 }
 libm_alias_ldouble (__floor, floor)
-- 
2.19.1

[PATCH v2 14/18] Adjust s_nearbyintf.c and s_nearbyintl.c regarding code style.

[Stefan Liebler]

This patch just adjusts the generic implementation regarding code style.
No functional change.
---
 sysdeps/ieee754/flt-32/s_nearbyintf.c   | 60 ++++++++++++-----------
 sysdeps/ieee754/ldbl-128/s_nearbyintl.c | 63 ++++++++++++++-----------
 2 files changed, 68 insertions(+), 55 deletions(-)

diff --git a/sysdeps/ieee754/flt-32/s_nearbyintf.c b/sysdeps/ieee754/flt-32/s_nearbyintf.c
index b37e003e12..2a79907168 100644
--- a/sysdeps/ieee754/flt-32/s_nearbyintf.c
+++ b/sysdeps/ieee754/flt-32/s_nearbyintf.c
@@ -24,7 +24,7 @@
 #include <math-use-builtins.h>
 
 float
-__nearbyintf(float x)
+__nearbyintf (float x)
 {
 #if USE_NEARBYINTF_BUILTIN
   return __builtin_nearbyintf (x);
@@ -35,33 +35,39 @@ __nearbyintf(float x)
 		8.3886080000e+06, /* 0x4b000000 */
 		-8.3886080000e+06, /* 0xcb000000 */
   };
-	fenv_t env;
-	int32_t i0,j0,sx;
-	float w,t;
-	GET_FLOAT_WORD(i0,x);
-	sx = (i0>>31)&1;
-	j0 = ((i0>>23)&0xff)-0x7f;
-	if(j0<23) {
-	    if(j0<0) {
-		libc_feholdexceptf (&env);
-		w = TWO23[sx] + math_opt_barrier (x);
-		t =  w-TWO23[sx];
-		math_force_eval (t);
-		libc_fesetenvf (&env);
-		GET_FLOAT_WORD(i0,t);
-		SET_FLOAT_WORD(t,(i0&0x7fffffff)|(sx<<31));
-		return t;
-	    }
-	} else {
-	    if(__builtin_expect(j0==0x80, 0)) return x+x;	/* inf or NaN */
-	    else return x;		/* x is integral */
+  fenv_t env;
+  int32_t i0, j0, sx;
+  float w, t;
+  GET_FLOAT_WORD (i0, x);
+  sx = (i0 >> 31) & 1;
+  j0 = ((i0 >> 23) & 0xff) - 0x7f;
+  if (j0 < 23)
+    {
+      if (j0 < 0)
+	{
+	  libc_feholdexceptf (&env);
+	  w = TWO23[sx] + math_opt_barrier (x);
+	  t =  w - TWO23[sx];
+	  math_force_eval (t);
+	  libc_fesetenvf (&env);
+	  GET_FLOAT_WORD (i0, t);
+	  SET_FLOAT_WORD (t, (i0 & 0x7fffffff) | (sx << 31));
+	  return t;
 	}
-	libc_feholdexceptf (&env);
-	w = TWO23[sx] + math_opt_barrier (x);
-	t = w-TWO23[sx];
-	math_force_eval (t);
-	libc_fesetenvf (&env);
-	return t;
+    }
+  else
+    {
+      if (__glibc_unlikely (j0 == 0x80))
+	return x + x;		/* inf or NaN  */
+      else
+	return x;		/* x is integral  */
+  }
+  libc_feholdexceptf (&env);
+  w = TWO23[sx] + math_opt_barrier (x);
+  t = w - TWO23[sx];
+  math_force_eval (t);
+  libc_fesetenvf (&env);
+  return t;
 #endif /* ! USE_NEARBYINT_BUILTIN  */
 }
 libm_alias_float (__nearbyint, nearbyint)
diff --git a/sysdeps/ieee754/ldbl-128/s_nearbyintl.c b/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
index a4ad8e82e5..8d26786f78 100644
--- a/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
+++ b/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
@@ -30,7 +30,8 @@
 #include <libm-alias-ldouble.h>
 #include <math-use-builtins.h>
 
-_Float128 __nearbyintl(_Float128 x)
+_Float128
+__nearbyintl (_Float128 x)
 {
 #if USE_NEARBYINTL_BUILTIN
   return __builtin_nearbyintl (x);
@@ -41,34 +42,40 @@ _Float128 __nearbyintl(_Float128 x)
 		 L(5.19229685853482762853049632922009600E+33), /* 0x406F000000000000, 0 */
 		 L(-5.19229685853482762853049632922009600E+33)  /* 0xC06F000000000000, 0 */
   };
-	fenv_t env;
-	int64_t i0,j0,sx;
-	uint64_t i1 __attribute__ ((unused));
-	_Float128 w,t;
-	GET_LDOUBLE_WORDS64(i0,i1,x);
-	sx = (((uint64_t)i0)>>63);
-	j0 = ((i0>>48)&0x7fff)-0x3fff;
-	if(j0<112) {
-	    if(j0<0) {
-		feholdexcept (&env);
-	        w = TWO112[sx] + math_opt_barrier (x);
-	        t = w-TWO112[sx];
-		math_force_eval (t);
-	        fesetenv (&env);
-		GET_LDOUBLE_MSW64(i0,t);
-		SET_LDOUBLE_MSW64(t,(i0&0x7fffffffffffffffLL)|(sx<<63));
-	        return t;
-	    }
-	} else {
-	    if(j0==0x4000) return x+x;	/* inf or NaN */
-	    else return x;		/* x is integral */
+  fenv_t env;
+  int64_t i0, j0, sx;
+  uint64_t i1 __attribute__ ((unused));
+  _Float128 w, t;
+  GET_LDOUBLE_WORDS64 (i0, i1, x);
+  sx = (((uint64_t) i0) >> 63);
+  j0 = ((i0 >> 48) & 0x7fff) - 0x3fff;
+  if (j0 < 112)
+    {
+      if (j0 < 0)
+	{
+	  feholdexcept (&env);
+	  w = TWO112[sx] + math_opt_barrier (x);
+	  t = w - TWO112[sx];
+	  math_force_eval (t);
+	  fesetenv (&env);
+	  GET_LDOUBLE_MSW64 (i0, t);
+	  SET_LDOUBLE_MSW64 (t, (i0 & 0x7fffffffffffffffLL) | (sx << 63));
+	  return t;
 	}
-	feholdexcept (&env);
-	w = TWO112[sx] + math_opt_barrier (x);
-	t = w-TWO112[sx];
-	math_force_eval (t);
-	fesetenv (&env);
-	return t;
+    }
+  else
+    {
+      if (j0 == 0x4000)
+	return x + x;		/* inf or NaN  */
+      else
+	return x;		/* x is integral  */
+    }
+  feholdexcept (&env);
+  w = TWO112[sx] + math_opt_barrier (x);
+  t = w - TWO112[sx];
+  math_force_eval (t);
+  fesetenv (&env);
+  return t;
 #endif /* ! USE_NEARBYINTL_BUILTIN  */
 }
 libm_alias_ldouble (__nearbyint, nearbyint)
-- 
2.19.1

[PATCH v2 15/18] Adjust s_rintf.c and s_rintl.c regarding code style.

[Stefan Liebler]

This patch just adjusts the generic implementation regarding code style.
No functional change.
---
 sysdeps/ieee754/flt-32/s_rintf.c   | 44 +++++++++++++++------------
 sysdeps/ieee754/ldbl-128/s_rintl.c | 49 +++++++++++++++++-------------
 2 files changed, 53 insertions(+), 40 deletions(-)

diff --git a/sysdeps/ieee754/flt-32/s_rintf.c b/sysdeps/ieee754/flt-32/s_rintf.c
index 34c16ea164..627bada566 100644
--- a/sysdeps/ieee754/flt-32/s_rintf.c
+++ b/sysdeps/ieee754/flt-32/s_rintf.c
@@ -20,7 +20,7 @@
 #include <math-use-builtins.h>
 
 float
-__rintf(float x)
+__rintf (float x)
 {
 #if USE_RINTF_BUILTIN
   return __builtin_rintf (x);
@@ -31,25 +31,31 @@ __rintf(float x)
 		8.3886080000e+06, /* 0x4b000000 */
 		-8.3886080000e+06, /* 0xcb000000 */
   };
-	int32_t i0,j0,sx;
-	float w,t;
-	GET_FLOAT_WORD(i0,x);
-	sx = (i0>>31)&1;
-	j0 = ((i0>>23)&0xff)-0x7f;
-	if(j0<23) {
-	    if(j0<0) {
-		w = TWO23[sx]+x;
-		t =  w-TWO23[sx];
-		GET_FLOAT_WORD(i0,t);
-		SET_FLOAT_WORD(t,(i0&0x7fffffff)|(sx<<31));
-		return t;
-	    }
-	} else {
-	    if(j0==0x80) return x+x;	/* inf or NaN */
-	    else return x;		/* x is integral */
+  int32_t i0, j0, sx;
+  float w, t;
+  GET_FLOAT_WORD (i0, x);
+  sx = (i0 >> 31) & 1;
+  j0 = ((i0 >> 23) & 0xff) - 0x7f;
+  if (j0 < 23)
+    {
+      if(j0 < 0)
+	{
+	  w = TWO23[sx] + x;
+	  t =  w - TWO23[sx];
+	  GET_FLOAT_WORD (i0, t);
+	  SET_FLOAT_WORD (t, (i0 & 0x7fffffff) | (sx << 31));
+	  return t;
 	}
-	w = TWO23[sx]+x;
-	return w-TWO23[sx];
+    }
+  else
+    {
+      if (j0 == 0x80)
+	return x + x;		/* inf or NaN  */
+      else
+	return x;		/* x is integral  */
+    }
+  w = TWO23[sx] + x;
+  return w - TWO23[sx];
 #endif /* ! USE_RINTF_BUILTIN  */
 }
 #ifndef __rintf
diff --git a/sysdeps/ieee754/ldbl-128/s_rintl.c b/sysdeps/ieee754/ldbl-128/s_rintl.c
index 3340c35ee1..16965f9582 100644
--- a/sysdeps/ieee754/ldbl-128/s_rintl.c
+++ b/sysdeps/ieee754/ldbl-128/s_rintl.c
@@ -13,7 +13,7 @@
  * ====================================================
  */
 
-#if defined(LIBM_SCCS) && !defined(lint)
+#if defined (LIBM_SCCS) && ! defined (lint)
 static char rcsid[] = "$NetBSD: $";
 #endif
 
@@ -33,7 +33,8 @@ static char rcsid[] = "$NetBSD: $";
 #include <libm-alias-ldouble.h>
 #include <math-use-builtins.h>
 
-_Float128 __rintl(_Float128 x)
+_Float128
+__rintl (_Float128 x)
 {
 #if USE_RINTL_BUILTIN
   return __builtin_rintl (x);
@@ -44,26 +45,32 @@ _Float128 __rintl(_Float128 x)
 		 5.19229685853482762853049632922009600E+33L, /* 0x406F000000000000, 0 */
 		 -5.19229685853482762853049632922009600E+33L  /* 0xC06F000000000000, 0 */
   };
-	int64_t i0,j0,sx;
-	uint64_t i1 __attribute__ ((unused));
-	_Float128 w,t;
-	GET_LDOUBLE_WORDS64(i0,i1,x);
-	sx = (((uint64_t)i0)>>63);
-	j0 = ((i0>>48)&0x7fff)-0x3fff;
-	if(j0<112) {
-	    if(j0<0) {
-	        w = TWO112[sx]+x;
-	        t = w-TWO112[sx];
-		GET_LDOUBLE_MSW64(i0,t);
-		SET_LDOUBLE_MSW64(t,(i0&0x7fffffffffffffffLL)|(sx<<63));
-	        return t;
-	    }
-	} else {
-	    if(j0==0x4000) return x+x;	/* inf or NaN */
-	    else return x;		/* x is integral */
+  int64_t i0, j0, sx;
+  uint64_t i1 __attribute__ ((unused));
+  _Float128 w, t;
+  GET_LDOUBLE_WORDS64 (i0, i1, x);
+  sx = (((uint64_t) i0) >> 63);
+  j0 = ((i0 >> 48) & 0x7fff) - 0x3fff;
+  if (j0 < 112)
+    {
+      if (j0 < 0)
+	{
+	  w = TWO112[sx] + x;
+	  t = w - TWO112[sx];
+	  GET_LDOUBLE_MSW64 (i0, t);
+	  SET_LDOUBLE_MSW64 (t, (i0 & 0x7fffffffffffffffLL) | (sx << 63));
+	  return t;
 	}
-	w = TWO112[sx]+x;
-	return w-TWO112[sx];
+    }
+  else
+    {
+      if (j0 == 0x4000)
+	return x + x;		/* inf or NaN  */
+      else
+	return x;		/* x is integral  */
+    }
+  w = TWO112[sx] + x;
+  return w - TWO112[sx];
 #endif /* ! USE_RINTL_BUILTIN  */
 }
 libm_alias_ldouble (__rint, rint)
-- 
2.19.1

[PATCH v2 18/18] Adjust s_copysignl.c regarding code style.

[Stefan Liebler]

This patch just adjusts the generic implementation regarding code style.
No functional change.
---
 sysdeps/ieee754/ldbl-128/s_copysignl.c | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/sysdeps/ieee754/ldbl-128/s_copysignl.c b/sysdeps/ieee754/ldbl-128/s_copysignl.c
index 848a184524..a8b0639d2e 100644
--- a/sysdeps/ieee754/ldbl-128/s_copysignl.c
+++ b/sysdeps/ieee754/ldbl-128/s_copysignl.c
@@ -13,7 +13,7 @@
  * ====================================================
  */
 
-#if defined(LIBM_SCCS) && !defined(lint)
+#if defined (LIBM_SCCS) && ! defined (lint)
 static char rcsid[] = "$NetBSD: $";
 #endif
 
@@ -29,18 +29,19 @@ static char rcsid[] = "$NetBSD: $";
 #include <libm-alias-ldouble.h>
 #include <math-use-builtins.h>
 
-_Float128 __copysignl(_Float128 x, _Float128 y)
+_Float128
+__copysignl (_Float128 x, _Float128 y)
 {
 #if USE_COPYSIGNL_BUILTIN
   return __builtin_copysignl (x, y);
 #else
   /* Use generic implementation.  */
-	uint64_t hx,hy;
-	GET_LDOUBLE_MSW64(hx,x);
-	GET_LDOUBLE_MSW64(hy,y);
-	SET_LDOUBLE_MSW64(x,(hx&0x7fffffffffffffffULL)
-			    |(hy&0x8000000000000000ULL));
-        return x;
+  uint64_t hx, hy;
+  GET_LDOUBLE_MSW64 (hx, x);
+  GET_LDOUBLE_MSW64 (hy, y);
+  SET_LDOUBLE_MSW64 (x, (hx & 0x7fffffffffffffffULL)
+		     | (hy & 0x8000000000000000ULL));
+  return x;
 #endif /* ! USE_COPYSIGNL_BUILTIN  */
 }
 libm_alias_ldouble (__copysign, copysign)
-- 
2.19.1

[PATCH v2 17/18] Adjust s_ceilf.c and s_ceill.c regarding code style.

[Stefan Liebler]

This patch just adjusts the generic implementation regarding code style.
No functional change.
---
 sysdeps/ieee754/flt-32/s_ceilf.c   | 54 +++++++++++-------
 sysdeps/ieee754/ldbl-128/s_ceill.c | 91 +++++++++++++++++++-----------
 2 files changed, 92 insertions(+), 53 deletions(-)

diff --git a/sysdeps/ieee754/flt-32/s_ceilf.c b/sysdeps/ieee754/flt-32/s_ceilf.c
index 7d4990f3ff..5c4abfe145 100644
--- a/sysdeps/ieee754/flt-32/s_ceilf.c
+++ b/sysdeps/ieee754/flt-32/s_ceilf.c
@@ -20,34 +20,46 @@
 #include <math-use-builtins.h>
 
 float
-__ceilf(float x)
+__ceilf (float x)
 {
 #if USE_CEILF_BUILTIN
   return __builtin_ceilf (x);
 #else
   /* Use generic implementation.  */
-	int32_t i0,j0;
-	uint32_t i;
+  int32_t i0, j0;
+  uint32_t i;
 
-	GET_FLOAT_WORD(i0,x);
-	j0 = ((i0>>23)&0xff)-0x7f;
-	if(j0<23) {
-	    if(j0<0) {
-		/* return 0*sign(x) if |x|<1 */
-		if(i0<0) {i0=0x80000000;}
-		else if(i0!=0) { i0=0x3f800000;}
-	    } else {
-		i = (0x007fffff)>>j0;
-		if((i0&i)==0) return x; /* x is integral */
-		if(i0>0) i0 += (0x00800000)>>j0;
-		i0 &= (~i);
-	    }
-	} else {
-	    if(__builtin_expect(j0==0x80, 0)) return x+x; /* inf or NaN */
-	    else return x;		/* x is integral */
+  GET_FLOAT_WORD (i0, x);
+  j0 = ((i0 >> 23) & 0xff) - 0x7f;
+  if (j0 < 23)
+    {
+      if (j0 < 0)
+	{
+	  /* return 0 * sign (x) if |x| < 1  */
+	  if (i0 < 0)
+	    i0 = 0x80000000;
+	  else if (i0 != 0)
+	    i0 = 0x3f800000;
 	}
-	SET_FLOAT_WORD(x,i0);
-	return x;
+      else
+	{
+	  i = (0x007fffff) >> j0;
+	  if ((i0 & i) == 0)
+	    return x;		/* x is integral  */
+	  if (i0 > 0)
+	    i0 += (0x00800000) >> j0;
+	  i0 &= (~i);
+	}
+    }
+  else
+    {
+      if (__glibc_unlikely (j0 == 0x80))
+	return x + x;		/* inf or NaN  */
+      else
+	return x;		/* x is integral  */
+    }
+  SET_FLOAT_WORD (x, i0);
+  return x;
 #endif /* ! USE_CEILF_BUILTIN  */
 }
 #ifndef __ceilf
diff --git a/sysdeps/ieee754/ldbl-128/s_ceill.c b/sysdeps/ieee754/ldbl-128/s_ceill.c
index 02ffa7af2b..c5d98e1e37 100644
--- a/sysdeps/ieee754/ldbl-128/s_ceill.c
+++ b/sysdeps/ieee754/ldbl-128/s_ceill.c
@@ -13,7 +13,7 @@
  * ====================================================
  */
 
-#if defined(LIBM_SCCS) && !defined(lint)
+#if defined (LIBM_SCCS) && ! defined (lint)
 static char rcsid[] = "$NetBSD: $";
 #endif
 
@@ -30,45 +30,72 @@ static char rcsid[] = "$NetBSD: $";
 #include <libm-alias-ldouble.h>
 #include <math-use-builtins.h>
 
-_Float128 __ceill(_Float128 x)
+_Float128
+__ceill (_Float128 x)
 {
 #if USE_CEILL_BUILTIN
   return __builtin_ceill (x);
 #else
   /* Use generic implementation.  */
-	int64_t i0,i1,j0;
-	uint64_t i,j;
-	GET_LDOUBLE_WORDS64(i0,i1,x);
-	j0 = ((i0>>48)&0x7fff)-0x3fff;
-	if(j0<48) {
-	    if(j0<0) {
-		/* return 0*sign(x) if |x|<1 */
-		if(i0<0) {i0=0x8000000000000000ULL;i1=0;}
-		else if((i0|i1)!=0) { i0=0x3fff000000000000ULL;i1=0;}
-	    } else {
-		i = (0x0000ffffffffffffULL)>>j0;
-		if(((i0&i)|i1)==0) return x; /* x is integral */
-		if(i0>0) i0 += (0x0001000000000000LL)>>j0;
-		i0 &= (~i); i1=0;
+  int64_t i0, i1, j0;
+  uint64_t i, j;
+  GET_LDOUBLE_WORDS64 (i0, i1, x);
+  j0 = ((i0 >> 48) & 0x7fff) - 0x3fff;
+  if (j0 < 48)
+    {
+      if (j0 < 0)
+	{
+	  /* return 0 * sign (x) if |x| < 1  */
+	  if (i0 < 0)
+	    {
+	      i0 = 0x8000000000000000ULL;
+	      i1 = 0;
 	    }
-	} else if (j0>111) {
-	    if(j0==0x4000) return x+x;	/* inf or NaN */
-	    else return x;		/* x is integral */
-	} else {
-	    i = -1ULL>>(j0-48);
-	    if((i1&i)==0) return x;	/* x is integral */
-	    if(i0>0) {
-		if(j0==48) i0+=1;
-		else {
-		    j = i1+(1LL<<(112-j0));
-		    if(j<i1) i0 +=1 ; 	/* got a carry */
-		    i1=j;
-		}
+	  else if ((i0 | i1) != 0)
+	    {
+	      i0 = 0x3fff000000000000ULL;
+	      i1 = 0;
 	    }
-	    i1 &= (~i);
 	}
-	SET_LDOUBLE_WORDS64(x,i0,i1);
-	return x;
+      else
+	{
+	  i = (0x0000ffffffffffffULL) >> j0;
+	  if (((i0 & i) | i1) == 0)
+	    return x;		/* x is integral  */
+	  if (i0 > 0)
+	    i0 += (0x0001000000000000LL) >> j0;
+	  i0 &= (~i);
+	  i1 = 0;
+	}
+    }
+  else if (j0 > 111)
+    {
+      if (j0 == 0x4000)
+	return x + x;		/* inf or NaN  */
+      else
+	return x;		/* x is integral  */
+    }
+  else
+    {
+      i = -1ULL >> (j0 - 48);
+      if ((i1 & i) == 0)
+	return x;		/* x is integral  */
+      if (i0 > 0)
+	{
+	  if (j0 == 48)
+	    i0 += 1;
+	  else
+	    {
+	      j = i1 + (1LL << (112 - j0));
+	      if (j < i1)
+		i0 += 1;	/* got a carry  */
+	      i1 = j;
+	    }
+	}
+      i1 &= (~i);
+    }
+  SET_LDOUBLE_WORDS64 (x, i0, i1);
+  return x;
 #endif /* ! USE_CEILL_BUILTIN  */
 }
 libm_alias_ldouble (__ceil, ceil)
-- 
2.19.1

Re: [PATCH v2 08/18] Use GCC builtins for rint functions if desired.

[Adhemerval Zanella]

On 09/12/2019 09:45, Stefan Liebler wrote:
> This patch is using the corresponding GCC builtin for rintf, rint,
> rintl and rintf128 if the USE_FUNCTION_BUILTIN macros are defined to one
> in math-use-builtins.h.
> 
> This is the case for s390 if build with at least --march=z196 --mzarch.
> Otherwise the generic implementation is used.  The code of the generic
> implementation is not changed.

LGTM, thanks.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

> ---
>  sysdeps/generic/math-use-builtins.h         |  5 +++++
>  sysdeps/ieee754/dbl-64/s_rint.c             | 17 +++++++++++------
>  sysdeps/ieee754/float128/float128_private.h |  3 +++
>  sysdeps/ieee754/flt-32/s_rintf.c            | 17 +++++++++++------
>  sysdeps/ieee754/ldbl-128/s_rintl.c          | 17 +++++++++++------
>  sysdeps/s390/fpu/math-use-builtins.h        | 11 +++++++++++
>  6 files changed, 52 insertions(+), 18 deletions(-)
> 
> diff --git a/sysdeps/generic/math-use-builtins.h b/sysdeps/generic/math-use-builtins.h
> index e12490ed41..64b4a4bb5b 100644
> --- a/sysdeps/generic/math-use-builtins.h
> +++ b/sysdeps/generic/math-use-builtins.h
> @@ -26,4 +26,9 @@
>  #define USE_NEARBYINTL_BUILTIN 0
>  #define USE_NEARBYINTF128_BUILTIN 0
>  
> +#define USE_RINT_BUILTIN 0
> +#define USE_RINTF_BUILTIN 0
> +#define USE_RINTL_BUILTIN 0
> +#define USE_RINTF128_BUILTIN 0
> +
>  #endif /* math-use-builtins.h */

Ok.

> diff --git a/sysdeps/ieee754/dbl-64/s_rint.c b/sysdeps/ieee754/dbl-64/s_rint.c
> index 66c9196473..8604733ef9 100644
> --- a/sysdeps/ieee754/dbl-64/s_rint.c
> +++ b/sysdeps/ieee754/dbl-64/s_rint.c
> @@ -23,16 +23,20 @@
>  #include <math.h>
>  #include <math_private.h>
>  #include <libm-alias-double.h>
> -
> -static const double
> -TWO52[2] = {
> -	    4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
> -	    -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
> -};
> +#include <math-use-builtins.h>
>  
>  double
>  __rint (double x)
>  {
> +#if USE_RINT_BUILTIN
> +  return __builtin_rint (x);
> +#else
> +  /* Use generic implementation.  */
> +  static const double
> +    TWO52[2] = {
> +		4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
> +		-4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
> +  };
>    int64_t i0, sx;
>    int32_t j0;
>    EXTRACT_WORDS64 (i0, x);
> @@ -59,6 +63,7 @@ __rint (double x)
>      }
>    double w = TWO52[sx] + x;
>    return w - TWO52[sx];
> +#endif /* ! USE_RINT_BUILTIN  */
>  }
>  #ifndef __rint
>  libm_alias_double (__rint, rint)

Ok.

> diff --git a/sysdeps/ieee754/float128/float128_private.h b/sysdeps/ieee754/float128/float128_private.h
> index e96986a968..f458e7b85f 100644
> --- a/sysdeps/ieee754/float128/float128_private.h
> +++ b/sysdeps/ieee754/float128/float128_private.h
> @@ -142,6 +142,8 @@
>  #include <math-use-builtins.h>
>  #undef USE_NEARBYINTL_BUILTIN
>  #define USE_NEARBYINTL_BUILTIN USE_NEARBYINTF128_BUILTIN
> +#undef USE_RINTL_BUILTIN
> +#define USE_RINTL_BUILTIN USE_RINTF128_BUILTIN
>  
>  /* IEEE function renames.  */
>  #define __ieee754_acoshl __ieee754_acoshf128
> @@ -346,6 +348,7 @@
>  #define __builtin_copysignl __builtin_copysignf128
>  #define __builtin_signbitl __builtin_signbit
>  #define __builtin_nearbyintl __builtin_nearbyintf128
> +#define __builtin_rintl __builtin_rintf128
>  
>  /* Get the constant suffix from bits/floatn-compat.h.  */
>  #define L(x) __f128 (x)

Ok.

> diff --git a/sysdeps/ieee754/flt-32/s_rintf.c b/sysdeps/ieee754/flt-32/s_rintf.c
> index 0306dc21f4..34c16ea164 100644
> --- a/sysdeps/ieee754/flt-32/s_rintf.c
> +++ b/sysdeps/ieee754/flt-32/s_rintf.c
> @@ -17,16 +17,20 @@
>  #include <math.h>
>  #include <math_private.h>
>  #include <libm-alias-float.h>
> -
> -static const float
> -TWO23[2]={
> -  8.3886080000e+06, /* 0x4b000000 */
> - -8.3886080000e+06, /* 0xcb000000 */
> -};
> +#include <math-use-builtins.h>
>  
>  float
>  __rintf(float x)
>  {
> +#if USE_RINTF_BUILTIN
> +  return __builtin_rintf (x);
> +#else
> +  /* Use generic implementation.  */
> +  static const float
> +    TWO23[2] = {
> +		8.3886080000e+06, /* 0x4b000000 */
> +		-8.3886080000e+06, /* 0xcb000000 */
> +  };
>  	int32_t i0,j0,sx;
>  	float w,t;
>  	GET_FLOAT_WORD(i0,x);
> @@ -46,6 +50,7 @@ __rintf(float x)
>  	}
>  	w = TWO23[sx]+x;
>  	return w-TWO23[sx];
> +#endif /* ! USE_RINTF_BUILTIN  */
>  }
>  #ifndef __rintf
>  libm_alias_float (__rint, rint)

Ok.

> diff --git a/sysdeps/ieee754/ldbl-128/s_rintl.c b/sysdeps/ieee754/ldbl-128/s_rintl.c
> index b6337e1d8a..3340c35ee1 100644
> --- a/sysdeps/ieee754/ldbl-128/s_rintl.c
> +++ b/sysdeps/ieee754/ldbl-128/s_rintl.c
> @@ -31,15 +31,19 @@ static char rcsid[] = "$NetBSD: $";
>  #include <math.h>
>  #include <math_private.h>
>  #include <libm-alias-ldouble.h>
> -
> -static const _Float128
> -TWO112[2]={
> -  5.19229685853482762853049632922009600E+33L, /* 0x406F000000000000, 0 */
> - -5.19229685853482762853049632922009600E+33L  /* 0xC06F000000000000, 0 */
> -};
> +#include <math-use-builtins.h>
>  
>  _Float128 __rintl(_Float128 x)
>  {
> +#if USE_RINTL_BUILTIN
> +  return __builtin_rintl (x);
> +#else
> +  /* Use generic implementation.  */
> +  static const _Float128
> +    TWO112[2] = {
> +		 5.19229685853482762853049632922009600E+33L, /* 0x406F000000000000, 0 */
> +		 -5.19229685853482762853049632922009600E+33L  /* 0xC06F000000000000, 0 */
> +  };
>  	int64_t i0,j0,sx;
>  	uint64_t i1 __attribute__ ((unused));
>  	_Float128 w,t;
> @@ -60,5 +64,6 @@ _Float128 __rintl(_Float128 x)
>  	}
>  	w = TWO112[sx]+x;
>  	return w-TWO112[sx];
> +#endif /* ! USE_RINTL_BUILTIN  */
>  }
>  libm_alias_ldouble (__rint, rint)

Ok.

> diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
> index 7abbfb3b50..8b702a6a90 100644
> --- a/sysdeps/s390/fpu/math-use-builtins.h
> +++ b/sysdeps/s390/fpu/math-use-builtins.h
> @@ -30,10 +30,16 @@
>  # define USE_NEARBYINTF_BUILTIN 1
>  # define USE_NEARBYINTL_BUILTIN 1
>  
> +# define USE_RINT_BUILTIN 1
> +# define USE_RINTF_BUILTIN 1
> +# define USE_RINTL_BUILTIN 1
> +
>  # if __GNUC_PREREQ (8, 0)
>  #  define USE_NEARBYINTF128_BUILTIN 1
> +#  define USE_RINTF128_BUILTIN 1
>  # else
>  #  define USE_NEARBYINTF128_BUILTIN 0
> +#  define USE_RINTF128_BUILTIN 0
>  # endif
>  
>  #else
> @@ -44,6 +50,11 @@
>  # define USE_NEARBYINTL_BUILTIN 0
>  # define USE_NEARBYINTF128_BUILTIN 0
>  
> +# define USE_RINT_BUILTIN 0
> +# define USE_RINTF_BUILTIN 0
> +# define USE_RINTL_BUILTIN 0
> +# define USE_RINTF128_BUILTIN 0
> +
>  #endif /* ! HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT  */
>  
>  #endif /* math-use-builtins.h */
> 

Ok.

Re: [PATCH v2 17/18] Adjust s_ceilf.c and s_ceill.c regarding code style.

[Adhemerval Zanella]

On 09/12/2019 09:46, Stefan Liebler wrote:
> This patch just adjusts the generic implementation regarding code style.
> No functional change.

LGTM, thanks.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

> ---
>  sysdeps/ieee754/flt-32/s_ceilf.c   | 54 +++++++++++-------
>  sysdeps/ieee754/ldbl-128/s_ceill.c | 91 +++++++++++++++++++-----------
>  2 files changed, 92 insertions(+), 53 deletions(-)
> 
> diff --git a/sysdeps/ieee754/flt-32/s_ceilf.c b/sysdeps/ieee754/flt-32/s_ceilf.c
> index 7d4990f3ff..5c4abfe145 100644
> --- a/sysdeps/ieee754/flt-32/s_ceilf.c
> +++ b/sysdeps/ieee754/flt-32/s_ceilf.c
> @@ -20,34 +20,46 @@
>  #include <math-use-builtins.h>
>  
>  float
> -__ceilf(float x)
> +__ceilf (float x)
>  {
>  #if USE_CEILF_BUILTIN
>    return __builtin_ceilf (x);
>  #else
>    /* Use generic implementation.  */
> -	int32_t i0,j0;
> -	uint32_t i;
> +  int32_t i0, j0;
> +  uint32_t i;
>  
> -	GET_FLOAT_WORD(i0,x);
> -	j0 = ((i0>>23)&0xff)-0x7f;
> -	if(j0<23) {
> -	    if(j0<0) {
> -		/* return 0*sign(x) if |x|<1 */
> -		if(i0<0) {i0=0x80000000;}
> -		else if(i0!=0) { i0=0x3f800000;}
> -	    } else {
> -		i = (0x007fffff)>>j0;
> -		if((i0&i)==0) return x; /* x is integral */
> -		if(i0>0) i0 += (0x00800000)>>j0;
> -		i0 &= (~i);
> -	    }
> -	} else {
> -	    if(__builtin_expect(j0==0x80, 0)) return x+x; /* inf or NaN */
> -	    else return x;		/* x is integral */
> +  GET_FLOAT_WORD (i0, x);
> +  j0 = ((i0 >> 23) & 0xff) - 0x7f;
> +  if (j0 < 23)
> +    {
> +      if (j0 < 0)
> +	{
> +	  /* return 0 * sign (x) if |x| < 1  */
> +	  if (i0 < 0)
> +	    i0 = 0x80000000;
> +	  else if (i0 != 0)
> +	    i0 = 0x3f800000;
>  	}
> -	SET_FLOAT_WORD(x,i0);
> -	return x;
> +      else
> +	{
> +	  i = (0x007fffff) >> j0;
> +	  if ((i0 & i) == 0)
> +	    return x;		/* x is integral  */
> +	  if (i0 > 0)
> +	    i0 += (0x00800000) >> j0;
> +	  i0 &= (~i);
> +	}
> +    }
> +  else
> +    {
> +      if (__glibc_unlikely (j0 == 0x80))
> +	return x + x;		/* inf or NaN  */
> +      else
> +	return x;		/* x is integral  */
> +    }
> +  SET_FLOAT_WORD (x, i0);
> +  return x;
>  #endif /* ! USE_CEILF_BUILTIN  */
>  }
>  #ifndef __ceilf

Ok.

> diff --git a/sysdeps/ieee754/ldbl-128/s_ceill.c b/sysdeps/ieee754/ldbl-128/s_ceill.c
> index 02ffa7af2b..c5d98e1e37 100644
> --- a/sysdeps/ieee754/ldbl-128/s_ceill.c
> +++ b/sysdeps/ieee754/ldbl-128/s_ceill.c
> @@ -13,7 +13,7 @@
>   * ====================================================
>   */
>  
> -#if defined(LIBM_SCCS) && !defined(lint)
> +#if defined (LIBM_SCCS) && ! defined (lint)
>  static char rcsid[] = "$NetBSD: $";
>  #endif
>  
> @@ -30,45 +30,72 @@ static char rcsid[] = "$NetBSD: $";
>  #include <libm-alias-ldouble.h>
>  #include <math-use-builtins.h>
>  
> -_Float128 __ceill(_Float128 x)
> +_Float128
> +__ceill (_Float128 x)
>  {
>  #if USE_CEILL_BUILTIN
>    return __builtin_ceill (x);
>  #else
>    /* Use generic implementation.  */
> -	int64_t i0,i1,j0;
> -	uint64_t i,j;
> -	GET_LDOUBLE_WORDS64(i0,i1,x);
> -	j0 = ((i0>>48)&0x7fff)-0x3fff;
> -	if(j0<48) {
> -	    if(j0<0) {
> -		/* return 0*sign(x) if |x|<1 */
> -		if(i0<0) {i0=0x8000000000000000ULL;i1=0;}
> -		else if((i0|i1)!=0) { i0=0x3fff000000000000ULL;i1=0;}
> -	    } else {
> -		i = (0x0000ffffffffffffULL)>>j0;
> -		if(((i0&i)|i1)==0) return x; /* x is integral */
> -		if(i0>0) i0 += (0x0001000000000000LL)>>j0;
> -		i0 &= (~i); i1=0;
> +  int64_t i0, i1, j0;
> +  uint64_t i, j;
> +  GET_LDOUBLE_WORDS64 (i0, i1, x);
> +  j0 = ((i0 >> 48) & 0x7fff) - 0x3fff;
> +  if (j0 < 48)
> +    {
> +      if (j0 < 0)
> +	{
> +	  /* return 0 * sign (x) if |x| < 1  */
> +	  if (i0 < 0)
> +	    {
> +	      i0 = 0x8000000000000000ULL;
> +	      i1 = 0;
>  	    }
> -	} else if (j0>111) {
> -	    if(j0==0x4000) return x+x;	/* inf or NaN */
> -	    else return x;		/* x is integral */
> -	} else {
> -	    i = -1ULL>>(j0-48);
> -	    if((i1&i)==0) return x;	/* x is integral */
> -	    if(i0>0) {
> -		if(j0==48) i0+=1;
> -		else {
> -		    j = i1+(1LL<<(112-j0));
> -		    if(j<i1) i0 +=1 ; 	/* got a carry */
> -		    i1=j;
> -		}
> +	  else if ((i0 | i1) != 0)
> +	    {
> +	      i0 = 0x3fff000000000000ULL;
> +	      i1 = 0;
>  	    }
> -	    i1 &= (~i);
>  	}
> -	SET_LDOUBLE_WORDS64(x,i0,i1);
> -	return x;
> +      else
> +	{
> +	  i = (0x0000ffffffffffffULL) >> j0;
> +	  if (((i0 & i) | i1) == 0)
> +	    return x;		/* x is integral  */
> +	  if (i0 > 0)
> +	    i0 += (0x0001000000000000LL) >> j0;
> +	  i0 &= (~i);
> +	  i1 = 0;
> +	}
> +    }
> +  else if (j0 > 111)
> +    {
> +      if (j0 == 0x4000)
> +	return x + x;		/* inf or NaN  */
> +      else
> +	return x;		/* x is integral  */
> +    }
> +  else
> +    {
> +      i = -1ULL >> (j0 - 48);
> +      if ((i1 & i) == 0)
> +	return x;		/* x is integral  */
> +      if (i0 > 0)
> +	{
> +	  if (j0 == 48)
> +	    i0 += 1;
> +	  else
> +	    {
> +	      j = i1 + (1LL << (112 - j0));
> +	      if (j < i1)
> +		i0 += 1;	/* got a carry  */
> +	      i1 = j;
> +	    }
> +	}
> +      i1 &= (~i);
> +    }
> +  SET_LDOUBLE_WORDS64 (x, i0, i1);
> +  return x;
>  #endif /* ! USE_CEILL_BUILTIN  */
>  }
>  libm_alias_ldouble (__ceil, ceil)
> 

Ok.

Re: [PATCH v2 09/18] Use GCC builtins for floor functions if desired.

[Adhemerval Zanella]

On 09/12/2019 09:45, Stefan Liebler wrote:
> This patch is using the corresponding GCC builtin for floorf, floor,
> floorl and floorf128 if the USE_FUNCTION_BUILTIN macros are defined to one
> in math-use-builtins.h.
> 
> This is the case for s390 if build with at least --march=z196 --mzarch.
> Otherwise the generic implementation is used.  The code of the generic
> implementation is not changed.

LGTM, thanks.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

> ---
>  sysdeps/generic/math-use-builtins.h         |  5 +++++
>  sysdeps/ieee754/dbl-64/s_floor.c            |  6 ++++++
>  sysdeps/ieee754/float128/float128_private.h |  3 +++
>  sysdeps/ieee754/flt-32/s_floorf.c           |  6 ++++++
>  sysdeps/ieee754/ldbl-128/s_floorl.c         |  6 ++++++
>  sysdeps/s390/fpu/math-use-builtins.h        | 11 +++++++++++
>  6 files changed, 37 insertions(+)
> 
> diff --git a/sysdeps/generic/math-use-builtins.h b/sysdeps/generic/math-use-builtins.h
> index 64b4a4bb5b..e1c5df62e4 100644
> --- a/sysdeps/generic/math-use-builtins.h
> +++ b/sysdeps/generic/math-use-builtins.h
> @@ -31,4 +31,9 @@
>  #define USE_RINTL_BUILTIN 0
>  #define USE_RINTF128_BUILTIN 0
>  
> +#define USE_FLOOR_BUILTIN 0
> +#define USE_FLOORF_BUILTIN 0
> +#define USE_FLOORL_BUILTIN 0
> +#define USE_FLOORF128_BUILTIN 0
> +
>  #endif /* math-use-builtins.h */

Ok.

> diff --git a/sysdeps/ieee754/dbl-64/s_floor.c b/sysdeps/ieee754/dbl-64/s_floor.c
> index ce0c42bdb6..78325214f4 100644
> --- a/sysdeps/ieee754/dbl-64/s_floor.c
> +++ b/sysdeps/ieee754/dbl-64/s_floor.c
> @@ -35,6 +35,7 @@
>  #include <math_private.h>
>  #include <stdint.h>
>  #include <libm-alias-double.h>
> +#include <math-use-builtins.h>
>  
>  /*
>   * floor(x)
> @@ -47,6 +48,10 @@
>  double
>  __floor (double x)
>  {
> +#if USE_FLOOR_BUILTIN
> +  return __builtin_floor (x);
> +#else
> +  /* Use generic implementation.  */
>    int64_t i0;
>    EXTRACT_WORDS64 (i0, x);
>    int32_t j0 = ((i0 >> 52) & 0x7ff) - 0x3ff;
> @@ -74,6 +79,7 @@ __floor (double x)
>    else if (j0 == 0x400)
>      return x + x;			/* inf or NaN */
>    return x;
> +#endif /* ! USE_FLOOR_BUILTIN  */
>  }
>  #ifndef __floor
>  libm_alias_double (__floor, floor)

Ok.

> diff --git a/sysdeps/ieee754/float128/float128_private.h b/sysdeps/ieee754/float128/float128_private.h
> index f458e7b85f..8c8a74a12c 100644
> --- a/sysdeps/ieee754/float128/float128_private.h
> +++ b/sysdeps/ieee754/float128/float128_private.h
> @@ -144,6 +144,8 @@
>  #define USE_NEARBYINTL_BUILTIN USE_NEARBYINTF128_BUILTIN
>  #undef USE_RINTL_BUILTIN
>  #define USE_RINTL_BUILTIN USE_RINTF128_BUILTIN
> +#undef USE_FLOORL_BUILTIN
> +#define USE_FLOORL_BUILTIN USE_FLOORF128_BUILTIN
>  
>  /* IEEE function renames.  */
>  #define __ieee754_acoshl __ieee754_acoshf128
> @@ -349,6 +351,7 @@
>  #define __builtin_signbitl __builtin_signbit
>  #define __builtin_nearbyintl __builtin_nearbyintf128
>  #define __builtin_rintl __builtin_rintf128
> +#define __builtin_floorl __builtin_floorf128
>  
>  /* Get the constant suffix from bits/floatn-compat.h.  */
>  #define L(x) __f128 (x)

Ok.

> diff --git a/sysdeps/ieee754/flt-32/s_floorf.c b/sysdeps/ieee754/flt-32/s_floorf.c
> index b34d967f01..afe02a1693 100644
> --- a/sysdeps/ieee754/flt-32/s_floorf.c
> +++ b/sysdeps/ieee754/flt-32/s_floorf.c
> @@ -24,10 +24,15 @@
>  #include <math.h>
>  #include <math_private.h>
>  #include <libm-alias-float.h>
> +#include <math-use-builtins.h>
>  
>  float
>  __floorf(float x)
>  {
> +#if USE_FLOORF_BUILTIN
> +  return __builtin_floorf (x);
> +#else
> +  /* Use generic implementation.  */
>  	int32_t i0,j0;
>  	uint32_t i;
>  	GET_FLOAT_WORD(i0,x);
> @@ -50,6 +55,7 @@ __floorf(float x)
>  	}
>  	SET_FLOAT_WORD(x,i0);
>  	return x;
> +#endif /* ! USE_FLOORF_BUILTIN  */
>  }
>  #ifndef __floorf
>  libm_alias_float (__floor, floor)

Ok.

> diff --git a/sysdeps/ieee754/ldbl-128/s_floorl.c b/sysdeps/ieee754/ldbl-128/s_floorl.c
> index f340a3fbca..cfe008392a 100644
> --- a/sysdeps/ieee754/ldbl-128/s_floorl.c
> +++ b/sysdeps/ieee754/ldbl-128/s_floorl.c
> @@ -28,9 +28,14 @@ static char rcsid[] = "$NetBSD: $";
>  #include <math.h>
>  #include <math_private.h>
>  #include <libm-alias-ldouble.h>
> +#include <math-use-builtins.h>
>  
>  _Float128 __floorl(_Float128 x)
>  {
> +#if USE_FLOORL_BUILTIN
> +  return __builtin_floorl (x);
> +#else
> +  /* Use generic implementation.  */
>  	int64_t i0,i1,j0;
>  	uint64_t i,j;
>  	GET_LDOUBLE_WORDS64(i0,i1,x);
> @@ -65,5 +70,6 @@ _Float128 __floorl(_Float128 x)
>  	}
>  	SET_LDOUBLE_WORDS64(x,i0,i1);
>  	return x;
> +#endif /* ! USE_FLOORL_BUILTIN  */
>  }
>  libm_alias_ldouble (__floor, floor)

Ok.

> diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
> index 8b702a6a90..c213c16c6f 100644
> --- a/sysdeps/s390/fpu/math-use-builtins.h
> +++ b/sysdeps/s390/fpu/math-use-builtins.h
> @@ -34,12 +34,18 @@
>  # define USE_RINTF_BUILTIN 1
>  # define USE_RINTL_BUILTIN 1
>  
> +# define USE_FLOOR_BUILTIN 1
> +# define USE_FLOORF_BUILTIN 1
> +# define USE_FLOORL_BUILTIN 1
> +
>  # if __GNUC_PREREQ (8, 0)
>  #  define USE_NEARBYINTF128_BUILTIN 1
>  #  define USE_RINTF128_BUILTIN 1
> +#  define USE_FLOORF128_BUILTIN 1
>  # else
>  #  define USE_NEARBYINTF128_BUILTIN 0
>  #  define USE_RINTF128_BUILTIN 0
> +#  define USE_FLOORF128_BUILTIN 0
>  # endif
>  
>  #else
> @@ -55,6 +61,11 @@
>  # define USE_RINTL_BUILTIN 0
>  # define USE_RINTF128_BUILTIN 0
>  
> +# define USE_FLOOR_BUILTIN 0
> +# define USE_FLOORF_BUILTIN 0
> +# define USE_FLOORL_BUILTIN 0
> +# define USE_FLOORF128_BUILTIN 0
> +
>  #endif /* ! HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT  */
>  
>  #endif /* math-use-builtins.h */
> 

Ok.

Re: [PATCH v2 11/18] Use GCC builtins for trunc functions if desired.

[Adhemerval Zanella]

On 09/12/2019 09:46, Stefan Liebler wrote:
> This patch is using the corresponding GCC builtin for truncf, trunc,
> truncl and truncf128 if the USE_FUNCTION_BUILTIN macros are defined to one
> in math-use-builtins.h.
> 
> This is the case for s390 if build with at least --march=z196 --mzarch.
> Otherwise the generic implementation is used.  The code of the generic
> implementation is not changed.

LGTM, thanks.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

> ---
>  sysdeps/generic/math-use-builtins.h         |  5 +++++
>  sysdeps/ieee754/dbl-64/s_trunc.c            |  6 ++++++
>  sysdeps/ieee754/float128/float128_private.h |  3 +++
>  sysdeps/ieee754/flt-32/s_truncf.c           |  6 ++++++
>  sysdeps/ieee754/ldbl-128/s_truncl.c         |  6 ++++++
>  sysdeps/s390/fpu/math-use-builtins.h        | 11 +++++++++++
>  6 files changed, 37 insertions(+)
> 
> diff --git a/sysdeps/generic/math-use-builtins.h b/sysdeps/generic/math-use-builtins.h
> index 076ec661b0..ab379f45ba 100644
> --- a/sysdeps/generic/math-use-builtins.h
> +++ b/sysdeps/generic/math-use-builtins.h
> @@ -41,4 +41,9 @@
>  #define USE_CEILL_BUILTIN 0
>  #define USE_CEILF128_BUILTIN 0
>  
> +#define USE_TRUNC_BUILTIN 0
> +#define USE_TRUNCF_BUILTIN 0
> +#define USE_TRUNCL_BUILTIN 0
> +#define USE_TRUNCF128_BUILTIN 0
> +
>  #endif /* math-use-builtins.h */

OK.

> diff --git a/sysdeps/ieee754/dbl-64/s_trunc.c b/sysdeps/ieee754/dbl-64/s_trunc.c
> index 0de68ce298..c3129fea7b 100644
> --- a/sysdeps/ieee754/dbl-64/s_trunc.c
> +++ b/sysdeps/ieee754/dbl-64/s_trunc.c
> @@ -22,11 +22,16 @@
>  
>  #include <math_private.h>
>  #include <libm-alias-double.h>
> +#include <math-use-builtins.h>
>  
>  
>  double
>  __trunc (double x)
>  {
> +#if USE_TRUNC_BUILTIN
> +  return __builtin_trunc (x);
> +#else
> +  /* Use generic implementation.  */
>    int64_t i0, j0;
>    int64_t sx;
>  
> @@ -49,6 +54,7 @@ __trunc (double x)
>      }
>  
>    return x;
> +#endif /* ! USE_TRUNC_BUILTIN  */
>  }
>  #ifndef __trunc
>  libm_alias_double (__trunc, trunc)

Ok.

> diff --git a/sysdeps/ieee754/float128/float128_private.h b/sysdeps/ieee754/float128/float128_private.h
> index 01881b574a..9cd3a63f11 100644
> --- a/sysdeps/ieee754/float128/float128_private.h
> +++ b/sysdeps/ieee754/float128/float128_private.h
> @@ -148,6 +148,8 @@
>  #define USE_FLOORL_BUILTIN USE_FLOORF128_BUILTIN
>  #undef USE_CEILL_BUILTIN
>  #define USE_CEILL_BUILTIN USE_CEILF128_BUILTIN
> +#undef USE_TRUNCL_BUILTIN
> +#define USE_TRUNCL_BUILTIN USE_TRUNCF128_BUILTIN
>  
>  /* IEEE function renames.  */
>  #define __ieee754_acoshl __ieee754_acoshf128
> @@ -355,6 +357,7 @@
>  #define __builtin_rintl __builtin_rintf128
>  #define __builtin_floorl __builtin_floorf128
>  #define __builtin_ceill __builtin_ceilf128
> +#define __builtin_truncl __builtin_truncf128
>  
>  /* Get the constant suffix from bits/floatn-compat.h.  */
>  #define L(x) __f128 (x)

Ok.

> diff --git a/sysdeps/ieee754/flt-32/s_truncf.c b/sysdeps/ieee754/flt-32/s_truncf.c
> index e587706b5b..274638820e 100644
> --- a/sysdeps/ieee754/flt-32/s_truncf.c
> +++ b/sysdeps/ieee754/flt-32/s_truncf.c
> @@ -22,11 +22,16 @@
>  
>  #include <math_private.h>
>  #include <libm-alias-float.h>
> +#include <math-use-builtins.h>
>  
>  
>  float
>  __truncf (float x)
>  {
> +#if USE_TRUNCF_BUILTIN
> +  return __builtin_truncf (x);
> +#else
> +  /* Use generic implementation.  */
>    int32_t i0, j0;
>    int sx;
>  
> @@ -49,6 +54,7 @@ __truncf (float x)
>      }
>  
>    return x;
> +#endif /* ! USE_TRUNCF_BUILTIN  */
>  }
>  #ifndef __truncf
>  libm_alias_float (__trunc, trunc)

Ok.

> diff --git a/sysdeps/ieee754/ldbl-128/s_truncl.c b/sysdeps/ieee754/ldbl-128/s_truncl.c
> index de4dd34d59..d11ab937e2 100644
> --- a/sysdeps/ieee754/ldbl-128/s_truncl.c
> +++ b/sysdeps/ieee754/ldbl-128/s_truncl.c
> @@ -23,11 +23,16 @@
>  
>  #include <math_private.h>
>  #include <libm-alias-ldouble.h>
> +#include <math-use-builtins.h>
>  
>  
>  _Float128
>  __truncl (_Float128 x)
>  {
> +#if USE_TRUNCL_BUILTIN
> +  return __builtin_truncl (x);
> +#else
> +  /* Use generic implementation.  */
>    int32_t j0;
>    uint64_t i0, i1, sx;
>  
> @@ -54,5 +59,6 @@ __truncl (_Float128 x)
>      }
>  
>    return x;
> +#endif /* ! USE_TRUNCL_BUILTIN  */
>  }
>  libm_alias_ldouble (__trunc, trunc)

Ok.

> diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
> index 5435cbb65f..a39715c612 100644
> --- a/sysdeps/s390/fpu/math-use-builtins.h
> +++ b/sysdeps/s390/fpu/math-use-builtins.h
> @@ -42,16 +42,22 @@
>  # define USE_CEILF_BUILTIN 1
>  # define USE_CEILL_BUILTIN 1
>  
> +# define USE_TRUNC_BUILTIN 1
> +# define USE_TRUNCF_BUILTIN 1
> +# define USE_TRUNCL_BUILTIN 1
> +
>  # if __GNUC_PREREQ (8, 0)
>  #  define USE_NEARBYINTF128_BUILTIN 1
>  #  define USE_RINTF128_BUILTIN 1
>  #  define USE_FLOORF128_BUILTIN 1
>  #  define USE_CEILF128_BUILTIN 1
> +#  define USE_TRUNCF128_BUILTIN 1
>  # else
>  #  define USE_NEARBYINTF128_BUILTIN 0
>  #  define USE_RINTF128_BUILTIN 0
>  #  define USE_FLOORF128_BUILTIN 0
>  #  define USE_CEILF128_BUILTIN 0
> +#  define USE_TRUNCF128_BUILTIN 0
>  # endif
>  
>  #else
> @@ -77,6 +83,11 @@
>  # define USE_CEILL_BUILTIN 0
>  # define USE_CEILF128_BUILTIN 0
>  
> +# define USE_TRUNC_BUILTIN 0
> +# define USE_TRUNCF_BUILTIN 0
> +# define USE_TRUNCL_BUILTIN 0
> +# define USE_TRUNCF128_BUILTIN 0
> +
>  #endif /* ! HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT  */
>  
>  #endif /* math-use-builtins.h */
> 

Ok.

Re: [PATCH v2 15/18] Adjust s_rintf.c and s_rintl.c regarding code style.

[Adhemerval Zanella]

On 09/12/2019 09:46, Stefan Liebler wrote:
> This patch just adjusts the generic implementation regarding code style.
> No functional change.

LGTM, thanks.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

> ---
>  sysdeps/ieee754/flt-32/s_rintf.c   | 44 +++++++++++++++------------
>  sysdeps/ieee754/ldbl-128/s_rintl.c | 49 +++++++++++++++++-------------
>  2 files changed, 53 insertions(+), 40 deletions(-)
> 
> diff --git a/sysdeps/ieee754/flt-32/s_rintf.c b/sysdeps/ieee754/flt-32/s_rintf.c
> index 34c16ea164..627bada566 100644
> --- a/sysdeps/ieee754/flt-32/s_rintf.c
> +++ b/sysdeps/ieee754/flt-32/s_rintf.c
> @@ -20,7 +20,7 @@
>  #include <math-use-builtins.h>
>  
>  float
> -__rintf(float x)
> +__rintf (float x)
>  {
>  #if USE_RINTF_BUILTIN
>    return __builtin_rintf (x);
> @@ -31,25 +31,31 @@ __rintf(float x)
>  		8.3886080000e+06, /* 0x4b000000 */
>  		-8.3886080000e+06, /* 0xcb000000 */
>    };
> -	int32_t i0,j0,sx;
> -	float w,t;
> -	GET_FLOAT_WORD(i0,x);
> -	sx = (i0>>31)&1;
> -	j0 = ((i0>>23)&0xff)-0x7f;
> -	if(j0<23) {
> -	    if(j0<0) {
> -		w = TWO23[sx]+x;
> -		t =  w-TWO23[sx];
> -		GET_FLOAT_WORD(i0,t);
> -		SET_FLOAT_WORD(t,(i0&0x7fffffff)|(sx<<31));
> -		return t;
> -	    }
> -	} else {
> -	    if(j0==0x80) return x+x;	/* inf or NaN */
> -	    else return x;		/* x is integral */
> +  int32_t i0, j0, sx;
> +  float w, t;
> +  GET_FLOAT_WORD (i0, x);
> +  sx = (i0 >> 31) & 1;
> +  j0 = ((i0 >> 23) & 0xff) - 0x7f;
> +  if (j0 < 23)
> +    {
> +      if(j0 < 0)
> +	{
> +	  w = TWO23[sx] + x;
> +	  t =  w - TWO23[sx];
> +	  GET_FLOAT_WORD (i0, t);
> +	  SET_FLOAT_WORD (t, (i0 & 0x7fffffff) | (sx << 31));
> +	  return t;
>  	}
> -	w = TWO23[sx]+x;
> -	return w-TWO23[sx];
> +    }
> +  else
> +    {
> +      if (j0 == 0x80)
> +	return x + x;		/* inf or NaN  */
> +      else
> +	return x;		/* x is integral  */
> +    }
> +  w = TWO23[sx] + x;
> +  return w - TWO23[sx];
>  #endif /* ! USE_RINTF_BUILTIN  */
>  }
>  #ifndef __rintf

Ok.

> diff --git a/sysdeps/ieee754/ldbl-128/s_rintl.c b/sysdeps/ieee754/ldbl-128/s_rintl.c
> index 3340c35ee1..16965f9582 100644
> --- a/sysdeps/ieee754/ldbl-128/s_rintl.c
> +++ b/sysdeps/ieee754/ldbl-128/s_rintl.c
> @@ -13,7 +13,7 @@
>   * ====================================================
>   */
>  
> -#if defined(LIBM_SCCS) && !defined(lint)
> +#if defined (LIBM_SCCS) && ! defined (lint)
>  static char rcsid[] = "$NetBSD: $";
>  #endif
>  
> @@ -33,7 +33,8 @@ static char rcsid[] = "$NetBSD: $";
>  #include <libm-alias-ldouble.h>
>  #include <math-use-builtins.h>
>  
> -_Float128 __rintl(_Float128 x)
> +_Float128
> +__rintl (_Float128 x)
>  {
>  #if USE_RINTL_BUILTIN
>    return __builtin_rintl (x);
> @@ -44,26 +45,32 @@ _Float128 __rintl(_Float128 x)
>  		 5.19229685853482762853049632922009600E+33L, /* 0x406F000000000000, 0 */
>  		 -5.19229685853482762853049632922009600E+33L  /* 0xC06F000000000000, 0 */
>    };
> -	int64_t i0,j0,sx;
> -	uint64_t i1 __attribute__ ((unused));
> -	_Float128 w,t;
> -	GET_LDOUBLE_WORDS64(i0,i1,x);
> -	sx = (((uint64_t)i0)>>63);
> -	j0 = ((i0>>48)&0x7fff)-0x3fff;
> -	if(j0<112) {
> -	    if(j0<0) {
> -	        w = TWO112[sx]+x;
> -	        t = w-TWO112[sx];
> -		GET_LDOUBLE_MSW64(i0,t);
> -		SET_LDOUBLE_MSW64(t,(i0&0x7fffffffffffffffLL)|(sx<<63));
> -	        return t;
> -	    }
> -	} else {
> -	    if(j0==0x4000) return x+x;	/* inf or NaN */
> -	    else return x;		/* x is integral */
> +  int64_t i0, j0, sx;
> +  uint64_t i1 __attribute__ ((unused));
> +  _Float128 w, t;
> +  GET_LDOUBLE_WORDS64 (i0, i1, x);
> +  sx = (((uint64_t) i0) >> 63);
> +  j0 = ((i0 >> 48) & 0x7fff) - 0x3fff;
> +  if (j0 < 112)
> +    {
> +      if (j0 < 0)
> +	{
> +	  w = TWO112[sx] + x;
> +	  t = w - TWO112[sx];
> +	  GET_LDOUBLE_MSW64 (i0, t);
> +	  SET_LDOUBLE_MSW64 (t, (i0 & 0x7fffffffffffffffLL) | (sx << 63));
> +	  return t;
>  	}
> -	w = TWO112[sx]+x;
> -	return w-TWO112[sx];
> +    }
> +  else
> +    {
> +      if (j0 == 0x4000)
> +	return x + x;		/* inf or NaN  */
> +      else
> +	return x;		/* x is integral  */
> +    }
> +  w = TWO112[sx] + x;
> +  return w - TWO112[sx];
>  #endif /* ! USE_RINTL_BUILTIN  */
>  }
>  libm_alias_ldouble (__rint, rint)
> 

Ok.

Re: [PATCH v2 12/18] Use GCC builtins for round functions if desired.

[Adhemerval Zanella]

On 09/12/2019 09:46, Stefan Liebler wrote:
> This patch is using the corresponding GCC builtin for roundf, round,
> roundl and roundf128 if the USE_FUNCTION_BUILTIN macros are defined to one
> in math-use-builtins.h.
> 
> This is the case for s390 if build with at least --march=z196 --mzarch.
> Otherwise the generic implementation is used.  The code of the generic
> implementation is not changed.

LGTM, thanks.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

> ---
>  sysdeps/generic/math-use-builtins.h         |  5 +++++
>  sysdeps/ieee754/dbl-64/s_round.c            |  6 ++++++
>  sysdeps/ieee754/float128/float128_private.h |  3 +++
>  sysdeps/ieee754/flt-32/s_roundf.c           |  6 ++++++
>  sysdeps/ieee754/ldbl-128/s_roundl.c         |  6 ++++++
>  sysdeps/s390/fpu/math-use-builtins.h        | 11 +++++++++++
>  6 files changed, 37 insertions(+)
> 
> diff --git a/sysdeps/generic/math-use-builtins.h b/sysdeps/generic/math-use-builtins.h
> index ab379f45ba..34ca438a8c 100644
> --- a/sysdeps/generic/math-use-builtins.h
> +++ b/sysdeps/generic/math-use-builtins.h
> @@ -46,4 +46,9 @@
>  #define USE_TRUNCL_BUILTIN 0
>  #define USE_TRUNCF128_BUILTIN 0
>  
> +#define USE_ROUND_BUILTIN 0
> +#define USE_ROUNDF_BUILTIN 0
> +#define USE_ROUNDL_BUILTIN 0
> +#define USE_ROUNDF128_BUILTIN 0
> +
>  #endif /* math-use-builtins.h */

Ok.

> diff --git a/sysdeps/ieee754/dbl-64/s_round.c b/sysdeps/ieee754/dbl-64/s_round.c
> index 8f4b7cff86..7eb1ecb482 100644
> --- a/sysdeps/ieee754/dbl-64/s_round.c
> +++ b/sysdeps/ieee754/dbl-64/s_round.c
> @@ -23,11 +23,16 @@
>  #include <math_private.h>
>  #include <libm-alias-double.h>
>  #include <stdint.h>
> +#include <math-use-builtins.h>
>  
>  
>  double
>  __round (double x)
>  {
> +#if USE_ROUND_BUILTIN
> +  return __builtin_round (x);
> +#else
> +  /* Use generic implementation.  */
>    int64_t i0, j0;
>  
>    EXTRACT_WORDS64 (i0, x);
> @@ -62,5 +67,6 @@ __round (double x)
>  
>    INSERT_WORDS64 (x, i0);
>    return x;
> +#endif /* ! USE_ROUND_BUILTIN  */
>  }
>  libm_alias_double (__round, round)

Ok.

> diff --git a/sysdeps/ieee754/float128/float128_private.h b/sysdeps/ieee754/float128/float128_private.h
> index 9cd3a63f11..a6c76ce364 100644
> --- a/sysdeps/ieee754/float128/float128_private.h
> +++ b/sysdeps/ieee754/float128/float128_private.h
> @@ -150,6 +150,8 @@
>  #define USE_CEILL_BUILTIN USE_CEILF128_BUILTIN
>  #undef USE_TRUNCL_BUILTIN
>  #define USE_TRUNCL_BUILTIN USE_TRUNCF128_BUILTIN
> +#undef USE_ROUNDL_BUILTIN
> +#define USE_ROUNDL_BUILTIN USE_ROUNDF128_BUILTIN
>  
>  /* IEEE function renames.  */
>  #define __ieee754_acoshl __ieee754_acoshf128
> @@ -358,6 +360,7 @@
>  #define __builtin_floorl __builtin_floorf128
>  #define __builtin_ceill __builtin_ceilf128
>  #define __builtin_truncl __builtin_truncf128
> +#define __builtin_roundl __builtin_roundf128
>  
>  /* Get the constant suffix from bits/floatn-compat.h.  */
>  #define L(x) __f128 (x)

Ok.

> diff --git a/sysdeps/ieee754/flt-32/s_roundf.c b/sysdeps/ieee754/flt-32/s_roundf.c
> index cddab7b505..5d91239d6e 100644
> --- a/sysdeps/ieee754/flt-32/s_roundf.c
> +++ b/sysdeps/ieee754/flt-32/s_roundf.c
> @@ -22,11 +22,16 @@
>  
>  #include <math_private.h>
>  #include <libm-alias-float.h>
> +#include <math-use-builtins.h>
>  
>  
>  float
>  __roundf (float x)
>  {
> +#if USE_ROUNDF_BUILTIN
> +  return __builtin_roundf (x);
> +#else
> +  /* Use generic implementation.  */
>    int32_t i0, j0;
>  
>    GET_FLOAT_WORD (i0, x);
> @@ -61,5 +66,6 @@ __roundf (float x)
>  
>    SET_FLOAT_WORD (x, i0);
>    return x;
> +#endif /* ! USE_ROUNDF_BUILTIN  */
>  }
>  libm_alias_float (__round, round)

Ok.

> diff --git a/sysdeps/ieee754/ldbl-128/s_roundl.c b/sysdeps/ieee754/ldbl-128/s_roundl.c
> index d41c9a04dc..8c7ae82217 100644
> --- a/sysdeps/ieee754/ldbl-128/s_roundl.c
> +++ b/sysdeps/ieee754/ldbl-128/s_roundl.c
> @@ -23,11 +23,16 @@
>  
>  #include <math_private.h>
>  #include <libm-alias-ldouble.h>
> +#include <math-use-builtins.h>
>  
>  
>  _Float128
>  __roundl (_Float128 x)
>  {
> +#if USE_ROUNDL_BUILTIN
> +  return __builtin_roundl (x);
> +#else
> +  /* Use generic implementation.  */
>    int32_t j0;
>    uint64_t i1, i0;
>  
> @@ -78,5 +83,6 @@ __roundl (_Float128 x)
>  
>    SET_LDOUBLE_WORDS64 (x, i0, i1);
>    return x;
> +#endif /* ! USE_ROUNDL_BUILTIN  */
>  }
>  libm_alias_ldouble (__round, round)

Ok.

> diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
> index a39715c612..51cb9f91ab 100644
> --- a/sysdeps/s390/fpu/math-use-builtins.h
> +++ b/sysdeps/s390/fpu/math-use-builtins.h
> @@ -46,18 +46,24 @@
>  # define USE_TRUNCF_BUILTIN 1
>  # define USE_TRUNCL_BUILTIN 1
>  
> +# define USE_ROUND_BUILTIN 1
> +# define USE_ROUNDF_BUILTIN 1
> +# define USE_ROUNDL_BUILTIN 1
> +
>  # if __GNUC_PREREQ (8, 0)
>  #  define USE_NEARBYINTF128_BUILTIN 1
>  #  define USE_RINTF128_BUILTIN 1
>  #  define USE_FLOORF128_BUILTIN 1
>  #  define USE_CEILF128_BUILTIN 1
>  #  define USE_TRUNCF128_BUILTIN 1
> +#  define USE_ROUNDF128_BUILTIN 1
>  # else
>  #  define USE_NEARBYINTF128_BUILTIN 0
>  #  define USE_RINTF128_BUILTIN 0
>  #  define USE_FLOORF128_BUILTIN 0
>  #  define USE_CEILF128_BUILTIN 0
>  #  define USE_TRUNCF128_BUILTIN 0
> +#  define USE_ROUNDF128_BUILTIN 0
>  # endif
>  
>  #else
> @@ -88,6 +94,11 @@
>  # define USE_TRUNCL_BUILTIN 0
>  # define USE_TRUNCF128_BUILTIN 0
>  
> +# define USE_ROUND_BUILTIN 0
> +# define USE_ROUNDF_BUILTIN 0
> +# define USE_ROUNDL_BUILTIN 0
> +# define USE_ROUNDF128_BUILTIN 0
> +
>  #endif /* ! HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT  */
>  
>  #endif /* math-use-builtins.h */
> 

Ok.

Re: [PATCH v2 07/18] Use GCC builtins for nearbyint functions if desired.

[Adhemerval Zanella]

On 09/12/2019 09:45, Stefan Liebler wrote:
> This patch is using the corresponding GCC builtin for nearbyintf, nearbyint,
> nearbintl and nearbyintf128 if the USE_FUNCTION_BUILTIN macros are defined to one
> in math-use-builtins.h.
> 
> This is the case for s390 if build with at least --march=z196 --mzarch.
> Otherwise the generic implementation is used.  The code of the generic
> implementation is not changed.

LGTM, thanks.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

> ---
>  sysdeps/generic/math-use-builtins.h         | 29 ++++++++++++
>  sysdeps/ieee754/dbl-64/s_nearbyint.c        | 17 ++++---
>  sysdeps/ieee754/float128/float128_private.h |  4 ++
>  sysdeps/ieee754/flt-32/s_nearbyintf.c       | 17 ++++---
>  sysdeps/ieee754/ldbl-128/s_nearbyintl.c     | 17 ++++---
>  sysdeps/s390/fpu/math-use-builtins.h        | 49 +++++++++++++++++++++
>  6 files changed, 115 insertions(+), 18 deletions(-)
>  create mode 100644 sysdeps/generic/math-use-builtins.h
>  create mode 100644 sysdeps/s390/fpu/math-use-builtins.h
> 
> diff --git a/sysdeps/generic/math-use-builtins.h b/sysdeps/generic/math-use-builtins.h
> new file mode 100644
> index 0000000000..e12490ed41
> --- /dev/null
> +++ b/sysdeps/generic/math-use-builtins.h
> @@ -0,0 +1,29 @@
> +/* Using math gcc builtins instead of generic implementation.  Generic version.
> +   Copyright (C) 2019 Free Software Foundation, Inc.
> +   This file is part of the GNU C Library.
> +
> +   The GNU C Library is free software; you can redistribute it and/or
> +   modify it under the terms of the GNU Lesser General Public
> +   License as published by the Free Software Foundation; either
> +   version 2.1 of the License, or (at your option) any later version.
> +
> +   The GNU C Library is distributed in the hope that it will be useful,
> +   but WITHOUT ANY WARRANTY; without even the implied warranty of
> +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> +   Lesser General Public License for more details.
> +
> +   You should have received a copy of the GNU Lesser General Public
> +   License along with the GNU C Library; if not, see
> +   <https://www.gnu.org/licenses/>.  */
> +
> +#ifndef MATH_USE_BUILTINS_H
> +#define MATH_USE_BUILTINS_H	1
> +
> +/* Define these macros to 1 to use __builtin_xyz instead of the
> +   generic implementation.  */
> +#define USE_NEARBYINT_BUILTIN 0
> +#define USE_NEARBYINTF_BUILTIN 0
> +#define USE_NEARBYINTL_BUILTIN 0
> +#define USE_NEARBYINTF128_BUILTIN 0
> +
> +#endif /* math-use-builtins.h */

Ok.

> diff --git a/sysdeps/ieee754/dbl-64/s_nearbyint.c b/sysdeps/ieee754/dbl-64/s_nearbyint.c
> index c261885c5a..2deaeb2568 100644
> --- a/sysdeps/ieee754/dbl-64/s_nearbyint.c
> +++ b/sysdeps/ieee754/dbl-64/s_nearbyint.c
> @@ -26,16 +26,20 @@
>  #include <math_private.h>
>  #include <fenv_private.h>
>  #include <libm-alias-double.h>
> -
> -static const double
> -TWO52[2] = {
> -	    4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
> -	    -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
> -};
> +#include <math-use-builtins.h>
>  
>  double
>  __nearbyint (double x)
>  {
> +#if USE_NEARBYINT_BUILTIN
> +  return __builtin_nearbyint (x);
> +#else
> +  /* Use generic implementation.  */
> +  static const double
> +    TWO52[2] = {
> +		4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
> +		-4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
> +  };
>    fenv_t env;
>    int64_t i0, sx;
>    int32_t j0;
> @@ -67,5 +71,6 @@ __nearbyint (double x)
>    math_force_eval (t);
>    libc_fesetenv (&env);
>    return t;
> +#endif /* ! USE_NEARBYINT_BUILTIN  */
>  }
>  libm_alias_double (__nearbyint, nearbyint)

Ok.

> diff --git a/sysdeps/ieee754/float128/float128_private.h b/sysdeps/ieee754/float128/float128_private.h
> index 4e31ef365b..e96986a968 100644
> --- a/sysdeps/ieee754/float128/float128_private.h
> +++ b/sysdeps/ieee754/float128/float128_private.h
> @@ -139,6 +139,9 @@
>  #undef libm_alias_double_ldouble
>  #define libm_alias_double_ldouble(func) libm_alias_float64_float128 (func)
>  
> +#include <math-use-builtins.h>
> +#undef USE_NEARBYINTL_BUILTIN
> +#define USE_NEARBYINTL_BUILTIN USE_NEARBYINTF128_BUILTIN
>  
>  /* IEEE function renames.  */
>  #define __ieee754_acoshl __ieee754_acoshf128
> @@ -342,6 +345,7 @@
>  /* Builtin renames.  */
>  #define __builtin_copysignl __builtin_copysignf128
>  #define __builtin_signbitl __builtin_signbit
> +#define __builtin_nearbyintl __builtin_nearbyintf128
>  
>  /* Get the constant suffix from bits/floatn-compat.h.  */
>  #define L(x) __f128 (x)

Ok.

> diff --git a/sysdeps/ieee754/flt-32/s_nearbyintf.c b/sysdeps/ieee754/flt-32/s_nearbyintf.c
> index acedf34c90..b37e003e12 100644
> --- a/sysdeps/ieee754/flt-32/s_nearbyintf.c
> +++ b/sysdeps/ieee754/flt-32/s_nearbyintf.c
> @@ -21,16 +21,20 @@
>  #include <math_private.h>
>  #include <fenv_private.h>
>  #include <libm-alias-float.h>
> -
> -static const float
> -TWO23[2]={
> -  8.3886080000e+06, /* 0x4b000000 */
> - -8.3886080000e+06, /* 0xcb000000 */
> -};
> +#include <math-use-builtins.h>
>  
>  float
>  __nearbyintf(float x)
>  {
> +#if USE_NEARBYINTF_BUILTIN
> +  return __builtin_nearbyintf (x);
> +#else
> +  /* Use generic implementation.  */
> +  static const float
> +    TWO23[2] = {
> +		8.3886080000e+06, /* 0x4b000000 */
> +		-8.3886080000e+06, /* 0xcb000000 */
> +  };
>  	fenv_t env;
>  	int32_t i0,j0,sx;
>  	float w,t;
> @@ -58,5 +62,6 @@ __nearbyintf(float x)
>  	math_force_eval (t);
>  	libc_fesetenvf (&env);
>  	return t;
> +#endif /* ! USE_NEARBYINT_BUILTIN  */
>  }
>  libm_alias_float (__nearbyint, nearbyint)

Ok.

> diff --git a/sysdeps/ieee754/ldbl-128/s_nearbyintl.c b/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
> index f044cb4334..a4ad8e82e5 100644
> --- a/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
> +++ b/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
> @@ -28,15 +28,19 @@
>  #include <math-barriers.h>
>  #include <math_private.h>
>  #include <libm-alias-ldouble.h>
> -
> -static const _Float128
> -TWO112[2]={
> -  L(5.19229685853482762853049632922009600E+33), /* 0x406F000000000000, 0 */
> - L(-5.19229685853482762853049632922009600E+33)  /* 0xC06F000000000000, 0 */
> -};
> +#include <math-use-builtins.h>
>  
>  _Float128 __nearbyintl(_Float128 x)
>  {
> +#if USE_NEARBYINTL_BUILTIN
> +  return __builtin_nearbyintl (x);
> +#else
> +  /* Use generic implementation.  */
> +  static const _Float128
> +    TWO112[2] = {
> +		 L(5.19229685853482762853049632922009600E+33), /* 0x406F000000000000, 0 */
> +		 L(-5.19229685853482762853049632922009600E+33)  /* 0xC06F000000000000, 0 */
> +  };
>  	fenv_t env;
>  	int64_t i0,j0,sx;
>  	uint64_t i1 __attribute__ ((unused));
> @@ -65,5 +69,6 @@ _Float128 __nearbyintl(_Float128 x)
>  	math_force_eval (t);
>  	fesetenv (&env);
>  	return t;
> +#endif /* ! USE_NEARBYINTL_BUILTIN  */
>  }
>  libm_alias_ldouble (__nearbyint, nearbyint)

Ok.

> diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
> new file mode 100644
> index 0000000000..7abbfb3b50
> --- /dev/null
> +++ b/sysdeps/s390/fpu/math-use-builtins.h
> @@ -0,0 +1,49 @@
> +/* Using math gcc builtins instead of generic implementation.  s390/s390x version.
> +   Copyright (C) 2019 Free Software Foundation, Inc.
> +   This file is part of the GNU C Library.
> +
> +   The GNU C Library is free software; you can redistribute it and/or
> +   modify it under the terms of the GNU Lesser General Public
> +   License as published by the Free Software Foundation; either
> +   version 2.1 of the License, or (at your option) any later version.
> +
> +   The GNU C Library is distributed in the hope that it will be useful,
> +   but WITHOUT ANY WARRANTY; without even the implied warranty of
> +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> +   Lesser General Public License for more details.
> +
> +   You should have received a copy of the GNU Lesser General Public
> +   License along with the GNU C Library; if not, see
> +   <https://www.gnu.org/licenses/>.  */
> +
> +#ifndef MATH_USE_BUILTINS_S390_H
> +#define MATH_USE_BUILTINS_S390_H	1
> +
> +#ifdef HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT
> +
> +# include <features.h> /* For __GNUC_PREREQ.  */
> +
> +/* GCC emits the z196 zarch "load fp integer" instructions for these
> +   builtins if build with at least --march=z196 -mzarch.  Otherwise a
> +   function call to libc is emitted.  */
> +# define USE_NEARBYINT_BUILTIN 1
> +# define USE_NEARBYINTF_BUILTIN 1
> +# define USE_NEARBYINTL_BUILTIN 1
> +
> +# if __GNUC_PREREQ (8, 0)
> +#  define USE_NEARBYINTF128_BUILTIN 1
> +# else
> +#  define USE_NEARBYINTF128_BUILTIN 0
> +# endif
> +
> +#else
> +
> +/* Disable the builtins if we do not have the z196 zarch instructions.  */
> +# define USE_NEARBYINT_BUILTIN 0
> +# define USE_NEARBYINTF_BUILTIN 0
> +# define USE_NEARBYINTL_BUILTIN 0
> +# define USE_NEARBYINTF128_BUILTIN 0
> +
> +#endif /* ! HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT  */
> +
> +#endif /* math-use-builtins.h */
> 

Ok.

Re: [PATCH v2 18/18] Adjust s_copysignl.c regarding code style.

[Adhemerval Zanella]

On 09/12/2019 09:46, Stefan Liebler wrote:
> This patch just adjusts the generic implementation regarding code style.
> No functional change.

LGTM, thanks.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

> ---
>  sysdeps/ieee754/ldbl-128/s_copysignl.c | 17 +++++++++--------
>  1 file changed, 9 insertions(+), 8 deletions(-)
> 
> diff --git a/sysdeps/ieee754/ldbl-128/s_copysignl.c b/sysdeps/ieee754/ldbl-128/s_copysignl.c
> index 848a184524..a8b0639d2e 100644
> --- a/sysdeps/ieee754/ldbl-128/s_copysignl.c
> +++ b/sysdeps/ieee754/ldbl-128/s_copysignl.c
> @@ -13,7 +13,7 @@
>   * ====================================================
>   */
>  
> -#if defined(LIBM_SCCS) && !defined(lint)
> +#if defined (LIBM_SCCS) && ! defined (lint)
>  static char rcsid[] = "$NetBSD: $";
>  #endif
>  
> @@ -29,18 +29,19 @@ static char rcsid[] = "$NetBSD: $";
>  #include <libm-alias-ldouble.h>
>  #include <math-use-builtins.h>
>  
> -_Float128 __copysignl(_Float128 x, _Float128 y)
> +_Float128
> +__copysignl (_Float128 x, _Float128 y)
>  {
>  #if USE_COPYSIGNL_BUILTIN
>    return __builtin_copysignl (x, y);
>  #else
>    /* Use generic implementation.  */
> -	uint64_t hx,hy;
> -	GET_LDOUBLE_MSW64(hx,x);
> -	GET_LDOUBLE_MSW64(hy,y);
> -	SET_LDOUBLE_MSW64(x,(hx&0x7fffffffffffffffULL)
> -			    |(hy&0x8000000000000000ULL));
> -        return x;
> +  uint64_t hx, hy;
> +  GET_LDOUBLE_MSW64 (hx, x);
> +  GET_LDOUBLE_MSW64 (hy, y);
> +  SET_LDOUBLE_MSW64 (x, (hx & 0x7fffffffffffffffULL)
> +		     | (hy & 0x8000000000000000ULL));
> +  return x;
>  #endif /* ! USE_COPYSIGNL_BUILTIN  */
>  }
>  libm_alias_ldouble (__copysign, copysign)
> 

Ok.

Re: [PATCH v2 13/18] Use GCC builtins for copysign functions if desired.

[Adhemerval Zanella]

On 09/12/2019 09:46, Stefan Liebler wrote:
> This patch is always using the corresponding GCC builtin for copysignf, copysign,
> and is using the builtin for copysignl, copysignf128 if the USE_FUNCTION_BUILTIN
> macros are defined to one in math-use-builtins.h.
> 
> Altough the long double version is enabled by default we still need
> the macro and the alternative implementation as the _Float128 version
> of the builtin is not available with all supported GCC versions.

LGTM, thanks.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

> ---
>  sysdeps/generic/math-use-builtins.h         |  9 +++++++++
>  sysdeps/ieee754/dbl-64/s_copysign.c         |  9 ++-------
>  sysdeps/ieee754/float128/float128_private.h |  3 +++
>  sysdeps/ieee754/flt-32/s_copysignf.c        | 12 ++++--------
>  sysdeps/ieee754/ldbl-128/s_copysignl.c      |  6 ++++++
>  sysdeps/s390/fpu/math-use-builtins.h        |  7 +++++++
>  6 files changed, 31 insertions(+), 15 deletions(-)
> 
> diff --git a/sysdeps/generic/math-use-builtins.h b/sysdeps/generic/math-use-builtins.h
> index 34ca438a8c..770b54ce61 100644
> --- a/sysdeps/generic/math-use-builtins.h
> +++ b/sysdeps/generic/math-use-builtins.h
> @@ -19,6 +19,8 @@
>  #ifndef MATH_USE_BUILTINS_H
>  #define MATH_USE_BUILTINS_H	1
>  
> +#include <features.h> /* For __GNUC_PREREQ.  */
> +
>  /* Define these macros to 1 to use __builtin_xyz instead of the
>     generic implementation.  */
>  #define USE_NEARBYINT_BUILTIN 0
> @@ -51,4 +53,11 @@
>  #define USE_ROUNDL_BUILTIN 0
>  #define USE_ROUNDF128_BUILTIN 0
>  
> +#define USE_COPYSIGNL_BUILTIN 1
> +#if __GNUC_PREREQ (7, 0)
> +# define USE_COPYSIGNF128_BUILTIN 1
> +#else
> +# define USE_COPYSIGNF128_BUILTIN 0
> +#endif
> +
>  #endif /* math-use-builtins.h */

Ok.

> diff --git a/sysdeps/ieee754/dbl-64/s_copysign.c b/sysdeps/ieee754/dbl-64/s_copysign.c
> index 589b088c95..94025b7854 100644
> --- a/sysdeps/ieee754/dbl-64/s_copysign.c
> +++ b/sysdeps/ieee754/dbl-64/s_copysign.c
> @@ -10,7 +10,7 @@
>   * ====================================================
>   */
>  
> -#if defined(LIBM_SCCS) && !defined(lint)
> +#if defined (LIBM_SCCS) && ! defined (lint)
>  static char rcsid[] = "$NetBSD: s_copysign.c,v 1.8 1995/05/10 20:46:57 jtc Exp $";
>  #endif
>  
> @@ -22,16 +22,11 @@ static char rcsid[] = "$NetBSD: s_copysign.c,v 1.8 1995/05/10 20:46:57 jtc Exp $
>  
>  #define NO_MATH_REDIRECT
>  #include <math.h>
> -#include <math_private.h>
>  #include <libm-alias-double.h>
>  
>  double
>  __copysign (double x, double y)
>  {
> -  uint32_t hx, hy;
> -  GET_HIGH_WORD (hx, x);
> -  GET_HIGH_WORD (hy, y);
> -  SET_HIGH_WORD (x, (hx & 0x7fffffff) | (hy & 0x80000000));
> -  return x;
> +  return __builtin_copysign (x, y);
>  }
>  libm_alias_double (__copysign, copysign)

Ok.

> diff --git a/sysdeps/ieee754/float128/float128_private.h b/sysdeps/ieee754/float128/float128_private.h
> index a6c76ce364..7f7f904152 100644
> --- a/sysdeps/ieee754/float128/float128_private.h
> +++ b/sysdeps/ieee754/float128/float128_private.h
> @@ -152,6 +152,8 @@
>  #define USE_TRUNCL_BUILTIN USE_TRUNCF128_BUILTIN
>  #undef USE_ROUNDL_BUILTIN
>  #define USE_ROUNDL_BUILTIN USE_ROUNDF128_BUILTIN
> +#undef USE_COPYSIGNL_BUILTIN
> +#define USE_COPYSIGNL_BUILTIN USE_COPYSIGNF128_BUILTIN
>  
>  /* IEEE function renames.  */
>  #define __ieee754_acoshl __ieee754_acoshf128
> @@ -361,6 +363,7 @@
>  #define __builtin_ceill __builtin_ceilf128
>  #define __builtin_truncl __builtin_truncf128
>  #define __builtin_roundl __builtin_roundf128
> +#define __builtin_copysignl __builtin_copysignf128
>  
>  /* Get the constant suffix from bits/floatn-compat.h.  */
>  #define L(x) __f128 (x)

Ok.

> diff --git a/sysdeps/ieee754/flt-32/s_copysignf.c b/sysdeps/ieee754/flt-32/s_copysignf.c
> index 77d1d90e92..1c097d313f 100644
> --- a/sysdeps/ieee754/flt-32/s_copysignf.c
> +++ b/sysdeps/ieee754/flt-32/s_copysignf.c
> @@ -13,7 +13,7 @@
>   * ====================================================
>   */
>  
> -#if defined(LIBM_SCCS) && !defined(lint)
> +#if defined (LIBM_SCCS) && ! defined (lint)
>  static char rcsid[] = "$NetBSD: s_copysignf.c,v 1.4 1995/05/10 20:46:59 jtc Exp $";
>  #endif
>  
> @@ -25,15 +25,11 @@ static char rcsid[] = "$NetBSD: s_copysignf.c,v 1.4 1995/05/10 20:46:59 jtc Exp
>  
>  #define NO_MATH_REDIRECT
>  #include <math.h>
> -#include <math_private.h>
>  #include <libm-alias-float.h>
>  
> -float __copysignf(float x, float y)
> +float
> +__copysignf (float x, float y)
>  {
> -	uint32_t ix,iy;
> -	GET_FLOAT_WORD(ix,x);
> -	GET_FLOAT_WORD(iy,y);
> -	SET_FLOAT_WORD(x,(ix&0x7fffffff)|(iy&0x80000000));
> -        return x;
> +  return __builtin_copysignf (x, y);
>  }
>  libm_alias_float (__copysign, copysign)

Ok.

> diff --git a/sysdeps/ieee754/ldbl-128/s_copysignl.c b/sysdeps/ieee754/ldbl-128/s_copysignl.c
> index a501139f71..848a184524 100644
> --- a/sysdeps/ieee754/ldbl-128/s_copysignl.c
> +++ b/sysdeps/ieee754/ldbl-128/s_copysignl.c
> @@ -27,14 +27,20 @@ static char rcsid[] = "$NetBSD: $";
>  #include <math.h>
>  #include <math_private.h>
>  #include <libm-alias-ldouble.h>
> +#include <math-use-builtins.h>
>  
>  _Float128 __copysignl(_Float128 x, _Float128 y)
>  {
> +#if USE_COPYSIGNL_BUILTIN
> +  return __builtin_copysignl (x, y);
> +#else
> +  /* Use generic implementation.  */
>  	uint64_t hx,hy;
>  	GET_LDOUBLE_MSW64(hx,x);
>  	GET_LDOUBLE_MSW64(hy,y);
>  	SET_LDOUBLE_MSW64(x,(hx&0x7fffffffffffffffULL)
>  			    |(hy&0x8000000000000000ULL));
>          return x;
> +#endif /* ! USE_COPYSIGNL_BUILTIN  */
>  }
>  libm_alias_ldouble (__copysign, copysign)

Ok.

> diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
> index 51cb9f91ab..4c4aad2ab5 100644
> --- a/sysdeps/s390/fpu/math-use-builtins.h
> +++ b/sysdeps/s390/fpu/math-use-builtins.h
> @@ -101,4 +101,11 @@
>  
>  #endif /* ! HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT  */
>  
> +#define USE_COPYSIGNL_BUILTIN 1
> +#if __GNUC_PREREQ (7, 0)
> +# define USE_COPYSIGNF128_BUILTIN 1
> +#else
> +# define USE_COPYSIGNF128_BUILTIN 0
> +#endif
> +
>  #endif /* math-use-builtins.h */
> 

Ok.

Re: [PATCH v2 14/18] Adjust s_nearbyintf.c and s_nearbyintl.c regarding code style.

[Adhemerval Zanella]

On 09/12/2019 09:46, Stefan Liebler wrote:
> This patch just adjusts the generic implementation regarding code style.
> No functional change.

LGTM, thanks.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

> ---
>  sysdeps/ieee754/flt-32/s_nearbyintf.c   | 60 ++++++++++++-----------
>  sysdeps/ieee754/ldbl-128/s_nearbyintl.c | 63 ++++++++++++++-----------
>  2 files changed, 68 insertions(+), 55 deletions(-)
> 
> diff --git a/sysdeps/ieee754/flt-32/s_nearbyintf.c b/sysdeps/ieee754/flt-32/s_nearbyintf.c
> index b37e003e12..2a79907168 100644
> --- a/sysdeps/ieee754/flt-32/s_nearbyintf.c
> +++ b/sysdeps/ieee754/flt-32/s_nearbyintf.c
> @@ -24,7 +24,7 @@
>  #include <math-use-builtins.h>
>  
>  float
> -__nearbyintf(float x)
> +__nearbyintf (float x)
>  {
>  #if USE_NEARBYINTF_BUILTIN
>    return __builtin_nearbyintf (x);
> @@ -35,33 +35,39 @@ __nearbyintf(float x)
>  		8.3886080000e+06, /* 0x4b000000 */
>  		-8.3886080000e+06, /* 0xcb000000 */
>    };
> -	fenv_t env;
> -	int32_t i0,j0,sx;
> -	float w,t;
> -	GET_FLOAT_WORD(i0,x);
> -	sx = (i0>>31)&1;
> -	j0 = ((i0>>23)&0xff)-0x7f;
> -	if(j0<23) {
> -	    if(j0<0) {
> -		libc_feholdexceptf (&env);
> -		w = TWO23[sx] + math_opt_barrier (x);
> -		t =  w-TWO23[sx];
> -		math_force_eval (t);
> -		libc_fesetenvf (&env);
> -		GET_FLOAT_WORD(i0,t);
> -		SET_FLOAT_WORD(t,(i0&0x7fffffff)|(sx<<31));
> -		return t;
> -	    }
> -	} else {
> -	    if(__builtin_expect(j0==0x80, 0)) return x+x;	/* inf or NaN */
> -	    else return x;		/* x is integral */
> +  fenv_t env;
> +  int32_t i0, j0, sx;
> +  float w, t;
> +  GET_FLOAT_WORD (i0, x);
> +  sx = (i0 >> 31) & 1;
> +  j0 = ((i0 >> 23) & 0xff) - 0x7f;
> +  if (j0 < 23)
> +    {
> +      if (j0 < 0)
> +	{
> +	  libc_feholdexceptf (&env);
> +	  w = TWO23[sx] + math_opt_barrier (x);
> +	  t =  w - TWO23[sx];
> +	  math_force_eval (t);
> +	  libc_fesetenvf (&env);
> +	  GET_FLOAT_WORD (i0, t);
> +	  SET_FLOAT_WORD (t, (i0 & 0x7fffffff) | (sx << 31));
> +	  return t;
>  	}
> -	libc_feholdexceptf (&env);
> -	w = TWO23[sx] + math_opt_barrier (x);
> -	t = w-TWO23[sx];
> -	math_force_eval (t);
> -	libc_fesetenvf (&env);
> -	return t;
> +    }
> +  else
> +    {
> +      if (__glibc_unlikely (j0 == 0x80))
> +	return x + x;		/* inf or NaN  */
> +      else
> +	return x;		/* x is integral  */
> +  }
> +  libc_feholdexceptf (&env);
> +  w = TWO23[sx] + math_opt_barrier (x);
> +  t = w - TWO23[sx];
> +  math_force_eval (t);
> +  libc_fesetenvf (&env);
> +  return t;
>  #endif /* ! USE_NEARBYINT_BUILTIN  */
>  }
>  libm_alias_float (__nearbyint, nearbyint)

Ok.

> diff --git a/sysdeps/ieee754/ldbl-128/s_nearbyintl.c b/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
> index a4ad8e82e5..8d26786f78 100644
> --- a/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
> +++ b/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
> @@ -30,7 +30,8 @@
>  #include <libm-alias-ldouble.h>
>  #include <math-use-builtins.h>
>  
> -_Float128 __nearbyintl(_Float128 x)
> +_Float128
> +__nearbyintl (_Float128 x)
>  {
>  #if USE_NEARBYINTL_BUILTIN
>    return __builtin_nearbyintl (x);
> @@ -41,34 +42,40 @@ _Float128 __nearbyintl(_Float128 x)
>  		 L(5.19229685853482762853049632922009600E+33), /* 0x406F000000000000, 0 */
>  		 L(-5.19229685853482762853049632922009600E+33)  /* 0xC06F000000000000, 0 */
>    };
> -	fenv_t env;
> -	int64_t i0,j0,sx;
> -	uint64_t i1 __attribute__ ((unused));
> -	_Float128 w,t;
> -	GET_LDOUBLE_WORDS64(i0,i1,x);
> -	sx = (((uint64_t)i0)>>63);
> -	j0 = ((i0>>48)&0x7fff)-0x3fff;
> -	if(j0<112) {
> -	    if(j0<0) {
> -		feholdexcept (&env);
> -	        w = TWO112[sx] + math_opt_barrier (x);
> -	        t = w-TWO112[sx];
> -		math_force_eval (t);
> -	        fesetenv (&env);
> -		GET_LDOUBLE_MSW64(i0,t);
> -		SET_LDOUBLE_MSW64(t,(i0&0x7fffffffffffffffLL)|(sx<<63));
> -	        return t;
> -	    }
> -	} else {
> -	    if(j0==0x4000) return x+x;	/* inf or NaN */
> -	    else return x;		/* x is integral */
> +  fenv_t env;
> +  int64_t i0, j0, sx;
> +  uint64_t i1 __attribute__ ((unused));
> +  _Float128 w, t;
> +  GET_LDOUBLE_WORDS64 (i0, i1, x);
> +  sx = (((uint64_t) i0) >> 63);
> +  j0 = ((i0 >> 48) & 0x7fff) - 0x3fff;
> +  if (j0 < 112)
> +    {
> +      if (j0 < 0)
> +	{
> +	  feholdexcept (&env);
> +	  w = TWO112[sx] + math_opt_barrier (x);
> +	  t = w - TWO112[sx];
> +	  math_force_eval (t);
> +	  fesetenv (&env);
> +	  GET_LDOUBLE_MSW64 (i0, t);
> +	  SET_LDOUBLE_MSW64 (t, (i0 & 0x7fffffffffffffffLL) | (sx << 63));
> +	  return t;
>  	}
> -	feholdexcept (&env);
> -	w = TWO112[sx] + math_opt_barrier (x);
> -	t = w-TWO112[sx];
> -	math_force_eval (t);
> -	fesetenv (&env);
> -	return t;
> +    }
> +  else
> +    {
> +      if (j0 == 0x4000)
> +	return x + x;		/* inf or NaN  */
> +      else
> +	return x;		/* x is integral  */
> +    }
> +  feholdexcept (&env);
> +  w = TWO112[sx] + math_opt_barrier (x);
> +  t = w - TWO112[sx];
> +  math_force_eval (t);
> +  fesetenv (&env);
> +  return t;
>  #endif /* ! USE_NEARBYINTL_BUILTIN  */
>  }
>  libm_alias_ldouble (__nearbyint, nearbyint)
> 

Ok.

Re: [PATCH v2 10/18] Use GCC builtins for ceil functions if desired.

[Adhemerval Zanella]

On 09/12/2019 09:46, Stefan Liebler wrote:
> This patch is using the corresponding GCC builtin for ceilf, ceil,
> ceill and ceilf128 if the USE_FUNCTION_BUILTIN macros are defined to one
> in math-use-builtins.h.
> 
> This is the case for s390 if build with at least --march=z196 --mzarch.
> Otherwise the generic implementation is used.  The code of the generic
> implementation is not changed.

LGTM, thanks.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

> ---
>  sysdeps/generic/math-use-builtins.h         |  5 +++++
>  sysdeps/ieee754/dbl-64/s_ceil.c             |  6 ++++++
>  sysdeps/ieee754/float128/float128_private.h |  3 +++
>  sysdeps/ieee754/flt-32/s_ceilf.c            |  7 ++++++-
>  sysdeps/ieee754/ldbl-128/s_ceill.c          |  6 ++++++
>  sysdeps/s390/fpu/math-use-builtins.h        | 11 +++++++++++
>  6 files changed, 37 insertions(+), 1 deletion(-)
> 
> diff --git a/sysdeps/generic/math-use-builtins.h b/sysdeps/generic/math-use-builtins.h
> index e1c5df62e4..076ec661b0 100644
> --- a/sysdeps/generic/math-use-builtins.h
> +++ b/sysdeps/generic/math-use-builtins.h
> @@ -36,4 +36,9 @@
>  #define USE_FLOORL_BUILTIN 0
>  #define USE_FLOORF128_BUILTIN 0
>  
> +#define USE_CEIL_BUILTIN 0
> +#define USE_CEILF_BUILTIN 0
> +#define USE_CEILL_BUILTIN 0
> +#define USE_CEILF128_BUILTIN 0
> +
>  #endif /* math-use-builtins.h */

Ok.

> diff --git a/sysdeps/ieee754/dbl-64/s_ceil.c b/sysdeps/ieee754/dbl-64/s_ceil.c
> index 8d66f027e7..3738211360 100644
> --- a/sysdeps/ieee754/dbl-64/s_ceil.c
> +++ b/sysdeps/ieee754/dbl-64/s_ceil.c
> @@ -21,10 +21,15 @@
>  #include <math.h>
>  #include <math_private.h>
>  #include <libm-alias-double.h>
> +#include <math-use-builtins.h>
>  
>  double
>  __ceil (double x)
>  {
> +#if USE_CEIL_BUILTIN
> +  return __builtin_ceil (x);
> +#else
> +  /* Use generic implementation.  */
>    int64_t i0, i;
>    int32_t j0;
>    EXTRACT_WORDS64 (i0, x);
> @@ -58,6 +63,7 @@ __ceil (double x)
>      }
>    INSERT_WORDS64 (x, i0);
>    return x;
> +#endif /* ! USE_CEIL_BUILTIN  */
>  }
>  #ifndef __ceil
>  libm_alias_double (__ceil, ceil)

Ok.

> diff --git a/sysdeps/ieee754/float128/float128_private.h b/sysdeps/ieee754/float128/float128_private.h
> index 8c8a74a12c..01881b574a 100644
> --- a/sysdeps/ieee754/float128/float128_private.h
> +++ b/sysdeps/ieee754/float128/float128_private.h
> @@ -146,6 +146,8 @@
>  #define USE_RINTL_BUILTIN USE_RINTF128_BUILTIN
>  #undef USE_FLOORL_BUILTIN
>  #define USE_FLOORL_BUILTIN USE_FLOORF128_BUILTIN
> +#undef USE_CEILL_BUILTIN
> +#define USE_CEILL_BUILTIN USE_CEILF128_BUILTIN
>  
>  /* IEEE function renames.  */
>  #define __ieee754_acoshl __ieee754_acoshf128
> @@ -352,6 +354,7 @@
>  #define __builtin_nearbyintl __builtin_nearbyintf128
>  #define __builtin_rintl __builtin_rintf128
>  #define __builtin_floorl __builtin_floorf128
> +#define __builtin_ceill __builtin_ceilf128
>  
>  /* Get the constant suffix from bits/floatn-compat.h.  */
>  #define L(x) __f128 (x)
> diff --git a/sysdeps/ieee754/flt-32/s_ceilf.c b/sysdeps/ieee754/flt-32/s_ceilf.c
> index 25cba0807c..7d4990f3ff 100644
> --- a/sysdeps/ieee754/flt-32/s_ceilf.c
> +++ b/sysdeps/ieee754/flt-32/s_ceilf.c
> @@ -17,11 +17,15 @@
>  #include <math.h>
>  #include <math_private.h>
>  #include <libm-alias-float.h>
> -
> +#include <math-use-builtins.h>
>  
>  float
>  __ceilf(float x)
>  {
> +#if USE_CEILF_BUILTIN
> +  return __builtin_ceilf (x);
> +#else
> +  /* Use generic implementation.  */
>  	int32_t i0,j0;
>  	uint32_t i;
>  
> @@ -44,6 +48,7 @@ __ceilf(float x)
>  	}
>  	SET_FLOAT_WORD(x,i0);
>  	return x;
> +#endif /* ! USE_CEILF_BUILTIN  */
>  }
>  #ifndef __ceilf
>  libm_alias_float (__ceil, ceil)

Ok.

> diff --git a/sysdeps/ieee754/ldbl-128/s_ceill.c b/sysdeps/ieee754/ldbl-128/s_ceill.c
> index 2ec55de25a..02ffa7af2b 100644
> --- a/sysdeps/ieee754/ldbl-128/s_ceill.c
> +++ b/sysdeps/ieee754/ldbl-128/s_ceill.c
> @@ -28,9 +28,14 @@ static char rcsid[] = "$NetBSD: $";
>  #include <math.h>
>  #include <math_private.h>
>  #include <libm-alias-ldouble.h>
> +#include <math-use-builtins.h>
>  
>  _Float128 __ceill(_Float128 x)
>  {
> +#if USE_CEILL_BUILTIN
> +  return __builtin_ceill (x);
> +#else
> +  /* Use generic implementation.  */
>  	int64_t i0,i1,j0;
>  	uint64_t i,j;
>  	GET_LDOUBLE_WORDS64(i0,i1,x);
> @@ -64,5 +69,6 @@ _Float128 __ceill(_Float128 x)
>  	}
>  	SET_LDOUBLE_WORDS64(x,i0,i1);
>  	return x;
> +#endif /* ! USE_CEILL_BUILTIN  */
>  }
>  libm_alias_ldouble (__ceil, ceil)

Ok.

> diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
> index c213c16c6f..5435cbb65f 100644
> --- a/sysdeps/s390/fpu/math-use-builtins.h
> +++ b/sysdeps/s390/fpu/math-use-builtins.h
> @@ -38,14 +38,20 @@
>  # define USE_FLOORF_BUILTIN 1
>  # define USE_FLOORL_BUILTIN 1
>  
> +# define USE_CEIL_BUILTIN 1
> +# define USE_CEILF_BUILTIN 1
> +# define USE_CEILL_BUILTIN 1
> +
>  # if __GNUC_PREREQ (8, 0)
>  #  define USE_NEARBYINTF128_BUILTIN 1
>  #  define USE_RINTF128_BUILTIN 1
>  #  define USE_FLOORF128_BUILTIN 1
> +#  define USE_CEILF128_BUILTIN 1
>  # else
>  #  define USE_NEARBYINTF128_BUILTIN 0
>  #  define USE_RINTF128_BUILTIN 0
>  #  define USE_FLOORF128_BUILTIN 0
> +#  define USE_CEILF128_BUILTIN 0
>  # endif
>  
>  #else
> @@ -66,6 +72,11 @@
>  # define USE_FLOORL_BUILTIN 0
>  # define USE_FLOORF128_BUILTIN 0
>  
> +# define USE_CEIL_BUILTIN 0
> +# define USE_CEILF_BUILTIN 0
> +# define USE_CEILL_BUILTIN 0
> +# define USE_CEILF128_BUILTIN 0
> +
>  #endif /* ! HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT  */
>  
>  #endif /* math-use-builtins.h */
> 

Ok.

Re: [PATCH v2 16/18] Adjust s_floorf.c and s_floorl.c regarding code style.

[Adhemerval Zanella]

On 09/12/2019 09:46, Stefan Liebler wrote:
> This patch just adjusts the generic implementation regarding code style.
> No functional change.

LGTM, thanks.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

> ---
>  sysdeps/ieee754/flt-32/s_floorf.c   | 55 +++++++++++-------
>  sysdeps/ieee754/ldbl-128/s_floorl.c | 89 ++++++++++++++++++-----------
>  2 files changed, 90 insertions(+), 54 deletions(-)
> 
> diff --git a/sysdeps/ieee754/flt-32/s_floorf.c b/sysdeps/ieee754/flt-32/s_floorf.c
> index afe02a1693..da6c6dfa8a 100644
> --- a/sysdeps/ieee754/flt-32/s_floorf.c
> +++ b/sysdeps/ieee754/flt-32/s_floorf.c
> @@ -27,34 +27,45 @@
>  #include <math-use-builtins.h>
>  
>  float
> -__floorf(float x)
> +__floorf (float x)
>  {
>  #if USE_FLOORF_BUILTIN
>    return __builtin_floorf (x);
>  #else
>    /* Use generic implementation.  */
> -	int32_t i0,j0;
> -	uint32_t i;
> -	GET_FLOAT_WORD(i0,x);
> -	j0 = ((i0>>23)&0xff)-0x7f;
> -	if(j0<23) {
> -	    if(j0<0) {
> -		/* return 0*sign(x) if |x|<1 */
> -		if(i0>=0) {i0=0;}
> -		else if((i0&0x7fffffff)!=0)
> -		  { i0=0xbf800000;}
> -	    } else {
> -		i = (0x007fffff)>>j0;
> -		if((i0&i)==0) return x; /* x is integral */
> -		if(i0<0) i0 += (0x00800000)>>j0;
> -		i0 &= (~i);
> -	    }
> -	} else {
> -	    if(__builtin_expect(j0==0x80, 0)) return x+x; /* inf or NaN */
> -	    else return x;		/* x is integral */
> +  int32_t i0, j0;
> +  uint32_t i;
> +  GET_FLOAT_WORD (i0, x);
> +  j0 = ((i0 >> 23) & 0xff) - 0x7f;
> +  if (j0 < 23)
> +    {
> +      if (j0 < 0)
> +	{
> +	  /* return 0 * sign (x) if |x| < 1  */
> +	  if (i0 >= 0)
> +	    i0 = 0;
> +	  else if ((i0 & 0x7fffffff) != 0)
> +	    i0 = 0xbf800000;
>  	}
> -	SET_FLOAT_WORD(x,i0);
> -	return x;
> +      else
> +	{
> +	  i = (0x007fffff) >> j0;
> +	  if ((i0 & i) == 0)
> +	    return x;		/* x is integral  */
> +	  if (i0 < 0)
> +	    i0 += (0x00800000) >> j0;
> +	  i0 &= (~i);
> +	}
> +    }
> +  else
> +    {
> +      if (__glibc_unlikely (j0 == 0x80))
> +	return x + x;		/* inf or NaN  */
> +      else
> +	return x;		/* x is integral  */
> +    }
> +  SET_FLOAT_WORD (x, i0);
> +  return x;
>  #endif /* ! USE_FLOORF_BUILTIN  */
>  }
>  #ifndef __floorf

Ok.

> diff --git a/sysdeps/ieee754/ldbl-128/s_floorl.c b/sysdeps/ieee754/ldbl-128/s_floorl.c
> index cfe008392a..0475120d7e 100644
> --- a/sysdeps/ieee754/ldbl-128/s_floorl.c
> +++ b/sysdeps/ieee754/ldbl-128/s_floorl.c
> @@ -30,46 +30,71 @@ static char rcsid[] = "$NetBSD: $";
>  #include <libm-alias-ldouble.h>
>  #include <math-use-builtins.h>
>  
> -_Float128 __floorl(_Float128 x)
> +_Float128
> +__floorl (_Float128 x)
>  {
>  #if USE_FLOORL_BUILTIN
>    return __builtin_floorl (x);
>  #else
>    /* Use generic implementation.  */
> -	int64_t i0,i1,j0;
> -	uint64_t i,j;
> -	GET_LDOUBLE_WORDS64(i0,i1,x);
> -	j0 = ((i0>>48)&0x7fff)-0x3fff;
> -	if(j0<48) {
> -	    if(j0<0) {
> -		/* return 0*sign(x) if |x|<1 */
> -		if(i0>=0) {i0=i1=0;}
> -		else if(((i0&0x7fffffffffffffffLL)|i1)!=0)
> -		    { i0=0xbfff000000000000ULL;i1=0;}
> -	    } else {
> -		i = (0x0000ffffffffffffULL)>>j0;
> -		if(((i0&i)|i1)==0) return x; /* x is integral */
> -		if(i0<0) i0 += (0x0001000000000000LL)>>j0;
> -		i0 &= (~i); i1=0;
> +  int64_t i0, i1, j0;
> +  uint64_t i, j;
> +  GET_LDOUBLE_WORDS64 (i0, i1, x);
> +  j0 = ((i0 >> 48) & 0x7fff) - 0x3fff;
> +  if (j0 < 48)
> +    {
> +      if (j0 < 0)
> +	{
> +	  /* return 0 * sign (x) if |x| < 1 */
> +	  if (i0 >= 0)
> +	    {
> +	      i0 = i1 = 0;
>  	    }
> -	} else if (j0>111) {
> -	    if(j0==0x4000) return x+x;	/* inf or NaN */
> -	    else return x;		/* x is integral */
> -	} else {
> -	    i = -1ULL>>(j0-48);
> -	    if((i1&i)==0) return x;	/* x is integral */
> -	    if(i0<0) {
> -		if(j0==48) i0+=1;
> -		else {
> -		    j = i1+(1LL<<(112-j0));
> -		    if(j<i1) i0 +=1 ; 	/* got a carry */
> -		    i1=j;
> -		}
> +	  else if (((i0 & 0x7fffffffffffffffLL) | i1) != 0)
> +	    {
> +	      i0 = 0xbfff000000000000ULL;
> +	      i1 = 0;
>  	    }
> -	    i1 &= (~i);
>  	}
> -	SET_LDOUBLE_WORDS64(x,i0,i1);
> -	return x;
> +      else
> +	{
> +	  i = (0x0000ffffffffffffULL) >> j0;
> +	  if (((i0 & i) | i1) == 0)
> +	    return x;		/* x is integral  */
> +	  if (i0 < 0)
> +	    i0 += (0x0001000000000000LL) >> j0;
> +	  i0 &= (~i);
> +	  i1 = 0;
> +	}
> +    }
> +  else if (j0 > 111)
> +    {
> +      if (j0 == 0x4000)
> +	return x + x;		/* inf or NaN  */
> +      else
> +	return x;		/* x is integral  */
> +    }
> +  else
> +    {
> +      i = -1ULL >> (j0 - 48);
> +      if ((i1 & i) == 0)
> +	return x;		/* x is integral  */
> +      if (i0 < 0)
> +	{
> +	  if (j0 == 48)
> +	    i0 += 1;
> +	  else
> +	    {
> +	      j = i1 + (1LL << (112 - j0));
> +	      if (j < i1)
> +		i0 += 1 ;	/* got a carry */
> +	      i1 = j;
> +	    }
> +	}
> +      i1 &= (~i);
> +    }
> +  SET_LDOUBLE_WORDS64 (x, i0, i1);
> +  return x;
>  #endif /* ! USE_FLOORL_BUILTIN  */
>  }
>  libm_alias_ldouble (__floor, floor)
> 

Ok.

Re: [PATCH v2 00/18] Use GCC builtins for some math functions if desired.

[Adhemerval Zanella]

On 09/12/2019 09:45, Stefan Liebler wrote:
> Hi,
> 
> this patch-series moves the nearbyint, rint, floor, ceil, trunc and round implementation from sysdeps/ieee754/dbl-64/wordsize-64 to sysdeps/ieee754/dbl-64/ as proposed by Adhemerval:
> ttps://www.sourceware.org/ml/libc-alpha/2019-11/msg00085.html
> 
> It also introduces the math-use-builtins.h header with __USE_<SYMBOL>_BUILTIN macros which allows to just use GCC __builtin_<SYMBOL> instead of the current common-code implementation.  There is a float, double, long double and _Float128 version of this macro for each <SYMBOL>.
> 
> The generic math-use-builtins.h header is defining all those macros to 0 in order to use the current common-code implenetation.  If an architecture wants to use the builtins, an architecture specific math-use-builtins.h needs to be created (e.g. done for s390) where those macros are defined to 1.
> 
> Changes compared to first version (see https://www.sourceware.org/ml/libc-alpha/2019-12/msg00029.html) due to review from:
> Joseph Myers:
> * The copysign builtins are now used unconditionally for float, double and long double.  For _Float128 the macro is defined to 1 if build with GCC >= 7.
> 
> Adhemerval Zanella:
> * Some static array definitions like TWO52 in s_nearbyint.c are moved inside the !USE_NEARBYINT_BUILTIN within the function.
> * The s390 math-use-builtins.h header is now replicating the USE_XYZ* macros for !HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT instead of just including the generic header file.
> * The changes regarding code style in the "Use GCC builtins for xyz functions if desired" patches are splitted out into the new patches "Adjust s_XYZ.c regarding code style."

Hi Stefan,

I reviewed the whole series and it looks good.  I haven't reviewed again the
parts 01 to 07 since they are essentially the same as previous version and
they are already reviewed.

Re: [PATCH v2 00/18] Use GCC builtins for some math functions if desired.

[Stefan Liebler]

On 12/10/19 8:18 PM, Adhemerval Zanella wrote:
> 
> 
> On 09/12/2019 09:45, Stefan Liebler wrote:
>> Hi,
>>
>> this patch-series moves the nearbyint, rint, floor, ceil, trunc and round implementation from sysdeps/ieee754/dbl-64/wordsize-64 to sysdeps/ieee754/dbl-64/ as proposed by Adhemerval:
>> ttps://www.sourceware.org/ml/libc-alpha/2019-11/msg00085.html
>>
>> It also introduces the math-use-builtins.h header with __USE_<SYMBOL>_BUILTIN macros which allows to just use GCC __builtin_<SYMBOL> instead of the current common-code implementation.  There is a float, double, long double and _Float128 version of this macro for each <SYMBOL>.
>>
>> The generic math-use-builtins.h header is defining all those macros to 0 in order to use the current common-code implenetation.  If an architecture wants to use the builtins, an architecture specific math-use-builtins.h needs to be created (e.g. done for s390) where those macros are defined to 1.
>>
>> Changes compared to first version (see https://www.sourceware.org/ml/libc-alpha/2019-12/msg00029.html) due to review from:
>> Joseph Myers:
>> * The copysign builtins are now used unconditionally for float, double and long double.  For _Float128 the macro is defined to 1 if build with GCC >= 7.
>>
>> Adhemerval Zanella:
>> * Some static array definitions like TWO52 in s_nearbyint.c are moved inside the !USE_NEARBYINT_BUILTIN within the function.
>> * The s390 math-use-builtins.h header is now replicating the USE_XYZ* macros for !HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT instead of just including the generic header file.
>> * The changes regarding code style in the "Use GCC builtins for xyz functions if desired" patches are splitted out into the new patches "Adjust s_XYZ.c regarding code style."
> 
> Hi Stefan,
> 
> I reviewed the whole series and it looks good.  I haven't reviewed again the
> parts 01 to 07 since they are essentially the same as previous version and
> they are already reviewed.
> 

Hi Adhemerval,

Thanks for the review. Yes, the first parts have not changed compared to 
the first version.

I've just committed the patches.

Bye
Stefan