AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-21 12:30:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

New <math.h> macro named issignaling to check for a signaling NaN (sNaN).

Browse Source 
It is based on draft TS 18661 and currently enabled as a GNU extension.
This commit is contained in:
Thomas Schwinge 2013-04-02 13:51:02 +02:00
parent 60c414c346
commit 572676160d
49 changed files with 692 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
ChangeLog
View File

@ -1,3 +1,35 @@
2013-04-02 Thomas Schwinge <thomas@codesourcery.com>
* Versions.def (libm): Add GLIBC_2.18.
* include/math.h [!_ISOMAC] (__issignaling, __issignalingf): Add
hidden libm prototypes.
[!_ISOMAC && !__NO_LONG_DOUBLE_MATH] (__issignalingl): Likewise.
* math/Makefile (libm-calls): Add s_issignaling.
* math/Versions (libm: GLIBC_2.18): Add __issignaling,
__issignalingf, __issignalingl. Adjust all libm.abilist files.
* math/bits/mathcalls.h [__USE_GNU] (__issignaling): New prototype
declaration.
* math/math.h [__USE_GNU] (issignaling): New macro.
* sysdeps/ieee754/flt-32/s_issignalingf.c: New file.
* sysdeps/ieee754/dbl-64/s_issignaling.c: Likewise.
* sysdeps/ieee754/dbl-64/wordsize-64/s_issignaling.c: Likewise.
* sysdeps/ieee754/ldbl-96/s_issignalingl.c: Likewise.
* sysdeps/ieee754/ldbl-128/s_issignalingl.c: Likewise.
* sysdeps/ieee754/ldbl-128ibm/s_issignalingl.c: Likewise.
* manual/arith.texi (issignaling): New section.
* manual/libm-err-tab.pl (@all_functions): Update comment.
* math/gen-libm-test.pl (parse_args): Apply special handling for
issignaling.
* math/libm-test.inc (print_float, issignaling_test): New
functions.
(check_float_internal): Add issignaling checks.
* sysdeps/generic/math-tests.h (SNAN_TESTS_TYPE_CAST): Provide
default definition.
* sysdeps/powerpc/math-tests.h: New file.
* math/basic-test.c (TEST_FUNC, TEST_TRUNC): Add issignaling
tests.
* math/test-snan.c (TEST_FUNC): Likewise.
2013-03-30 David S. Miller <davem@davemloft.net>
* po/de.po: Update from translation team.

2
NEWS
View File

@ -26,6 +26,8 @@ Version 2.18
* Added a benchmark framework to track performance of functions in glibc.
* New <math.h> macro named issignaling to check for a signaling NaN (sNaN).
It is based on draft TS 18661 and currently enabled as a GNU extension.
Version 2.17

1
Versions.def
View File

@ -58,6 +58,7 @@ libm {
GLIBC_2.3.4
GLIBC_2.4
GLIBC_2.15
GLIBC_2.18
}
libnsl {
GLIBC_2.0

3
include/math.h
View File

@ -23,11 +23,14 @@ hidden_proto (__isnanl)
libm_hidden_proto (__fpclassify)
libm_hidden_proto (__fpclassifyf)
libm_hidden_proto (__issignaling)
libm_hidden_proto (__issignalingf)
libm_hidden_proto (__exp)
libm_hidden_proto (__expf)
# ifndef __NO_LONG_DOUBLE_MATH
libm_hidden_proto (__fpclassifyl)
libm_hidden_proto (__issignalingl)
libm_hidden_proto (__expl)
libm_hidden_proto (__expm1l)
# endif

8
manual/arith.texi
View File

@ -387,6 +387,14 @@ to
@end smallexample
@end deftypefn
@comment math.h
@comment GNU
@deftypefn {Macro} int issignaling (@emph{float-type} @var{x})
This macro returns a nonzero value if @var{x} is a signaling NaN
(sNaN). It is based on draft TS 18661 and currently enabled as a GNU
extension.
@end deftypefn
Another set of floating-point classification functions was provided by
BSD. @Theglibc{} also supports these functions; however, we
recommend that you use the ISO C99 macros in new code. Those are standard

4
manual/libm-err-tab.pl
View File

@ -77,7 +77,9 @@ use vars qw (%results @all_floats %suffices @all_functions);
"remainder", "remquo", "rint", "round", "scalb", "scalbn", "scalbln",
"sin", "sincos", "sinh", "sqrt", "tan", "tanh", "tgamma",
"trunc", "y0", "y1", "yn" );
# "fpclassify", "isfinite", "isnormal", "signbit" are not tabulated
# fpclassify, isnormal, isfinite, isinf, isnan, issignaling, signbit,
# isgreater, isgreaterequal, isless, islessequal, islessgreater, isunordered
# are not tabulated.
if ($#ARGV == 0) {
$sources = $ARGV[0];

2
math/Makefile
View File

@ -58,7 +58,7 @@ libm-calls = e_acos e_acosh e_asin e_atan2 e_atanh e_cosh e_exp e_fmod \
s_catan s_casin s_ccos s_csin s_ctan s_ctanh s_cacos \
s_casinh s_cacosh s_catanh s_csqrt s_cpow s_cproj s_clog10 \
s_fma s_lrint s_llrint s_lround s_llround e_exp10 w_log2 \
s_isinf_ns $(calls:s_%=m_%) x2y2m1 k_casinh
s_isinf_ns s_issignaling $(calls:s_%=m_%) x2y2m1 k_casinh
include ../Makeconfig

3
math/Versions
View File

@ -198,4 +198,7 @@ libm {
__gamma_r_finite; __gammaf_r_finite; __gammal_r_finite;
__exp_finite; __expf_finite; __expl_finite;
}
GLIBC_2.18 {
__issignaling; __issignalingf; __issignalingl;
}
}

65
math/basic-test.c
View File

@ -20,6 +20,9 @@
#include <float.h>
#include <stdio.h>
#include <math-tests.h>
static int errors = 0;
@ -39,6 +42,10 @@ NAME (void) \
/* Variables are declared volatile to forbid some compiler \
optimizations. */ \
volatile FLOAT Inf_var, qNaN_var, zero_var, one_var; \
/* A sNaN is only guaranteed to be representable in variables with */ \
/* static (or thread-local) storage duration. */ \
static volatile FLOAT sNaN_var = __builtin_nans ## SUFFIX (""); \
static volatile FLOAT minus_sNaN_var = -__builtin_nans ## SUFFIX (""); \
FLOAT x1, x2; \
\
zero_var = 0.0; \
@ -49,6 +56,8 @@ NAME (void) \
(void) &zero_var; \
(void) &one_var; \
(void) &qNaN_var; \
(void) &sNaN_var; \
(void) &minus_sNaN_var; \
(void) &Inf_var; \
\
\
@ -56,16 +65,41 @@ NAME (void) \
check (#FLOAT " isinf (-inf) == -1", isinf (-Inf_var) == -1); \
check (#FLOAT " !isinf (1)", !(isinf (one_var))); \
check (#FLOAT " !isinf (qNaN)", !(isinf (qNaN_var))); \
if (SNAN_TESTS (FLOAT)) \
check (#FLOAT " !isinf (sNaN)", !(isinf (sNaN_var))); \
\
check (#FLOAT " isnan (qNaN)", isnan (qNaN_var)); \
if (SNAN_TESTS (FLOAT)) \
check (#FLOAT " isnan (sNaN)", isnan (sNaN_var)); \
check (#FLOAT " isnan (-qNaN)", isnan (-qNaN_var)); \
if (SNAN_TESTS (FLOAT)) \
check (#FLOAT " isnan (-sNaN)", isnan (minus_sNaN_var)); \
check (#FLOAT " !isnan (1)", !(isnan (one_var))); \
check (#FLOAT " !isnan (inf)", !(isnan (Inf_var))); \
\
check (#FLOAT " !issignaling (qNaN)", !(issignaling (qNaN_var))); \
if (SNAN_TESTS (FLOAT)) \
check (#FLOAT " issignaling (sNaN)", issignaling (sNaN_var)); \
check (#FLOAT " !issignaling (-qNaN)", !(issignaling (-qNaN_var))); \
if (SNAN_TESTS (FLOAT)) \
check (#FLOAT " issignaling (-sNaN)", issignaling (minus_sNaN_var)); \
check (#FLOAT " !issignaling (1)", !(issignaling (one_var))); \
check (#FLOAT " !issignaling (inf)", !(issignaling (Inf_var))); \
\
check (#FLOAT " inf == inf", Inf_var == Inf_var); \
check (#FLOAT " -inf == -inf", -Inf_var == -Inf_var); \
check (#FLOAT " inf != -inf", Inf_var != -Inf_var); \
check (#FLOAT " qNaN != qNaN", qNaN_var != qNaN_var); \
if (SNAN_TESTS (FLOAT)) \
check (#FLOAT " sNaN != sNaN", sNaN_var != sNaN_var); \
if (SNAN_TESTS (FLOAT)) \
check (#FLOAT " qNaN != sNaN", qNaN_var != sNaN_var); \
if (SNAN_TESTS (FLOAT)) \
check (#FLOAT " -sNaN != -sNaN", minus_sNaN_var != minus_sNaN_var); \
if (SNAN_TESTS (FLOAT)) \
check (#FLOAT " sNaN != -sNaN", sNaN_var != minus_sNaN_var); \
if (SNAN_TESTS (FLOAT)) \
check (#FLOAT " qNaN != -sNaN", qNaN_var != minus_sNaN_var); \
\
/* \
the same tests but this time with NAN from <bits/nan.h> \
@ -76,6 +110,11 @@ NAME (void) \
check (#FLOAT " !isinf (NAN)", !(isinf (NAN))); \
check (#FLOAT " !isinf (-NAN)", !(isinf (-NAN))); \
check (#FLOAT " NAN != NAN", NAN != NAN); \
check (#FLOAT " NAN != qNaN", NAN != qNaN_var); \
if (SNAN_TESTS (FLOAT)) \
check (#FLOAT " NAN != sNaN", NAN != sNaN_var); \
if (SNAN_TESTS (FLOAT)) \
check (#FLOAT " NAN != -sNaN", NAN != minus_sNaN_var); \
\
/* \
And again with the value returned by the `nan' function. \
@ -86,6 +125,12 @@ NAME (void) \
check (#FLOAT " !isinf (-nan (\"\"))", !(isinf (-nan ## SUFFIX ("")))); \
check (#FLOAT " nan (\"\") != nan (\"\")", \
nan ## SUFFIX ("") != nan ## SUFFIX ("")); \
check (#FLOAT " nan (\"\") != qNaN", nan ## SUFFIX ("") != qNaN_var); \
if (SNAN_TESTS (FLOAT)) \
check (#FLOAT " nan (\"\") != sNaN", nan ## SUFFIX ("") != sNaN_var); \
if (SNAN_TESTS (FLOAT)) \
check (#FLOAT " nan (\"\") != -sNaN", \
nan ## SUFFIX ("") != minus_sNaN_var); \
\
/* test if EPSILON is ok */ \
x1 = 1.0; \
@ -108,6 +153,9 @@ void \
NAME (void) \
{ \
volatile DOUBLE Inf_var, qNaN_var, zero_var, one_var; \
/* A sNaN is only guaranteed to be representable in variables with */ \
/* static (or thread-local) storage duration. */ \
static volatile DOUBLE sNaN_var = __builtin_nans ## SUFFIX (""); \
FLOAT x1, x2; \
\
zero_var = 0.0; \
@ -116,10 +164,25 @@ NAME (void) \
Inf_var = one_var / zero_var; \
\
(void) &qNaN_var; \
(void) &sNaN_var; \
(void) &Inf_var; \
\
x1 = (FLOAT) qNaN_var; \
check (" "#FLOAT" x = ("#FLOAT") ("#DOUBLE") qNaN", isnan (x1) != 0); \
check (" "#FLOAT" x = ("#FLOAT") ("#DOUBLE") qNaN, isnan", isnan (x1)); \
check (" "#FLOAT" x = ("#FLOAT") ("#DOUBLE") qNaN, !issignaling", \
!issignaling (x1)); \
if (SNAN_TESTS (FLOAT)) \
{ \
x1 = (FLOAT) sNaN_var; \
check (" "#FLOAT" x = ("#FLOAT") ("#DOUBLE") sNaN, isnan", isnan (x1)); \
if (SNAN_TESTS_TYPE_CAST) \
{ \
/* Upon type conversion, a sNaN is converted into a qNaN plus an */ \
/* INVALID exception (not checked here). */ \
check (" "#FLOAT" x = ("#FLOAT") ("#DOUBLE") sNaN, !issignaling", \
!issignaling (x1)); \
} \
} \
x2 = (FLOAT) Inf_var; \
check (" "#FLOAT" x = ("#FLOAT") ("#DOUBLE") Inf", isinf (x2) != 0); \
}

6
math/bits/mathcalls.h
View File

@ -360,6 +360,12 @@ __MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));
__END_NAMESPACE_C99
#endif
#ifdef __USE_GNU
/* Test for signaling NaN. */
__MATHDECL_1 (int, __issignaling,, (_Mdouble_ __value))
__attribute__ ((__const__));
#endif
#if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
/* Return X times (2 to the Nth power). */
__MATHCALL (scalb,, (_Mdouble_ __x, _Mdouble_ __n));

2
math/gen-libm-test.pl
View File

@ -322,7 +322,7 @@ sub parse_args {
}
# Special handling for some macros:
$cline .= " (\"$str\", ";
if ($args[0] =~ /fpclassify|isnormal|isfinite|isinf|isnan|signbit
if ($args[0] =~ /fpclassify|isnormal|isfinite|isinf|isnan|issignaling|signbit
|isgreater|isgreaterequal|isless|islessequal
|islessgreater|isunordered/x) {
$c_call = "$args[0] (";

56
math/libm-test.inc
View File

@ -42,7 +42,7 @@
cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp10, exp2, expm1,
fabs, fdim, finite, floor, fma, fmax, fmin, fmod, fpclassify,
frexp, gamma, hypot,
ilogb, isfinite, isinf, isnan, isnormal,
ilogb, isfinite, isinf, isnan, isnormal, issignaling,
isless, islessequal, isgreater, isgreaterequal, islessgreater, isunordered,
j0, j1, jn,
ldexp, lgamma, log, log10, log1p, log2, logb,
@ -87,9 +87,8 @@
aren't checked at the moment.
NaN values: There exist signalling and quiet NaNs. This implementation
only uses quiet NaN as parameter but does not differentiate
between the two kinds of NaNs as result. Where the sign of a NaN is
significant, this is not tested.
only uses quiet NaN as parameter. Where the sign of a NaN is
significant, this is not tested. The payload of NaNs is not examined.
Inline functions: Inlining functions should give an improvement in
speed - but not in precission. The inlined functions return
@ -265,6 +264,19 @@ set_max_error (FLOAT current, FLOAT *curr_max_error)
}
/* Print a FLOAT. */
static void
print_float (FLOAT f)
{
/* As printf doesn't differ between a sNaN and a qNaN, do this manually. */
if (issignaling (f))
printf ("sNaN\n");
else if (isnan (f))
printf ("qNaN\n");
else
printf ("% .20" PRINTF_EXPR " % .20" PRINTF_XEXPR "\n", f, f);
}
/* Should the message print to screen? This depends on the verbose flag,
and the test status. */
static int
@ -534,7 +546,11 @@ check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
FLOAT ulp = 0;
test_exceptions (test_name, exceptions);
if (isnan (computed) && isnan (expected))
if (issignaling (computed) && issignaling (expected))
ok = 1;
else if (issignaling (computed) || issignaling (expected))
ok = 0;
else if (isnan (computed) && isnan (expected))
ok = 1;
else if (isinf (computed) && isinf (expected))
{
@ -548,8 +564,9 @@ check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
else
ok = 1;
}
/* Don't calc ulp for NaNs or infinities. */
else if (isinf (computed) || isnan (computed) || isinf (expected) || isnan (expected))
/* Don't calculate ULPs for infinities or any kind of NaNs. */
else if (isinf (computed) || isnan (computed)
|| isinf (expected) || isnan (expected))
ok = 0;
else
{
@ -594,10 +611,10 @@ check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
printf ("Failure: ");
printf ("Test: %s\n", test_name);
printf ("Result:\n");
printf (" is: % .20" PRINTF_EXPR " % .20" PRINTF_XEXPR "\n",
computed, computed);
printf (" should be: % .20" PRINTF_EXPR " % .20" PRINTF_XEXPR "\n",
expected, expected);
printf (" is: ");
print_float (computed);
printf (" should be: ");
print_float (expected);
if (print_diff)
{
printf (" difference: % .20" PRINTF_EXPR " % .20" PRINTF_XEXPR
@ -7812,6 +7829,22 @@ isnormal_test (void)
END (isnormal);
}
static void
issignaling_test (void)
{
START (issignaling);
TEST_f_b (issignaling, 0, 0);
TEST_f_b (issignaling, minus_zero, 0);
TEST_f_b (issignaling, 10, 0);
TEST_f_b (issignaling, min_subnorm_value, 0);
TEST_f_b (issignaling, plus_infty, 0);
TEST_f_b (issignaling, minus_infty, 0);
TEST_f_b (issignaling, qnan_value, 0);
END (issignaling);
}
static void
isunordered_test (void)
{
@ -12448,6 +12481,7 @@ main (int argc, char **argv)
isinf_test ();
isnan_test ();
isnormal_test ();
issignaling_test ();
signbit_test ();
/* Trigonometric functions: */

14
math/math.h
View File

@ -282,6 +282,20 @@ enum
#endif /* Use ISO C99. */
#ifdef __USE_GNU
/* Return nonzero value if X is a signaling NaN. */
# ifdef __NO_LONG_DOUBLE_MATH
# define issignaling(x) \
(sizeof (x) == sizeof (float) ? __issignalingf (x) : __issignaling (x))
# else
# define issignaling(x) \
(sizeof (x) == sizeof (float) \
? __issignalingf (x) \
: sizeof (x) == sizeof (double) \
? __issignaling (x) : __issignalingl (x))
# endif
#endif /* Use GNU. */
#ifdef __USE_MISC
/* Support for various different standard error handling behaviors. */
typedef enum

44
math/test-snan.c
View File

@ -1,4 +1,4 @@
/* Test signaling NaNs in isnan, isinf, and similar functions.
/* Test signaling NaNs in issignaling, isnan, isinf, and similar functions.
Copyright (C) 2008-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Andreas Jaeger <aj@suse.de>, 2005.
@ -117,6 +117,48 @@ NAME (void) \
\
feclearexcept(FE_ALL_EXCEPT); \
feenableexcept (FE_ALL_EXCEPT); \
if (sigsetjmp(sigfpe_buf, 0)) \
{ \
printf (#FLOAT " issignaling (qNaN) raised SIGFPE\n"); \
errors++; \
} else { \
check (#FLOAT " issignaling (qNaN)", !issignaling (qNaN_var)); \
} \
\
feclearexcept(FE_ALL_EXCEPT); \
feenableexcept (FE_ALL_EXCEPT); \
if (sigsetjmp(sigfpe_buf, 0)) \
{ \
printf (#FLOAT " issignaling (-qNaN) raised SIGFPE\n"); \
errors++; \
} else { \
check (#FLOAT " issignaling (-qNaN)", !issignaling (-qNaN_var)); \
} \
\
feclearexcept(FE_ALL_EXCEPT); \
feenableexcept (FE_ALL_EXCEPT); \
if (sigsetjmp(sigfpe_buf, 0)) \
{ \
printf (#FLOAT " issignaling (sNaN) raised SIGFPE\n"); \
errors++; \
} else { \
check (#FLOAT " issignaling (sNaN)", \
SNAN_TESTS (FLOAT) ? issignaling (sNaN_var) : 1); \
} \
\
feclearexcept(FE_ALL_EXCEPT); \
feenableexcept (FE_ALL_EXCEPT); \
if (sigsetjmp(sigfpe_buf, 0)) \
{ \
printf (#FLOAT " issignaling (-sNaN) raised SIGFPE\n"); \
errors++; \
} else { \
check (#FLOAT " issignaling (-sNaN)", \
SNAN_TESTS (FLOAT) ? issignaling (minus_sNaN_var) : 1); \
} \
\
feclearexcept(FE_ALL_EXCEPT); \
feenableexcept (FE_ALL_EXCEPT); \
if (sigsetjmp(sigfpe_buf, 0)) \
{ \
printf (#FLOAT " isnan (qNaN) raised SIGFPE\n"); \

4
ports/ChangeLog.hppa
View File

@ -1,3 +1,7 @@
2013-04-02 Thomas Schwinge <thomas@codesourcery.com>
* sysdeps/hppa/math_private.h: New file.
2013-03-06 Andreas Jaeger <aj@suse.de>
* sysdeps/unix/sysv/linux/hppa/bits/msq.h (MSG_COPY): Define.

4
ports/ChangeLog.mips
View File

@ -1,3 +1,7 @@
2013-04-02 Thomas Schwinge <thomas@codesourcery.com>
* sysdeps/mips/math_private.h: New file.
2013-03-20 Joseph Myers <joseph@codesourcery.com>
* sysdeps/unix/sysv/linux/mips/configure.in (default-abi): Set

27
ports/sysdeps/hppa/math_private.h Normal file
View File

@ -0,0 +1,27 @@
/* Internal math stuff. HPPA version.
Copyright (C) 2013 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
<http://www.gnu.org/licenses/>. */
#ifndef _MATH_PRIVATE_H
/* One of the few architectures where the meaning of the quiet/signaling bit is
inverse to IEEE 754-2008 (as well as common practice for IEEE 754-1985). */
#define HIGH_ORDER_BIT_IS_SET_FOR_SNAN
#include_next <math_private.h>
#endif

27
ports/sysdeps/mips/math_private.h Normal file
View File

@ -0,0 +1,27 @@
/* Internal math stuff. MIPS version.
Copyright (C) 2013 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
<http://www.gnu.org/licenses/>. */
#ifndef _MATH_PRIVATE_H
/* One of the few architectures where the meaning of the quiet/signaling bit is
inverse to IEEE 754-2008 (as well as common practice for IEEE 754-1985). */
#define HIGH_ORDER_BIT_IS_SET_FOR_SNAN
#include_next <math_private.h>
#endif

5
ports/sysdeps/unix/sysv/linux/aarch64/nptl/libm.abilist
View File

@ -395,3 +395,8 @@ GLIBC_2.17
yn F
ynf F
ynl F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F

5
ports/sysdeps/unix/sysv/linux/alpha/nptl/libm.abilist
View File

@ -391,6 +391,11 @@ GLIBC_2.15
__yn_finite F
__ynf_finite F
__ynl_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F
GLIBC_2.2
GLIBC_2.2 A
feclearexcept F

4
ports/sysdeps/unix/sysv/linux/arm/nptl/libm.abilist
View File

@ -54,6 +54,10 @@ GLIBC_2.15
__y1f_finite F
__yn_finite F
__ynf_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
GLIBC_2.4
GLIBC_2.4 A
_LIB_VERSION D 0x4

5
ports/sysdeps/unix/sysv/linux/ia64/nptl/libm.abilist
View File

@ -18,6 +18,11 @@ GLIBC_2.15
__yn_finite F
__ynf_finite F
__ynl_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F
GLIBC_2.2
GLIBC_2.2 A
_LIB_VERSION D 0x4

4
ports/sysdeps/unix/sysv/linux/m68k/coldfire/nptl/libm.abilist
View File

@ -54,6 +54,10 @@ GLIBC_2.15
__y1f_finite F
__yn_finite F
__ynf_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
GLIBC_2.4
GLIBC_2.4 A
_LIB_VERSION D 0x4

5
ports/sysdeps/unix/sysv/linux/m68k/m680x0/nptl/libm.abilist
View File

@ -396,6 +396,11 @@ GLIBC_2.15
__yn_finite F
__ynf_finite F
__ynl_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F
GLIBC_2.2
GLIBC_2.2 A
feclearexcept F

4
ports/sysdeps/unix/sysv/linux/mips/mips32/nptl/libm.abilist
View File

@ -212,6 +212,10 @@ GLIBC_2.15
__y1f_finite F
__yn_finite F
__ynf_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
GLIBC_2.2
GLIBC_2.2 A
__clog10 F

5
ports/sysdeps/unix/sysv/linux/mips/mips64/n32/nptl/libm.abilist
View File

@ -239,6 +239,11 @@ GLIBC_2.15
__yn_finite F
__ynf_finite F
__ynl_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F
GLIBC_2.2
GLIBC_2.2 A
__clog10 F

5
ports/sysdeps/unix/sysv/linux/mips/mips64/n64/nptl/libm.abilist
View File

@ -239,6 +239,11 @@ GLIBC_2.15
__yn_finite F
__ynf_finite F
__ynl_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F
GLIBC_2.2
GLIBC_2.2 A
__clog10 F

5
ports/sysdeps/unix/sysv/linux/powerpc/powerpc32/nofpu/nptl/libm.abilist
View File

@ -396,6 +396,11 @@ GLIBC_2.15
__yn_finite F
__ynf_finite F
__ynl_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F
GLIBC_2.2
GLIBC_2.2 A
feclearexcept F

4
ports/sysdeps/unix/sysv/linux/tile/tilegx/tilegx32/nptl/libm.abilist
View File

@ -367,3 +367,7 @@ GLIBC_2.15
__y1f_finite F
__yn_finite F
__ynf_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F

4
ports/sysdeps/unix/sysv/linux/tile/tilegx/tilegx64/nptl/libm.abilist
View File

@ -367,3 +367,7 @@ GLIBC_2.15
__y1f_finite F
__yn_finite F
__ynf_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F

4
ports/sysdeps/unix/sysv/linux/tile/tilepro/nptl/libm.abilist
View File

@ -367,3 +367,7 @@ GLIBC_2.15
__y1f_finite F
__yn_finite F
__ynf_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F

6
sysdeps/generic/math-tests.h
View File

@ -34,3 +34,9 @@
(sizeof (x) == sizeof (float) ? SNAN_TESTS_float \
: sizeof (x) == sizeof (double) ? SNAN_TESTS_double \
: SNAN_TESTS_long_double)
/* Indicate whether to run tests involving type casts of sNaN values. These
are run unless overridden. */
#ifndef SNAN_TESTS_TYPE_CAST
# define SNAN_TESTS_TYPE_CAST 1
#endif

46
sysdeps/ieee754/dbl-64/s_issignaling.c Normal file
View File

@ -0,0 +1,46 @@
/* Test for signaling NaN.
Copyright (C) 2013 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
<http://www.gnu.org/licenses/>. */
#include <math.h>
#include <math_private.h>
int
__issignaling (double x)
{
#ifdef HIGH_ORDER_BIT_IS_SET_FOR_SNAN
u_int32_t hxi;
GET_HIGH_WORD (hxi, x);
/* We only have to care about the high-order bit of x's significand, because
having it set (sNaN) already makes the significand different from that
used to designate infinity. */
return (hxi & 0x7ff80000) == 0x7ff80000;
#else
u_int32_t hxi, lxi;
EXTRACT_WORDS (hxi, lxi, x);
/* To keep the following comparison simple, toggle the quiet/signaling bit,
so that it is set for sNaNs. This is inverse to IEEE 754-2008 (as well as
common practice for IEEE 754-1985). */
hxi ^= 0x00080000;
/* If lxi != 0, then set any suitable bit of the significand in hxi. */
hxi |= (lxi | -lxi) >> 31;
/* We have to compare for greater (instead of greater or equal), because x's
significand being all-zero designates infinity not NaN. */
return (hxi & 0x7fffffff) > 0x7ff80000;
#endif
}
libm_hidden_def (__issignaling)

43
sysdeps/ieee754/dbl-64/wordsize-64/s_issignaling.c Normal file
View File

@ -0,0 +1,43 @@
/* Test for signaling NaN.
Copyright (C) 2013 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
<http://www.gnu.org/licenses/>. */
#include <math.h>
#include <math_private.h>
int
__issignaling (double x)
{
u_int64_t xi;
EXTRACT_WORDS64 (xi, x);
#ifdef HIGH_ORDER_BIT_IS_SET_FOR_SNAN
# error untested
/* We only have to care about the high-order bit of x's significand, because
having it set (sNaN) already makes the significand different from that
used to designate infinity. */
return (xi & UINT64_C (0x7ff8000000000000)) == UINT64_C (0x7ff8000000000000);
#else
/* To keep the following comparison simple, toggle the quiet/signaling bit,
so that it is set for sNaNs. This is inverse to IEEE 754-2008 (as well as
common practice for IEEE 754-1985). */
xi ^= UINT64_C (0x0008000000000000);
/* We have to compare for greater (instead of greater or equal), because x's
significand being all-zero designates infinity not NaN. */
return (xi & UINT64_C (0x7fffffffffffffff)) > UINT64_C (0x7ff8000000000000);
#endif
}
libm_hidden_def (__issignaling)

42
sysdeps/ieee754/flt-32/s_issignalingf.c Normal file
View File

@ -0,0 +1,42 @@
/* Test for signaling NaN.
Copyright (C) 2013 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
<http://www.gnu.org/licenses/>. */
#include <math.h>
#include <math_private.h>
int
__issignalingf (float x)
{
u_int32_t xi;
GET_FLOAT_WORD (xi, x);
#ifdef HIGH_ORDER_BIT_IS_SET_FOR_SNAN
/* We only have to care about the high-order bit of x's significand, because
having it set (sNaN) already makes the significand different from that
used to designate infinity. */
return (xi & 0x7fc00000) == 0x7fc00000;
#else
/* To keep the following comparison simple, toggle the quiet/signaling bit,
so that it is set for sNaNs. This is inverse to IEEE 754-2008 (as well as
common practice for IEEE 754-1985). */
xi ^= 0x00400000;
/* We have to compare for greater (instead of greater or equal), because x's
significand being all-zero designates infinity not NaN. */
return (xi & 0x7fffffff) > 0x7fc00000;
#endif
}
libm_hidden_def (__issignalingf)

45
sysdeps/ieee754/ldbl-128/s_issignalingl.c Normal file
View File

@ -0,0 +1,45 @@
/* Test for signaling NaN.
Copyright (C) 2013 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
<http://www.gnu.org/licenses/>. */
#include <math.h>
#include <math_private.h>
int
__issignalingl (long double x)
{
u_int64_t hxi, lxi __attribute__ ((unused));
GET_LDOUBLE_WORDS64 (hxi, lxi, x);
#ifdef HIGH_ORDER_BIT_IS_SET_FOR_SNAN
/* We only have to care about the high-order bit of x's significand, because
having it set (sNaN) already makes the significand different from that
used to designate infinity. */
return ((hxi & UINT64_C (0x7fff800000000000))
== UINT64_C (0x7fff800000000000));
#else
/* To keep the following comparison simple, toggle the quiet/signaling bit,
so that it is set for sNaNs. This is inverse to IEEE 754-2008 (as well as
common practice for IEEE 754-1985). */
hxi ^= UINT64_C (0x0000800000000000);
/* If lxi != 0, then set any suitable bit of the significand in hxi. */
hxi |= (lxi | -lxi) >> 63;
/* We have to compare for greater (instead of greater or equal), because x's
significand being all-zero designates infinity not NaN. */
return (hxi & UINT64_C (0x7fffffffffffffff)) > UINT64_C (0x7fff800000000000);
#endif
}
libm_hidden_def (__issignalingl)

45
sysdeps/ieee754/ldbl-128ibm/s_issignalingl.c Normal file
View File

@ -0,0 +1,45 @@
/* Test for signaling NaN.
Copyright (C) 2013 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
<http://www.gnu.org/licenses/>. */
#include <math.h>
#include <math_private.h>
int
__issignalingl (long double x)
{
u_int64_t xi;
/* For inspecting NaN status, we only have to look at the first of the pair
of IEEE 754 64-bit precision numbers. */
GET_LDOUBLE_MSW64 (xi, x);
#ifdef HIGH_ORDER_BIT_IS_SET_FOR_SNAN
# error untested
/* We only have to care about the high-order bit of x's significand, because
having it set (sNaN) already makes the significand different from that
used to designate infinity. */
return (xi & UINT64_C (0x7ff8000000000000)) == UINT64_C (0x7ff8000000000000);
#else
/* To keep the following comparison simple, toggle the quiet/signaling bit,
so that it is set for sNaNs. This is inverse to IEEE 754-2008 (as well as
common practice for IEEE 754-1985). */
xi ^= UINT64_C (0x0008000000000000);
/* We have to compare for greater (instead of greater or equal), because x's
significand being all-zero designates infinity not NaN. */
return (xi & UINT64_C (0x7fffffffffffffff)) > UINT64_C (0x7ff8000000000000);
#endif
}
libm_hidden_def (__issignalingl)

43
sysdeps/ieee754/ldbl-96/s_issignalingl.c Normal file
View File

@ -0,0 +1,43 @@
/* Test for signaling NaN.
Copyright (C) 2013 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
<http://www.gnu.org/licenses/>. */
#include <math.h>
#include <math_private.h>
int
__issignalingl (long double x)
{
u_int32_t exi, hxi, lxi;
GET_LDOUBLE_WORDS (exi, hxi, lxi, x);
#ifdef HIGH_ORDER_BIT_IS_SET_FOR_SNAN
# error not implemented
#else
/* To keep the following comparison simple, toggle the quiet/signaling bit,
so that it is set for sNaNs. This is inverse to IEEE 754-2008 (as well as
common practice for IEEE 754-1985). */
hxi ^= 0x40000000;
/* If lxi != 0, then set any suitable bit of the significand in hxi. */
hxi |= (lxi | -lxi) >> 31;
/* We do not recognize a pseudo NaN as sNaN; they're invalid on 80387 and
later. */
/* We have to compare for greater (instead of greater or equal), because x's
significand being all-zero designates infinity not NaN. */
return ((exi & 0x7fff) == 0x7fff) && (hxi > 0xc0000000);
#endif
}
libm_hidden_def (__issignalingl)

26
sysdeps/powerpc/math-tests.h Normal file
View File

@ -0,0 +1,26 @@
/* Configuration for math tests. PowerPC version.
Copyright (C) 2013 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
<http://www.gnu.org/licenses/>. */
/* On PowerPC, in versions of GCC up to at least 4.7.2, a type cast -- which is
a IEEE 754-2008 general-computational convertFormat operation (IEEE
754-2008, 5.4.2) -- does not turn a sNaN into a qNaN (whilst raising an
INVALID exception), which is contrary to IEEE 754-2008 5.1 and 7.2. This
renders certain tests infeasible in this scenario. */
#define SNAN_TESTS_TYPE_CAST 0
#include_next <math-tests.h>

5
sysdeps/unix/sysv/linux/i386/nptl/libm.abilist
View File

@ -396,6 +396,11 @@ GLIBC_2.15
__yn_finite F
__ynf_finite F
__ynl_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F
GLIBC_2.2
GLIBC_2.2 A
__expl F

5
sysdeps/unix/sysv/linux/powerpc/powerpc32/fpu/nptl/libm.abilist
View File

@ -397,6 +397,11 @@ GLIBC_2.15
__yn_finite F
__ynf_finite F
__ynl_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F
GLIBC_2.2
GLIBC_2.2 A
feclearexcept F

5
sysdeps/unix/sysv/linux/powerpc/powerpc64/nptl/libm.abilist
View File

@ -81,6 +81,11 @@ GLIBC_2.15
__yn_finite F
__ynf_finite F
__ynl_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F
GLIBC_2.3
GLIBC_2.3 A
_LIB_VERSION D 0x4

5
sysdeps/unix/sysv/linux/s390/s390-32/nptl/libm.abilist
View File

@ -393,6 +393,11 @@ GLIBC_2.15
__yn_finite F
__ynf_finite F
__ynl_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F
GLIBC_2.2
GLIBC_2.2 A
fedisableexcept F

5
sysdeps/unix/sysv/linux/s390/s390-64/nptl/libm.abilist
View File

@ -81,6 +81,11 @@ GLIBC_2.15
__yn_finite F
__ynf_finite F
__ynl_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F
GLIBC_2.2
GLIBC_2.2 A
_LIB_VERSION D 0x4

4
sysdeps/unix/sysv/linux/sh/nptl/libm.abilist
View File

@ -54,6 +54,10 @@ GLIBC_2.15
__y1f_finite F
__yn_finite F
__ynf_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
GLIBC_2.2
GLIBC_2.2 A
_LIB_VERSION D 0x4

5
sysdeps/unix/sysv/linux/sparc/sparc32/nptl/libm.abilist
View File

@ -388,6 +388,11 @@ GLIBC_2.15
__yn_finite F
__ynf_finite F
__ynl_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F
GLIBC_2.2
GLIBC_2.2 A
feclearexcept F

5
sysdeps/unix/sysv/linux/sparc/sparc64/nptl/libm.abilist
View File

@ -81,6 +81,11 @@ GLIBC_2.15
__yn_finite F
__ynf_finite F
__ynl_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F
GLIBC_2.2
GLIBC_2.2 A
_LIB_VERSION D 0x4

5
sysdeps/unix/sysv/linux/x86_64/64/nptl/libm.abilist
View File

@ -81,6 +81,11 @@ GLIBC_2.15
__yn_finite F
__ynf_finite F
__ynl_finite F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F
GLIBC_2.2.5
GLIBC_2.2.5 A
_LIB_VERSION D 0x4

5
sysdeps/unix/sysv/linux/x86_64/x32/nptl/libm.abilist
View File

@ -395,3 +395,8 @@ GLIBC_2.16
yn F
ynf F
ynl F
GLIBC_2.18
GLIBC_2.18 A
__issignaling F
__issignalingf F
__issignalingl F