+2023-10-09 Bruno Haible <bruno@clisp.org>
+
+ 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 <bruno@clisp.org>
isfinite: Work around a bug with 'long double' in glibc 2.5/ia64.
Files:
tests/test-isfinite.c
tests/infinity.h
+tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentf.m4
m4/exponentd.m4
Files:
tests/test-isinf.c
tests/infinity.h
+tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentf.m4
m4/exponentd.m4
tests/minus-zero.h
tests/infinity.h
tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentf.m4
m4/exponentd.m4
tests/minus-zero.h
tests/infinity.h
tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentd.m4
tests/minus-zero.h
tests/infinity.h
tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentd.m4
tests/minus-zero.h
tests/infinity.h
tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentf.m4
tests/minus-zero.h
tests/infinity.h
tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentf.m4
tests/minus-zero.h
tests/infinity.h
tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentl.m4
tests/minus-zero.h
tests/infinity.h
tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentl.m4
tests/infinity.h
tests/nan.h
tests/qnan.h
+tests/snan.h
tests/macros.h
m4/exponentf.m4
m4/exponentd.m4
Files:
tests/test-stdio.c
tests/nan.h
+tests/qnan.h
+tests/snan.h
tests/macros.h
m4/exponentd.m4
--- /dev/null
+/* 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 <https://www.gnu.org/licenses/>. */
+
+#include <float.h>
+#include <limits.h>
+#include <math.h>
+
+#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
#include <limits.h>
#include "infinity.h"
+#include "snan.h"
#include "macros.h"
float zerof = 0.0f;
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
}
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. */
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
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
ASSERT (isfinite (x.value) || !isfinite (x.value));
}
-#endif
-
#undef NWORDS
+#endif
}
int
#include <limits.h>
#include "infinity.h"
+#include "snan.h"
#include "macros.h"
float zerof = 0.0f;
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
}
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. */
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
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
ASSERT (isinf (x.value) || !isinf (x.value));
}
-#endif
-
#undef NWORDS
+#endif
}
int
#include "minus-zero.h"
#include "infinity.h"
#include "nan.h"
+#include "snan.h"
#include "macros.h"
static 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
}
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));
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
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
ASSERT (isnan (x.value) || !isnan (x.value));
}
+ #undef NWORDS
#endif
}
#include "minus-zero.h"
#include "infinity.h"
#include "nan.h"
+#include "snan.h"
#include "macros.h"
int
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;
}
#include "minus-zero.h"
#include "infinity.h"
#include "nan.h"
+#include "snan.h"
#include "macros.h"
int
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;
}
#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));
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
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
ASSERT (isnanl (x.value) || !isnanl (x.value));
}
+ #undef NWORDS
#endif
return 0;
#include "minus-zero.h"
#include "infinity.h"
#include "qnan.h"
+#include "snan.h"
#include "macros.h"
float zerof = 0.0f;
/* 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
}
/* 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
}
/* 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
}
#include <string.h>
-#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. */
{
memory_double value2;
char buf[64];
- value1 = NaNd();
+ value1 = SNaNd();
sprintf (buf, "%g", value1);
ASSERT (strlen (buf) <= _PRINTF_NAN_LEN_MAX);