mirror of
https://sourceware.org/git/glibc.git
synced 2025-08-08 17:42:12 +03:00
Add narrowing square root functions
This patch adds the narrowing square root functions from TS 18661-1 / TS 18661-3 / C2X to glibc's libm: fsqrt, fsqrtl, dsqrtl, f32sqrtf64, f32sqrtf32x, f32xsqrtf64 for all configurations; f32sqrtf64x, f32sqrtf128, f64sqrtf64x, f64sqrtf128, f32xsqrtf64x, f32xsqrtf128, f64xsqrtf128 for configurations with _Float64x and _Float128; __f32sqrtieee128 and __f64sqrtieee128 aliases in the powerpc64le case (for calls to fsqrtl and dsqrtl when long double is IEEE binary128). Corresponding tgmath.h macro support is also added. The changes are mostly similar to those for the other narrowing functions previously added, so the description of those generally applies to this patch as well. However, the not-actually-narrowing cases (where the two types involved in the function have the same floating-point format) are aliased to sqrt, sqrtl or sqrtf128 rather than needing a separately built not-actually-narrowing function such as was needed for add / sub / mul / div. Thus, there is no __nldbl_dsqrtl name for ldbl-opt because no such name was needed (whereas the other functions needed such a name since the only other name for that entry point was e.g. f32xaddf64, not reserved by TS 18661-1); the headers are made to arrange for sqrt to be called in that case instead. The DIAG_* calls in sysdeps/ieee754/soft-fp/s_dsqrtl.c are because they were observed to be needed in GCC 7 testing of riscv32-linux-gnu-rv32imac-ilp32. The other sysdeps/ieee754/soft-fp/ files added didn't need such DIAG_* in any configuration I tested with build-many-glibcs.py, but if they do turn out to be needed in more files with some other configuration / GCC version, they can always be added there. I reused the same test inputs in auto-libm-test-in as for non-narrowing sqrt rather than adding extra or separate inputs for narrowing sqrt. The tests in libm-test-narrow-sqrt.inc also follow those for non-narrowing sqrt. Tested as followed: natively with the full glibc testsuite for x86_64 (GCC 11, 7, 6) and x86 (GCC 11); with build-many-glibcs.py with GCC 11, 7 and 6; cross testing of math/ tests for powerpc64le, powerpc32 hard float, mips64 (all three ABIs, both hard and soft float). The different GCC versions are to cover the different cases in tgmath.h and tgmath.h tests properly (GCC 6 has _Float* only as typedefs in glibc headers, GCC 7 has proper _Float* support, GCC 8 adds __builtin_tgmath).
This commit is contained in:
Joseph Myers
@@ -27,16 +27,20 @@
|
||||
#include <math-barriers.h>
|
||||
#include <math_private.h>
|
||||
#include <fenv_private.h>
|
||||
#include <math-narrow-alias.h>
|
||||
|
||||
/* Carry out a computation using round-to-odd. The computation is
|
||||
EXPR; the union type in which to store the result is UNION and the
|
||||
subfield of the "ieee" field of that union with the low part of the
|
||||
mantissa is MANTISSA; SUFFIX is the suffix for the libc_fe* macros
|
||||
to ensure that the correct rounding mode is used, for platforms
|
||||
with multiple rounding modes where those macros set only the
|
||||
relevant mode. This macro does not work correctly if the sign of
|
||||
an exact zero result depends on the rounding mode, so that case
|
||||
must be checked for separately. */
|
||||
mantissa is MANTISSA; SUFFIX is the suffix for both underlying libm
|
||||
functions for the argument type (for computations where a libm
|
||||
function rather than a C operator is used when argument and result
|
||||
types are the same) and the libc_fe* macros to ensure that the
|
||||
correct rounding mode is used, for platforms with multiple rounding
|
||||
modes where those macros set only the relevant mode. This macro
|
||||
does not work correctly if the sign of an exact zero result depends
|
||||
on the rounding mode, so that case must be checked for
|
||||
separately. */
|
||||
#define ROUND_TO_ODD(EXPR, UNION, SUFFIX, MANTISSA) \
|
||||
({ \
|
||||
fenv_t env; \
|
||||
@@ -273,85 +277,58 @@
|
||||
} \
|
||||
while (0)
|
||||
|
||||
/* The following macros declare aliases for a narrowing function. The
|
||||
sole argument is the base name of a family of functions, such as
|
||||
"add". If any platform changes long double format after the
|
||||
introduction of narrowing functions, in a way requiring symbol
|
||||
versioning compatibility, additional variants of these macros will
|
||||
be needed. */
|
||||
/* Check for error conditions from a narrowing square root function
|
||||
returning RET with argument X and set errno as needed. Overflow
|
||||
and underflow can occur for finite positive arguments and a domain
|
||||
error for negative arguments. */
|
||||
#define CHECK_NARROW_SQRT(RET, X) \
|
||||
do \
|
||||
{ \
|
||||
if (!isfinite (RET)) \
|
||||
{ \
|
||||
if (isnan (RET)) \
|
||||
{ \
|
||||
if (!isnan (X)) \
|
||||
__set_errno (EDOM); \
|
||||
} \
|
||||
else if (isfinite (X)) \
|
||||
__set_errno (ERANGE); \
|
||||
} \
|
||||
else if ((RET) == 0 && (X) != 0) \
|
||||
__set_errno (ERANGE); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
#define libm_alias_float_double_main(func) \
|
||||
weak_alias (__f ## func, f ## func) \
|
||||
weak_alias (__f ## func, f32 ## func ## f64) \
|
||||
weak_alias (__f ## func, f32 ## func ## f32x)
|
||||
/* Implement narrowing square root using round-to-odd. The argument
|
||||
is X, the return type is TYPE and UNION, MANTISSA and SUFFIX are as
|
||||
for ROUND_TO_ODD. */
|
||||
#define NARROW_SQRT_ROUND_TO_ODD(X, TYPE, UNION, SUFFIX, MANTISSA) \
|
||||
do \
|
||||
{ \
|
||||
TYPE ret; \
|
||||
\
|
||||
ret = (TYPE) ROUND_TO_ODD (sqrt ## SUFFIX (math_opt_barrier (X)), \
|
||||
UNION, SUFFIX, MANTISSA); \
|
||||
\
|
||||
CHECK_NARROW_SQRT (ret, (X)); \
|
||||
return ret; \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
#ifdef NO_LONG_DOUBLE
|
||||
# define libm_alias_float_double(func) \
|
||||
libm_alias_float_double_main (func) \
|
||||
weak_alias (__f ## func, f ## func ## l)
|
||||
#else
|
||||
# define libm_alias_float_double(func) \
|
||||
libm_alias_float_double_main (func)
|
||||
#endif
|
||||
|
||||
#define libm_alias_float32x_float64_main(func) \
|
||||
weak_alias (__f32x ## func ## f64, f32x ## func ## f64)
|
||||
|
||||
#ifdef NO_LONG_DOUBLE
|
||||
# define libm_alias_float32x_float64(func) \
|
||||
libm_alias_float32x_float64_main (func) \
|
||||
weak_alias (__f32x ## func ## f64, d ## func ## l)
|
||||
#elif defined __LONG_DOUBLE_MATH_OPTIONAL
|
||||
# define libm_alias_float32x_float64(func) \
|
||||
libm_alias_float32x_float64_main (func) \
|
||||
weak_alias (__f32x ## func ## f64, __nldbl_d ## func ## l)
|
||||
#else
|
||||
# define libm_alias_float32x_float64(func) \
|
||||
libm_alias_float32x_float64_main (func)
|
||||
#endif
|
||||
|
||||
#if __HAVE_FLOAT128 && !__HAVE_DISTINCT_FLOAT128
|
||||
# define libm_alias_float_ldouble_f128(func) \
|
||||
weak_alias (__f ## func ## l, f32 ## func ## f128)
|
||||
# define libm_alias_double_ldouble_f128(func) \
|
||||
weak_alias (__d ## func ## l, f32x ## func ## f128) \
|
||||
weak_alias (__d ## func ## l, f64 ## func ## f128)
|
||||
#else
|
||||
# define libm_alias_float_ldouble_f128(func)
|
||||
# define libm_alias_double_ldouble_f128(func)
|
||||
#endif
|
||||
|
||||
#if __HAVE_FLOAT64X_LONG_DOUBLE
|
||||
# define libm_alias_float_ldouble_f64x(func) \
|
||||
weak_alias (__f ## func ## l, f32 ## func ## f64x)
|
||||
# define libm_alias_double_ldouble_f64x(func) \
|
||||
weak_alias (__d ## func ## l, f32x ## func ## f64x) \
|
||||
weak_alias (__d ## func ## l, f64 ## func ## f64x)
|
||||
#else
|
||||
# define libm_alias_float_ldouble_f64x(func)
|
||||
# define libm_alias_double_ldouble_f64x(func)
|
||||
#endif
|
||||
|
||||
#define libm_alias_float_ldouble(func) \
|
||||
weak_alias (__f ## func ## l, f ## func ## l) \
|
||||
libm_alias_float_ldouble_f128 (func) \
|
||||
libm_alias_float_ldouble_f64x (func)
|
||||
|
||||
#define libm_alias_double_ldouble(func) \
|
||||
weak_alias (__d ## func ## l, d ## func ## l) \
|
||||
libm_alias_double_ldouble_f128 (func) \
|
||||
libm_alias_double_ldouble_f64x (func)
|
||||
|
||||
#define libm_alias_float64x_float128(func) \
|
||||
weak_alias (__f64x ## func ## f128, f64x ## func ## f128)
|
||||
|
||||
#define libm_alias_float32_float128_main(func) \
|
||||
weak_alias (__f32 ## func ## f128, f32 ## func ## f128)
|
||||
|
||||
#define libm_alias_float64_float128_main(func) \
|
||||
weak_alias (__f64 ## func ## f128, f64 ## func ## f128) \
|
||||
weak_alias (__f64 ## func ## f128, f32x ## func ## f128)
|
||||
|
||||
#include <math-narrow-alias-float128.h>
|
||||
/* Implement a narrowing square root function where no attempt is made
|
||||
to be correctly rounding (this only applies to IBM long double; the
|
||||
case where the function is not actually narrowing is handled by
|
||||
aliasing other sqrt functions in libm, not using this macro). The
|
||||
argument is X and the return type is TYPE. */
|
||||
#define NARROW_SQRT_TRIVIAL(X, TYPE, SUFFIX) \
|
||||
do \
|
||||
{ \
|
||||
TYPE ret; \
|
||||
\
|
||||
ret = (TYPE) (sqrt ## SUFFIX (X)); \
|
||||
CHECK_NARROW_SQRT (ret, (X)); \
|
||||
return ret; \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
#endif /* math-narrow.h. */
|
||||
|
||||
Reference in New Issue
Block a user