From: Bruno Haible Date: Mon, 9 Oct 2023 09:04:44 +0000 (+0200) Subject: tests: Refactor functions for signalling NaNs. X-Git-Tag: v1.0~725 X-Git-Url: https://gitweb.git.savannah.gnu.org/gitweb/?a=commitdiff_plain;h=d0355fa5caefab3de190168424f1494b6dfe75be;p=gnulib.git tests: Refactor functions for signalling NaNs. * tests/snan.h: New file, based on tests/test-isnanf.h, tests/test-isnand.h, tests/test-isnanl.h. * tests/test-isfinite.c: Include snan.h. (test_isfinitef, test_isfinited, test_isfinitel): Simplify. * tests/test-isinf.c: Include snan.h. (test_isinff, test_isinfd, test_isinfl): Simplify. * tests/test-isnan.c: Include snan.h. (test_float, test_double, test_long_double): Simplify. * tests/test-isnanf.h: Include snan.h. (main): Simplify. * tests/test-isnand.h: Include snan.h. (main): Simplify. * tests/test-isnanl.h: Include snan.h. (main): Simplify. * tests/test-signbit.c: Include snan.h. (test_signbitf, test_signbitd, test_signbitl): Simplify. * tests/test-stdio.c: Include qnan.h, snan.h instead of nan.h. (main): Test quiet NaNs always. Also test a signalling NaN. * modules/isfinite-tests (Files): Add tests/nan.h, tests/snan.h. * modules/isinf-tests (Files): Likewise. * modules/isnan-tests (Files): Add tests/snan.h. * modules/isnanf-tests (Files): Likewise. * modules/isnanf-nolibm-tests (Files): Likewise. * modules/isnand-tests (Files): Likewise. * modules/isnand-nolibm-tests (Files): Likewise. * modules/isnanl-tests (Files): Likewise. * modules/isnanl-nolibm-tests (Files): Likewise. * modules/signbit-tests (Files): Likewise. * modules/stdio-tests (Files): Add tests/qnan.h, tests/snan.h. --- diff --git a/ChangeLog b/ChangeLog index bcd840abb4..ef036d1585 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,36 @@ +2023-10-09 Bruno Haible + + tests: Refactor functions for signalling NaNs. + * tests/snan.h: New file, based on tests/test-isnanf.h, + tests/test-isnand.h, tests/test-isnanl.h. + * tests/test-isfinite.c: Include snan.h. + (test_isfinitef, test_isfinited, test_isfinitel): Simplify. + * tests/test-isinf.c: Include snan.h. + (test_isinff, test_isinfd, test_isinfl): Simplify. + * tests/test-isnan.c: Include snan.h. + (test_float, test_double, test_long_double): Simplify. + * tests/test-isnanf.h: Include snan.h. + (main): Simplify. + * tests/test-isnand.h: Include snan.h. + (main): Simplify. + * tests/test-isnanl.h: Include snan.h. + (main): Simplify. + * tests/test-signbit.c: Include snan.h. + (test_signbitf, test_signbitd, test_signbitl): Simplify. + * tests/test-stdio.c: Include qnan.h, snan.h instead of nan.h. + (main): Test quiet NaNs always. Also test a signalling NaN. + * modules/isfinite-tests (Files): Add tests/nan.h, tests/snan.h. + * modules/isinf-tests (Files): Likewise. + * modules/isnan-tests (Files): Add tests/snan.h. + * modules/isnanf-tests (Files): Likewise. + * modules/isnanf-nolibm-tests (Files): Likewise. + * modules/isnand-tests (Files): Likewise. + * modules/isnand-nolibm-tests (Files): Likewise. + * modules/isnanl-tests (Files): Likewise. + * modules/isnanl-nolibm-tests (Files): Likewise. + * modules/signbit-tests (Files): Likewise. + * modules/stdio-tests (Files): Add tests/qnan.h, tests/snan.h. + 2023-10-08 Bruno Haible isfinite: Work around a bug with 'long double' in glibc 2.5/ia64. diff --git a/modules/isfinite-tests b/modules/isfinite-tests index 56207be027..bf7964648b 100644 --- a/modules/isfinite-tests +++ b/modules/isfinite-tests @@ -1,6 +1,8 @@ Files: tests/test-isfinite.c tests/infinity.h +tests/nan.h +tests/snan.h tests/macros.h m4/exponentf.m4 m4/exponentd.m4 diff --git a/modules/isinf-tests b/modules/isinf-tests index 02719fe601..fb958d74ea 100644 --- a/modules/isinf-tests +++ b/modules/isinf-tests @@ -1,6 +1,8 @@ Files: tests/test-isinf.c tests/infinity.h +tests/nan.h +tests/snan.h tests/macros.h m4/exponentf.m4 m4/exponentd.m4 diff --git a/modules/isnan-tests b/modules/isnan-tests index c794455c5b..06ebb72156 100644 --- a/modules/isnan-tests +++ b/modules/isnan-tests @@ -3,6 +3,7 @@ tests/test-isnan.c tests/minus-zero.h tests/infinity.h tests/nan.h +tests/snan.h tests/macros.h m4/exponentf.m4 m4/exponentd.m4 diff --git a/modules/isnand-nolibm-tests b/modules/isnand-nolibm-tests index 7b74b0b7ed..c8d92f3a75 100644 --- a/modules/isnand-nolibm-tests +++ b/modules/isnand-nolibm-tests @@ -4,6 +4,7 @@ tests/test-isnand.h tests/minus-zero.h tests/infinity.h tests/nan.h +tests/snan.h tests/macros.h m4/exponentd.m4 diff --git a/modules/isnand-tests b/modules/isnand-tests index fb3fc494c9..30a2c6f9e6 100644 --- a/modules/isnand-tests +++ b/modules/isnand-tests @@ -4,6 +4,7 @@ tests/test-isnand.h tests/minus-zero.h tests/infinity.h tests/nan.h +tests/snan.h tests/macros.h m4/exponentd.m4 diff --git a/modules/isnanf-nolibm-tests b/modules/isnanf-nolibm-tests index 4635edd9a5..acd8bd34bc 100644 --- a/modules/isnanf-nolibm-tests +++ b/modules/isnanf-nolibm-tests @@ -4,6 +4,7 @@ tests/test-isnanf.h tests/minus-zero.h tests/infinity.h tests/nan.h +tests/snan.h tests/macros.h m4/exponentf.m4 diff --git a/modules/isnanf-tests b/modules/isnanf-tests index 1566695546..c094c02a37 100644 --- a/modules/isnanf-tests +++ b/modules/isnanf-tests @@ -4,6 +4,7 @@ tests/test-isnanf.h tests/minus-zero.h tests/infinity.h tests/nan.h +tests/snan.h tests/macros.h m4/exponentf.m4 diff --git a/modules/isnanl-nolibm-tests b/modules/isnanl-nolibm-tests index 927ad69388..58a0f51fa1 100644 --- a/modules/isnanl-nolibm-tests +++ b/modules/isnanl-nolibm-tests @@ -4,6 +4,7 @@ tests/test-isnanl.h tests/minus-zero.h tests/infinity.h tests/nan.h +tests/snan.h tests/macros.h m4/exponentl.m4 diff --git a/modules/isnanl-tests b/modules/isnanl-tests index b00e5d5910..5a2d880c3f 100644 --- a/modules/isnanl-tests +++ b/modules/isnanl-tests @@ -4,6 +4,7 @@ tests/test-isnanl.h tests/minus-zero.h tests/infinity.h tests/nan.h +tests/snan.h tests/macros.h m4/exponentl.m4 diff --git a/modules/signbit-tests b/modules/signbit-tests index 9465de790b..3b3ef9b6b6 100644 --- a/modules/signbit-tests +++ b/modules/signbit-tests @@ -4,6 +4,7 @@ tests/minus-zero.h tests/infinity.h tests/nan.h tests/qnan.h +tests/snan.h tests/macros.h m4/exponentf.m4 m4/exponentd.m4 diff --git a/modules/stdio-tests b/modules/stdio-tests index 52b753e2f7..84199d5aa3 100644 --- a/modules/stdio-tests +++ b/modules/stdio-tests @@ -1,6 +1,8 @@ Files: tests/test-stdio.c tests/nan.h +tests/qnan.h +tests/snan.h tests/macros.h m4/exponentd.m4 diff --git a/tests/snan.h b/tests/snan.h new file mode 100644 index 0000000000..e877000ece --- /dev/null +++ b/tests/snan.h @@ -0,0 +1,120 @@ +/* Macros for signalling not-a-number. + Copyright (C) 2007-2023 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include +#include +#include + +#include "nan.h" + + +#if defined FLT_EXPBIT0_WORD && defined FLT_EXPBIT0_BIT + +# define HAVE_SNANF 1 + +/* Returns a signalling 'float' NaN. */ +_GL_UNUSED static float +SNaNf () +{ + #define NWORDS \ + ((sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) + typedef union { float value; unsigned int word[NWORDS]; } memory_float; + memory_float m; + m.value = NaNf (); + #if FLT_EXPBIT0_BIT > 0 + m.word[FLT_EXPBIT0_WORD] ^= (unsigned int) 1 << (FLT_EXPBIT0_BIT - 1); + #else + m.word[FLT_EXPBIT0_WORD + (FLT_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] + ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); + #endif + if (FLT_EXPBIT0_WORD < NWORDS / 2) + m.word[FLT_EXPBIT0_WORD + 1] |= (unsigned int) 1 << FLT_EXPBIT0_BIT; + else + m.word[0] |= (unsigned int) 1; + #undef NWORDS + return m.value; +} + +#endif + + +#if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT + +# define HAVE_SNAND 1 + +/* Returns a signalling 'double' NaN. */ +_GL_UNUSED static double +SNaNd () +{ + #define NWORDS \ + ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) + typedef union { double value; unsigned int word[NWORDS]; } memory_double; + memory_double m; + m.value = NaNd (); + #if DBL_EXPBIT0_BIT > 0 + m.word[DBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (DBL_EXPBIT0_BIT - 1); + #else + m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] + ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); + #endif + m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] + |= (unsigned int) 1 << DBL_EXPBIT0_BIT; + #undef NWORDS + return m.value; +} + +#endif + + +#if defined LDBL_EXPBIT0_WORD && defined LDBL_EXPBIT0_BIT + +# define HAVE_SNANL 1 + +/* Returns a signalling 'long double' NaN. */ +_GL_UNUSED static long double +SNaNl () +{ + /* A bit pattern that is different from a Quiet NaN. With a bit of luck, + it's a Signalling NaN. */ + #define NWORDS \ + ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) + typedef union { unsigned int word[NWORDS]; long double value; } + memory_long_double; + memory_long_double m; + m.value = NaNl (); + #if defined __powerpc__ && LDBL_MANT_DIG == 106 + /* This is PowerPC "double double", a pair of two doubles. Inf and NaN are + represented as the corresponding 64-bit IEEE values in the first double; + the second is ignored. Manipulate only the first double. */ + #define HNWORDS \ + ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) + #else + #define HNWORDS NWORDS + #endif + #if LDBL_EXPBIT0_BIT > 0 + m.word[LDBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (LDBL_EXPBIT0_BIT - 1); + #else + m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < HNWORDS / 2 ? 1 : - 1)] + ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); + #endif + m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < HNWORDS / 2 ? 1 : - 1)] + |= (unsigned int) 1 << LDBL_EXPBIT0_BIT; + #undef HNWORDS + #undef NWORDS + return m.value; +} + +#endif diff --git a/tests/test-isfinite.c b/tests/test-isfinite.c index edb5f43327..3c6da8d128 100644 --- a/tests/test-isfinite.c +++ b/tests/test-isfinite.c @@ -30,6 +30,7 @@ #include #include "infinity.h" +#include "snan.h" #include "macros.h" float zerof = 0.0f; @@ -56,27 +57,9 @@ test_isfinitef () ASSERT (!isfinite (- Infinityf ())); /* Quiet NaN. */ ASSERT (!isfinite (zerof / zerof)); -#if defined FLT_EXPBIT0_WORD && defined FLT_EXPBIT0_BIT +#if HAVE_SNANF /* Signalling NaN. */ - { - #define NWORDS \ - ((sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { float value; unsigned int word[NWORDS]; } memory_float; - memory_float m; - m.value = zerof / zerof; -# if FLT_EXPBIT0_BIT > 0 - m.word[FLT_EXPBIT0_WORD] ^= (unsigned int) 1 << (FLT_EXPBIT0_BIT - 1); -# else - m.word[FLT_EXPBIT0_WORD + (FLT_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - if (FLT_EXPBIT0_WORD < NWORDS / 2) - m.word[FLT_EXPBIT0_WORD + 1] |= (unsigned int) 1 << FLT_EXPBIT0_BIT; - else - m.word[0] |= (unsigned int) 1; - ASSERT (!isfinite (m.value)); - #undef NWORDS - } + ASSERT (!isfinite (SNaNf ())); #endif } @@ -100,36 +83,15 @@ test_isfinited () ASSERT (!isfinite (- Infinityd ())); /* Quiet NaN. */ ASSERT (!isfinite (zerod / zerod)); -#if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT +#if HAVE_SNAND /* Signalling NaN. */ - { - #define NWORDS \ - ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { double value; unsigned int word[NWORDS]; } memory_double; - memory_double m; - m.value = zerod / zerod; -# if DBL_EXPBIT0_BIT > 0 - m.word[DBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (DBL_EXPBIT0_BIT - 1); -# else - m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - |= (unsigned int) 1 << DBL_EXPBIT0_BIT; - ASSERT (!isfinite (m.value)); - #undef NWORDS - } + ASSERT (!isfinite (SNaNd ())); #endif } static void test_isfinitel () { - #define NWORDS \ - ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { unsigned int word[NWORDS]; long double value; } - memory_long_double; - /* Zero. */ ASSERT (isfinite (0.0L)); /* Subnormal values. */ @@ -147,35 +109,16 @@ test_isfinitel () ASSERT (!isfinite (- Infinityl ())); /* Quiet NaN. */ ASSERT (!isfinite (zerol / zerol)); - -#if defined LDBL_EXPBIT0_WORD && defined LDBL_EXPBIT0_BIT - /* A bit pattern that is different from a Quiet NaN. With a bit of luck, - it's a Signalling NaN. */ - { -#if defined __powerpc__ && LDBL_MANT_DIG == 106 - /* This is PowerPC "double double", a pair of two doubles. Inf and Nan are - represented as the corresponding 64-bit IEEE values in the first double; - the second is ignored. Manipulate only the first double. */ - #undef NWORDS - #define NWORDS \ - ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) -#endif - - memory_long_double m; - m.value = zerol / zerol; -# if LDBL_EXPBIT0_BIT > 0 - m.word[LDBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (LDBL_EXPBIT0_BIT - 1); -# else - m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - |= (unsigned int) 1 << LDBL_EXPBIT0_BIT; - ASSERT (!isfinite (m.value)); - } +#if HAVE_SNANL + /* Signalling NaN. */ + ASSERT (!isfinite (SNaNl ())); #endif #if ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE + #define NWORDS \ + ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) + typedef union { unsigned int word[NWORDS]; long double value; } + memory_long_double; /* Representation of an 80-bit 'long double' as an initializer for a sequence of 'unsigned int' words. */ # ifdef WORDS_BIGENDIAN @@ -225,9 +168,8 @@ test_isfinitel () { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) }; ASSERT (isfinite (x.value) || !isfinite (x.value)); } -#endif - #undef NWORDS +#endif } int diff --git a/tests/test-isinf.c b/tests/test-isinf.c index f1bca0ce10..d3e435b3b2 100644 --- a/tests/test-isinf.c +++ b/tests/test-isinf.c @@ -30,6 +30,7 @@ #include #include "infinity.h" +#include "snan.h" #include "macros.h" float zerof = 0.0f; @@ -58,27 +59,9 @@ test_isinff () ASSERT (isinf (- Infinityf ())); /* Quiet NaN. */ ASSERT (!isinf (zerof / zerof)); -#if defined FLT_EXPBIT0_WORD && defined FLT_EXPBIT0_BIT +#if HAVE_SNANF /* Signalling NaN. */ - { - #define NWORDS \ - ((sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { float value; unsigned int word[NWORDS]; } memory_float; - memory_float m; - m.value = zerof / zerof; -# if FLT_EXPBIT0_BIT > 0 - m.word[FLT_EXPBIT0_WORD] ^= (unsigned int) 1 << (FLT_EXPBIT0_BIT - 1); -# else - m.word[FLT_EXPBIT0_WORD + (FLT_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - if (FLT_EXPBIT0_WORD < NWORDS / 2) - m.word[FLT_EXPBIT0_WORD + 1] |= (unsigned int) 1 << FLT_EXPBIT0_BIT; - else - m.word[0] |= (unsigned int) 1; - ASSERT (!isinf (m.value)); - #undef NWORDS - } + ASSERT (!isinf (SNaNf ())); #endif } @@ -104,36 +87,15 @@ test_isinfd () ASSERT (isinf (- Infinityd ())); /* Quiet NaN. */ ASSERT (!isinf (zerod / zerod)); -#if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT +#if HAVE_SNAND /* Signalling NaN. */ - { - #define NWORDS \ - ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { double value; unsigned int word[NWORDS]; } memory_double; - memory_double m; - m.value = zerod / zerod; -# if DBL_EXPBIT0_BIT > 0 - m.word[DBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (DBL_EXPBIT0_BIT - 1); -# else - m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - |= (unsigned int) 1 << DBL_EXPBIT0_BIT; - ASSERT (!isinf (m.value)); - #undef NWORDS - } + ASSERT (!isinf (SNaNd ())); #endif } static void test_isinfl () { - #define NWORDS \ - ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { unsigned int word[NWORDS]; long double value; } - memory_long_double; - /* Zero. */ ASSERT (!isinf (0.0L)); /* Subnormal values. */ @@ -153,35 +115,16 @@ test_isinfl () ASSERT (isinf (- Infinityl ())); /* Quiet NaN. */ ASSERT (!isinf (zerol / zerol)); - -#if defined LDBL_EXPBIT0_WORD && defined LDBL_EXPBIT0_BIT - /* A bit pattern that is different from a Quiet NaN. With a bit of luck, - it's a Signalling NaN. */ - { -#if defined __powerpc__ && LDBL_MANT_DIG == 106 - /* This is PowerPC "double double", a pair of two doubles. Inf and Nan are - represented as the corresponding 64-bit IEEE values in the first double; - the second is ignored. Manipulate only the first double. */ - #undef NWORDS - #define NWORDS \ - ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) -#endif - - memory_long_double m; - m.value = zerol / zerol; -# if LDBL_EXPBIT0_BIT > 0 - m.word[LDBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (LDBL_EXPBIT0_BIT - 1); -# else - m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - |= (unsigned int) 1 << LDBL_EXPBIT0_BIT; - ASSERT (!isinf (m.value)); - } +#if HAVE_SNANL + /* Signalling NaN. */ + ASSERT (!isinf (SNaNl ())); #endif #if ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE + #define NWORDS \ + ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) + typedef union { unsigned int word[NWORDS]; long double value; } + memory_long_double; /* Representation of an 80-bit 'long double' as an initializer for a sequence of 'unsigned int' words. */ # ifdef WORDS_BIGENDIAN @@ -231,9 +174,8 @@ test_isinfl () { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) }; ASSERT (isinf (x.value) || !isinf (x.value)); } -#endif - #undef NWORDS +#endif } int diff --git a/tests/test-isnan.c b/tests/test-isnan.c index 062c4cad24..2d744596f5 100644 --- a/tests/test-isnan.c +++ b/tests/test-isnan.c @@ -32,6 +32,7 @@ #include "minus-zero.h" #include "infinity.h" #include "nan.h" +#include "snan.h" #include "macros.h" static void @@ -51,26 +52,9 @@ test_float (void) ASSERT (!isnan (- Infinityf ())); /* Quiet NaN. */ ASSERT (isnan (NaNf ())); -#if defined FLT_EXPBIT0_WORD && defined FLT_EXPBIT0_BIT +#if HAVE_SNANF /* Signalling NaN. */ - { - #define NWORDSF \ - ((sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { float value; unsigned int word[NWORDSF]; } memory_float; - memory_float m; - m.value = NaNf (); -# if FLT_EXPBIT0_BIT > 0 - m.word[FLT_EXPBIT0_WORD] ^= (unsigned int) 1 << (FLT_EXPBIT0_BIT - 1); -# else - m.word[FLT_EXPBIT0_WORD + (FLT_EXPBIT0_WORD < NWORDSF / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - if (FLT_EXPBIT0_WORD < NWORDSF / 2) - m.word[FLT_EXPBIT0_WORD + 1] |= (unsigned int) 1 << FLT_EXPBIT0_BIT; - else - m.word[0] |= (unsigned int) 1; - ASSERT (isnan (m.value)); - } + ASSERT (isnan (SNaNf ())); #endif } @@ -91,35 +75,15 @@ test_double (void) ASSERT (!isnan (- Infinityd ())); /* Quiet NaN. */ ASSERT (isnan (NaNd ())); -#if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT +#if HAVE_SNAND /* Signalling NaN. */ - { - #define NWORDSD \ - ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { double value; unsigned int word[NWORDSD]; } memory_double; - memory_double m; - m.value = NaNd (); -# if DBL_EXPBIT0_BIT > 0 - m.word[DBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (DBL_EXPBIT0_BIT - 1); -# else - m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDSD / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDSD / 2 ? 1 : - 1)] - |= (unsigned int) 1 << DBL_EXPBIT0_BIT; - ASSERT (isnan (m.value)); - } + ASSERT (isnan (SNaNd ())); #endif } static void test_long_double (void) { - #define NWORDSL \ - ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { unsigned int word[NWORDSL]; long double value; } - memory_long_double; - /* Finite values. */ ASSERT (!isnan (3.141L)); ASSERT (!isnan (3.141e30L)); @@ -134,35 +98,16 @@ test_long_double (void) ASSERT (!isnan (- Infinityl ())); /* Quiet NaN. */ ASSERT (isnan (NaNl ())); - -#if defined LDBL_EXPBIT0_WORD && defined LDBL_EXPBIT0_BIT - /* A bit pattern that is different from a Quiet NaN. With a bit of luck, - it's a Signalling NaN. */ - { -#if defined __powerpc__ && LDBL_MANT_DIG == 106 - /* This is PowerPC "double double", a pair of two doubles. Inf and Nan are - represented as the corresponding 64-bit IEEE values in the first double; - the second is ignored. Manipulate only the first double. */ - #undef NWORDSL - #define NWORDSL \ - ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) -#endif - - memory_long_double m; - m.value = NaNl (); -# if LDBL_EXPBIT0_BIT > 0 - m.word[LDBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (LDBL_EXPBIT0_BIT - 1); -# else - m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDSL / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDSL / 2 ? 1 : - 1)] - |= (unsigned int) 1 << LDBL_EXPBIT0_BIT; - ASSERT (isnan (m.value)); - } +#if HAVE_SNANL + /* Signalling NaN. */ + ASSERT (isnan (SNaNl ())); #endif #if ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE + #define NWORDS \ + ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) + typedef union { unsigned int word[NWORDS]; long double value; } + memory_long_double; /* Representation of an 80-bit 'long double' as an initializer for a sequence of 'unsigned int' words. */ # ifdef WORDS_BIGENDIAN @@ -212,6 +157,7 @@ test_long_double (void) { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) }; ASSERT (isnan (x.value) || !isnan (x.value)); } + #undef NWORDS #endif } diff --git a/tests/test-isnand.h b/tests/test-isnand.h index 2d89ce1aed..e52756efd5 100644 --- a/tests/test-isnand.h +++ b/tests/test-isnand.h @@ -21,6 +21,7 @@ #include "minus-zero.h" #include "infinity.h" #include "nan.h" +#include "snan.h" #include "macros.h" int @@ -40,24 +41,9 @@ main () ASSERT (!isnand (- Infinityd ())); /* Quiet NaN. */ ASSERT (isnand (NaNd ())); -#if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT +#if HAVE_SNAND /* Signalling NaN. */ - { - #define NWORDS \ - ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { double value; unsigned int word[NWORDS]; } memory_double; - memory_double m; - m.value = NaNd (); -# if DBL_EXPBIT0_BIT > 0 - m.word[DBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (DBL_EXPBIT0_BIT - 1); -# else - m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - |= (unsigned int) 1 << DBL_EXPBIT0_BIT; - ASSERT (isnand (m.value)); - } + ASSERT (isnand (SNaNd ())); #endif return 0; } diff --git a/tests/test-isnanf.h b/tests/test-isnanf.h index aa2a72c128..0cd78350a6 100644 --- a/tests/test-isnanf.h +++ b/tests/test-isnanf.h @@ -21,6 +21,7 @@ #include "minus-zero.h" #include "infinity.h" #include "nan.h" +#include "snan.h" #include "macros.h" int @@ -40,26 +41,9 @@ main () ASSERT (!isnanf (- Infinityf ())); /* Quiet NaN. */ ASSERT (isnanf (NaNf ())); -#if defined FLT_EXPBIT0_WORD && defined FLT_EXPBIT0_BIT +#if HAVE_SNANF /* Signalling NaN. */ - { - #define NWORDS \ - ((sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { float value; unsigned int word[NWORDS]; } memory_float; - memory_float m; - m.value = NaNf (); -# if FLT_EXPBIT0_BIT > 0 - m.word[FLT_EXPBIT0_WORD] ^= (unsigned int) 1 << (FLT_EXPBIT0_BIT - 1); -# else - m.word[FLT_EXPBIT0_WORD + (FLT_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - if (FLT_EXPBIT0_WORD < NWORDS / 2) - m.word[FLT_EXPBIT0_WORD + 1] |= (unsigned int) 1 << FLT_EXPBIT0_BIT; - else - m.word[0] |= (unsigned int) 1; - ASSERT (isnanf (m.value)); - } + ASSERT (isnanf (SNaNf ())); #endif return 0; } diff --git a/tests/test-isnanl.h b/tests/test-isnanl.h index 4ca408bf91..fa7d87b3cd 100644 --- a/tests/test-isnanl.h +++ b/tests/test-isnanl.h @@ -22,16 +22,12 @@ #include "minus-zero.h" #include "infinity.h" #include "nan.h" +#include "snan.h" #include "macros.h" int main () { - #define NWORDS \ - ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { unsigned int word[NWORDS]; long double value; } - memory_long_double; - /* Finite values. */ ASSERT (!isnanl (3.141L)); ASSERT (!isnanl (3.141e30L)); @@ -46,35 +42,16 @@ main () ASSERT (!isnanl (- Infinityl ())); /* Quiet NaN. */ ASSERT (isnanl (NaNl ())); - -#if defined LDBL_EXPBIT0_WORD && defined LDBL_EXPBIT0_BIT - /* A bit pattern that is different from a Quiet NaN. With a bit of luck, - it's a Signalling NaN. */ - { -#if defined __powerpc__ && LDBL_MANT_DIG == 106 - /* This is PowerPC "double double", a pair of two doubles. Inf and Nan are - represented as the corresponding 64-bit IEEE values in the first double; - the second is ignored. Manipulate only the first double. */ - #undef NWORDS - #define NWORDS \ - ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) -#endif - - memory_long_double m; - m.value = NaNl (); -# if LDBL_EXPBIT0_BIT > 0 - m.word[LDBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (LDBL_EXPBIT0_BIT - 1); -# else - m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - |= (unsigned int) 1 << LDBL_EXPBIT0_BIT; - ASSERT (isnanl (m.value)); - } +#if HAVE_SNANL + /* Signalling NaN. */ + ASSERT (isnanl (SNaNl ())); #endif #if ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE + #define NWORDS \ + ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) + typedef union { unsigned int word[NWORDS]; long double value; } + memory_long_double; /* Representation of an 80-bit 'long double' as an initializer for a sequence of 'unsigned int' words. */ # ifdef WORDS_BIGENDIAN @@ -124,6 +101,7 @@ main () { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) }; ASSERT (isnanl (x.value) || !isnanl (x.value)); } + #undef NWORDS #endif return 0; diff --git a/tests/test-signbit.c b/tests/test-signbit.c index 2c1daccef2..f89fdf6d05 100644 --- a/tests/test-signbit.c +++ b/tests/test-signbit.c @@ -31,6 +31,7 @@ #include "minus-zero.h" #include "infinity.h" #include "qnan.h" +#include "snan.h" #include "macros.h" float zerof = 0.0f; @@ -59,27 +60,9 @@ test_signbitf () /* Quiet NaN. */ ASSERT (!signbit (positive_NaNf ())); ASSERT (signbit (negative_NaNf ())); -#if defined FLT_EXPBIT0_WORD && defined FLT_EXPBIT0_BIT +#if HAVE_SNANF /* Signalling NaN. */ - { - #define NWORDS \ - ((sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { float value; unsigned int word[NWORDS]; } memory_float; - memory_float m; - m.value = zerof / zerof; -# if FLT_EXPBIT0_BIT > 0 - m.word[FLT_EXPBIT0_WORD] ^= (unsigned int) 1 << (FLT_EXPBIT0_BIT - 1); -# else - m.word[FLT_EXPBIT0_WORD + (FLT_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - if (FLT_EXPBIT0_WORD < NWORDS / 2) - m.word[FLT_EXPBIT0_WORD + 1] |= (unsigned int) 1 << FLT_EXPBIT0_BIT; - else - m.word[0] |= (unsigned int) 1; - (void) signbit (m.value); - #undef NWORDS - } + (void) signbit (SNaNf ()); #endif } @@ -105,25 +88,9 @@ test_signbitd () /* Quiet NaN. */ ASSERT (!signbit (positive_NaNd ())); ASSERT (signbit (negative_NaNd ())); -#if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT +#if HAVE_SNAND /* Signalling NaN. */ - { - #define NWORDS \ - ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { double value; unsigned int word[NWORDS]; } memory_double; - memory_double m; - m.value = zerod / zerod; -# if DBL_EXPBIT0_BIT > 0 - m.word[DBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (DBL_EXPBIT0_BIT - 1); -# else - m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - |= (unsigned int) 1 << DBL_EXPBIT0_BIT; - (void) signbit (m.value); - #undef NWORDS - } + (void) signbit (SNaNd ()); #endif } @@ -149,35 +116,9 @@ test_signbitl () /* Quiet NaN. */ ASSERT (!signbit (positive_NaNl ())); ASSERT (signbit (negative_NaNl ())); -#if defined LDBL_EXPBIT0_WORD && defined LDBL_EXPBIT0_BIT +#if HAVE_SNANL /* Signalling NaN. */ - { - #define NWORDS \ - ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) - typedef union { long double value; unsigned int word[NWORDS]; } memory_long_double; - -#if defined __powerpc__ && LDBL_MANT_DIG == 106 - /* This is PowerPC "double double", a pair of two doubles. Inf and Nan are - represented as the corresponding 64-bit IEEE values in the first double; - the second is ignored. Manipulate only the first double. */ - #undef NWORDS - #define NWORDS \ - ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) -#endif - - memory_long_double m; - m.value = zerol / zerol; -# if LDBL_EXPBIT0_BIT > 0 - m.word[LDBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (LDBL_EXPBIT0_BIT - 1); -# else - m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1); -# endif - m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)] - |= (unsigned int) 1 << LDBL_EXPBIT0_BIT; - (void) signbit (m.value); - #undef NWORDS - } + (void) signbit (SNaNl ()); #endif } diff --git a/tests/test-stdio.c b/tests/test-stdio.c index 9794f4d856..cc44250150 100644 --- a/tests/test-stdio.c +++ b/tests/test-stdio.c @@ -39,12 +39,25 @@ va_list t5; #include -#include "nan.h" +#include "qnan.h" +#include "snan.h" #include "macros.h" int main (void) { + { + double value1; + char buf[64]; + + value1 = positive_NaNd(); + sprintf (buf, "%g", value1); + ASSERT (strlen (buf) <= _PRINTF_NAN_LEN_MAX); + + value1 = negative_NaNd(); + sprintf (buf, "%g", value1); + ASSERT (strlen (buf) <= _PRINTF_NAN_LEN_MAX); + } #if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT /* Check the value of _PRINTF_NAN_LEN_MAX. */ { @@ -56,7 +69,7 @@ main (void) memory_double value2; char buf[64]; - value1 = NaNd(); + value1 = SNaNd(); sprintf (buf, "%g", value1); ASSERT (strlen (buf) <= _PRINTF_NAN_LEN_MAX);