It is based on draft TS 18661 and currently enabled as a GNU extension.
+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.
* 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.
\f
Version 2.17
GLIBC_2.3.4
GLIBC_2.4
GLIBC_2.15
+ GLIBC_2.18
}
libnsl {
GLIBC_2.0
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
@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
"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];
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
__gamma_r_finite; __gammaf_r_finite; __gammal_r_finite;
__exp_finite; __expf_finite; __expl_finite;
}
+ GLIBC_2.18 {
+ __issignaling; __issignalingf; __issignalingl;
+ }
}
#include <float.h>
#include <stdio.h>
+#include <math-tests.h>
+
+
static int errors = 0;
/* 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; \
(void) &zero_var; \
(void) &one_var; \
(void) &qNaN_var; \
+ (void) &sNaN_var; \
+ (void) &minus_sNaN_var; \
(void) &Inf_var; \
\
\
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> \
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. \
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; \
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; \
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); \
}
__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));
}
# 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] (";
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,
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
}
+/* 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
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))
{
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
{
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
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)
{
isinf_test ();
isnan_test ();
isnormal_test ();
+ issignaling_test ();
signbit_test ();
/* Trigonometric functions: */
#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
-/* 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.
\
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"); \
+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.
+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
--- /dev/null
+/* 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
--- /dev/null
+/* 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
yn F
ynf F
ynl F
+GLIBC_2.18
+ GLIBC_2.18 A
+ __issignaling F
+ __issignalingf F
+ __issignalingl F
__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
__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
__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
__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
__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
__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
__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
__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
__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
__y1f_finite F
__yn_finite F
__ynf_finite F
+GLIBC_2.18
+ GLIBC_2.18 A
+ __issignaling F
+ __issignalingf F
__y1f_finite F
__yn_finite F
__ynf_finite F
+GLIBC_2.18
+ GLIBC_2.18 A
+ __issignaling F
+ __issignalingf F
__y1f_finite F
__yn_finite F
__ynf_finite F
+GLIBC_2.18
+ GLIBC_2.18 A
+ __issignaling F
+ __issignalingf F
(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
--- /dev/null
+/* 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)
--- /dev/null
+/* 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)
--- /dev/null
+/* 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)
--- /dev/null
+/* 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)
--- /dev/null
+/* 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)
--- /dev/null
+/* 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)
--- /dev/null
+/* 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>
__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
__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
__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
__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
__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
__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
__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
__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
__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
yn F
ynf F
ynl F
+GLIBC_2.18
+ GLIBC_2.18 A
+ __issignaling F
+ __issignalingf F
+ __issignalingl F
projects / thirdparty / glibc.git / commitdiff
