This is the mail archive of the
libc-alpha@sourceware.org
mailing list for the glibc project.
Re: [PATCH 07/13] Use GCC builtins for nearbyint functions if desired.
On 02/12/2019 11:46, 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 except changes in code style.
LGTM with some changes below.
Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>
> ---
> sysdeps/generic/math-use-builtins.h | 29 ++++++++
> sysdeps/ieee754/dbl-64/s_nearbyint.c | 8 +++
> sysdeps/ieee754/float128/float128_private.h | 4 ++
> sysdeps/ieee754/flt-32/s_nearbyintf.c | 74 ++++++++++++--------
> sysdeps/ieee754/ldbl-128/s_nearbyintl.c | 76 ++++++++++++---------
> sysdeps/s390/fpu/math-use-builtins.h | 45 ++++++++++++
> 6 files changed, 175 insertions(+), 61 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..08a148e21e 100644
> --- a/sysdeps/ieee754/dbl-64/s_nearbyint.c
> +++ b/sysdeps/ieee754/dbl-64/s_nearbyint.c
> @@ -26,16 +26,23 @@
> #include <math_private.h>
> #include <fenv_private.h>
> #include <libm-alias-double.h>
> +#include <math-use-builtins.h>
>
> +#if ! USE_NEARBYINT_BUILTIN
> static const double
> TWO52[2] = {
> 4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
> -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
> };
> +#endif
You could just move it inside the !USE_NEARBYINT_BUILTIN within the
function.
>
> double
> __nearbyint (double x)
> {
> +#if USE_NEARBYINT_BUILTIN
> + return __builtin_nearbyint (x);
> +#else
> + /* Use generic implementation. */
> fenv_t env;
> int64_t i0, sx;
> int32_t j0;
> @@ -67,5 +74,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
Ok.
>
> /* 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..d31bbdd19a 100644
> --- a/sysdeps/ieee754/flt-32/s_nearbyintf.c
> +++ b/sysdeps/ieee754/flt-32/s_nearbyintf.c
> @@ -21,42 +21,56 @@
> #include <math_private.h>
> #include <fenv_private.h>
> #include <libm-alias-float.h>
> +#include <math-use-builtins.h>
>
> +#if ! USE_NEARBYINTF_BUILTIN
> static const float
> -TWO23[2]={
> - 8.3886080000e+06, /* 0x4b000000 */
> - -8.3886080000e+06, /* 0xcb000000 */
> +TWO23[2] = {
> + 8.3886080000e+06, /* 0x4b000000 */
> + -8.3886080000e+06, /* 0xcb000000 */
> };
> +#endif
You could just move it inside the !USE_NEARBYINT_BUILTIN within the
function.
>
> float
> -__nearbyintf(float x)
> +__nearbyintf (float x)
> {
> - 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 */
> +#if USE_NEARBYINTF_BUILTIN
> + return __builtin_nearbyintf (x);
> +#else
> + /* Use generic implementation. */
> + 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, but fix the indentation in a separted patch.
> diff --git a/sysdeps/ieee754/ldbl-128/s_nearbyintl.c b/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
> index f044cb4334..8f3a7e8e6b 100644
> --- a/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
> +++ b/sysdeps/ieee754/ldbl-128/s_nearbyintl.c
> @@ -28,42 +28,56 @@
> #include <math-barriers.h>
> #include <math_private.h>
> #include <libm-alias-ldouble.h>
> +#include <math-use-builtins.h>
>
> +#if ! USE_NEARBYINTL_BUILTIN
> static const _Float128
> -TWO112[2]={
> - L(5.19229685853482762853049632922009600E+33), /* 0x406F000000000000, 0 */
> - L(-5.19229685853482762853049632922009600E+33) /* 0xC06F000000000000, 0 */
> +TWO112[2] = {
> + L(5.19229685853482762853049632922009600E+33), /* 0x406F000000000000, 0 */
> + L(-5.19229685853482762853049632922009600E+33) /* 0xC06F000000000000, 0 */
> };
> +#endif
You could just move it inside the !USE_NEARBYINT_BUILTIN within the
function.
>
> -_Float128 __nearbyintl(_Float128 x)
> +_Float128 __nearbyintl (_Float128 x)
> {
> - 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 */
> +#if USE_NEARBYINTL_BUILTIN
> + return __builtin_nearbyintl (x);
> +#else
> + /* Use generic implementation. */
> + 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, but fix the indentation in a separated patch.
> diff --git a/sysdeps/s390/fpu/math-use-builtins.h b/sysdeps/s390/fpu/math-use-builtins.h
> new file mode 100644
> index 0000000000..fd9da8893e
> --- /dev/null
> +++ b/sysdeps/s390/fpu/math-use-builtins.h
> @@ -0,0 +1,45 @@
> +/* 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, 1)
> +# define USE_NEARBYINTF128_BUILTIN 1
> +# else
> +# define USE_NEARBYINTF128_BUILTIN 0
> +# endif
> +
> +#else
> +
> +# include_next <math-use-builtins.h>
> +
> +#endif
> +
> +#endif /* math-use-builtins.h */
>
Ok, but since the idea is to just override it by the architecture I think
it should be more clear to just replicate the expected USE_NEARBYINT*
values for !HAVE_S390_MIN_Z196_ZARCH_ASM_SUPPORT.