From c7ca62b05502124efdb7125563caa4912bb76fd3 Mon Sep 17 00:00:00 2001 From: MSVSphere Packaging Team Date: Fri, 20 Dec 2024 13:31:28 +0300 Subject: [PATCH] import glibc-2.39-31.el10 --- SOURCES/glibc-RHEL-12867-2.patch | 117 + SOURCES/glibc-RHEL-12867-3.patch | 32 + SOURCES/glibc-RHEL-12867.patch | 811 ++ SOURCES/glibc-build-xtests-1.patch | 28 + SOURCES/glibc-build-xtests-2.patch | 82 + SOURCES/glibc-upstream-2.39-100.patch | 29 + SOURCES/glibc-upstream-2.39-101.patch | 277 + SOURCES/glibc-upstream-2.39-102.patch | 73 + SOURCES/glibc-upstream-2.39-103.patch | 23 + SOURCES/glibc-upstream-2.39-104.patch | 174 + SOURCES/glibc-upstream-2.39-105.patch | 72 + SOURCES/glibc-upstream-2.39-106.patch | 24 + SOURCES/glibc-upstream-2.39-107.patch | 156 + SOURCES/glibc-upstream-2.39-108.patch | 23 + SOURCES/glibc-upstream-2.39-109.patch | 139 + SOURCES/glibc-upstream-2.39-110.patch | 226 + SOURCES/glibc-upstream-2.39-111.patch | 168 + SOURCES/glibc-upstream-2.39-112.patch | 142 + SOURCES/glibc-upstream-2.39-113.patch | 70 + SOURCES/glibc-upstream-2.39-114.patch | 135 + SOURCES/glibc-upstream-2.39-115.patch | 83 + SOURCES/glibc-upstream-2.39-116.patch | 129 + SOURCES/glibc-upstream-2.39-117.patch | 499 + SOURCES/glibc-upstream-2.39-118.patch | 93 + SOURCES/glibc-upstream-2.39-119.patch | 540 + SOURCES/glibc-upstream-2.39-120.patch | 27 + SOURCES/glibc-upstream-2.39-121.patch | 140 + SOURCES/glibc-upstream-2.39-122.patch | 28 + SOURCES/glibc-upstream-2.39-123.patch | 275 + SOURCES/glibc-upstream-2.39-124.patch | 165 + SOURCES/glibc-upstream-2.39-125.patch | 51 + SOURCES/glibc-upstream-2.39-126.patch | 16725 ++++++++++++++++++++++++ SOURCES/glibc-upstream-2.39-127.patch | 447 + SOURCES/glibc-upstream-2.39-128.patch | 600 + SOURCES/glibc-upstream-2.39-129.patch | 142 + SOURCES/glibc-upstream-2.39-130.patch | 149 + SOURCES/glibc-upstream-2.39-131.patch | 77 + SOURCES/glibc-upstream-2.39-132.patch | 256 + SOURCES/glibc-upstream-2.39-133.patch | 81 + SOURCES/glibc-upstream-2.39-134.patch | 40 + SOURCES/glibc-upstream-2.39-135.patch | 219 + SOURCES/glibc-upstream-2.39-136.patch | 441 + SOURCES/glibc-upstream-2.39-137.patch | 31 + SOURCES/glibc-upstream-2.39-95.patch | 196 + SOURCES/glibc-upstream-2.39-96.patch | 257 + SOURCES/glibc-upstream-2.39-97.patch | 50 + SOURCES/glibc-upstream-2.39-98.patch | 83 + SOURCES/glibc-upstream-2.39-99.patch | 286 + SPECS/glibc.spec | 921 +- 49 files changed, 25316 insertions(+), 516 deletions(-) create mode 100644 SOURCES/glibc-RHEL-12867-2.patch create mode 100644 SOURCES/glibc-RHEL-12867-3.patch create mode 100644 SOURCES/glibc-RHEL-12867.patch create mode 100644 SOURCES/glibc-build-xtests-1.patch create mode 100644 SOURCES/glibc-build-xtests-2.patch create mode 100644 SOURCES/glibc-upstream-2.39-100.patch create mode 100644 SOURCES/glibc-upstream-2.39-101.patch create mode 100644 SOURCES/glibc-upstream-2.39-102.patch create mode 100644 SOURCES/glibc-upstream-2.39-103.patch create mode 100644 SOURCES/glibc-upstream-2.39-104.patch create mode 100644 SOURCES/glibc-upstream-2.39-105.patch create mode 100644 SOURCES/glibc-upstream-2.39-106.patch create mode 100644 SOURCES/glibc-upstream-2.39-107.patch create mode 100644 SOURCES/glibc-upstream-2.39-108.patch create mode 100644 SOURCES/glibc-upstream-2.39-109.patch create mode 100644 SOURCES/glibc-upstream-2.39-110.patch create mode 100644 SOURCES/glibc-upstream-2.39-111.patch create mode 100644 SOURCES/glibc-upstream-2.39-112.patch create mode 100644 SOURCES/glibc-upstream-2.39-113.patch create mode 100644 SOURCES/glibc-upstream-2.39-114.patch create mode 100644 SOURCES/glibc-upstream-2.39-115.patch create mode 100644 SOURCES/glibc-upstream-2.39-116.patch create mode 100644 SOURCES/glibc-upstream-2.39-117.patch create mode 100644 SOURCES/glibc-upstream-2.39-118.patch create mode 100644 SOURCES/glibc-upstream-2.39-119.patch create mode 100644 SOURCES/glibc-upstream-2.39-120.patch create mode 100644 SOURCES/glibc-upstream-2.39-121.patch create mode 100644 SOURCES/glibc-upstream-2.39-122.patch create mode 100644 SOURCES/glibc-upstream-2.39-123.patch create mode 100644 SOURCES/glibc-upstream-2.39-124.patch create mode 100644 SOURCES/glibc-upstream-2.39-125.patch create mode 100644 SOURCES/glibc-upstream-2.39-126.patch create mode 100644 SOURCES/glibc-upstream-2.39-127.patch create mode 100644 SOURCES/glibc-upstream-2.39-128.patch create mode 100644 SOURCES/glibc-upstream-2.39-129.patch create mode 100644 SOURCES/glibc-upstream-2.39-130.patch create mode 100644 SOURCES/glibc-upstream-2.39-131.patch create mode 100644 SOURCES/glibc-upstream-2.39-132.patch create mode 100644 SOURCES/glibc-upstream-2.39-133.patch create mode 100644 SOURCES/glibc-upstream-2.39-134.patch create mode 100644 SOURCES/glibc-upstream-2.39-135.patch create mode 100644 SOURCES/glibc-upstream-2.39-136.patch create mode 100644 SOURCES/glibc-upstream-2.39-137.patch create mode 100644 SOURCES/glibc-upstream-2.39-95.patch create mode 100644 SOURCES/glibc-upstream-2.39-96.patch create mode 100644 SOURCES/glibc-upstream-2.39-97.patch create mode 100644 SOURCES/glibc-upstream-2.39-98.patch create mode 100644 SOURCES/glibc-upstream-2.39-99.patch diff --git a/SOURCES/glibc-RHEL-12867-2.patch b/SOURCES/glibc-RHEL-12867-2.patch new file mode 100644 index 0000000..4f67be7 --- /dev/null +++ b/SOURCES/glibc-RHEL-12867-2.patch @@ -0,0 +1,117 @@ +commit 4f5704ea347e52ac3f272d1341da10aed6e9973e +Author: Florian Weimer +Date: Tue Dec 10 16:17:06 2024 +0100 + + powerpc: Use correct procedure call standard for getrandom vDSO call (bug 32440) + + A plain indirect function call does not work on POWER because + success and failure are signaled through a flag register, and + not via the usual Linux negative return value convention. + + This has potential security impact, in two ways: the return value + could be out of bounds (EAGAIN is 11 on powerpc6le), and no + random bytes have been written despite the non-error return value. + + Fixes commit 461cab1de747f3842f27a5d24977d78d561d45f9 ("linux: Add + support for getrandom vDSO"). + + Reported-by: Ján Stanček + Reviewed-by: Carlos O'Donell + +diff --git a/stdlib/Makefile b/stdlib/Makefile +index 44a118da59f96c17..d3f55249434cc3e8 100644 +--- a/stdlib/Makefile ++++ b/stdlib/Makefile +@@ -276,6 +276,7 @@ tests := \ + tst-cxa_atexit \ + tst-environ \ + tst-getrandom \ ++ tst-getrandom-errno \ + tst-getrandom2 \ + tst-labs \ + tst-limits \ +diff --git a/stdlib/tst-getrandom-errno.c b/stdlib/tst-getrandom-errno.c +new file mode 100644 +index 0000000000000000..75a60e53ad4e7350 +--- /dev/null ++++ b/stdlib/tst-getrandom-errno.c +@@ -0,0 +1,37 @@ ++/* Test errno handling in getrandom (bug 32440). ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++#include ++#include ++#include ++ ++static ++int do_test (void) ++{ ++ errno = -1181968554; /* Just a random value. */ ++ char buf[4]; ++ int ret = getrandom (buf, sizeof (buf), -1); /* All flags set. */ ++ if (errno != ENOSYS) ++ TEST_COMPARE (errno, EINVAL); ++ TEST_COMPARE (ret, -1); ++ ++ return 0; ++} ++ ++#include +diff --git a/sysdeps/unix/sysv/linux/getrandom.c b/sysdeps/unix/sysv/linux/getrandom.c +index c8c578263da456b2..0dc8fa6e65b9ef6a 100644 +--- a/sysdeps/unix/sysv/linux/getrandom.c ++++ b/sysdeps/unix/sysv/linux/getrandom.c +@@ -20,6 +20,8 @@ + #include + #include + #include ++#include ++#include + + static inline ssize_t + getrandom_syscall (void *buffer, size_t length, unsigned int flags, +@@ -201,11 +203,12 @@ getrandom_vdso (void *buffer, size_t length, unsigned int flags, bool cancel) + cancellation bridge (__syscall_cancel_arch), use GRND_NONBLOCK so there + is no potential unbounded blocking in the kernel. It should be a rare + situation, only at system startup when RNG is not initialized. */ +- ssize_t ret = GLRO (dl_vdso_getrandom) (buffer, +- length, +- flags | GRND_NONBLOCK, +- state, +- state_size); ++ long int ret = INTERNAL_VSYSCALL_CALL (GLRO (dl_vdso_getrandom), 5, ++ buffer, ++ length, ++ flags | GRND_NONBLOCK, ++ state, ++ state_size); + if (INTERNAL_SYSCALL_ERROR_P (ret)) + { + /* Fallback to the syscall if the kernel would block. */ +@@ -241,7 +244,9 @@ __getrandom_early_init (_Bool initial) + uint32_t mmap_flags; + uint32_t reserved[13]; + } params; +- if (GLRO(dl_vdso_getrandom) (NULL, 0, 0, ¶ms, ~0UL) == 0) ++ long int ret = INTERNAL_VSYSCALL_CALL (GLRO(dl_vdso_getrandom), ++ 5, NULL, 0, 0, ¶ms, ~0UL); ++ if (! INTERNAL_SYSCALL_ERROR_P (ret)) + { + /* Align each opaque state to L1 data cache size to avoid false + sharing. If the size can not be obtained, use the kernel diff --git a/SOURCES/glibc-RHEL-12867-3.patch b/SOURCES/glibc-RHEL-12867-3.patch new file mode 100644 index 0000000..4c09288 --- /dev/null +++ b/SOURCES/glibc-RHEL-12867-3.patch @@ -0,0 +1,32 @@ +commit b933e5cef63a6c136fe57de29eba7abc51b678de +Author: Florian Weimer +Date: Sun Dec 15 17:05:25 2024 +0100 + + Linux: Check for 0 return value from vDSO getrandom probe + + As of Linux 6.13, there is no code in the vDSO that declines this + initialization request with the special ~0UL state size. If the vDSO + has the function, the call succeeds and returns 0. It's expected + that the code would follow the “a negative value indicating an error” + convention, as indicated in the __cvdso_getrandom_data function + comment, so that INTERNAL_SYSCALL_ERROR_P on glibc's side would return + true. This commit changes the commit to check for zero to indicate + success instead, which covers potential future non-zero success + return values and error returns. + + Fixes commit 4f5704ea347e52ac3f272d1341da10aed6e9973e ("powerpc: Use + correct procedure call standard for getrandom vDSO call (bug 32440)"). + +diff --git a/sysdeps/unix/sysv/linux/getrandom.c b/sysdeps/unix/sysv/linux/getrandom.c +index 0dc8fa6e65b9ef6a..d3eab66a1af6229e 100644 +--- a/sysdeps/unix/sysv/linux/getrandom.c ++++ b/sysdeps/unix/sysv/linux/getrandom.c +@@ -246,7 +246,7 @@ __getrandom_early_init (_Bool initial) + } params; + long int ret = INTERNAL_VSYSCALL_CALL (GLRO(dl_vdso_getrandom), + 5, NULL, 0, 0, ¶ms, ~0UL); +- if (! INTERNAL_SYSCALL_ERROR_P (ret)) ++ if (ret == 0) + { + /* Align each opaque state to L1 data cache size to avoid false + sharing. If the size can not be obtained, use the kernel diff --git a/SOURCES/glibc-RHEL-12867.patch b/SOURCES/glibc-RHEL-12867.patch new file mode 100644 index 0000000..9f18ba4 --- /dev/null +++ b/SOURCES/glibc-RHEL-12867.patch @@ -0,0 +1,811 @@ +commit 461cab1de747f3842f27a5d24977d78d561d45f9 +Author: Adhemerval Zanella +Date: Wed Sep 18 16:01:22 2024 +0200 + + linux: Add support for getrandom vDSO + + Linux 6.11 has getrandom() in vDSO. It operates on a thread-local opaque + state allocated with mmap using flags specified by the vDSO. + + Multiple states are allocated at once, as many as fit into a page, and + these are held in an array of available states to be doled out to each + thread upon first use, and recycled when a thread terminates. As these + states run low, more are allocated. + + To make this procedure async-signal-safe, a simple guard is used in the + LSB of the opaque state address, falling back to the syscall if there's + reentrancy contention. + + Also, _Fork() is handled by blocking signals on opaque state allocation + (so _Fork() always sees a consistent state even if it interrupts a + getrandom() call) and by iterating over the thread stack cache on + reclaim_stack. Each opaque state will be in the free states list + (grnd_alloc.states) or allocated to a running thread. + + The cancellation is handled by always using GRND_NONBLOCK flags while + calling the vDSO, and falling back to the cancellable syscall if the + kernel returns EAGAIN (would block). Since getrandom is not defined by + POSIX and cancellation is supported as an extension, the cancellation is + handled as 'may occur' instead of 'shall occur' [1], meaning that if + vDSO does not block (the expected behavior) getrandom will not act as a + cancellation entrypoint. It avoids a pthread_testcancel call on the fast + path (different than 'shall occur' functions, like sem_wait()). + + It is currently enabled for x86_64, which is available in Linux 6.11, + and aarch64, powerpc32, powerpc64, loongarch64, and s390x, which are + available in Linux 6.12. + + Link: https://pubs.opengroup.org/onlinepubs/9799919799/nframe.html [1] + Co-developed-by: Jason A. Donenfeld + Tested-by: Jason A. Donenfeld # x86_64 + Tested-by: Adhemerval Zanella # x86_64, aarch64 + Tested-by: Xi Ruoyao # x86_64, aarch64, loongarch64 + Tested-by: Stefan Liebler # s390x + +Conflicts: + stdlib/Makefile + (usual test differences) + sysdeps/unix/sysv/linux/dl-vdso-setup.h + (glibc-2.39 does not have riscv hwprobe vdso support) + +diff --git a/elf/libc_early_init.c b/elf/libc_early_init.c +index 575b837f8f43cb75..20c71fd48b5bd604 100644 +--- a/elf/libc_early_init.c ++++ b/elf/libc_early_init.c +@@ -23,6 +23,7 @@ + #include + #include + #include ++#include + + #ifdef SHARED + _Bool __libc_initial; +@@ -43,6 +44,8 @@ __libc_early_init (_Bool initial) + + __pthread_early_init (); + ++ __getrandom_early_init (initial); ++ + #if ENABLE_ELISION_SUPPORT + __lll_elision_init (); + #endif +diff --git a/malloc/malloc.c b/malloc/malloc.c +index bcb6e5b83ca9777d..9e577ab90010a0f1 100644 +--- a/malloc/malloc.c ++++ b/malloc/malloc.c +@@ -3140,8 +3140,8 @@ static void + tcache_key_initialize (void) + { + /* We need to use the _nostatus version here, see BZ 29624. */ +- if (__getrandom_nocancel_nostatus (&tcache_key, sizeof(tcache_key), +- GRND_NONBLOCK) ++ if (__getrandom_nocancel_nostatus_direct (&tcache_key, sizeof(tcache_key), ++ GRND_NONBLOCK) + != sizeof (tcache_key)) + { + tcache_key = random_bits (); +diff --git a/nptl/allocatestack.c b/nptl/allocatestack.c +index f35a8369bd5d197a..9ed886573fdc3b7d 100644 +--- a/nptl/allocatestack.c ++++ b/nptl/allocatestack.c +@@ -132,6 +132,8 @@ get_cached_stack (size_t *sizep, void **memp) + __libc_lock_init (result->exit_lock); + memset (&result->tls_state, 0, sizeof result->tls_state); + ++ result->getrandom_buf = NULL; ++ + /* Clear the DTV. */ + dtv_t *dtv = GET_DTV (TLS_TPADJ (result)); + for (size_t cnt = 0; cnt < dtv[-1].counter; ++cnt) +diff --git a/nptl/descr.h b/nptl/descr.h +index 8cef95810c81eb3b..4697f633e16c7359 100644 +--- a/nptl/descr.h ++++ b/nptl/descr.h +@@ -404,6 +404,9 @@ struct pthread + /* Used on strsignal. */ + struct tls_internal_t tls_state; + ++ /* getrandom vDSO per-thread opaque state. */ ++ void *getrandom_buf; ++ + /* rseq area registered with the kernel. Use a custom definition + here to isolate from kernel struct rseq changes. The + implementation of sched_getcpu needs acccess to the cpu_id field; +diff --git a/nptl/pthread_create.c b/nptl/pthread_create.c +index 1d3665d5edb684e3..ef3ec3329027ac9f 100644 +--- a/nptl/pthread_create.c ++++ b/nptl/pthread_create.c +@@ -38,6 +38,7 @@ + #include + #include + #include ++#include + + #include + +@@ -549,6 +550,10 @@ start_thread (void *arg) + } + #endif + ++ /* Release the vDSO getrandom per-thread buffer with all signal blocked, ++ to avoid creating a new free-state block during thread release. */ ++ __getrandom_vdso_release (pd); ++ + if (!pd->user_stack) + advise_stack_range (pd->stackblock, pd->stackblock_size, (uintptr_t) pd, + pd->guardsize); +diff --git a/stdlib/Makefile b/stdlib/Makefile +index 9898cc5d8a560625..44a118da59f96c17 100644 +--- a/stdlib/Makefile ++++ b/stdlib/Makefile +@@ -276,6 +276,7 @@ tests := \ + tst-cxa_atexit \ + tst-environ \ + tst-getrandom \ ++ tst-getrandom2 \ + tst-labs \ + tst-limits \ + tst-llabs \ +@@ -622,3 +623,4 @@ $(objpfx)tst-setcontext3.out: tst-setcontext3.sh $(objpfx)tst-setcontext3 + $(evaluate-test) + + $(objpfx)tst-qsort5: $(libm) ++$(objpfx)tst-getrandom2: $(shared-thread-library) +diff --git a/stdlib/tst-getrandom2.c b/stdlib/tst-getrandom2.c +new file mode 100644 +index 0000000000000000..f085b4b74fcf1a28 +--- /dev/null ++++ b/stdlib/tst-getrandom2.c +@@ -0,0 +1,47 @@ ++/* Tests for the getrandom functions. ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++#include ++#include ++#include ++#include ++ ++static __typeof (getrandom) *getrandom_ptr; ++ ++static void * ++threadfunc (void *ignored) ++{ ++ char buffer; ++ TEST_COMPARE (getrandom_ptr (&buffer, 1, 0), 1); ++ return NULL; ++} ++ ++static int ++do_test (void) ++{ ++ /* Check if issuing getrandom in the secondary libc.so works when ++ the vDSO might be potentially used. */ ++ void *handle = xdlmopen (LM_ID_NEWLM, LIBC_SO, RTLD_NOW); ++ getrandom_ptr = xdlsym (handle, "getrandom"); ++ for (int i = 0; i < 1000; ++i) ++ xpthread_join (xpthread_create (NULL, threadfunc, NULL)); ++ return 0; ++} ++ ++#include +diff --git a/sysdeps/generic/getrandom-internal.h b/sysdeps/generic/getrandom-internal.h +new file mode 100644 +index 0000000000000000..3fe46532a0ed3834 +--- /dev/null ++++ b/sysdeps/generic/getrandom-internal.h +@@ -0,0 +1,26 @@ ++/* Internal definitions for getrandom implementation. ++ Copyright (C) 2024 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 ++ . */ ++ ++#ifndef _GETRANDOM_INTERNAL_H ++#define _GETRANDOM_INTERNAL_H ++ ++static inline void __getrandom_early_init (_Bool) ++{ ++} ++ ++#endif +diff --git a/sysdeps/generic/not-cancel.h b/sysdeps/generic/not-cancel.h +index 2dd10646004611cf..8e3f49cc07c85d76 100644 +--- a/sysdeps/generic/not-cancel.h ++++ b/sysdeps/generic/not-cancel.h +@@ -51,7 +51,9 @@ + __fcntl64 (fd, cmd, __VA_ARGS__) + #define __getrandom_nocancel(buf, size, flags) \ + __getrandom (buf, size, flags) +-#define __getrandom_nocancel_nostatus(buf, size, flags) \ ++#define __getrandom_nocancel_direct(buf, size, flags) \ ++ __getrandom (buf, size, flags) ++#define __getrandom_nocancel_nostatus_direct(buf, size, flags) \ + __getrandom (buf, size, flags) + #define __poll_infinity_nocancel(fds, nfds) \ + __poll (fds, nfds, -1) +diff --git a/sysdeps/mach/hurd/not-cancel.h b/sysdeps/mach/hurd/not-cancel.h +index 69fb3c00ef774d00..ec5f5aa8954baa4d 100644 +--- a/sysdeps/mach/hurd/not-cancel.h ++++ b/sysdeps/mach/hurd/not-cancel.h +@@ -79,7 +79,7 @@ __typeof (__fcntl) __fcntl_nocancel; + /* Non cancellable getrandom syscall that does not also set errno in case of + failure. */ + static inline ssize_t +-__getrandom_nocancel_nostatus (void *buf, size_t buflen, unsigned int flags) ++__getrandom_nocancel_nostatus_direct (void *buf, size_t buflen, unsigned int flags) + { + int save_errno = errno; + ssize_t r = __getrandom (buf, buflen, flags); +@@ -90,6 +90,8 @@ __getrandom_nocancel_nostatus (void *buf, size_t buflen, unsigned int flags) + + #define __getrandom_nocancel(buf, size, flags) \ + __getrandom (buf, size, flags) ++#define __getrandom_nocancel_direct(buf, size, flags) \ ++ __getrandom (buf, size, flags) + + #define __poll_infinity_nocancel(fds, nfds) \ + __poll (fds, nfds, -1) +diff --git a/sysdeps/nptl/_Fork.c b/sysdeps/nptl/_Fork.c +index ef199ddbc37e556c..c82fd50649c427c9 100644 +--- a/sysdeps/nptl/_Fork.c ++++ b/sysdeps/nptl/_Fork.c +@@ -18,6 +18,7 @@ + + #include + #include ++#include + + pid_t + _Fork (void) +@@ -43,6 +44,7 @@ _Fork (void) + self->robust_head.list = &self->robust_head; + INTERNAL_SYSCALL_CALL (set_robust_list, &self->robust_head, + sizeof (struct robust_list_head)); ++ call_function_static_weak (__getrandom_fork_subprocess); + } + return pid; + } +diff --git a/sysdeps/nptl/fork.h b/sysdeps/nptl/fork.h +index 7643926df9e3a22e..eabf3c81b0127b34 100644 +--- a/sysdeps/nptl/fork.h ++++ b/sysdeps/nptl/fork.h +@@ -26,6 +26,7 @@ + #include + #include + #include ++#include + + static inline void + fork_system_setup (void) +@@ -46,6 +47,7 @@ fork_system_setup_after_fork (void) + + call_function_static_weak (__mq_notify_fork_subprocess); + call_function_static_weak (__timer_fork_subprocess); ++ call_function_static_weak (__getrandom_fork_subprocess); + } + + /* In case of a fork() call the memory allocation in the child will be +@@ -128,9 +130,19 @@ reclaim_stacks (void) + curp->specific_used = true; + } + } ++ ++ call_function_static_weak (__getrandom_reset_state, curp); + } + } + ++ /* Also reset stale getrandom states for user stack threads. */ ++ list_for_each (runp, &GL (dl_stack_user)) ++ { ++ struct pthread *curp = list_entry (runp, struct pthread, list); ++ if (curp != self) ++ call_function_static_weak (__getrandom_reset_state, curp); ++ } ++ + /* Add the stack of all running threads to the cache. */ + list_splice (&GL (dl_stack_used), &GL (dl_stack_cache)); + +diff --git a/sysdeps/unix/sysv/linux/aarch64/sysdep.h b/sysdeps/unix/sysv/linux/aarch64/sysdep.h +index bbbe35723cac80ef..974b503b2f93511d 100644 +--- a/sysdeps/unix/sysv/linux/aarch64/sysdep.h ++++ b/sysdeps/unix/sysv/linux/aarch64/sysdep.h +@@ -164,6 +164,7 @@ + # define HAVE_CLOCK_GETRES64_VSYSCALL "__kernel_clock_getres" + # define HAVE_CLOCK_GETTIME64_VSYSCALL "__kernel_clock_gettime" + # define HAVE_GETTIMEOFDAY_VSYSCALL "__kernel_gettimeofday" ++# define HAVE_GETRANDOM_VSYSCALL "__kernel_getrandom" + + # define HAVE_CLONE3_WRAPPER 1 + +diff --git a/sysdeps/unix/sysv/linux/dl-vdso-setup.c b/sysdeps/unix/sysv/linux/dl-vdso-setup.c +index 5dd7ed9d126feedc..9afde3d589199e7a 100644 +--- a/sysdeps/unix/sysv/linux/dl-vdso-setup.c ++++ b/sysdeps/unix/sysv/linux/dl-vdso-setup.c +@@ -66,6 +66,11 @@ PROCINFO_CLASS int (*_dl_vdso_clock_getres) (clockid_t, + PROCINFO_CLASS int (*_dl_vdso_clock_getres_time64) (clockid_t, + struct __timespec64 *) RELRO; + # endif ++# ifdef HAVE_GETRANDOM_VSYSCALL ++PROCINFO_CLASS ssize_t (*_dl_vdso_getrandom) (void *buffer, size_t len, ++ unsigned int flags, void *state, ++ size_t state_len) RELRO; ++# endif + + /* PowerPC specific ones. */ + # ifdef HAVE_GET_TBFREQ +diff --git a/sysdeps/unix/sysv/linux/dl-vdso-setup.h b/sysdeps/unix/sysv/linux/dl-vdso-setup.h +index e87d88694098588e..e8faeaef7d2c127a 100644 +--- a/sysdeps/unix/sysv/linux/dl-vdso-setup.h ++++ b/sysdeps/unix/sysv/linux/dl-vdso-setup.h +@@ -47,6 +47,9 @@ setup_vdso_pointers (void) + #ifdef HAVE_GET_TBFREQ + GLRO(dl_vdso_get_tbfreq) = dl_vdso_vsym (HAVE_GET_TBFREQ); + #endif ++#ifdef HAVE_GETRANDOM_VSYSCALL ++ GLRO(dl_vdso_getrandom) = dl_vdso_vsym (HAVE_GETRANDOM_VSYSCALL); ++#endif + } + + #endif +diff --git a/sysdeps/unix/sysv/linux/getrandom-internal.h b/sysdeps/unix/sysv/linux/getrandom-internal.h +new file mode 100644 +index 0000000000000000..37e6c9bc150ba061 +--- /dev/null ++++ b/sysdeps/unix/sysv/linux/getrandom-internal.h +@@ -0,0 +1,29 @@ ++/* Internal definitions for Linux getrandom implementation. ++ Copyright (C) 2024 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 ++ . */ ++ ++#ifndef _GETRANDOM_INTERNAL_H ++#define _GETRANDOM_INTERNAL_H ++ ++#include ++ ++extern void __getrandom_early_init (_Bool) attribute_hidden; ++ ++extern void __getrandom_fork_subprocess (void) attribute_hidden; ++extern void __getrandom_vdso_release (struct pthread *curp) attribute_hidden; ++extern void __getrandom_reset_state (struct pthread *curp) attribute_hidden; ++#endif +diff --git a/sysdeps/unix/sysv/linux/getrandom.c b/sysdeps/unix/sysv/linux/getrandom.c +index 777d1decf0fa50ea..c8c578263da456b2 100644 +--- a/sysdeps/unix/sysv/linux/getrandom.c ++++ b/sysdeps/unix/sysv/linux/getrandom.c +@@ -21,12 +21,314 @@ + #include + #include + ++static inline ssize_t ++getrandom_syscall (void *buffer, size_t length, unsigned int flags, ++ bool cancel) ++{ ++ return cancel ++ ? SYSCALL_CANCEL (getrandom, buffer, length, flags) ++ : INLINE_SYSCALL_CALL (getrandom, buffer, length, flags); ++} ++ ++#ifdef HAVE_GETRANDOM_VSYSCALL ++# include ++# include ++# include ++# include ++# include ++# include ++# include ++# include ++ ++/* These values will be initialized at loading time by calling the ++ _dl_vdso_getrandom with a special value. The 'state_size' is the opaque ++ state size per-thread allocated with a mmap using 'mmap_prot' and ++ 'mmap_flags' argument. */ ++static uint32_t state_size; ++static uint32_t state_size_cache_aligned; ++static uint32_t mmap_prot; ++static uint32_t mmap_flags; ++ ++/* The function below are used on reentracy handling with (i.e. SA_NODEFER). ++ Before allocating a new state or issue the vDSO, atomically read the ++ current thread buffer, and if this is already reserved (is_reserved_ptr) ++ fallback to the syscall. Otherwise, reserve the buffer by atomically ++ setting the LSB of the opaque state pointer. The bit is cleared after the ++ vDSO is called, or before issuing the fallback syscall. */ ++ ++static inline void *reserve_ptr (void *p) ++{ ++ return (void *) ((uintptr_t) (p) | 1UL); ++} ++ ++static inline void *release_ptr (void *p) ++{ ++ return (void *) ((uintptr_t) (p) & ~1UL); ++} ++ ++static inline bool is_reserved_ptr (void *p) ++{ ++ return (uintptr_t) (p) & 1UL; ++} ++ ++static struct ++{ ++ __libc_lock_define (, lock); ++ ++ void **states; /* Queue of opaque states allocated with the kernel ++ provided flags and used on getrandom vDSO call. */ ++ size_t len; /* Number of available free states in the queue. */ ++ size_t total; /* Number of states allocated from the kernel. */ ++ size_t cap; /* Total number of states that 'states' can hold before ++ needed to be resized. */ ++} grnd_alloc = { ++ .lock = LLL_LOCK_INITIALIZER ++}; ++ ++static bool ++vgetrandom_get_state_alloc (void) ++{ ++ /* Start by allocating one page for the opaque states. */ ++ size_t block_size = ALIGN_UP (state_size_cache_aligned, GLRO(dl_pagesize)); ++ size_t states_per_page = GLRO (dl_pagesize) / state_size_cache_aligned; ++ void *block = __mmap (NULL, GLRO(dl_pagesize), mmap_prot, mmap_flags, -1, 0); ++ if (block == MAP_FAILED) ++ return false; ++ __set_vma_name (block, block_size, " glibc: getrandom"); ++ ++ if (grnd_alloc.total + states_per_page > grnd_alloc.cap) ++ { ++ /* Use a new mmap instead of trying to mremap. It avoids a ++ potential multithread fork issue where fork is called just after ++ mremap returns but before assigning to the grnd_alloc.states, ++ thus making the its value invalid in the child. */ ++ void *old_states = grnd_alloc.states; ++ size_t new_states_size = ALIGN_UP ((grnd_alloc.total + states_per_page) ++ * sizeof (*grnd_alloc.states), ++ GLRO(dl_pagesize)); ++ ++ /* There is no need to memcpy any opaque state information because ++ all the allocated opaque states are assigned to running threads ++ (meaning that if we iterate over them we can reconstruct the state ++ list). */ ++ void **states = __mmap (NULL, new_states_size, PROT_READ | PROT_WRITE, ++ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); ++ if (states == MAP_FAILED) ++ { ++ __munmap (block, block_size); ++ return false; ++ } ++ ++ /* Atomically replace the old state, so if a fork happens the child ++ process will see a consistent free state buffer. The size might ++ not be updated, but it does not really matter since the buffer is ++ always increased. */ ++ grnd_alloc.states = states; ++ atomic_thread_fence_seq_cst (); ++ if (old_states != NULL) ++ __munmap (old_states, grnd_alloc.cap * sizeof (*grnd_alloc.states)); ++ ++ __set_vma_name (states, new_states_size, " glibc: getrandom states"); ++ grnd_alloc.cap = new_states_size / sizeof (*grnd_alloc.states); ++ atomic_thread_fence_seq_cst (); ++ } ++ ++ for (size_t i = 0; i < states_per_page; ++i) ++ { ++ /* There is no need to handle states that straddle a page because ++ we allocate only one page. */ ++ grnd_alloc.states[i] = block; ++ block += state_size_cache_aligned; ++ } ++ /* Concurrent fork should not observe the previous pointer value. */ ++ grnd_alloc.len = states_per_page; ++ grnd_alloc.total += states_per_page; ++ atomic_thread_fence_seq_cst (); ++ ++ return true; ++} ++ ++/* Allocate an opaque state for vgetrandom. If the grnd_alloc does not have ++ any, mmap() another page of them using the vgetrandom parameters. */ ++static void * ++vgetrandom_get_state (void) ++{ ++ void *state = NULL; ++ ++ /* The signal blocking avoid the potential issue where _Fork() (which is ++ async-signal-safe) is called with the lock taken. The function is ++ called only once during thread lifetime, so the overhead should be ++ minimal. */ ++ internal_sigset_t set; ++ internal_signal_block_all (&set); ++ __libc_lock_lock (grnd_alloc.lock); ++ ++ if (grnd_alloc.len > 0 || vgetrandom_get_state_alloc ()) ++ state = grnd_alloc.states[--grnd_alloc.len]; ++ ++ __libc_lock_unlock (grnd_alloc.lock); ++ internal_signal_restore_set (&set); ++ ++ return state; ++} ++ ++/* Returns true when vgetrandom is used successfully. Returns false if the ++ syscall fallback should be issued in the case the vDSO is not present, in ++ the case of reentrancy, or if any memory allocation fails. */ ++static ssize_t ++getrandom_vdso (void *buffer, size_t length, unsigned int flags, bool cancel) ++{ ++ if (__glibc_unlikely (state_size == 0)) ++ return getrandom_syscall (buffer, length, flags, cancel); ++ ++ struct pthread *self = THREAD_SELF; ++ ++ void *state = atomic_load_relaxed (&self->getrandom_buf); ++ if (is_reserved_ptr (state)) ++ return getrandom_syscall (buffer, length, flags, cancel); ++ atomic_store_relaxed (&self->getrandom_buf, reserve_ptr (state)); ++ __atomic_signal_fence (__ATOMIC_ACQ_REL); ++ ++ bool r = false; ++ if (state == NULL) ++ { ++ state = vgetrandom_get_state (); ++ if (state == NULL) ++ goto out; ++ } ++ ++ /* Since the vDSO implementation does not issue the syscall with the ++ cancellation bridge (__syscall_cancel_arch), use GRND_NONBLOCK so there ++ is no potential unbounded blocking in the kernel. It should be a rare ++ situation, only at system startup when RNG is not initialized. */ ++ ssize_t ret = GLRO (dl_vdso_getrandom) (buffer, ++ length, ++ flags | GRND_NONBLOCK, ++ state, ++ state_size); ++ if (INTERNAL_SYSCALL_ERROR_P (ret)) ++ { ++ /* Fallback to the syscall if the kernel would block. */ ++ int err = INTERNAL_SYSCALL_ERRNO (ret); ++ if (err == EAGAIN && !(flags & GRND_NONBLOCK)) ++ goto out; ++ ++ __set_errno (err); ++ ret = -1; ++ } ++ r = true; ++ ++out: ++ __atomic_signal_fence (__ATOMIC_ACQ_REL); ++ atomic_store_relaxed (&self->getrandom_buf, state); ++ return r ? ret : getrandom_syscall (buffer, length, flags, cancel); ++} ++#endif ++ ++void ++__getrandom_early_init (_Bool initial) ++{ ++#ifdef HAVE_GETRANDOM_VSYSCALL ++ /* libcs loaded for audit modules, dlmopen, etc. fallback to syscall. */ ++ if (initial && (GLRO (dl_vdso_getrandom) != NULL)) ++ { ++ /* Used to query the vDSO for the required mmap flags and the opaque ++ per-thread state size. Defined by linux/random.h. */ ++ struct vgetrandom_opaque_params ++ { ++ uint32_t size_of_opaque_state; ++ uint32_t mmap_prot; ++ uint32_t mmap_flags; ++ uint32_t reserved[13]; ++ } params; ++ if (GLRO(dl_vdso_getrandom) (NULL, 0, 0, ¶ms, ~0UL) == 0) ++ { ++ /* Align each opaque state to L1 data cache size to avoid false ++ sharing. If the size can not be obtained, use the kernel ++ provided one. */ ++ state_size = params.size_of_opaque_state; ++ ++ long int ld1sz = __sysconf (_SC_LEVEL1_DCACHE_LINESIZE); ++ if (ld1sz <= 0) ++ ld1sz = 1; ++ state_size_cache_aligned = ALIGN_UP (state_size, ld1sz); ++ /* Do not enable vDSO if the required opaque state size is larger ++ than a page because we only allocate one page per time to hold ++ the states. */ ++ if (state_size_cache_aligned > GLRO(dl_pagesize)) ++ { ++ state_size = 0; ++ return; ++ } ++ mmap_prot = params.mmap_prot; ++ mmap_flags = params.mmap_flags; ++ } ++ } ++#endif ++} ++ ++/* Re-add the state state from CURP on the free list. This function is ++ called after fork returns in the child, so no locking is required. */ ++void ++__getrandom_reset_state (struct pthread *curp) ++{ ++#ifdef HAVE_GETRANDOM_VSYSCALL ++ if (grnd_alloc.states == NULL || curp->getrandom_buf == NULL) ++ return; ++ assert (grnd_alloc.len < grnd_alloc.cap); ++ grnd_alloc.states[grnd_alloc.len++] = release_ptr (curp->getrandom_buf); ++ curp->getrandom_buf = NULL; ++#endif ++} ++ ++/* Called when a thread terminates, and adds its random buffer back into the ++ allocator pool for use in a future thread. This is called by ++ pthread_create during thread termination, and after signal has been ++ blocked. */ ++void ++__getrandom_vdso_release (struct pthread *curp) ++{ ++#ifdef HAVE_GETRANDOM_VSYSCALL ++ if (curp->getrandom_buf == NULL) ++ return; ++ ++ __libc_lock_lock (grnd_alloc.lock); ++ grnd_alloc.states[grnd_alloc.len++] = curp->getrandom_buf; ++ __libc_lock_unlock (grnd_alloc.lock); ++#endif ++} ++ ++/* Reset the internal lock state in case another thread has locked while ++ this thread calls fork. The stale thread states will be handled by ++ reclaim_stacks which calls __getrandom_reset_state on each thread. */ ++void ++__getrandom_fork_subprocess (void) ++{ ++#ifdef HAVE_GETRANDOM_VSYSCALL ++ grnd_alloc.lock = LLL_LOCK_INITIALIZER; ++#endif ++} ++ ++ssize_t ++__getrandom_nocancel (void *buffer, size_t length, unsigned int flags) ++{ ++#ifdef HAVE_GETRANDOM_VSYSCALL ++ return getrandom_vdso (buffer, length, flags, false); ++#else ++ return getrandom_syscall (buffer, length, flags, false); ++#endif ++} ++ + /* Write up to LENGTH bytes of randomness starting at BUFFER. + Return the number of bytes written, or -1 on error. */ + ssize_t + __getrandom (void *buffer, size_t length, unsigned int flags) + { +- return SYSCALL_CANCEL (getrandom, buffer, length, flags); ++#ifdef HAVE_GETRANDOM_VSYSCALL ++ return getrandom_vdso (buffer, length, flags, true); ++#else ++ return getrandom_syscall (buffer, length, flags, true); ++#endif + } + libc_hidden_def (__getrandom) + weak_alias (__getrandom, getrandom) +diff --git a/sysdeps/unix/sysv/linux/loongarch/sysdep.h b/sysdeps/unix/sysv/linux/loongarch/sysdep.h +index eb0ba790daa6e27c..e2d853ae3e3c77fb 100644 +--- a/sysdeps/unix/sysv/linux/loongarch/sysdep.h ++++ b/sysdeps/unix/sysv/linux/loongarch/sysdep.h +@@ -119,6 +119,7 @@ + #define HAVE_CLOCK_GETTIME64_VSYSCALL "__vdso_clock_gettime" + #define HAVE_GETTIMEOFDAY_VSYSCALL "__vdso_gettimeofday" + #define HAVE_GETCPU_VSYSCALL "__vdso_getcpu" ++#define HAVE_GETRANDOM_VSYSCALL "__vdso_getrandom" + + #define HAVE_CLONE3_WRAPPER 1 + +diff --git a/sysdeps/unix/sysv/linux/not-cancel.h b/sysdeps/unix/sysv/linux/not-cancel.h +index 2a7585b73f2b23f7..12f26912d3f03640 100644 +--- a/sysdeps/unix/sysv/linux/not-cancel.h ++++ b/sysdeps/unix/sysv/linux/not-cancel.h +@@ -27,6 +27,7 @@ + #include + #include + #include ++#include + + /* Non cancellable open syscall. */ + __typeof (open) __open_nocancel; +@@ -84,15 +85,17 @@ __writev_nocancel_nostatus (int fd, const struct iovec *iov, int iovcnt) + } + + static inline ssize_t +-__getrandom_nocancel (void *buf, size_t buflen, unsigned int flags) ++__getrandom_nocancel_direct (void *buf, size_t buflen, unsigned int flags) + { + return INLINE_SYSCALL_CALL (getrandom, buf, buflen, flags); + } + ++__typeof (getrandom) __getrandom_nocancel attribute_hidden; ++ + /* Non cancellable getrandom syscall that does not also set errno in case of + failure. */ + static inline ssize_t +-__getrandom_nocancel_nostatus (void *buf, size_t buflen, unsigned int flags) ++__getrandom_nocancel_nostatus_direct (void *buf, size_t buflen, unsigned int flags) + { + return INTERNAL_SYSCALL_CALL (getrandom, buf, buflen, flags); + } +diff --git a/sysdeps/unix/sysv/linux/powerpc/sysdep.h b/sysdeps/unix/sysv/linux/powerpc/sysdep.h +index a69b7db33843d488..48f3d0d1b2c271cf 100644 +--- a/sysdeps/unix/sysv/linux/powerpc/sysdep.h ++++ b/sysdeps/unix/sysv/linux/powerpc/sysdep.h +@@ -223,5 +223,6 @@ + #define HAVE_TIME_VSYSCALL "__kernel_time" + #define HAVE_GETTIMEOFDAY_VSYSCALL "__kernel_gettimeofday" + #define HAVE_GET_TBFREQ "__kernel_get_tbfreq" ++#define HAVE_GETRANDOM_VSYSCALL "__kernel_getrandom" + + #endif /* _LINUX_POWERPC_SYSDEP_H */ +diff --git a/sysdeps/unix/sysv/linux/s390/sysdep.h b/sysdeps/unix/sysv/linux/s390/sysdep.h +index 9b3000ca62a0e00d..9698c57a03d19607 100644 +--- a/sysdeps/unix/sysv/linux/s390/sysdep.h ++++ b/sysdeps/unix/sysv/linux/s390/sysdep.h +@@ -72,6 +72,7 @@ + #ifdef __s390x__ + #define HAVE_CLOCK_GETRES64_VSYSCALL "__kernel_clock_getres" + #define HAVE_CLOCK_GETTIME64_VSYSCALL "__kernel_clock_gettime" ++#define HAVE_GETRANDOM_VSYSCALL "__kernel_getrandom" + #else + #define HAVE_CLOCK_GETRES_VSYSCALL "__kernel_clock_getres" + #define HAVE_CLOCK_GETTIME_VSYSCALL "__kernel_clock_gettime" +diff --git a/sysdeps/unix/sysv/linux/x86_64/sysdep.h b/sysdeps/unix/sysv/linux/x86_64/sysdep.h +index a2b021bd86f5d472..7dc072ae2da8f7c3 100644 +--- a/sysdeps/unix/sysv/linux/x86_64/sysdep.h ++++ b/sysdeps/unix/sysv/linux/x86_64/sysdep.h +@@ -376,6 +376,7 @@ + # define HAVE_TIME_VSYSCALL "__vdso_time" + # define HAVE_GETCPU_VSYSCALL "__vdso_getcpu" + # define HAVE_CLOCK_GETRES64_VSYSCALL "__vdso_clock_getres" ++# define HAVE_GETRANDOM_VSYSCALL "__vdso_getrandom" + + # define HAVE_CLONE3_WRAPPER 1 + diff --git a/SOURCES/glibc-build-xtests-1.patch b/SOURCES/glibc-build-xtests-1.patch new file mode 100644 index 0000000..134acc9 --- /dev/null +++ b/SOURCES/glibc-build-xtests-1.patch @@ -0,0 +1,28 @@ +commit 734e7f91e752f44984fe42c2384c23a0290b6e56 +Author: Samuel Thibault +Date: Tue Aug 20 16:22:07 2024 +0200 + + Rules: Also build memcheck tests even when not running them + + This will avoid in the future cases like a57cbbd85379 ("malloc: Link + threading tests with $(shared-thread-library") missing the memcheck + cases added in 251843e16fce ("malloc: Link threading tests with + $(shared-thread-library)") + +diff --git a/Rules b/Rules +index 9010c5d5b269a805..27846abf82b65f60 100644 +--- a/Rules ++++ b/Rules +@@ -145,7 +145,11 @@ others: $(py-const) + ifeq ($(run-built-tests),no) + tests: $(addprefix $(objpfx),$(filter-out $(tests-unsupported), \ + $(tests) $(tests-internal) \ +- $(tests-container)) \ ++ $(tests-container) \ ++ $(tests-mcheck:%=%-mcheck) \ ++ $(tests-malloc-check:%=%-malloc-check) \ ++ $(tests-malloc-hugetlb1:%=%-malloc-hugetlb1) \ ++ $(tests-malloc-hugetlb2:%=%-malloc-hugetlb2)) \ + $(test-srcs)) $(tests-special) \ + $(tests-printers-programs) + xtests: tests $(xtests-special) diff --git a/SOURCES/glibc-build-xtests-2.patch b/SOURCES/glibc-build-xtests-2.patch new file mode 100644 index 0000000..73049c1 --- /dev/null +++ b/SOURCES/glibc-build-xtests-2.patch @@ -0,0 +1,82 @@ +commit d5a3ca4061f7adc59196fa58e34eacebbebcbcfe +Author: Florian Weimer +Date: Thu Sep 19 15:40:05 2024 +0200 + + Implement run-built-tests=no for make xcheck, always build xtests + + Previously, the second occurrence of the xtests target + expected all xtests to run (as the result of specifying + $(xtests)), but these tests have not been run due to + the the first xtests target is set up for run-built-tests=no: + it only runs tests in $(xtests-special). Consequently, + xtests are reported as UNSUPPORTED with “make xcheck + run-built-tests=no”. The xtests were not built, either. + + After this change always, xtests are built regardless + of the $(run-built-tests) variable (except for xtests listed + in $(tests-unsupported)). To fix the UNSUPPORTED issue, + introduce xtests-expected and use that manage test + expectations in the second xtests target. + + Reviewed-by: Carlos O'Donell + +diff --git a/Rules b/Rules +index 27846abf82b65f60..713c225d2ebf5506 100644 +--- a/Rules ++++ b/Rules +@@ -143,8 +143,9 @@ endif + others: $(py-const) + + ifeq ($(run-built-tests),no) ++# The $(xtests) dependency ensures that xtests are always built. + tests: $(addprefix $(objpfx),$(filter-out $(tests-unsupported), \ +- $(tests) $(tests-internal) \ ++ $(tests) $(tests-internal) $(xtests) \ + $(tests-container) \ + $(tests-mcheck:%=%-mcheck) \ + $(tests-malloc-check:%=%-malloc-check) \ +@@ -153,8 +154,10 @@ tests: $(addprefix $(objpfx),$(filter-out $(tests-unsupported), \ + $(test-srcs)) $(tests-special) \ + $(tests-printers-programs) + xtests: tests $(xtests-special) +-else ++else # $(run-built-tests) != no ++# The $(xtests) dependency ensures that xtests are always built. + tests: $(tests:%=$(objpfx)%.out) $(tests-internal:%=$(objpfx)%.out) \ ++ $(addprefix $(objpfx),$(filter-out $(tests-unsupported), $(xtests))) \ + $(tests-container:%=$(objpfx)%.out) \ + $(tests-mcheck:%=$(objpfx)%-mcheck.out) \ + $(tests-malloc-check:%=$(objpfx)%-malloc-check.out) \ +@@ -162,26 +165,28 @@ tests: $(tests:%=$(objpfx)%.out) $(tests-internal:%=$(objpfx)%.out) \ + $(tests-malloc-hugetlb2:%=$(objpfx)%-malloc-hugetlb2.out) \ + $(tests-special) $(tests-printers-out) + xtests: tests $(xtests:%=$(objpfx)%.out) $(xtests-special) +-endif ++endif # $(run-built-tests) != no + + tests-special-notdir = $(patsubst $(objpfx)%, %, $(tests-special)) + xtests-special-notdir = $(patsubst $(objpfx)%, %, $(xtests-special)) + ifeq ($(run-built-tests),no) + tests-expected = +-else ++xtests-expected = ++else # $(run-built-tests) != no + tests-expected = $(tests) $(tests-internal) $(tests-printers) \ + $(tests-container) $(tests-malloc-check:%=%-malloc-check) \ + $(tests-malloc-hugetlb1:%=%-malloc-hugetlb1) \ + $(tests-malloc-hugetlb2:%=%-malloc-hugetlb2) \ + $(tests-mcheck:%=%-mcheck) +-endif ++xtests-expected = $(xtests) ++endif # $(run-built-tests) != no + tests: + $(..)scripts/merge-test-results.sh -s $(objpfx) $(subdir) \ + $(sort $(tests-expected) $(tests-special-notdir:.out=)) \ + > $(objpfx)subdir-tests.sum + xtests: + $(..)scripts/merge-test-results.sh -s $(objpfx) $(subdir) \ +- $(sort $(xtests) $(xtests-special-notdir:.out=)) \ ++ $(sort $(xtests-expected) $(xtests-special-notdir:.out=)) \ + > $(objpfx)subdir-xtests.sum + + ifeq ($(build-programs),yes) diff --git a/SOURCES/glibc-upstream-2.39-100.patch b/SOURCES/glibc-upstream-2.39-100.patch new file mode 100644 index 0000000..0eeecc0 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-100.patch @@ -0,0 +1,29 @@ +commit 5a5eb72d8ee4783c28fead080143d53cac993e1d +Author: Florian Weimer +Date: Thu Aug 1 10:46:10 2024 +0200 + + resolv: Fix tst-resolv-short-response for older GCC (bug 32042) + + Previous GCC versions do not support the C23 change that + allows labels on declarations. + + Reviewed-by: Adhemerval Zanella + (cherry picked from commit ec119972cb2598c04ec7d4219e20506006836f64) + +diff --git a/resolv/tst-resolv-short-response.c b/resolv/tst-resolv-short-response.c +index be354ae1c7f2a81a..9b06b0c1762f860c 100644 +--- a/resolv/tst-resolv-short-response.c ++++ b/resolv/tst-resolv-short-response.c +@@ -33,8 +33,10 @@ response (const struct resolv_response_context *ctx, + { + case 0: + /* First server times out. */ +- struct resolv_response_flags flags = {.rcode = rcode}; +- resolv_response_init (b, flags); ++ { ++ struct resolv_response_flags flags = {.rcode = rcode}; ++ resolv_response_init (b, flags); ++ } + break; + case 1: + /* Second server sends reply. */ diff --git a/SOURCES/glibc-upstream-2.39-101.patch b/SOURCES/glibc-upstream-2.39-101.patch new file mode 100644 index 0000000..5d94db8 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-101.patch @@ -0,0 +1,277 @@ +commit afc15c2044cb9449ba506fe910fa8ab77394833c +Author: Andreas Schwab +Date: Mon Aug 5 10:55:51 2024 +0200 + + Fix name space violation in fortify wrappers (bug 32052) + + Rename the identifier sz to __sz everywhere. + + Fixes: a643f60c53 ("Make sure that the fortified function conditionals are constant") + (cherry picked from commit 39ca997ab378990d5ac1aadbaa52aaf1db6d526f) + (redone from scratch because of many conflicts) + +diff --git a/libio/bits/stdio2.h b/libio/bits/stdio2.h +index f9e8d37610d720aa..0dc4e87c652471f6 100644 +--- a/libio/bits/stdio2.h ++++ b/libio/bits/stdio2.h +@@ -195,24 +195,24 @@ __fortify_function __wur __fortified_attr_access (__write_only__, 1, 2) + __nonnull ((3)) char * + fgets (char *__restrict __s, int __n, FILE *__restrict __stream) + { +- size_t sz = __glibc_objsize (__s); +- if (__glibc_safe_or_unknown_len (__n, sizeof (char), sz)) ++ size_t __sz = __glibc_objsize (__s); ++ if (__glibc_safe_or_unknown_len (__n, sizeof (char), __sz)) + return __fgets_alias (__s, __n, __stream); +- if (__glibc_unsafe_len (__n, sizeof (char), sz)) +- return __fgets_chk_warn (__s, sz, __n, __stream); +- return __fgets_chk (__s, sz, __n, __stream); ++ if (__glibc_unsafe_len (__n, sizeof (char), __sz)) ++ return __fgets_chk_warn (__s, __sz, __n, __stream); ++ return __fgets_chk (__s, __sz, __n, __stream); + } + + __fortify_function __wur __nonnull ((4)) size_t + fread (void *__restrict __ptr, size_t __size, size_t __n, + FILE *__restrict __stream) + { +- size_t sz = __glibc_objsize0 (__ptr); +- if (__glibc_safe_or_unknown_len (__n, __size, sz)) ++ size_t __sz = __glibc_objsize0 (__ptr); ++ if (__glibc_safe_or_unknown_len (__n, __size, __sz)) + return __fread_alias (__ptr, __size, __n, __stream); +- if (__glibc_unsafe_len (__n, __size, sz)) +- return __fread_chk_warn (__ptr, sz, __size, __n, __stream); +- return __fread_chk (__ptr, sz, __size, __n, __stream); ++ if (__glibc_unsafe_len (__n, __size, __sz)) ++ return __fread_chk_warn (__ptr, __sz, __size, __n, __stream); ++ return __fread_chk (__ptr, __sz, __size, __n, __stream); + } + + #ifdef __USE_GNU +@@ -220,12 +220,12 @@ __fortify_function __wur __fortified_attr_access (__write_only__, 1, 2) + __nonnull ((3)) char * + fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream) + { +- size_t sz = __glibc_objsize (__s); +- if (__glibc_safe_or_unknown_len (__n, sizeof (char), sz)) ++ size_t __sz = __glibc_objsize (__s); ++ if (__glibc_safe_or_unknown_len (__n, sizeof (char), __sz)) + return __fgets_unlocked_alias (__s, __n, __stream); +- if (__glibc_unsafe_len (__n, sizeof (char), sz)) +- return __fgets_unlocked_chk_warn (__s, sz, __n, __stream); +- return __fgets_unlocked_chk (__s, sz, __n, __stream); ++ if (__glibc_unsafe_len (__n, sizeof (char), __sz)) ++ return __fgets_unlocked_chk_warn (__s, __sz, __n, __stream); ++ return __fgets_unlocked_chk (__s, __sz, __n, __stream); + } + #endif + +@@ -235,8 +235,8 @@ __fortify_function __wur __nonnull ((4)) size_t + fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n, + FILE *__restrict __stream) + { +- size_t sz = __glibc_objsize0 (__ptr); +- if (__glibc_safe_or_unknown_len (__n, __size, sz)) ++ size_t __sz = __glibc_objsize0 (__ptr); ++ if (__glibc_safe_or_unknown_len (__n, __size, __sz)) + { + # ifdef __USE_EXTERN_INLINES + if (__builtin_constant_p (__size) +@@ -261,9 +261,9 @@ fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n, + # endif + return __fread_unlocked_alias (__ptr, __size, __n, __stream); + } +- if (__glibc_unsafe_len (__n, __size, sz)) +- return __fread_unlocked_chk_warn (__ptr, sz, __size, __n, __stream); +- return __fread_unlocked_chk (__ptr, sz, __size, __n, __stream); ++ if (__glibc_unsafe_len (__n, __size, __sz)) ++ return __fread_unlocked_chk_warn (__ptr, __sz, __size, __n, __stream); ++ return __fread_unlocked_chk (__ptr, __sz, __size, __n, __stream); + + } + #endif +diff --git a/socket/bits/socket2.h b/socket/bits/socket2.h +index a88cb643703a4008..71f8d9c741049afd 100644 +--- a/socket/bits/socket2.h ++++ b/socket/bits/socket2.h +@@ -33,12 +33,12 @@ extern ssize_t __REDIRECT (__recv_chk_warn, + __fortify_function ssize_t + recv (int __fd, void *__buf, size_t __n, int __flags) + { +- size_t sz = __glibc_objsize0 (__buf); +- if (__glibc_safe_or_unknown_len (__n, sizeof (char), sz)) ++ size_t __sz = __glibc_objsize0 (__buf); ++ if (__glibc_safe_or_unknown_len (__n, sizeof (char), __sz)) + return __recv_alias (__fd, __buf, __n, __flags); +- if (__glibc_unsafe_len (__n, sizeof (char), sz)) +- return __recv_chk_warn (__fd, __buf, __n, sz, __flags); +- return __recv_chk (__fd, __buf, __n, sz, __flags); ++ if (__glibc_unsafe_len (__n, sizeof (char), __sz)) ++ return __recv_chk_warn (__fd, __buf, __n, __sz, __flags); ++ return __recv_chk (__fd, __buf, __n, __sz, __flags); + } + + extern ssize_t __recvfrom_chk (int __fd, void *__restrict __buf, size_t __n, +@@ -61,11 +61,11 @@ __fortify_function ssize_t + recvfrom (int __fd, void *__restrict __buf, size_t __n, int __flags, + __SOCKADDR_ARG __addr, socklen_t *__restrict __addr_len) + { +- size_t sz = __glibc_objsize0 (__buf); +- if (__glibc_safe_or_unknown_len (__n, sizeof (char), sz)) ++ size_t __sz = __glibc_objsize0 (__buf); ++ if (__glibc_safe_or_unknown_len (__n, sizeof (char), __sz)) + return __recvfrom_alias (__fd, __buf, __n, __flags, __addr, __addr_len); +- if (__glibc_unsafe_len (__n, sizeof (char), sz)) +- return __recvfrom_chk_warn (__fd, __buf, __n, sz, __flags, __addr, ++ if (__glibc_unsafe_len (__n, sizeof (char), __sz)) ++ return __recvfrom_chk_warn (__fd, __buf, __n, __sz, __flags, __addr, + __addr_len); +- return __recvfrom_chk (__fd, __buf, __n, sz, __flags, __addr, __addr_len); ++ return __recvfrom_chk (__fd, __buf, __n, __sz, __flags, __addr, __addr_len); + } +diff --git a/stdlib/bits/stdlib.h b/stdlib/bits/stdlib.h +index 1c7191ba574946ef..32f7ef5020eadc4c 100644 +--- a/stdlib/bits/stdlib.h ++++ b/stdlib/bits/stdlib.h +@@ -36,16 +36,16 @@ extern char *__REDIRECT_NTH (__realpath_chk_warn, + __fortify_function __wur char * + __NTH (realpath (const char *__restrict __name, char *__restrict __resolved)) + { +- size_t sz = __glibc_objsize (__resolved); ++ size_t __sz = __glibc_objsize (__resolved); + +- if (sz == (size_t) -1) ++ if (__sz == (size_t) -1) + return __realpath_alias (__name, __resolved); + + #if defined _LIBC_LIMITS_H_ && defined PATH_MAX +- if (__glibc_unsafe_len (PATH_MAX, sizeof (char), sz)) +- return __realpath_chk_warn (__name, __resolved, sz); ++ if (__glibc_unsafe_len (PATH_MAX, sizeof (char), __sz)) ++ return __realpath_chk_warn (__name, __resolved, __sz); + #endif +- return __realpath_chk (__name, __resolved, sz); ++ return __realpath_chk (__name, __resolved, __sz); + } + + +diff --git a/wcsmbs/bits/wchar2.h b/wcsmbs/bits/wchar2.h +index 49f19bca194fd601..c863b60ec203495e 100644 +--- a/wcsmbs/bits/wchar2.h ++++ b/wcsmbs/bits/wchar2.h +@@ -59,18 +59,18 @@ __NTH (wmemset (wchar_t *__s, wchar_t __c, size_t __n)) + __fortify_function wchar_t * + __NTH (wcscpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) + { +- size_t sz = __glibc_objsize (__dest); +- if (sz != (size_t) -1) +- return __wcscpy_chk (__dest, __src, sz / sizeof (wchar_t)); ++ size_t __sz = __glibc_objsize (__dest); ++ if (__sz != (size_t) -1) ++ return __wcscpy_chk (__dest, __src, __sz / sizeof (wchar_t)); + return __wcscpy_alias (__dest, __src); + } + + __fortify_function wchar_t * + __NTH (wcpcpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) + { +- size_t sz = __glibc_objsize (__dest); +- if (sz != (size_t) -1) +- return __wcpcpy_chk (__dest, __src, sz / sizeof (wchar_t)); ++ size_t __sz = __glibc_objsize (__dest); ++ if (__sz != (size_t) -1) ++ return __wcpcpy_chk (__dest, __src, __sz / sizeof (wchar_t)); + return __wcpcpy_alias (__dest, __src); + } + +@@ -95,9 +95,9 @@ __NTH (wcpncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, + __fortify_function wchar_t * + __NTH (wcscat (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) + { +- size_t sz = __glibc_objsize (__dest); +- if (sz != (size_t) -1) +- return __wcscat_chk (__dest, __src, sz / sizeof (wchar_t)); ++ size_t __sz = __glibc_objsize (__dest); ++ if (__sz != (size_t) -1) ++ return __wcscat_chk (__dest, __src, __sz / sizeof (wchar_t)); + return __wcscat_alias (__dest, __src); + } + +@@ -105,9 +105,9 @@ __fortify_function wchar_t * + __NTH (wcsncat (wchar_t *__restrict __dest, const wchar_t *__restrict __src, + size_t __n)) + { +- size_t sz = __glibc_objsize (__dest); +- if (sz != (size_t) -1) +- return __wcsncat_chk (__dest, __src, __n, sz / sizeof (wchar_t)); ++ size_t __sz = __glibc_objsize (__dest); ++ if (__sz != (size_t) -1) ++ return __wcsncat_chk (__dest, __src, __n, __sz / sizeof (wchar_t)); + return __wcsncat_alias (__dest, __src, __n); + } + +@@ -144,10 +144,10 @@ __fortify_function int + __NTH (swprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __fmt, ...)) + { +- size_t sz = __glibc_objsize (__s); +- if (sz != (size_t) -1 || __USE_FORTIFY_LEVEL > 1) ++ size_t __sz = __glibc_objsize (__s); ++ if (__sz != (size_t) -1 || __USE_FORTIFY_LEVEL > 1) + return __swprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, +- sz / sizeof (wchar_t), __fmt, __va_arg_pack ()); ++ __sz / sizeof (wchar_t), __fmt, __va_arg_pack ()); + return __swprintf_alias (__s, __n, __fmt, __va_arg_pack ()); + } + #elif !defined __cplusplus +@@ -163,10 +163,10 @@ __fortify_function int + __NTH (vswprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __fmt, __gnuc_va_list __ap)) + { +- size_t sz = __glibc_objsize (__s); +- if (sz != (size_t) -1 || __USE_FORTIFY_LEVEL > 1) ++ size_t __sz = __glibc_objsize (__s); ++ if (__sz != (size_t) -1 || __USE_FORTIFY_LEVEL > 1) + return __vswprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, +- sz / sizeof (wchar_t), __fmt, __ap); ++ __sz / sizeof (wchar_t), __fmt, __ap); + return __vswprintf_alias (__s, __n, __fmt, __ap); + } + +@@ -210,25 +210,25 @@ vfwprintf (__FILE *__restrict __stream, + __fortify_function __wur wchar_t * + fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) + { +- size_t sz = __glibc_objsize (__s); +- if (__glibc_safe_or_unknown_len (__n, sizeof (wchar_t), sz)) ++ size_t __sz = __glibc_objsize (__s); ++ if (__glibc_safe_or_unknown_len (__n, sizeof (wchar_t), __sz)) + return __fgetws_alias (__s, __n, __stream); +- if (__glibc_unsafe_len (__n, sizeof (wchar_t), sz)) +- return __fgetws_chk_warn (__s, sz / sizeof (wchar_t), __n, __stream); +- return __fgetws_chk (__s, sz / sizeof (wchar_t), __n, __stream); ++ if (__glibc_unsafe_len (__n, sizeof (wchar_t), __sz)) ++ return __fgetws_chk_warn (__s, __sz / sizeof (wchar_t), __n, __stream); ++ return __fgetws_chk (__s, __sz / sizeof (wchar_t), __n, __stream); + } + + #ifdef __USE_GNU + __fortify_function __wur wchar_t * + fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) + { +- size_t sz = __glibc_objsize (__s); +- if (__glibc_safe_or_unknown_len (__n, sizeof (wchar_t), sz)) ++ size_t __sz = __glibc_objsize (__s); ++ if (__glibc_safe_or_unknown_len (__n, sizeof (wchar_t), __sz)) + return __fgetws_unlocked_alias (__s, __n, __stream); +- if (__glibc_unsafe_len (__n, sizeof (wchar_t), sz)) +- return __fgetws_unlocked_chk_warn (__s, sz / sizeof (wchar_t), __n, ++ if (__glibc_unsafe_len (__n, sizeof (wchar_t), __sz)) ++ return __fgetws_unlocked_chk_warn (__s, __sz / sizeof (wchar_t), __n, + __stream); +- return __fgetws_unlocked_chk (__s, sz / sizeof (wchar_t), __n, __stream); ++ return __fgetws_unlocked_chk (__s, __sz / sizeof (wchar_t), __n, __stream); + } + #endif + diff --git a/SOURCES/glibc-upstream-2.39-102.patch b/SOURCES/glibc-upstream-2.39-102.patch new file mode 100644 index 0000000..91b388a --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-102.patch @@ -0,0 +1,73 @@ +commit 6eebc92cb290bed20dfb5726a88bafa02f6a2ba7 +Author: Arjun Shankar +Date: Tue Jul 30 11:37:57 2024 +0200 + + manual/stdio: Further clarify putc, putwc, getc, and getwc + + This is a follow-up to 10de4a47ef3f481592e3c62eb07bcda23e9fde4d that + reworded the manual entries for putc and putwc and removed any + performance claims. + + This commit further clarifies these entries and brings getc and getwc in + line with the descriptions of putc and putwc, removing any performance + claims from them as well. + Reviewed-by: Florian Weimer + + (cherry picked from commit 942670c81dc8071dd75d6213e771daa5d2084cb6) + +diff --git a/manual/stdio.texi b/manual/stdio.texi +index c11d37b363385531..0b31aeff958528c6 100644 +--- a/manual/stdio.texi ++++ b/manual/stdio.texi +@@ -904,20 +904,16 @@ This function is a GNU extension. + @standards{ISO, stdio.h} + @safety{@prelim{}@mtsafe{}@asunsafe{@asucorrupt{}}@acunsafe{@acucorrupt{} @aculock{}}} + This is just like @code{fputc}, except that it may be implemented as +-a macro, making it faster. One consequence is that it may evaluate the +-@var{stream} argument more than once, which is an exception to the +-general rule for macros. Therefore, @var{stream} should never be an +-expression with side-effects. ++a macro and may evaluate the @var{stream} argument more than once. ++Therefore, @var{stream} should never be an expression with side-effects. + @end deftypefun + + @deftypefun wint_t putwc (wchar_t @var{wc}, FILE *@var{stream}) + @standards{ISO, wchar.h} + @safety{@prelim{}@mtsafe{}@asunsafe{@asucorrupt{}}@acunsafe{@acucorrupt{} @aculock{}}} + This is just like @code{fputwc}, except that it may be implemented as +-a macro, making it faster. One consequence is that it may evaluate the +-@var{stream} argument more than once, which is an exception to the +-general rule for macros. Therefore, @var{stream} should never be an +-expression with side-effects. ++a macro and may evaluate the @var{stream} argument more than once. ++Therefore, @var{stream} should never be an expression with side-effects. + @end deftypefun + + @deftypefun int putc_unlocked (int @var{c}, FILE *@var{stream}) +@@ -1110,20 +1106,17 @@ This function is a GNU extension. + @deftypefun int getc (FILE *@var{stream}) + @standards{ISO, stdio.h} + @safety{@prelim{}@mtsafe{}@asunsafe{@asucorrupt{}}@acunsafe{@aculock{} @acucorrupt{}}} +-This is just like @code{fgetc}, except that it is permissible (and +-typical) for it to be implemented as a macro that evaluates the +-@var{stream} argument more than once. @code{getc} is often highly +-optimized, so it is usually the best function to use to read a single +-character. ++This is just like @code{fgetc}, except that it may be implemented as ++a macro and may evaluate the @var{stream} argument more than once. ++Therefore, @var{stream} should never be an expression with side-effects. + @end deftypefun + + @deftypefun wint_t getwc (FILE *@var{stream}) + @standards{ISO, wchar.h} + @safety{@prelim{}@mtsafe{}@asunsafe{@asucorrupt{}}@acunsafe{@aculock{} @acucorrupt{}}} +-This is just like @code{fgetwc}, except that it is permissible for it to +-be implemented as a macro that evaluates the @var{stream} argument more +-than once. @code{getwc} can be highly optimized, so it is usually the +-best function to use to read a single wide character. ++This is just like @code{fgetwc}, except that it may be implemented as ++a macro and may evaluate the @var{stream} argument more than once. ++Therefore, @var{stream} should never be an expression with side-effects. + @end deftypefun + + @deftypefun int getc_unlocked (FILE *@var{stream}) diff --git a/SOURCES/glibc-upstream-2.39-103.patch b/SOURCES/glibc-upstream-2.39-103.patch new file mode 100644 index 0000000..206d5c0 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-103.patch @@ -0,0 +1,23 @@ +commit 1ab7faf86db2f6ebe76e6e077cc7899cd9edc518 +Author: Florian Weimer +Date: Fri Aug 9 17:01:17 2024 +0200 + + support: Add options list terminator to the test driver + + This avoids crashes if a test is passed unknown options. + + Reviewed-by: Adhemerval Zanella + (cherry picked from commit c2a474f4617ede7a8bf56b7257acb37dc757b2d1) + +diff --git a/support/test-driver.c b/support/test-driver.c +index f4c3e4d666918270..04ceebc08f320b8b 100644 +--- a/support/test-driver.c ++++ b/support/test-driver.c +@@ -155,6 +155,7 @@ main (int argc, char **argv) + { + CMDLINE_OPTIONS + TEST_DEFAULT_OPTIONS ++ { 0, } + }; + test_config.options = &options; + #endif diff --git a/SOURCES/glibc-upstream-2.39-104.patch b/SOURCES/glibc-upstream-2.39-104.patch new file mode 100644 index 0000000..5e7d07e --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-104.patch @@ -0,0 +1,174 @@ +commit eeff407b196f2ffaadb5d41142688482e4a2a761 +Author: H.J. Lu +Date: Mon Jul 22 17:47:21 2024 -0700 + + x86-64: Remove sysdeps/x86_64/x32/dl-machine.h + + Remove sysdeps/x86_64/x32/dl-machine.h by folding x32 ARCH_LA_PLTENTER, + ARCH_LA_PLTEXIT and RTLD_START into sysdeps/x86_64/dl-machine.h. There + are no regressions on x86-64 nor x32. There are no changes in x86-64 + _dl_start_user. On x32, _dl_start_user changes are + + <_dl_start_user>: + mov %eax,%r12d + + mov %esp,%r13d + mov (%rsp),%edx + mov %edx,%esi + - mov %esp,%r13d + and $0xfffffff0,%esp + mov 0x0(%rip),%edi # <_dl_start_user+0x14> + lea 0x8(%r13,%rdx,4),%ecx + + Signed-off-by: H.J. Lu + Reviewed-by: Noah Goldstein + (cherry picked from commit 652c6cf26927352fc0e37e4e60c6fc98ddf6d3b4) + +diff --git a/sysdeps/x86_64/dl-machine.h b/sysdeps/x86_64/dl-machine.h +index ff5d45f7cb7cd81d..899f56576f245a3f 100644 +--- a/sysdeps/x86_64/dl-machine.h ++++ b/sysdeps/x86_64/dl-machine.h +@@ -139,37 +139,37 @@ elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[], + .globl _start\n\ + .globl _dl_start_user\n\ + _start:\n\ +- movq %rsp, %rdi\n\ ++ mov %" RSP_LP ", %" RDI_LP "\n\ + call _dl_start\n\ + _dl_start_user:\n\ + # Save the user entry point address in %r12.\n\ +- movq %rax, %r12\n\ ++ mov %" RAX_LP ", %" R12_LP "\n\ + # Save %rsp value in %r13.\n\ +- movq %rsp, %r13\n\ ++ mov %" RSP_LP ", % " R13_LP "\n\ + "\ + RTLD_START_ENABLE_X86_FEATURES \ + "\ + # Read the original argument count.\n\ +- movq (%rsp), %rdx\n\ ++ mov (%rsp), %" RDX_LP "\n\ + # Call _dl_init (struct link_map *main_map, int argc, char **argv, char **env)\n\ + # argc -> rsi\n\ +- movq %rdx, %rsi\n\ ++ mov %" RDX_LP ", %" RSI_LP "\n\ + # And align stack for the _dl_init call. \n\ +- andq $-16, %rsp\n\ ++ and $-16, %" RSP_LP "\n\ + # _dl_loaded -> rdi\n\ +- movq _rtld_local(%rip), %rdi\n\ ++ mov _rtld_local(%rip), %" RDI_LP "\n\ + # env -> rcx\n\ +- leaq 16(%r13,%rdx,8), %rcx\n\ ++ lea 2*" LP_SIZE "(%r13,%rdx," LP_SIZE "), %" RCX_LP "\n\ + # argv -> rdx\n\ +- leaq 8(%r13), %rdx\n\ ++ lea " LP_SIZE "(%r13), %" RDX_LP "\n\ + # Clear %rbp to mark outermost frame obviously even for constructors.\n\ + xorl %ebp, %ebp\n\ + # Call the function to run the initializers.\n\ + call _dl_init\n\ + # Pass our finalizer function to the user in %rdx, as per ELF ABI.\n\ +- leaq _dl_fini(%rip), %rdx\n\ ++ lea _dl_fini(%rip), %" RDX_LP "\n\ + # And make sure %rsp points to argc stored on the stack.\n\ +- movq %r13, %rsp\n\ ++ mov %" R13_LP ", %" RSP_LP "\n\ + # Jump to the user's entry point.\n\ + jmp *%r12\n\ + .previous\n\ +@@ -234,8 +234,13 @@ elf_machine_plt_value (struct link_map *map, const ElfW(Rela) *reloc, + + + /* Names of the architecture-specific auditing callback functions. */ ++#ifdef __LP64__ + #define ARCH_LA_PLTENTER x86_64_gnu_pltenter + #define ARCH_LA_PLTEXIT x86_64_gnu_pltexit ++#else ++#define ARCH_LA_PLTENTER x32_gnu_pltenter ++#define ARCH_LA_PLTEXIT x32_gnu_pltexit ++#endif + + #endif /* !dl_machine_h */ + +diff --git a/sysdeps/x86_64/x32/dl-machine.h b/sysdeps/x86_64/x32/dl-machine.h +deleted file mode 100644 +index c35cee92619923a2..0000000000000000 +--- a/sysdeps/x86_64/x32/dl-machine.h ++++ /dev/null +@@ -1,76 +0,0 @@ +-/* Machine-dependent ELF dynamic relocation inline functions. x32 version. +- Copyright (C) 2012-2024 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 +- . */ +- +-/* Must allow to be included more than once. +- See #ifdef RESOLVE_MAP in sysdeps/x86_64/dl-machine.h. */ +-#include +- +-#ifndef _X32_DL_MACHINE_H +-#define _X32_DL_MACHINE_H +- +-#undef ARCH_LA_PLTENTER +-#undef ARCH_LA_PLTEXIT +-#undef RTLD_START +- +-/* Names of the architecture-specific auditing callback functions. */ +-#define ARCH_LA_PLTENTER x32_gnu_pltenter +-#define ARCH_LA_PLTEXIT x32_gnu_pltexit +- +-/* Initial entry point code for the dynamic linker. +- The C function `_dl_start' is the real entry point; +- its return value is the user program's entry point. */ +-#define RTLD_START asm ("\n\ +-.text\n\ +- .p2align 4\n\ +-.globl _start\n\ +-.globl _dl_start_user\n\ +-_start:\n\ +- movl %esp, %edi\n\ +- call _dl_start\n\ +-_dl_start_user:\n\ +- # Save the user entry point address in %r12.\n\ +- movl %eax, %r12d\n\ +- # Read the original argument count.\n\ +- movl (%rsp), %edx\n\ +- # Call _dl_init (struct link_map *main_map, int argc, char **argv, char **env)\n\ +- # argc -> rsi\n\ +- movl %edx, %esi\n\ +- # Save %rsp value in %r13.\n\ +- movl %esp, %r13d\n\ +- # And align stack for the _dl_init call.\n\ +- and $-16, %esp\n\ +- # _dl_loaded -> rdi\n\ +- movl _rtld_local(%rip), %edi\n\ +- # env -> rcx\n\ +- lea 8(%r13,%rdx,4), %ecx\n\ +- # argv -> rdx\n\ +- lea 4(%r13), %edx\n\ +- # Clear %rbp to mark outermost frame obviously even for constructors.\n\ +- xorl %ebp, %ebp\n\ +- # Call the function to run the initializers.\n\ +- call _dl_init\n\ +- # Pass our finalizer function to the user in %rdx, as per ELF ABI.\n\ +- lea _dl_fini(%rip), %edx\n\ +- # And make sure %rsp points to argc stored on the stack.\n\ +- movl %r13d, %esp\n\ +- # Jump to the user's entry point.\n\ +- jmp *%r12\n\ +-.previous\n\ +-"); +- +-#endif /* !_X32_DL_MACHINE_H */ diff --git a/SOURCES/glibc-upstream-2.39-105.patch b/SOURCES/glibc-upstream-2.39-105.patch new file mode 100644 index 0000000..3bba75f --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-105.patch @@ -0,0 +1,72 @@ +commit 9fbbe86f7c6ab19356cfa7ca15b4b7c29b72e8cb +Author: H.J. Lu +Date: Mon Jul 22 17:47:22 2024 -0700 + + x32/cet: Support shadow stack during startup for Linux 6.10 + + Use RXX_LP in RTLD_START_ENABLE_X86_FEATURES. Support shadow stack during + startup for Linux 6.10: + + commit 2883f01ec37dd8668e7222dfdb5980c86fdfe277 + Author: H.J. Lu + Date: Fri Mar 15 07:04:33 2024 -0700 + + x86/shstk: Enable shadow stacks for x32 + + 1. Add shadow stack support to x32 signal. + 2. Use the 64-bit map_shadow_stack syscall for x32. + 3. Set up shadow stack for x32. + + Add the map_shadow_stack system call to and regenerate + arch-syscall.h. Tested on Intel Tiger Lake with CET enabled x32. There + are no regressions with CET enabled x86-64. There are no changes in CET + enabled x86-64 _dl_start_user. + + Signed-off-by: H.J. Lu + Reviewed-by: Noah Goldstein + (cherry picked from commit 8344c1f5514b1b5b1c8c6e48f4b802653bd23b71) + +diff --git a/sysdeps/unix/sysv/linux/x86_64/dl-cet.h b/sysdeps/unix/sysv/linux/x86_64/dl-cet.h +index 1fe313340611d9c5..b4f7e6c9cd7548a2 100644 +--- a/sysdeps/unix/sysv/linux/x86_64/dl-cet.h ++++ b/sysdeps/unix/sysv/linux/x86_64/dl-cet.h +@@ -92,9 +92,9 @@ dl_cet_ibt_enabled (void) + # Pass GL(dl_x86_feature_1) to _dl_cet_setup_features.\n\ + movl %edx, %edi\n\ + # Align stack for the _dl_cet_setup_features call.\n\ +- andq $-16, %rsp\n\ ++ and $-16, %" RSP_LP "\n\ + call _dl_cet_setup_features\n\ + # Restore %rax and %rsp from %r12 and %r13.\n\ +- movq %r12, %rax\n\ +- movq %r13, %rsp\n\ ++ mov %" R12_LP ", %" RAX_LP "\n\ ++ mov %" R13_LP ", %" RSP_LP "\n\ + " +diff --git a/sysdeps/unix/sysv/linux/x86_64/x32/arch-syscall.h b/sysdeps/unix/sysv/linux/x86_64/x32/arch-syscall.h +index b9db8bc5be05eed8..645e85802f95a78c 100644 +--- a/sysdeps/unix/sysv/linux/x86_64/x32/arch-syscall.h ++++ b/sysdeps/unix/sysv/linux/x86_64/x32/arch-syscall.h +@@ -151,6 +151,7 @@ + #define __NR_lsetxattr 1073742013 + #define __NR_lstat 1073741830 + #define __NR_madvise 1073741852 ++#define __NR_map_shadow_stack 1073742277 + #define __NR_mbind 1073742061 + #define __NR_membarrier 1073742148 + #define __NR_memfd_create 1073742143 +diff --git a/sysdeps/unix/sysv/linux/x86_64/x32/fixup-asm-unistd.h b/sysdeps/unix/sysv/linux/x86_64/x32/fixup-asm-unistd.h +index 98124169e6035ea8..47fa8af4ce9af68e 100644 +--- a/sysdeps/unix/sysv/linux/x86_64/x32/fixup-asm-unistd.h ++++ b/sysdeps/unix/sysv/linux/x86_64/x32/fixup-asm-unistd.h +@@ -15,6 +15,10 @@ + License along with the GNU C Library; if not, see + . */ + ++#ifndef __NR_map_shadow_stack ++# define __NR_map_shadow_stack 1073742277 ++#endif ++ + /* X32 uses the same 64-bit syscall interface for set_thread_area. */ + #ifndef __NR_set_thread_area + # define __NR_set_thread_area 1073742029 diff --git a/SOURCES/glibc-upstream-2.39-106.patch b/SOURCES/glibc-upstream-2.39-106.patch new file mode 100644 index 0000000..8f1c95b --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-106.patch @@ -0,0 +1,24 @@ +commit 81631a0dd1b76e6fe8e0ffcd9ee411676031b1bb +Author: Florian Weimer +Date: Fri Jul 19 15:57:46 2024 +0200 + + Adjust check-local-headers test for libaudit 4.0 + + The new version introduces /usr/include/audit_logging.h and + /usr/include/audit-records.h. + + (cherry picked from commit 91eb62d63887a959e43aafb6fc022a87614dc7c9) + +diff --git a/scripts/check-local-headers.sh b/scripts/check-local-headers.sh +index 5d3e61f8894b600e..ad23840333f7c7e5 100755 +--- a/scripts/check-local-headers.sh ++++ b/scripts/check-local-headers.sh +@@ -33,7 +33,7 @@ exec ${AWK} -v includedir="$includedir" ' + BEGIN { + status = 0 + exclude = "^" includedir \ +- "/(.*-.*-.*/|.*-.*/|)(asm[-/]|arch|linux/|selinux/|mach/|mach_debug/|device/|hurd/(((hurd|ioctl)_types|paths)\\.h|ioctls\\.defs|ihash\\.h|version\\.h)|gd|nss3/|nspr4?/|c\\+\\+/|sys/(capability|sdt(|-config))\\.h|libaudit\\.h)" ++ "/(.*-.*-.*/|.*-.*/|)(asm[-/]|arch|linux/|selinux/|mach/|mach_debug/|device/|hurd/(((hurd|ioctl)_types|paths)\\.h|ioctls\\.defs|ihash\\.h|version\\.h)|gd|nss3/|nspr4?/|c\\+\\+/|sys/(capability|sdt(|-config))\\.h|libaudit\\.h|audit(_logging|-records)\\.h)" + } + /^[^ ]/ && $1 ~ /.*:/ { obj = $1 } + { diff --git a/SOURCES/glibc-upstream-2.39-107.patch b/SOURCES/glibc-upstream-2.39-107.patch new file mode 100644 index 0000000..a9ca460 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-107.patch @@ -0,0 +1,156 @@ +commit 49953727d1768baeef2914f709f35cb4acad2d0b +Author: Noah Goldstein +Date: Tue Aug 13 23:29:14 2024 +0800 + + x86: Fix bug in strchrnul-evex512 [BZ #32078] + + Issue was we were expecting not matches with CHAR before the start of + the string in the page cross case. + + The check code in the page cross case: + ``` + and $0xffffffffffffffc0,%rax + vmovdqa64 (%rax),%zmm17 + vpcmpneqb %zmm17,%zmm16,%k1 + vptestmb %zmm17,%zmm17,%k0{%k1} + kmovq %k0,%rax + inc %rax + shr %cl,%rax + je L(continue) + ``` + + expects that all characters that neither match null nor CHAR will be + 1s in `rax` prior to the `inc`. Then the `inc` will overflow all of + the 1s where no relevant match was found. + + This is incorrect in the page-cross case, as the + `vmovdqa64 (%rax),%zmm17` loads from before the start of the input + string. + + If there are matches with CHAR before the start of the string, `rax` + won't properly overflow. + + The fix is quite simple. Just replace: + + ``` + inc %rax + shr %cl,%rax + ``` + With: + ``` + sar %cl,%rax + inc %rax + ``` + + The arithmetic shift will clear any matches prior to the start of the + string while maintaining the signbit so the 1s can properly overflow + to zero in the case of no matches. + Reviewed-by: H.J. Lu + + (cherry picked from commit 7da08862471dfec6fdae731c2a5f351ad485c71f) + +diff --git a/string/test-strchr.c b/string/test-strchr.c +index c795eac6fa7b93b9..72b17af687f6ad0e 100644 +--- a/string/test-strchr.c ++++ b/string/test-strchr.c +@@ -255,6 +255,69 @@ check1 (void) + check_result (impl, s, c, exp_result); + } + ++static void ++check2 (void) ++{ ++ CHAR *s = (CHAR *) (buf1 + getpagesize () - 4 * sizeof (CHAR)); ++ CHAR *s_begin = (CHAR *) (buf1 + getpagesize () - 64); ++#ifndef USE_FOR_STRCHRNUL ++ CHAR *exp_result = NULL; ++#else ++ CHAR *exp_result = s + 1; ++#endif ++ CHAR val = 0x12; ++ for (; s_begin != s; ++s_begin) ++ *s_begin = val; ++ ++ s[0] = val + 1; ++ s[1] = 0; ++ s[2] = val + 1; ++ s[3] = val + 1; ++ ++ { ++ FOR_EACH_IMPL (impl, 0) ++ check_result (impl, s, val, exp_result); ++ } ++ s[3] = val; ++ { ++ FOR_EACH_IMPL (impl, 0) ++ check_result (impl, s, val, exp_result); ++ } ++ exp_result = s; ++ s[0] = val; ++ { ++ FOR_EACH_IMPL (impl, 0) ++ check_result (impl, s, val, exp_result); ++ } ++ ++ s[3] = val + 1; ++ { ++ FOR_EACH_IMPL (impl, 0) ++ check_result (impl, s, val, exp_result); ++ } ++ ++ s[0] = val + 1; ++ s[1] = val + 1; ++ s[2] = val + 1; ++ s[3] = val + 1; ++ s[4] = val; ++ exp_result = s + 4; ++ { ++ FOR_EACH_IMPL (impl, 0) ++ check_result (impl, s, val, exp_result); ++ } ++ s[4] = 0; ++#ifndef USE_FOR_STRCHRNUL ++ exp_result = NULL; ++#else ++ exp_result = s + 4; ++#endif ++ { ++ FOR_EACH_IMPL (impl, 0) ++ check_result (impl, s, val, exp_result); ++ } ++} ++ + int + test_main (void) + { +@@ -263,7 +326,7 @@ test_main (void) + test_init (); + + check1 (); +- ++ check2 (); + printf ("%20s", ""); + FOR_EACH_IMPL (impl, 0) + printf ("\t%s", impl->name); +diff --git a/sysdeps/x86_64/multiarch/strchr-evex-base.S b/sysdeps/x86_64/multiarch/strchr-evex-base.S +index 04e2c0e79e381691..3a0b7c9d6429fb20 100644 +--- a/sysdeps/x86_64/multiarch/strchr-evex-base.S ++++ b/sysdeps/x86_64/multiarch/strchr-evex-base.S +@@ -124,13 +124,13 @@ L(page_cross): + VPCMPNE %VMM(1), %VMM(0), %k1 + VPTEST %VMM(1), %VMM(1), %k0{%k1} + KMOV %k0, %VRAX +-# ifdef USE_AS_WCSCHR ++ sar %cl, %VRAX ++#ifdef USE_AS_WCSCHR + sub $VEC_MATCH_MASK, %VRAX +-# else ++#else + inc %VRAX +-# endif ++#endif + /* Ignore number of character for alignment adjustment. */ +- shr %cl, %VRAX + jz L(align_more) + + bsf %VRAX, %VRAX diff --git a/SOURCES/glibc-upstream-2.39-108.patch b/SOURCES/glibc-upstream-2.39-108.patch new file mode 100644 index 0000000..3bf9400 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-108.patch @@ -0,0 +1,23 @@ +commit 37c2aa4eaa0adc4193bc0e1f520b677ad30c9e4d +Author: Florian Weimer +Date: Fri Aug 9 16:17:14 2024 +0200 + + Define __libc_initial for the static libc + + Reviewed-by: Adhemerval Zanella + (cherry picked from commit eb0e50e9a1cf80a2ba6f33f990a08ef37a3267fb) + +diff --git a/include/libc-internal.h b/include/libc-internal.h +index 87ac591835637e4d..1ef43ffe673907a0 100644 +--- a/include/libc-internal.h ++++ b/include/libc-internal.h +@@ -53,6 +53,9 @@ extern __typeof (__profile_frequency) __profile_frequency attribute_hidden; + is not for an audit module, not loaded via dlmopen, and not loaded + via static dlopen either). */ + extern _Bool __libc_initial attribute_hidden; ++#else ++/* The static libc is always the initial namespace. */ ++# define __libc_initial ((_Bool) 1) + #endif + + #endif /* _LIBC_INTERNAL */ diff --git a/SOURCES/glibc-upstream-2.39-109.patch b/SOURCES/glibc-upstream-2.39-109.patch new file mode 100644 index 0000000..026fd73 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-109.patch @@ -0,0 +1,139 @@ +commit e73fd06b7f12d6ddaae4f91f9c5088a621a82ce4 +Author: Florian Weimer +Date: Mon Aug 19 15:48:03 2024 +0200 + + string: strerror, strsignal cannot use buffer after dlmopen (bug 32026) + + Secondary namespaces have a different malloc. Allocating the + buffer in one namespace and freeing it another results in + heap corruption. Fix this by using a static string (potentially + translated) in secondary namespaces. It would also be possible + to use the malloc from the initial namespace to manage the + buffer, but these functions would still not be safe to use in + auditors etc. because a call to strerror could still free a + buffer while it is used by the application. Another approach + could use proper initial-exec TLS, duplicated in secondary + namespaces, but that would need a callback interface for freeing + libc resources in namespaces on thread exit, which does not exist + today. + + Reviewed-by: Adhemerval Zanella + (cherry picked from commit 25a5eb4010df94b412c67db9e346029de316d06b) + +diff --git a/string/strerror_l.c b/string/strerror_l.c +index 15cce261e6b406a7..70456e5bb45e5b52 100644 +--- a/string/strerror_l.c ++++ b/string/strerror_l.c +@@ -20,7 +20,7 @@ + #include + #include + #include +- ++#include + + static const char * + translate (const char *str, locale_t loc) +@@ -31,6 +31,12 @@ translate (const char *str, locale_t loc) + return res; + } + ++static char * ++unknown_error (locale_t loc) ++{ ++ return (char *) translate ("Unknown error", loc); ++} ++ + + /* Return a string describing the errno code in ERRNUM. */ + char * +@@ -40,18 +46,25 @@ __strerror_l (int errnum, locale_t loc) + char *err = (char *) __get_errlist (errnum); + if (__glibc_unlikely (err == NULL)) + { +- struct tls_internal_t *tls_internal = __glibc_tls_internal (); +- free (tls_internal->strerror_l_buf); +- if (__asprintf (&tls_internal->strerror_l_buf, "%s%d", +- translate ("Unknown error ", loc), errnum) > 0) +- err = tls_internal->strerror_l_buf; +- else ++ if (__libc_initial) + { +- /* The memory was freed above. */ +- tls_internal->strerror_l_buf = NULL; +- /* Provide a fallback translation. */ +- err = (char *) translate ("Unknown error", loc); ++ struct tls_internal_t *tls_internal = __glibc_tls_internal (); ++ free (tls_internal->strerror_l_buf); ++ if (__asprintf (&tls_internal->strerror_l_buf, "%s%d", ++ translate ("Unknown error ", loc), errnum) > 0) ++ err = tls_internal->strerror_l_buf; ++ else ++ { ++ /* The memory was freed above. */ ++ tls_internal->strerror_l_buf = NULL; ++ /* Provide a fallback translation. */ ++ err = unknown_error (loc); ++ } + } ++ else ++ /* Secondary namespaces use a different malloc, so cannot ++ participate in the buffer management. */ ++ err = unknown_error (loc); + } + else + err = (char *) translate (err, loc); +diff --git a/string/strsignal.c b/string/strsignal.c +index 31146015647c1d4a..d9b03654683a6805 100644 +--- a/string/strsignal.c ++++ b/string/strsignal.c +@@ -21,6 +21,7 @@ + #include + #include + #include ++#include + + /* Return a string describing the meaning of the signal number SIGNUM. */ + char * +@@ -30,21 +31,28 @@ strsignal (int signum) + if (desc != NULL) + return _(desc); + +- struct tls_internal_t *tls_internal = __glibc_tls_internal (); +- free (tls_internal->strsignal_buf); ++ if (__libc_initial) ++ { ++ struct tls_internal_t *tls_internal = __glibc_tls_internal (); ++ free (tls_internal->strsignal_buf); + +- int r; ++ int r; + #ifdef SIGRTMIN +- if (signum >= SIGRTMIN && signum <= SIGRTMAX) +- r = __asprintf (&tls_internal->strsignal_buf, _("Real-time signal %d"), +- signum - SIGRTMIN); +- else ++ if (signum >= SIGRTMIN && signum <= SIGRTMAX) ++ r = __asprintf (&tls_internal->strsignal_buf, _("Real-time signal %d"), ++ signum - SIGRTMIN); ++ else + #endif +- r = __asprintf (&tls_internal->strsignal_buf, _("Unknown signal %d"), +- signum); +- +- if (r == -1) +- tls_internal->strsignal_buf = NULL; +- +- return tls_internal->strsignal_buf; ++ r = __asprintf (&tls_internal->strsignal_buf, _("Unknown signal %d"), ++ signum); ++ ++ if (r >= 0) ++ return tls_internal->strsignal_buf; ++ else ++ tls_internal->strsignal_buf = NULL; ++ } ++ /* Fall through on asprintf error, and for !__libc_initial: ++ secondary namespaces use a different malloc and cannot ++ participate in the buffer management. */ ++ return _("Unknown signal"); + } diff --git a/SOURCES/glibc-upstream-2.39-110.patch b/SOURCES/glibc-upstream-2.39-110.patch new file mode 100644 index 0000000..fd10591 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-110.patch @@ -0,0 +1,226 @@ +commit 98de2f2baebeeac13748f064017b7bd2b94fafee +Author: Maciej W. Rozycki +Date: Fri Jul 26 13:21:34 2024 +0100 + + support: Add FAIL test failure helper + + Add a FAIL test failure helper analogous to FAIL_RET, that does not + cause the current function to return, providing a standardized way to + report a test failure with a message supplied while permitting the + caller to continue executing, for further reporting, cleaning up, etc. + + Update existing test cases that provide a conflicting definition of FAIL + by removing the local FAIL definition and then as follows: + + - tst-fortify-syslog: provide a meaningful message in addition to the + file name already added by ; 'support_record_failure' + is already called by 'support_print_failure_impl' invoked by the new + FAIL test failure helper. + + - tst-ctype: no update to FAIL calls required, with the name of the file + and the line number within of the failure site additionally included + by the new FAIL test failure helper, and error counting plus count + reporting upon test program termination also already provided by + 'support_record_failure' and 'support_report_failure' respectively, + called by 'support_print_failure_impl' and 'adjust_exit_status' also + respectively. However in a number of places 'printf' is called and + the error count adjusted by hand, so update these places to make use + of FAIL instead. And last but not least adjust the final summary just + to report completion, with any error count following as reported by + the test driver. + + - test-tgmath2: no update to FAIL calls required, with the name of the + file of the failure site additionally included by the new FAIL test + failure helper. Also there is no need to track the return status by + hand as any call to FAIL will eventually cause the test case to return + an unsuccesful exit status regardless of the return status from the + test function, via a call to 'adjust_exit_status' made by the test + driver. + + Reviewed-by: DJ Delorie + (cherry picked from commit 1b97a9f23bf605ca608162089c94187573fb2a9e) + +diff --git a/debug/tst-fortify-syslog.c b/debug/tst-fortify-syslog.c +index a7ddbf7c6b6d33c9..2712acf689ff5af2 100644 +--- a/debug/tst-fortify-syslog.c ++++ b/debug/tst-fortify-syslog.c +@@ -22,7 +22,6 @@ + #include + #include + #include +-#include + + #include + #include +@@ -46,18 +45,13 @@ handler (int sig) + _exit (127); + } + +-#define FAIL() \ +- do { \ +- printf ("Failure on line %d\n", __LINE__); \ +- support_record_failure (); \ +- } while (0) + #define CHK_FAIL_START \ + chk_fail_ok = 1; \ + if (! setjmp (chk_fail_buf)) \ + { + #define CHK_FAIL_END \ + chk_fail_ok = 0; \ +- FAIL (); \ ++ FAIL ("not supposed to reach here"); \ + } + + static void +diff --git a/localedata/tst-ctype.c b/localedata/tst-ctype.c +index 9de979a2d7592789..a23689719c173711 100644 +--- a/localedata/tst-ctype.c ++++ b/localedata/tst-ctype.c +@@ -21,6 +21,8 @@ + #include + #include + ++#include ++ + + static const char lower[] = "abcdefghijklmnopqrstuvwxyz"; + static const char upper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; +@@ -53,19 +55,11 @@ static struct classes + #define nclasses (sizeof (classes) / sizeof (classes[0])) + + +-#define FAIL(str, args...) \ +- { \ +- printf (" " str "\n", ##args); \ +- ++errors; \ +- } +- +- + static int + do_test (void) + { + const char *cp; + const char *cp2; +- int errors = 0; + char *inpline = NULL; + size_t inplinelen = 0; + char *resline = NULL; +@@ -394,11 +388,8 @@ punct = %04x alnum = %04x\n", + { + if (((__ctype_b[(unsigned int) *inp] & classes[n].mask) != 0) + != (*resp != '0')) +- { +- printf (" is%s('%c' = '\\x%02x') %s true\n", inpline, +- *inp, *inp, *resp == '1' ? "not" : "is"); +- ++errors; +- } ++ FAIL (" is%s('%c' = '\\x%02x') %s true\n", inpline, ++ *inp, *inp, *resp == '1' ? "not" : "is"); + ++inp; + ++resp; + } +@@ -408,11 +399,8 @@ punct = %04x alnum = %04x\n", + while (*inp != '\0') + { + if (tolower (*inp) != *resp) +- { +- printf (" tolower('%c' = '\\x%02x') != '%c'\n", +- *inp, *inp, *resp); +- ++errors; +- } ++ FAIL (" tolower('%c' = '\\x%02x') != '%c'\n", ++ *inp, *inp, *resp); + ++inp; + ++resp; + } +@@ -422,11 +410,8 @@ punct = %04x alnum = %04x\n", + while (*inp != '\0') + { + if (toupper (*inp) != *resp) +- { +- printf (" toupper('%c' = '\\x%02x') != '%c'\n", +- *inp, *inp, *resp); +- ++errors; +- } ++ FAIL (" toupper('%c' = '\\x%02x') != '%c'\n", ++ *inp, *inp, *resp); + ++inp; + ++resp; + } +@@ -436,14 +421,7 @@ punct = %04x alnum = %04x\n", + } + + +- if (errors != 0) +- { +- printf (" %d error%s for `%s' locale\n\n\n", errors, +- errors == 1 ? "" : "s", setlocale (LC_ALL, NULL)); +- return 1; +- } +- +- printf (" No errors for `%s' locale\n\n\n", setlocale (LC_ALL, NULL)); ++ printf ("Completed testing for `%s' locale\n\n\n", setlocale (LC_ALL, NULL)); + return 0; + } + +diff --git a/math/test-tgmath2.c b/math/test-tgmath2.c +index 37afa8a08a5a4a9c..4aeb877b8e54c0a4 100644 +--- a/math/test-tgmath2.c ++++ b/math/test-tgmath2.c +@@ -24,6 +24,8 @@ + #include + #include + ++#include ++ + //#define DEBUG + + typedef complex float cfloat; +@@ -87,13 +89,6 @@ enum + int count; + int counts[Tlast][C_last]; + +-#define FAIL(str) \ +- do \ +- { \ +- printf ("%s failure on line %d\n", (str), __LINE__); \ +- result = 1; \ +- } \ +- while (0) + #define TEST_TYPE_ONLY(expr, rettype) \ + do \ + { \ +@@ -133,8 +128,6 @@ int counts[Tlast][C_last]; + int + test_cos (const int Vint4, const long long int Vllong4) + { +- int result = 0; +- + TEST (cos (vfloat1), float, cos); + TEST (cos (vdouble1), double, cos); + TEST (cos (vldouble1), ldouble, cos); +@@ -152,7 +145,7 @@ test_cos (const int Vint4, const long long int Vllong4) + TEST (cos (Vcdouble1), cdouble, cos); + TEST (cos (Vcldouble1), cldouble, cos); + +- return result; ++ return 0; + } + + int +diff --git a/support/check.h b/support/check.h +index 711f34b83b95b594..7ea22c7a2cba5cfd 100644 +--- a/support/check.h ++++ b/support/check.h +@@ -24,6 +24,11 @@ + + __BEGIN_DECLS + ++/* Record a test failure, print the failure message to standard output ++ and pass the result of 1 through. */ ++#define FAIL(...) \ ++ support_print_failure_impl (__FILE__, __LINE__, __VA_ARGS__) ++ + /* Record a test failure, print the failure message to standard output + and return 1. */ + #define FAIL_RET(...) \ diff --git a/SOURCES/glibc-upstream-2.39-111.patch b/SOURCES/glibc-upstream-2.39-111.patch new file mode 100644 index 0000000..03ba58b --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-111.patch @@ -0,0 +1,168 @@ +commit 3c5f493d871c11de9d8358b8ac84c144a0d848fa +Author: Maciej W. Rozycki +Date: Fri Jul 26 13:21:34 2024 +0100 + + stdio-common: Add test for vfscanf with matches longer than INT_MAX [BZ #27650] + + Complement commit b03e4d7bd25b ("stdio: fix vfscanf with matches longer + than INT_MAX (bug 27650)") and add a test case for the issue, inspired + by the reproducer provided with the bug report. + + This has been verified to succeed as from the commit referred and fail + beforehand. + + As the test requires 2GiB of data to be passed around its performance + has been evaluated using a choice of systems and the execution time + determined to be respectively in the range of 9s for POWER9@2.166GHz, + 24s for FU740@1.2GHz, and 40s for 74Kf@950MHz. As this is on the verge + of and beyond the default timeout it has been increased by the factor of + 8. Regardless, following recent practice the test has been added to the + standard rather than extended set. + + Reviewed-by: DJ Delorie + (cherry picked from commit 89cddc8a7096f3d9225868304d2bc0a1aaf07d63) + +diff --git a/stdio-common/Makefile b/stdio-common/Makefile +index e312565f3b671463..159dc472e4c76b9a 100644 +--- a/stdio-common/Makefile ++++ b/stdio-common/Makefile +@@ -243,6 +243,7 @@ tests := \ + tst-scanf-binary-c2x \ + tst-scanf-binary-gnu11 \ + tst-scanf-binary-gnu89 \ ++ tst-scanf-bz27650 \ + tst-scanf-intn \ + tst-scanf-round \ + tst-scanf-to_inpunct \ +@@ -313,6 +314,7 @@ generated += \ + tst-printf-fp-free.mtrace \ + tst-printf-fp-leak-mem.out \ + tst-printf-fp-leak.mtrace \ ++ tst-scanf-bz27650.mtrace \ + tst-vfprintf-width-prec-mem.out \ + tst-vfprintf-width-prec.mtrace \ + # generated +@@ -402,6 +404,9 @@ tst-printf-fp-free-ENV = \ + tst-printf-fp-leak-ENV = \ + MALLOC_TRACE=$(objpfx)tst-printf-fp-leak.mtrace \ + LD_PRELOAD=$(common-objpfx)/malloc/libc_malloc_debug.so ++tst-scanf-bz27650-ENV = \ ++ MALLOC_TRACE=$(objpfx)tst-scanf-bz27650.mtrace \ ++ LD_PRELOAD=$(common-objpfx)malloc/libc_malloc_debug.so + + $(objpfx)tst-unbputc.out: tst-unbputc.sh $(objpfx)tst-unbputc + $(SHELL) $< $(common-objpfx) '$(test-program-prefix)'; \ +diff --git a/stdio-common/tst-scanf-bz27650.c b/stdio-common/tst-scanf-bz27650.c +new file mode 100644 +index 0000000000000000..3a742bc86556908c +--- /dev/null ++++ b/stdio-common/tst-scanf-bz27650.c +@@ -0,0 +1,108 @@ ++/* Test for BZ #27650, formatted input matching beyond INT_MAX. ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include ++ ++#include ++#include ++ ++/* Produce a stream of more than INT_MAX characters via buffer BUF of ++ size SIZE according to bookkeeping in COOKIE and then return EOF. */ ++ ++static ssize_t ++io_read (void *cookie, char *buf, size_t size) ++{ ++ unsigned int *written = cookie; ++ unsigned int w = *written; ++ ++ if (w > INT_MAX) ++ return 0; ++ ++ memset (buf, 'a', size); ++ *written = w + size; ++ return size; ++} ++ ++/* Consume a stream of more than INT_MAX characters from an artificial ++ input stream of which none is the new line character. The call to ++ fscanf is supposed to complete upon the EOF condition of input, ++ however in the presence of BZ #27650 it will terminate prematurely ++ with characters still outstanding in input. Diagnose the condition ++ and return status accordingly. */ ++ ++int ++do_test (void) ++{ ++ static cookie_io_functions_t io_funcs = { .read = io_read }; ++ unsigned int written = 0; ++ FILE *in; ++ int v; ++ ++ mtrace (); ++ ++ in = fopencookie (&written, "r", io_funcs); ++ if (in == NULL) ++ { ++ FAIL ("fopencookie: %m"); ++ goto out; ++ } ++ ++ v = fscanf (in, "%*[^\n]"); ++ if (ferror (in)) ++ { ++ FAIL ("fscanf: input failure, at %u: %m", written); ++ goto out_close; ++ } ++ else if (v == EOF) ++ { ++ FAIL ("fscanf: unexpected end of file, at %u", written); ++ goto out_close; ++ } ++ ++ if (!feof (in)) ++ { ++ v = fgetc (in); ++ if (ferror (in)) ++ FAIL ("fgetc: input failure: %m"); ++ else if (v == EOF) ++ FAIL ("fgetc: unexpected end of file after missing end of file"); ++ else if (v == '\n') ++ FAIL ("unexpected new line character received"); ++ else ++ FAIL ("character received after end of file expected: \\x%02x", v); ++ } ++ ++out_close: ++ if (fclose (in) != 0) ++ FAIL ("fclose: %m"); ++ ++out: ++ return EXIT_SUCCESS; ++} ++ ++#define TIMEOUT (DEFAULT_TIMEOUT * 8) ++#include diff --git a/SOURCES/glibc-upstream-2.39-112.patch b/SOURCES/glibc-upstream-2.39-112.patch new file mode 100644 index 0000000..784739e --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-112.patch @@ -0,0 +1,142 @@ +commit f0c308ab239340190f5ca9a226e43f3041d487f7 +Author: Siddhesh Poyarekar +Date: Wed Aug 14 19:20:04 2024 -0400 + + Make tst-ungetc use libsupport + + Signed-off-by: Siddhesh Poyarekar + Reviewed-by: Carlos O'Donell + (cherry picked from commit 3f7df7e757f4efec38e45d4068e5492efcac4856) + +diff --git a/stdio-common/tst-ungetc.c b/stdio-common/tst-ungetc.c +index 1344b2b591e3d6b1..5c808f073419f00b 100644 +--- a/stdio-common/tst-ungetc.c ++++ b/stdio-common/tst-ungetc.c +@@ -1,70 +1,72 @@ +-/* Test for ungetc bugs. */ ++/* Test for ungetc bugs. ++ Copyright (C) 1996-2024 Free Software Foundation, Inc. ++ Copyright The GNU Toolchain Authors. ++ 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 ++ . */ + + #include + #include +-#include +- +-#undef assert +-#define assert(x) \ +- if (!(x)) \ +- { \ +- fputs ("test failed: " #x "\n", stderr); \ +- retval = 1; \ +- goto the_end; \ +- } ++#include ++#include ++#include ++#include ++#include + +-int +-main (int argc, char *argv[]) ++static int ++do_test (void) + { +- char name[] = "/tmp/tst-ungetc.XXXXXX"; ++ char *name = NULL; + FILE *fp = NULL; +- int retval = 0; + int c; + char buffer[64]; + +- int fd = mkstemp (name); ++ int fd = create_temp_file ("tst-ungetc.", &name); + if (fd == -1) +- { +- printf ("mkstemp failed: %m\n"); +- return 1; +- } +- close (fd); +- fp = fopen (name, "w"); +- assert (fp != NULL) +- fputs ("bla", fp); +- fclose (fp); +- fp = NULL; ++ FAIL_EXIT1 ("cannot create temporary file: %m"); ++ xclose (fd); + +- fp = fopen (name, "r"); +- assert (fp != NULL); +- assert (ungetc ('z', fp) == 'z'); +- assert (getc (fp) == 'z'); +- assert (getc (fp) == 'b'); +- assert (getc (fp) == 'l'); +- assert (ungetc ('m', fp) == 'm'); +- assert (getc (fp) == 'm'); +- assert ((c = getc (fp)) == 'a'); +- assert (getc (fp) == EOF); +- assert (ungetc (c, fp) == c); +- assert (feof (fp) == 0); +- assert (getc (fp) == c); +- assert (getc (fp) == EOF); +- fclose (fp); +- fp = NULL; ++ fp = xfopen (name, "w"); ++ fputs ("bla", fp); ++ xfclose (fp); + +- fp = fopen (name, "r"); +- assert (fp != NULL); +- assert (getc (fp) == 'b'); +- assert (getc (fp) == 'l'); +- assert (ungetc ('b', fp) == 'b'); +- assert (fread (buffer, 1, 64, fp) == 2); +- assert (buffer[0] == 'b'); +- assert (buffer[1] == 'a'); ++ fp = xfopen (name, "r"); ++ TEST_VERIFY_EXIT (ungetc ('z', fp) == 'z'); ++ TEST_VERIFY_EXIT (getc (fp) == 'z'); ++ TEST_VERIFY_EXIT (getc (fp) == 'b'); ++ TEST_VERIFY_EXIT (getc (fp) == 'l'); ++ TEST_VERIFY_EXIT (ungetc ('m', fp) == 'm'); ++ TEST_VERIFY_EXIT (getc (fp) == 'm'); ++ TEST_VERIFY_EXIT ((c = getc (fp)) == 'a'); ++ TEST_VERIFY_EXIT (getc (fp) == EOF); ++ TEST_VERIFY_EXIT (ungetc (c, fp) == c); ++ TEST_VERIFY_EXIT (feof (fp) == 0); ++ TEST_VERIFY_EXIT (getc (fp) == c); ++ TEST_VERIFY_EXIT (getc (fp) == EOF); ++ xfclose (fp); + +-the_end: +- if (fp != NULL) +- fclose (fp); +- unlink (name); ++ fp = xfopen (name, "r"); ++ TEST_VERIFY_EXIT (getc (fp) == 'b'); ++ TEST_VERIFY_EXIT (getc (fp) == 'l'); ++ TEST_VERIFY_EXIT (ungetc ('b', fp) == 'b'); ++ TEST_VERIFY_EXIT (fread (buffer, 1, 64, fp) == 2); ++ TEST_VERIFY_EXIT (buffer[0] == 'b'); ++ TEST_VERIFY_EXIT (buffer[1] == 'a'); ++ xfclose (fp); + +- return retval; ++ return 0; + } ++ ++#include diff --git a/SOURCES/glibc-upstream-2.39-113.patch b/SOURCES/glibc-upstream-2.39-113.patch new file mode 100644 index 0000000..51b7c89 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-113.patch @@ -0,0 +1,70 @@ +commit 70939528c67507f12d6d41423b7fac25153a6dce +Author: Siddhesh Poyarekar +Date: Tue Aug 13 21:00:06 2024 -0400 + + ungetc: Fix uninitialized read when putting into unused streams [BZ #27821] + + When ungetc is called on an unused stream, the backup buffer is + allocated without the main get area being present. This results in + every subsequent ungetc (as the stream remains in the backup area) + checking uninitialized memory in the backup buffer when trying to put a + character back into the stream. + + Avoid comparing the input character with buffer contents when in backup + to avoid this uninitialized read. The uninitialized read is harmless in + this context since the location is promptly overwritten with the input + character, thus fulfilling ungetc functionality. + + Also adjust wording in the manual to drop the paragraph that says glibc + cannot do multiple ungetc back to back since with this change, ungetc + can actually do this. + + Signed-off-by: Siddhesh Poyarekar + Reviewed-by: Carlos O'Donell + (cherry picked from commit cdf0f88f97b0aaceb894cc02b21159d148d7065c) + +diff --git a/libio/genops.c b/libio/genops.c +index bc45e60a09437ae5..4f5c6136f3ef1b88 100644 +--- a/libio/genops.c ++++ b/libio/genops.c +@@ -635,7 +635,7 @@ _IO_sputbackc (FILE *fp, int c) + { + int result; + +- if (fp->_IO_read_ptr > fp->_IO_read_base ++ if (fp->_IO_read_ptr > fp->_IO_read_base && !_IO_in_backup (fp) + && (unsigned char)fp->_IO_read_ptr[-1] == (unsigned char)c) + { + fp->_IO_read_ptr--; +diff --git a/manual/stdio.texi b/manual/stdio.texi +index 0b31aeff958528c6..393ed9c665792609 100644 +--- a/manual/stdio.texi ++++ b/manual/stdio.texi +@@ -1467,11 +1467,9 @@ program; usually @code{ungetc} is used only to unread a character that + was just read from the same stream. @Theglibc{} supports this + even on files opened in binary mode, but other systems might not. + +-@Theglibc{} only supports one character of pushback---in other +-words, it does not work to call @code{ungetc} twice without doing input +-in between. Other systems might let you push back multiple characters; +-then reading from the stream retrieves the characters in the reverse +-order that they were pushed. ++@Theglibc{} supports pushing back multiple characters; subsequently ++reading from the stream retrieves the characters in the reverse order ++that they were pushed. + + Pushing back characters doesn't alter the file; only the internal + buffering for the stream is affected. If a file positioning function +diff --git a/stdio-common/tst-ungetc.c b/stdio-common/tst-ungetc.c +index 5c808f073419f00b..388b202493ddd586 100644 +--- a/stdio-common/tst-ungetc.c ++++ b/stdio-common/tst-ungetc.c +@@ -48,6 +48,8 @@ do_test (void) + TEST_VERIFY_EXIT (getc (fp) == 'b'); + TEST_VERIFY_EXIT (getc (fp) == 'l'); + TEST_VERIFY_EXIT (ungetc ('m', fp) == 'm'); ++ TEST_VERIFY_EXIT (ungetc ('n', fp) == 'n'); ++ TEST_VERIFY_EXIT (getc (fp) == 'n'); + TEST_VERIFY_EXIT (getc (fp) == 'm'); + TEST_VERIFY_EXIT ((c = getc (fp)) == 'a'); + TEST_VERIFY_EXIT (getc (fp) == EOF); diff --git a/SOURCES/glibc-upstream-2.39-114.patch b/SOURCES/glibc-upstream-2.39-114.patch new file mode 100644 index 0000000..d64ebf8 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-114.patch @@ -0,0 +1,135 @@ +commit a500b48bd2a6401de442c00f433079d24331dbb6 +Author: Siddhesh Poyarekar +Date: Tue Aug 13 21:08:49 2024 -0400 + + ungetc: Fix backup buffer leak on program exit [BZ #27821] + + If a file descriptor is left unclosed and is cleaned up by _IO_cleanup + on exit, its backup buffer remains unfreed, registering as a leak in + valgrind. This is not strictly an issue since (1) the program should + ideally be closing the stream once it's not in use and (2) the program + is about to exit anyway, so keeping the backup buffer around a wee bit + longer isn't a real problem. Free it anyway to keep valgrind happy + when the streams in question are the standard ones, i.e. stdout, stdin + or stderr. + + Also, the _IO_have_backup macro checks for _IO_save_base, + which is a roundabout way to check for a backup buffer instead of + directly looking for _IO_backup_base. The roundabout check breaks when + the main get area has not been used and user pushes a char into the + backup buffer with ungetc. Fix this to use the _IO_backup_base + directly. + + Signed-off-by: Siddhesh Poyarekar + Reviewed-by: Carlos O'Donell + (cherry picked from commit 3e1d8d1d1dca24ae90df2ea826a8916896fc7e77) + +diff --git a/libio/genops.c b/libio/genops.c +index 4f5c6136f3ef1b88..bb1d9594ebb60375 100644 +--- a/libio/genops.c ++++ b/libio/genops.c +@@ -789,6 +789,12 @@ _IO_unbuffer_all (void) + legacy = 1; + #endif + ++ /* Free up the backup area if it was ever allocated. */ ++ if (_IO_have_backup (fp)) ++ _IO_free_backup_area (fp); ++ if (fp->_mode > 0 && _IO_have_wbackup (fp)) ++ _IO_free_wbackup_area (fp); ++ + if (! (fp->_flags & _IO_UNBUFFERED) + /* Iff stream is un-orientated, it wasn't used. */ + && (legacy || fp->_mode != 0)) +diff --git a/libio/libioP.h b/libio/libioP.h +index 1af287b19f30fa2a..616253fcd00f04db 100644 +--- a/libio/libioP.h ++++ b/libio/libioP.h +@@ -577,8 +577,8 @@ extern void _IO_old_init (FILE *fp, int flags) __THROW; + ((__fp)->_wide_data->_IO_write_base \ + = (__fp)->_wide_data->_IO_write_ptr = __p, \ + (__fp)->_wide_data->_IO_write_end = (__ep)) +-#define _IO_have_backup(fp) ((fp)->_IO_save_base != NULL) +-#define _IO_have_wbackup(fp) ((fp)->_wide_data->_IO_save_base != NULL) ++#define _IO_have_backup(fp) ((fp)->_IO_backup_base != NULL) ++#define _IO_have_wbackup(fp) ((fp)->_wide_data->_IO_backup_base != NULL) + #define _IO_in_backup(fp) ((fp)->_flags & _IO_IN_BACKUP) + #define _IO_have_markers(fp) ((fp)->_markers != NULL) + #define _IO_blen(fp) ((fp)->_IO_buf_end - (fp)->_IO_buf_base) +diff --git a/stdio-common/Makefile b/stdio-common/Makefile +index 159dc472e4c76b9a..b9c38ce6b3b2f43a 100644 +--- a/stdio-common/Makefile ++++ b/stdio-common/Makefile +@@ -257,6 +257,7 @@ tests := \ + tst-swscanf \ + tst-tmpnam \ + tst-ungetc \ ++ tst-ungetc-leak \ + tst-unlockedio \ + tst-vfprintf-mbs-prec \ + tst-vfprintf-user-type \ +@@ -301,6 +302,7 @@ tests-special += \ + $(objpfx)tst-printfsz-islongdouble.out \ + $(objpfx)tst-setvbuf1-cmp.out \ + $(objpfx)tst-unbputc.out \ ++ $(objpfx)tst-ungetc-leak-mem.out \ + $(objpfx)tst-vfprintf-width-prec-mem.out \ + # tests-special + +@@ -315,6 +317,8 @@ generated += \ + tst-printf-fp-leak-mem.out \ + tst-printf-fp-leak.mtrace \ + tst-scanf-bz27650.mtrace \ ++ tst-ungetc-leak-mem.out \ ++ tst-ungetc-leak.mtrace \ + tst-vfprintf-width-prec-mem.out \ + tst-vfprintf-width-prec.mtrace \ + # generated +@@ -407,6 +411,9 @@ tst-printf-fp-leak-ENV = \ + tst-scanf-bz27650-ENV = \ + MALLOC_TRACE=$(objpfx)tst-scanf-bz27650.mtrace \ + LD_PRELOAD=$(common-objpfx)malloc/libc_malloc_debug.so ++tst-ungetc-leak-ENV = \ ++ MALLOC_TRACE=$(objpfx)tst-ungetc-leak.mtrace \ ++ LD_PRELOAD=$(common-objpfx)malloc/libc_malloc_debug.so + + $(objpfx)tst-unbputc.out: tst-unbputc.sh $(objpfx)tst-unbputc + $(SHELL) $< $(common-objpfx) '$(test-program-prefix)'; \ +diff --git a/stdio-common/tst-ungetc-leak.c b/stdio-common/tst-ungetc-leak.c +new file mode 100644 +index 0000000000000000..6c5152b43f80b217 +--- /dev/null ++++ b/stdio-common/tst-ungetc-leak.c +@@ -0,0 +1,32 @@ ++/* Test for memory leak with ungetc when stream is unused. ++ Copyright The GNU Toolchain Authors. ++ 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 ++ . */ ++ ++#include ++#include ++#include ++#include ++ ++static int ++do_test (void) ++{ ++ mtrace (); ++ TEST_COMPARE (ungetc('y', stdin), 'y'); ++ return 0; ++} ++ ++#include diff --git a/SOURCES/glibc-upstream-2.39-115.patch b/SOURCES/glibc-upstream-2.39-115.patch new file mode 100644 index 0000000..3475ed3 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-115.patch @@ -0,0 +1,83 @@ +commit cae418638e83bcac4e65d612036edbd58f6e9364 +Author: Maciej W. Rozycki +Date: Fri Jul 26 13:21:34 2024 +0100 + + posix: Use facilities in tst-truncate and tst-truncate64 + + Remove local FAIL macro in favor to FAIL_RET from , + which provides equivalent reporting, with the name of the file of the + failure site additionally included, for the tst-truncate-common core + shared between the tst-truncate and tst-truncate64 tests. + + Reviewed-by: DJ Delorie + (cherry picked from commit fe47595504a55e7bb992f8928533df154b510383) + +diff --git a/posix/tst-truncate-common.c b/posix/tst-truncate-common.c +index b774fa46b80412b4..b8c561ffdb2b2903 100644 +--- a/posix/tst-truncate-common.c ++++ b/posix/tst-truncate-common.c +@@ -21,6 +21,8 @@ + #include + #include + ++#include ++ + static void do_prepare (void); + #define PREPARE(argc, argv) do_prepare () + static int do_test (void); +@@ -42,9 +44,6 @@ do_prepare (void) + } + } + +-#define FAIL(str) \ +- do { printf ("error: %s (line %d)\n", str, __LINE__); return 1; } while (0) +- + static int + do_test_with_offset (off_t offset) + { +@@ -54,35 +53,35 @@ do_test_with_offset (off_t offset) + memset (buf, 0xcf, sizeof (buf)); + + if (pwrite (temp_fd, buf, sizeof (buf), offset) != sizeof (buf)) +- FAIL ("write failed"); ++ FAIL_RET ("write failed"); + if (fstat (temp_fd, &st) < 0 || st.st_size != (offset + sizeof (buf))) +- FAIL ("initial size wrong"); ++ FAIL_RET ("initial size wrong"); + + if (ftruncate (temp_fd, offset + 800) < 0) +- FAIL ("size reduction with ftruncate failed"); ++ FAIL_RET ("size reduction with ftruncate failed"); + if (fstat (temp_fd, &st) < 0 || st.st_size != (offset + 800)) +- FAIL ("size after reduction with ftruncate is incorrect"); ++ FAIL_RET ("size after reduction with ftruncate is incorrect"); + + /* The following test covers more than POSIX. POSIX does not require + that ftruncate() can increase the file size. But we are testing + Unix systems. */ + if (ftruncate (temp_fd, offset + 1200) < 0) +- FAIL ("size increate with ftruncate failed"); ++ FAIL_RET ("size increate with ftruncate failed"); + if (fstat (temp_fd, &st) < 0 || st.st_size != (offset + 1200)) +- FAIL ("size after increase is incorrect"); ++ FAIL_RET ("size after increase is incorrect"); + + if (truncate (temp_filename, offset + 800) < 0) +- FAIL ("size reduction with truncate failed"); ++ FAIL_RET ("size reduction with truncate failed"); + if (fstat (temp_fd, &st) < 0 || st.st_size != (offset + 800)) +- FAIL ("size after reduction with truncate incorrect"); ++ FAIL_RET ("size after reduction with truncate incorrect"); + + /* The following test covers more than POSIX. POSIX does not require + that truncate() can increase the file size. But we are testing + Unix systems. */ + if (truncate (temp_filename, (offset + 1200)) < 0) +- FAIL ("size increase with truncate failed"); ++ FAIL_RET ("size increase with truncate failed"); + if (fstat (temp_fd, &st) < 0 || st.st_size != (offset + 1200)) +- FAIL ("size increase with truncate is incorrect"); ++ FAIL_RET ("size increase with truncate is incorrect"); + + return 0; + } diff --git a/SOURCES/glibc-upstream-2.39-116.patch b/SOURCES/glibc-upstream-2.39-116.patch new file mode 100644 index 0000000..3295a2f --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-116.patch @@ -0,0 +1,129 @@ +commit 5ff30b2f75681e1f752eeaad9d48ad249dabe71c +Author: Maciej W. Rozycki +Date: Fri Jul 26 13:21:34 2024 +0100 + + nptl: Use facilities in tst-setuid3 + + Remove local FAIL macro in favor to FAIL_EXIT1 from , + which provides equivalent reporting, with the name of the file and the + line number within of the failure site additionally included. Remove + FAIL_ERR altogether and include ": %m" explicitly with the format string + supplied to FAIL_EXIT1 as there seems little value to have a separate + macro just for this. + + Reviewed-by: DJ Delorie + (cherry picked from commit 8c98195af6e6f1ce21743fc26c723e0f7e45bcf2) + +diff --git a/sysdeps/pthread/tst-setuid3.c b/sysdeps/pthread/tst-setuid3.c +index 83f42a0ae5b06df5..3845ab03d306cf0f 100644 +--- a/sysdeps/pthread/tst-setuid3.c ++++ b/sysdeps/pthread/tst-setuid3.c +@@ -15,24 +15,19 @@ + License along with the GNU C Library; if not, see + . */ + +-#include + #include + #include + #include + #include + ++#include ++ + /* The test must run under a non-privileged user ID. */ + static const uid_t test_uid = 1; + + static pthread_barrier_t barrier1; + static pthread_barrier_t barrier2; + +-#define FAIL(fmt, ...) \ +- do { printf ("FAIL: " fmt "\n", __VA_ARGS__); _exit (1); } while (0) +- +-#define FAIL_ERR(fmt, ...) \ +- do { printf ("FAIL: " fmt ": %m\n", __VA_ARGS__); _exit (1); } while (0) +- + /* True if x is not a successful return code from pthread_barrier_wait. */ + static inline bool + is_invalid_barrier_ret (int x) +@@ -45,10 +40,10 @@ thread_func (void *ctx __attribute__ ((unused))) + { + int ret = pthread_barrier_wait (&barrier1); + if (is_invalid_barrier_ret (ret)) +- FAIL ("pthread_barrier_wait (barrier1) (on thread): %d", ret); ++ FAIL_EXIT1 ("pthread_barrier_wait (barrier1) (on thread): %d", ret); + ret = pthread_barrier_wait (&barrier2); + if (is_invalid_barrier_ret (ret)) +- FAIL ("pthread_barrier_wait (barrier2) (on thread): %d", ret); ++ FAIL_EXIT1 ("pthread_barrier_wait (barrier2) (on thread): %d", ret); + return NULL; + } + +@@ -59,13 +54,13 @@ setuid_failure (int phase) + switch (ret) + { + case 0: +- FAIL ("setuid succeeded unexpectedly in phase %d", phase); ++ FAIL_EXIT1 ("setuid succeeded unexpectedly in phase %d", phase); + case -1: + if (errno != EPERM) +- FAIL_ERR ("setuid phase %d", phase); ++ FAIL_EXIT1 ("setuid phase %d: %m", phase); + break; + default: +- FAIL ("invalid setuid return value in phase %d: %d", phase, ret); ++ FAIL_EXIT1 ("invalid setuid return value in phase %d: %d", phase, ret); + } + } + +@@ -74,42 +69,42 @@ do_test (void) + { + if (getuid () == 0) + if (setuid (test_uid) != 0) +- FAIL_ERR ("setuid (%u)", (unsigned) test_uid); ++ FAIL_EXIT1 ("setuid (%u): %m", (unsigned) test_uid); + if (setuid (getuid ())) +- FAIL_ERR ("setuid (%s)", "getuid ()"); ++ FAIL_EXIT1 ("setuid (%s): %m", "getuid ()"); + setuid_failure (1); + + int ret = pthread_barrier_init (&barrier1, NULL, 2); + if (ret != 0) +- FAIL ("pthread_barrier_init (barrier1): %d", ret); ++ FAIL_EXIT1 ("pthread_barrier_init (barrier1): %d", ret); + ret = pthread_barrier_init (&barrier2, NULL, 2); + if (ret != 0) +- FAIL ("pthread_barrier_init (barrier2): %d", ret); ++ FAIL_EXIT1 ("pthread_barrier_init (barrier2): %d", ret); + + pthread_t thread; + ret = pthread_create (&thread, NULL, thread_func, NULL); + if (ret != 0) +- FAIL ("pthread_create: %d", ret); ++ FAIL_EXIT1 ("pthread_create: %d", ret); + + /* Ensure that the thread is running properly. */ + ret = pthread_barrier_wait (&barrier1); + if (is_invalid_barrier_ret (ret)) +- FAIL ("pthread_barrier_wait (barrier1): %d", ret); ++ FAIL_EXIT1 ("pthread_barrier_wait (barrier1): %d", ret); + + setuid_failure (2); + + /* Check success case. */ + if (setuid (getuid ()) != 0) +- FAIL_ERR ("setuid (%s)", "getuid ()"); ++ FAIL_EXIT1 ("setuid (%s): %m", "getuid ()"); + + /* Shutdown. */ + ret = pthread_barrier_wait (&barrier2); + if (is_invalid_barrier_ret (ret)) +- FAIL ("pthread_barrier_wait (barrier2): %d", ret); ++ FAIL_EXIT1 ("pthread_barrier_wait (barrier2): %d", ret); + + ret = pthread_join (thread, NULL); + if (ret != 0) +- FAIL ("pthread_join: %d", ret); ++ FAIL_EXIT1 ("pthread_join: %d", ret); + + return 0; + } diff --git a/SOURCES/glibc-upstream-2.39-117.patch b/SOURCES/glibc-upstream-2.39-117.patch new file mode 100644 index 0000000..53b7ce9 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-117.patch @@ -0,0 +1,499 @@ +commit 28c4f32f71c4cdd8549842c646819538206ba3a6 +Author: Florian Weimer +Date: Mon Jul 1 17:42:04 2024 +0200 + + elf: Support recursive use of dynamic TLS in interposed malloc + + It turns out that quite a few applications use bundled mallocs that + have been built to use global-dynamic TLS (instead of the recommended + initial-exec TLS). The previous workaround from + commit afe42e935b3ee97bac9a7064157587777259c60e ("elf: Avoid some + free (NULL) calls in _dl_update_slotinfo") does not fix all + encountered cases unfortunatelly. + + This change avoids the TLS generation update for recursive use + of TLS from a malloc that was called during a TLS update. This + is possible because an interposed malloc has a fixed module ID and + TLS slot. (It cannot be unloaded.) If an initially-loaded module ID + is encountered in __tls_get_addr and the dynamic linker is already + in the middle of a TLS update, use the outdated DTV, thus avoiding + another call into malloc. It's still necessary to update the + DTV to the most recent generation, to get out of the slow path, + which is why the check for recursion is needed. + + The bookkeeping is done using a global counter instead of per-thread + flag because TLS access in the dynamic linker is tricky. + + All this will go away once the dynamic linker stops using malloc + for TLS, likely as part of a change that pre-allocates all TLS + during pthread_create/dlopen. + + Fixes commit d2123d68275acc0f061e73d5f86ca504e0d5a344 ("elf: Fix slow + tls access after dlopen [BZ #19924]"). + + Reviewed-by: Szabolcs Nagy + (cherry picked from commit 018f0fc3b818d4d1460a4e2384c24802504b1d20) + +diff --git a/elf/Makefile b/elf/Makefile +index a50a988e7362cf3b..d81309321031fcb6 100644 +--- a/elf/Makefile ++++ b/elf/Makefile +@@ -443,6 +443,7 @@ tests += \ + tst-p_align1 \ + tst-p_align2 \ + tst-p_align3 \ ++ tst-recursive-tls \ + tst-relsort1 \ + tst-ro-dynamic \ + tst-rtld-run-static \ +@@ -877,6 +878,23 @@ modules-names += \ + tst-null-argv-lib \ + tst-p_alignmod-base \ + tst-p_alignmod3 \ ++ tst-recursive-tlsmallocmod \ ++ tst-recursive-tlsmod0 \ ++ tst-recursive-tlsmod1 \ ++ tst-recursive-tlsmod2 \ ++ tst-recursive-tlsmod3 \ ++ tst-recursive-tlsmod4 \ ++ tst-recursive-tlsmod5 \ ++ tst-recursive-tlsmod6 \ ++ tst-recursive-tlsmod7 \ ++ tst-recursive-tlsmod8 \ ++ tst-recursive-tlsmod9 \ ++ tst-recursive-tlsmod10 \ ++ tst-recursive-tlsmod11 \ ++ tst-recursive-tlsmod12 \ ++ tst-recursive-tlsmod13 \ ++ tst-recursive-tlsmod14 \ ++ tst-recursive-tlsmod15 \ + tst-relsort1mod1 \ + tst-relsort1mod2 \ + tst-ro-dynamic-mod \ +@@ -3064,3 +3082,11 @@ CFLAGS-tst-gnu2-tls2mod0.c += -mtls-dialect=$(have-mtls-descriptor) + CFLAGS-tst-gnu2-tls2mod1.c += -mtls-dialect=$(have-mtls-descriptor) + CFLAGS-tst-gnu2-tls2mod2.c += -mtls-dialect=$(have-mtls-descriptor) + endif ++ ++$(objpfx)tst-recursive-tls: $(objpfx)tst-recursive-tlsmallocmod.so ++# More objects than DTV_SURPLUS, to trigger DTV reallocation. ++$(objpfx)tst-recursive-tls.out: \ ++ $(patsubst %,$(objpfx)tst-recursive-tlsmod%.so, \ ++ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) ++$(objpfx)tst-recursive-tlsmod%.os: tst-recursive-tlsmodN.c ++ $(compile-command.c) -DVAR=thread_$* -DFUNC=get_threadvar_$* +diff --git a/elf/dl-tls.c b/elf/dl-tls.c +index 670dbc42fc2e3334..3d221273f1915f19 100644 +--- a/elf/dl-tls.c ++++ b/elf/dl-tls.c +@@ -75,6 +75,31 @@ + /* Default for dl_tls_static_optional. */ + #define OPTIONAL_TLS 512 + ++/* Used to count the number of threads currently executing dynamic TLS ++ updates. Used to avoid recursive malloc calls in __tls_get_addr ++ for an interposed malloc that uses global-dynamic TLS (which is not ++ recommended); see _dl_tls_allocate_active checks. This could be a ++ per-thread flag, but would need TLS access in the dynamic linker. */ ++unsigned int _dl_tls_threads_in_update; ++ ++static inline void ++_dl_tls_allocate_begin (void) ++{ ++ atomic_fetch_add_relaxed (&_dl_tls_threads_in_update, 1); ++} ++ ++static inline void ++_dl_tls_allocate_end (void) ++{ ++ atomic_fetch_add_relaxed (&_dl_tls_threads_in_update, -1); ++} ++ ++static inline bool ++_dl_tls_allocate_active (void) ++{ ++ return atomic_load_relaxed (&_dl_tls_threads_in_update) > 0; ++} ++ + /* Compute the static TLS surplus based on the namespace count and the + TLS space that can be used for optimizations. */ + static inline int +@@ -425,12 +450,18 @@ _dl_allocate_tls_storage (void) + size += TLS_PRE_TCB_SIZE; + #endif + +- /* Perform the allocation. Reserve space for the required alignment +- and the pointer to the original allocation. */ ++ /* Reserve space for the required alignment and the pointer to the ++ original allocation. */ + size_t alignment = GLRO (dl_tls_static_align); ++ ++ /* Perform the allocation. */ ++ _dl_tls_allocate_begin (); + void *allocated = malloc (size + alignment + sizeof (void *)); + if (__glibc_unlikely (allocated == NULL)) +- return NULL; ++ { ++ _dl_tls_allocate_end (); ++ return NULL; ++ } + + /* Perform alignment and allocate the DTV. */ + #if TLS_TCB_AT_TP +@@ -466,6 +497,8 @@ _dl_allocate_tls_storage (void) + result = allocate_dtv (result); + if (result == NULL) + free (allocated); ++ ++ _dl_tls_allocate_end (); + return result; + } + +@@ -483,6 +516,7 @@ _dl_resize_dtv (dtv_t *dtv, size_t max_modid) + size_t newsize = max_modid + DTV_SURPLUS; + size_t oldsize = dtv[-1].counter; + ++ _dl_tls_allocate_begin (); + if (dtv == GL(dl_initial_dtv)) + { + /* This is the initial dtv that was either statically allocated in +@@ -502,6 +536,7 @@ _dl_resize_dtv (dtv_t *dtv, size_t max_modid) + if (newp == NULL) + oom (); + } ++ _dl_tls_allocate_end (); + + newp[0].counter = newsize; + +@@ -676,7 +711,9 @@ allocate_dtv_entry (size_t alignment, size_t size) + if (powerof2 (alignment) && alignment <= _Alignof (max_align_t)) + { + /* The alignment is supported by malloc. */ ++ _dl_tls_allocate_begin (); + void *ptr = malloc (size); ++ _dl_tls_allocate_end (); + return (struct dtv_pointer) { ptr, ptr }; + } + +@@ -688,7 +725,10 @@ allocate_dtv_entry (size_t alignment, size_t size) + + /* Perform the allocation. This is the pointer we need to free + later. */ ++ _dl_tls_allocate_begin (); + void *start = malloc (alloc_size); ++ _dl_tls_allocate_end (); ++ + if (start == NULL) + return (struct dtv_pointer) {}; + +@@ -826,7 +866,11 @@ _dl_update_slotinfo (unsigned long int req_modid, size_t new_gen) + free implementation. Checking here papers over at + least some dynamic TLS usage by interposed mallocs. */ + if (dtv[modid].pointer.to_free != NULL) +- free (dtv[modid].pointer.to_free); ++ { ++ _dl_tls_allocate_begin (); ++ free (dtv[modid].pointer.to_free); ++ _dl_tls_allocate_end (); ++ } + dtv[modid].pointer.val = TLS_DTV_UNALLOCATED; + dtv[modid].pointer.to_free = NULL; + +@@ -956,10 +1000,22 @@ __tls_get_addr (GET_ADDR_ARGS) + size_t gen = atomic_load_relaxed (&GL(dl_tls_generation)); + if (__glibc_unlikely (dtv[0].counter != gen)) + { +- /* Update DTV up to the global generation, see CONCURRENCY NOTES +- in _dl_update_slotinfo. */ +- gen = atomic_load_acquire (&GL(dl_tls_generation)); +- return update_get_addr (GET_ADDR_PARAM, gen); ++ if (_dl_tls_allocate_active () ++ && GET_ADDR_MODULE < _dl_tls_initial_modid_limit) ++ /* This is a reentrant __tls_get_addr call, but we can ++ satisfy it because it's an initially-loaded module ID. ++ These TLS slotinfo slots do not change, so the ++ out-of-date generation counter does not matter. However, ++ if not in a TLS update, still update_get_addr below, to ++ get off the slow path eventually. */ ++ ; ++ else ++ { ++ /* Update DTV up to the global generation, see CONCURRENCY NOTES ++ in _dl_update_slotinfo. */ ++ gen = atomic_load_acquire (&GL(dl_tls_generation)); ++ return update_get_addr (GET_ADDR_PARAM, gen); ++ } + } + + void *p = dtv[GET_ADDR_MODULE].pointer.val; +@@ -969,7 +1025,7 @@ __tls_get_addr (GET_ADDR_ARGS) + + return (char *) p + GET_ADDR_OFFSET; + } +-#endif ++#endif /* SHARED */ + + + /* Look up the module's TLS block as for __tls_get_addr, +@@ -1018,6 +1074,25 @@ _dl_tls_get_addr_soft (struct link_map *l) + return data; + } + ++size_t _dl_tls_initial_modid_limit; ++ ++void ++_dl_tls_initial_modid_limit_setup (void) ++{ ++ struct dtv_slotinfo_list *listp = GL(dl_tls_dtv_slotinfo_list); ++ size_t idx; ++ for (idx = 0; idx < listp->len; ++idx) ++ { ++ struct link_map *l = listp->slotinfo[idx].map; ++ if (l == NULL ++ /* The object can be unloaded, so its modid can be ++ reassociated. */ ++ || !(l->l_type == lt_executable || l->l_type == lt_library)) ++ break; ++ } ++ _dl_tls_initial_modid_limit = idx; ++} ++ + + void + _dl_add_to_slotinfo (struct link_map *l, bool do_add) +@@ -1050,9 +1125,11 @@ _dl_add_to_slotinfo (struct link_map *l, bool do_add) + the first slot. */ + assert (idx == 0); + ++ _dl_tls_allocate_begin (); + listp = (struct dtv_slotinfo_list *) + malloc (sizeof (struct dtv_slotinfo_list) + + TLS_SLOTINFO_SURPLUS * sizeof (struct dtv_slotinfo)); ++ _dl_tls_allocate_end (); + if (listp == NULL) + { + /* We ran out of memory while resizing the dtv slotinfo list. */ +diff --git a/elf/rtld.c b/elf/rtld.c +index ac4bb236527882db..4b01e9352acd327b 100644 +--- a/elf/rtld.c ++++ b/elf/rtld.c +@@ -788,6 +788,8 @@ init_tls (size_t naudit) + _dl_fatal_printf ("\ + cannot allocate TLS data structures for initial thread\n"); + ++ _dl_tls_initial_modid_limit_setup (); ++ + /* Store for detection of the special case by __tls_get_addr + so it knows not to pass this dtv to the normal realloc. */ + GL(dl_initial_dtv) = GET_DTV (tcbp); +diff --git a/elf/tst-recursive-tls.c b/elf/tst-recursive-tls.c +new file mode 100644 +index 0000000000000000..716d1f783a67ddc2 +--- /dev/null ++++ b/elf/tst-recursive-tls.c +@@ -0,0 +1,60 @@ ++/* Test with interposed malloc with dynamic TLS. ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++#include ++#include ++#include ++ ++/* Defined in tst-recursive-tlsmallocmod.so. */ ++extern __thread unsigned int malloc_subsytem_counter; ++ ++static int ++do_test (void) ++{ ++ /* 16 is large enough to exercise the DTV resizing case. */ ++ void *handles[16]; ++ ++ for (unsigned int i = 0; i < array_length (handles); ++i) ++ { ++ /* Re-use the TLS slot for module 0. */ ++ if (i > 0) ++ xdlclose (handles[0]); ++ ++ char soname[30]; ++ snprintf (soname, sizeof (soname), "tst-recursive-tlsmod%u.so", i); ++ handles[i] = xdlopen (soname, RTLD_NOW); ++ ++ if (i > 0) ++ { ++ handles[0] = xdlopen ("tst-recursive-tlsmod0.so", RTLD_NOW); ++ int (*fptr) (void) = xdlsym (handles[0], "get_threadvar_0"); ++ /* May trigger TLS storage allocation using malloc. */ ++ TEST_COMPARE (fptr (), 0); ++ } ++ } ++ ++ for (unsigned int i = 0; i < array_length (handles); ++i) ++ xdlclose (handles[i]); ++ ++ printf ("info: malloc subsystem calls: %u\n", malloc_subsytem_counter); ++ TEST_VERIFY (malloc_subsytem_counter > 0); ++ return 0; ++} ++ ++#include +diff --git a/elf/tst-recursive-tlsmallocmod.c b/elf/tst-recursive-tlsmallocmod.c +new file mode 100644 +index 0000000000000000..c24e9945d1b6db58 +--- /dev/null ++++ b/elf/tst-recursive-tlsmallocmod.c +@@ -0,0 +1,64 @@ ++/* Interposed malloc with dynamic TLS. ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++#include ++ ++__thread unsigned int malloc_subsytem_counter; ++ ++static __typeof (malloc) *malloc_fptr; ++static __typeof (free) *free_fptr; ++static __typeof (calloc) *calloc_fptr; ++static __typeof (realloc) *realloc_fptr; ++ ++static void __attribute__ ((constructor)) ++init (void) ++{ ++ malloc_fptr = dlsym (RTLD_NEXT, "malloc"); ++ free_fptr = dlsym (RTLD_NEXT, "free"); ++ calloc_fptr = dlsym (RTLD_NEXT, "calloc"); ++ realloc_fptr = dlsym (RTLD_NEXT, "realloc"); ++} ++ ++void * ++malloc (size_t size) ++{ ++ ++malloc_subsytem_counter; ++ return malloc_fptr (size); ++} ++ ++void ++free (void *ptr) ++{ ++ ++malloc_subsytem_counter; ++ return free_fptr (ptr); ++} ++ ++void * ++calloc (size_t a, size_t b) ++{ ++ ++malloc_subsytem_counter; ++ return calloc_fptr (a, b); ++} ++ ++void * ++realloc (void *ptr, size_t size) ++{ ++ ++malloc_subsytem_counter; ++ return realloc_fptr (ptr, size); ++} +diff --git a/elf/tst-recursive-tlsmodN.c b/elf/tst-recursive-tlsmodN.c +new file mode 100644 +index 0000000000000000..bb7592aee6ed347e +--- /dev/null ++++ b/elf/tst-recursive-tlsmodN.c +@@ -0,0 +1,28 @@ ++/* Test module with global-dynamic TLS. Used to trigger DTV reallocation. ++ Copyright (C) 2024 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 ++ . */ ++ ++/* Compiled with VAR and FUNC set via -D. FUNC requires some ++ relocation against TLS variable VAR. */ ++ ++__thread int VAR; ++ ++int ++FUNC (void) ++{ ++ return VAR; ++} +diff --git a/sysdeps/generic/ldsodefs.h b/sysdeps/generic/ldsodefs.h +index 50f58a60e3f02330..656e8a3fa005021d 100644 +--- a/sysdeps/generic/ldsodefs.h ++++ b/sysdeps/generic/ldsodefs.h +@@ -1256,6 +1256,20 @@ extern struct link_map *_dl_update_slotinfo (unsigned long int req_modid, + size_t gen) + attribute_hidden; + ++/* The last TLS module ID that is initially loaded, plus 1. TLS ++ addresses for modules with IDs lower than that can be obtained from ++ the DTV even if its generation is outdated. */ ++extern size_t _dl_tls_initial_modid_limit attribute_hidden attribute_relro; ++ ++/* Compute _dl_tls_initial_modid_limit. To be called after initial ++ relocation. */ ++void _dl_tls_initial_modid_limit_setup (void) attribute_hidden; ++ ++/* Number of threads currently in a TLS update. This is used to ++ detect reentrant __tls_get_addr calls without a per-thread ++ flag. */ ++extern unsigned int _dl_tls_threads_in_update attribute_hidden; ++ + /* Look up the module's TLS block as for __tls_get_addr, + but never touch anything. Return null if it's not allocated yet. */ + extern void *_dl_tls_get_addr_soft (struct link_map *l) attribute_hidden; +diff --git a/sysdeps/x86_64/dl-tls.c b/sysdeps/x86_64/dl-tls.c +index 869023bbba6f5817..b3c1e4fcd7813b8b 100644 +--- a/sysdeps/x86_64/dl-tls.c ++++ b/sysdeps/x86_64/dl-tls.c +@@ -41,7 +41,10 @@ __tls_get_addr_slow (GET_ADDR_ARGS) + dtv_t *dtv = THREAD_DTV (); + + size_t gen = atomic_load_acquire (&GL(dl_tls_generation)); +- if (__glibc_unlikely (dtv[0].counter != gen)) ++ if (__glibc_unlikely (dtv[0].counter != gen) ++ /* See comment in __tls_get_addr in elf/dl-tls.c. */ ++ && !(_dl_tls_allocate_active () ++ && GET_ADDR_MODULE < _dl_tls_initial_modid_limit)) + return update_get_addr (GET_ADDR_PARAM, gen); + + return tls_get_addr_tail (GET_ADDR_PARAM, dtv, NULL); diff --git a/SOURCES/glibc-upstream-2.39-118.patch b/SOURCES/glibc-upstream-2.39-118.patch new file mode 100644 index 0000000..2d12af8 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-118.patch @@ -0,0 +1,93 @@ +commit e3d5d2d3508faeb8545f871a419f4ac46fa16df2 +Author: Florian Weimer +Date: Thu Aug 1 23:31:23 2024 +0200 + + elf: Clarify and invert second argument of _dl_allocate_tls_init + + Also remove an outdated comment: _dl_allocate_tls_init is + called as part of pthread_create. + + Reviewed-by: Carlos O'Donell + (cherry picked from commit fe06fb313bddf7e4530056897d4a706606e49377) + +diff --git a/elf/dl-tls.c b/elf/dl-tls.c +index 3d221273f1915f19..ecb966d282213131 100644 +--- a/elf/dl-tls.c ++++ b/elf/dl-tls.c +@@ -552,9 +552,14 @@ _dl_resize_dtv (dtv_t *dtv, size_t max_modid) + /* Allocate initial TLS. RESULT should be a non-NULL pointer to storage + for the TLS space. The DTV may be resized, and so this function may + call malloc to allocate that space. The loader's GL(dl_load_tls_lock) +- is taken when manipulating global TLS-related data in the loader. */ ++ is taken when manipulating global TLS-related data in the loader. ++ ++ If MAIN_THREAD, this is the first call during process ++ initialization. In this case, TLS initialization for secondary ++ (audit) namespaces is skipped because that has already been handled ++ by dlopen. */ + void * +-_dl_allocate_tls_init (void *result, bool init_tls) ++_dl_allocate_tls_init (void *result, bool main_thread) + { + if (result == NULL) + /* The memory allocation failed. */ +@@ -633,7 +638,7 @@ _dl_allocate_tls_init (void *result, bool init_tls) + because it would already be set by the audit setup. However, + subsequent thread creation would need to follow the default + behaviour. */ +- if (map->l_ns != LM_ID_BASE && !init_tls) ++ if (map->l_ns != LM_ID_BASE && main_thread) + continue; + memset (__mempcpy (dest, map->l_tls_initimage, + map->l_tls_initimage_size), '\0', +@@ -661,7 +666,7 @@ _dl_allocate_tls (void *mem) + { + return _dl_allocate_tls_init (mem == NULL + ? _dl_allocate_tls_storage () +- : allocate_dtv (mem), true); ++ : allocate_dtv (mem), false); + } + rtld_hidden_def (_dl_allocate_tls) + +diff --git a/elf/rtld.c b/elf/rtld.c +index 4b01e9352acd327b..3ca9a11009a74626 100644 +--- a/elf/rtld.c ++++ b/elf/rtld.c +@@ -2337,7 +2337,7 @@ dl_main (const ElfW(Phdr) *phdr, + into the main thread's TLS area, which we allocated above. + Note: thread-local variables must only be accessed after completing + the next step. */ +- _dl_allocate_tls_init (tcbp, false); ++ _dl_allocate_tls_init (tcbp, true); + + /* And finally install it for the main thread. */ + if (! __rtld_tls_init_tp_called) +diff --git a/nptl/allocatestack.c b/nptl/allocatestack.c +index 9ed886573fdc3b7d..d9adb5856cefa533 100644 +--- a/nptl/allocatestack.c ++++ b/nptl/allocatestack.c +@@ -141,7 +141,7 @@ get_cached_stack (size_t *sizep, void **memp) + memset (dtv, '\0', (dtv[-1].counter + 1) * sizeof (dtv_t)); + + /* Re-initialize the TLS. */ +- _dl_allocate_tls_init (TLS_TPADJ (result), true); ++ _dl_allocate_tls_init (TLS_TPADJ (result), false); + + return result; + } +diff --git a/sysdeps/generic/ldsodefs.h b/sysdeps/generic/ldsodefs.h +index 656e8a3fa005021d..154efb0e1985e907 100644 +--- a/sysdeps/generic/ldsodefs.h ++++ b/sysdeps/generic/ldsodefs.h +@@ -1200,10 +1200,8 @@ extern void _dl_get_tls_static_info (size_t *sizep, size_t *alignp); + + extern void _dl_allocate_static_tls (struct link_map *map) attribute_hidden; + +-/* These are internal entry points to the two halves of _dl_allocate_tls, +- only used within rtld.c itself at startup time. */ + extern void *_dl_allocate_tls_storage (void) attribute_hidden; +-extern void *_dl_allocate_tls_init (void *, bool); ++extern void *_dl_allocate_tls_init (void *result, bool main_thread); + rtld_hidden_proto (_dl_allocate_tls_init) + + /* True if the TCB has been set up. */ diff --git a/SOURCES/glibc-upstream-2.39-119.patch b/SOURCES/glibc-upstream-2.39-119.patch new file mode 100644 index 0000000..18c30ed --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-119.patch @@ -0,0 +1,540 @@ +commit 27a0c6b4902b49efa156e530a63640495c4b1179 +Author: Florian Weimer +Date: Thu Aug 1 23:31:30 2024 +0200 + + elf: Avoid re-initializing already allocated TLS in dlopen (bug 31717) + + The old code used l_init_called as an indicator for whether TLS + initialization was complete. However, it is possible that + TLS for an object is initialized, written to, and then dlopen + for this object is called again, and l_init_called is not true at + this point. Previously, this resulted in TLS being initialized + twice, discarding any interim writes (technically introducing a + use-after-free bug even). + + This commit introduces an explicit per-object flag, l_tls_in_slotinfo. + It indicates whether _dl_add_to_slotinfo has been called for this + object. This flag is used to avoid double-initialization of TLS. + In update_tls_slotinfo, the first_static_tls micro-optimization + is removed because preserving the initalization flag for subsequent + use by the second loop for static TLS is a bit complicated, and + another per-object flag does not seem to be worth it. Furthermore, + the l_init_called flag is dropped from the second loop (for static + TLS initialization) because l_need_tls_init on its own prevents + double-initialization. + + The remaining l_init_called usage in resize_scopes and update_scopes + is just an optimization due to the use of scope_has_map, so it is + not changed in this commit. + + The isupper check ensures that libc.so.6 is TLS is not reverted. + Such a revert happens if l_need_tls_init is not cleared in + _dl_allocate_tls_init for the main_thread case, now that + l_init_called is not checked anymore in update_tls_slotinfo + in elf/dl-open.c. + + Reported-by: Jonathon Anderson + Reviewed-by: Carlos O'Donell + (cherry picked from commit 5097cd344fd243fb8deb6dec96e8073753f962f9) + +diff --git a/elf/Makefile b/elf/Makefile +index d81309321031fcb6..a90305d39b68fb5e 100644 +--- a/elf/Makefile ++++ b/elf/Makefile +@@ -414,6 +414,10 @@ tests += \ + tst-dlmopen4 \ + tst-dlopen-self \ + tst-dlopen-tlsmodid \ ++ tst-dlopen-tlsreinit1 \ ++ tst-dlopen-tlsreinit2 \ ++ tst-dlopen-tlsreinit3 \ ++ tst-dlopen-tlsreinit4 \ + tst-dlopenfail \ + tst-dlopenfail-2 \ + tst-dlopenrpath \ +@@ -838,6 +842,9 @@ modules-names += \ + tst-dlmopen-twice-mod1 \ + tst-dlmopen-twice-mod2 \ + tst-dlmopen1mod \ ++ tst-dlopen-tlsreinitmod1 \ ++ tst-dlopen-tlsreinitmod2 \ ++ tst-dlopen-tlsreinitmod3 \ + tst-dlopenfaillinkmod \ + tst-dlopenfailmod1 \ + tst-dlopenfailmod2 \ +@@ -3090,3 +3097,26 @@ $(objpfx)tst-recursive-tls.out: \ + 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + $(objpfx)tst-recursive-tlsmod%.os: tst-recursive-tlsmodN.c + $(compile-command.c) -DVAR=thread_$* -DFUNC=get_threadvar_$* ++ ++# Order matters here. The test needs the constructor for ++# tst-dlopen-tlsreinitmod2.so to be called first. ++LDFLAGS-tst-dlopen-tlsreinitmod1.so = -Wl,--no-as-needed ++$(objpfx)tst-dlopen-tlsreinitmod1.so: \ ++ $(objpfx)tst-dlopen-tlsreinitmod3.so $(objpfx)tst-dlopen-tlsreinitmod2.so ++LDFLAGS-tst-dlopen-tlsreinit2 = -Wl,--no-as-needed ++$(objpfx)tst-dlopen-tlsreinit2: \ ++ $(objpfx)tst-dlopen-tlsreinitmod3.so $(objpfx)tst-dlopen-tlsreinitmod2.so ++LDFLAGS-tst-dlopen-tlsreinit4 = -Wl,--no-as-needed ++$(objpfx)tst-dlopen-tlsreinit4: \ ++ $(objpfx)tst-dlopen-tlsreinitmod3.so $(objpfx)tst-dlopen-tlsreinitmod2.so ++# tst-dlopen-tlsreinitmod2.so is underlinked and refers to ++# tst-dlopen-tlsreinitmod3.so. The dependency is provided via ++# $(objpfx)tst-dlopen-tlsreinitmod1.so. ++tst-dlopen-tlsreinitmod2.so-no-z-defs = yes ++$(objpfx)tst-dlopen-tlsreinit.out: $(objpfx)tst-dlopen-tlsreinitmod1.so \ ++ $(objpfx)tst-dlopen-tlsreinitmod2.so $(objpfx)tst-dlopen-tlsreinitmod3.so ++# Reuse an audit module which provides ample debug logging. ++$(objpfx)tst-dlopen-tlsreinit3.out: $(objpfx)tst-auditmod1.so ++tst-dlopen-tlsreinit3-ENV = LD_AUDIT=$(objpfx)tst-auditmod1.so ++$(objpfx)tst-dlopen-tlsreinit4.out: $(objpfx)tst-auditmod1.so ++tst-dlopen-tlsreinit4-ENV = LD_AUDIT=$(objpfx)tst-auditmod1.so +diff --git a/elf/dl-open.c b/elf/dl-open.c +index c378da16c025f825..8556e7bd2fb0b40e 100644 +--- a/elf/dl-open.c ++++ b/elf/dl-open.c +@@ -363,17 +363,8 @@ resize_tls_slotinfo (struct link_map *new) + { + bool any_tls = false; + for (unsigned int i = 0; i < new->l_searchlist.r_nlist; ++i) +- { +- struct link_map *imap = new->l_searchlist.r_list[i]; +- +- /* Only add TLS memory if this object is loaded now and +- therefore is not yet initialized. */ +- if (! imap->l_init_called && imap->l_tls_blocksize > 0) +- { +- _dl_add_to_slotinfo (imap, false); +- any_tls = true; +- } +- } ++ if (_dl_add_to_slotinfo (new->l_searchlist.r_list[i], false)) ++ any_tls = true; + return any_tls; + } + +@@ -383,22 +374,8 @@ resize_tls_slotinfo (struct link_map *new) + static void + update_tls_slotinfo (struct link_map *new) + { +- unsigned int first_static_tls = new->l_searchlist.r_nlist; + for (unsigned int i = 0; i < new->l_searchlist.r_nlist; ++i) +- { +- struct link_map *imap = new->l_searchlist.r_list[i]; +- +- /* Only add TLS memory if this object is loaded now and +- therefore is not yet initialized. */ +- if (! imap->l_init_called && imap->l_tls_blocksize > 0) +- { +- _dl_add_to_slotinfo (imap, true); +- +- if (imap->l_need_tls_init +- && first_static_tls == new->l_searchlist.r_nlist) +- first_static_tls = i; +- } +- } ++ _dl_add_to_slotinfo (new->l_searchlist.r_list[i], true); + + size_t newgen = GL(dl_tls_generation) + 1; + if (__glibc_unlikely (newgen == 0)) +@@ -410,13 +387,11 @@ TLS generation counter wrapped! Please report this.")); + /* We need a second pass for static tls data, because + _dl_update_slotinfo must not be run while calls to + _dl_add_to_slotinfo are still pending. */ +- for (unsigned int i = first_static_tls; i < new->l_searchlist.r_nlist; ++i) ++ for (unsigned int i = 0; i < new->l_searchlist.r_nlist; ++i) + { + struct link_map *imap = new->l_searchlist.r_list[i]; + +- if (imap->l_need_tls_init +- && ! imap->l_init_called +- && imap->l_tls_blocksize > 0) ++ if (imap->l_need_tls_init && imap->l_tls_blocksize > 0) + { + /* For static TLS we have to allocate the memory here and + now, but we can delay updating the DTV. */ +diff --git a/elf/dl-tls.c b/elf/dl-tls.c +index ecb966d282213131..3d529b722cb271d9 100644 +--- a/elf/dl-tls.c ++++ b/elf/dl-tls.c +@@ -632,17 +632,21 @@ _dl_allocate_tls_init (void *result, bool main_thread) + some platforms use in static programs requires it. */ + dtv[map->l_tls_modid].pointer.val = dest; + +- /* Copy the initialization image and clear the BSS part. For +- audit modules or dependencies with initial-exec TLS, we can not +- set the initial TLS image on default loader initialization +- because it would already be set by the audit setup. However, +- subsequent thread creation would need to follow the default +- behaviour. */ ++ /* Copy the initialization image and clear the BSS part. ++ For audit modules or dependencies with initial-exec TLS, ++ we can not set the initial TLS image on default loader ++ initialization because it would already be set by the ++ audit setup, which uses the dlopen code and already ++ clears l_need_tls_init. Calls with !main_thread from ++ pthread_create need to initialze TLS for the current ++ thread regardless of namespace. */ + if (map->l_ns != LM_ID_BASE && main_thread) + continue; + memset (__mempcpy (dest, map->l_tls_initimage, + map->l_tls_initimage_size), '\0', + map->l_tls_blocksize - map->l_tls_initimage_size); ++ if (main_thread) ++ map->l_need_tls_init = 0; + } + + total += cnt; +@@ -1099,9 +1103,32 @@ _dl_tls_initial_modid_limit_setup (void) + } + + +-void ++/* Add module to slot information data. If DO_ADD is false, only the ++ required memory is allocated. Must be called with ++ GL (dl_load_tls_lock) acquired. If the function has already been ++ called for the link map L with !DO_ADD, then this function will not ++ raise an exception, otherwise it is possible that it encounters a ++ memory allocation failure. ++ ++ Return false if L has already been added to the slotinfo data, or ++ if L has no TLS data. If the returned value is true, L has been ++ added with this call (DO_ADD), or has been added in a previous call ++ (!DO_ADD). ++ ++ The expected usage is as follows: Call _dl_add_to_slotinfo for ++ several link maps with DO_ADD set to false, and record if any calls ++ result in a true result. If there was a true result, call ++ _dl_add_to_slotinfo again, this time with DO_ADD set to true. (For ++ simplicity, it's possible to call the function for link maps where ++ the previous result was false.) The return value from the second ++ round of calls can be ignored. If there was true result initially, ++ call _dl_update_slotinfo to update the TLS generation counter. */ ++bool + _dl_add_to_slotinfo (struct link_map *l, bool do_add) + { ++ if (l->l_tls_blocksize == 0 || l->l_tls_in_slotinfo) ++ return false; ++ + /* Now that we know the object is loaded successfully add + modules containing TLS data to the dtv info table. We + might have to increase its size. */ +@@ -1157,7 +1184,10 @@ cannot create TLS data structures")); + atomic_store_relaxed (&listp->slotinfo[idx].map, l); + atomic_store_relaxed (&listp->slotinfo[idx].gen, + GL(dl_tls_generation) + 1); ++ l->l_tls_in_slotinfo = true; + } ++ ++ return true; + } + + #if PTHREAD_IN_LIBC +diff --git a/elf/tst-dlopen-tlsreinit1.c b/elf/tst-dlopen-tlsreinit1.c +new file mode 100644 +index 0000000000000000..2016b9b0c646a11d +--- /dev/null ++++ b/elf/tst-dlopen-tlsreinit1.c +@@ -0,0 +1,40 @@ ++/* Test that dlopen preserves already accessed TLS (bug 31717). ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++#include ++#include ++#include ++ ++static int ++do_test (void) ++{ ++ void *handle = xdlopen ("tst-dlopen-tlsreinitmod1.so", RTLD_NOW); ++ ++ bool *tlsreinitmod3_tested = xdlsym (handle, "tlsreinitmod3_tested"); ++ TEST_VERIFY (*tlsreinitmod3_tested); ++ ++ xdlclose (handle); ++ ++ /* This crashes if the libc.so.6 TLS image has been reverted. */ ++ TEST_VERIFY (!isupper ('@')); ++ ++ return 0; ++} ++ ++#include +diff --git a/elf/tst-dlopen-tlsreinit2.c b/elf/tst-dlopen-tlsreinit2.c +new file mode 100644 +index 0000000000000000..90ad2c7713776b4d +--- /dev/null ++++ b/elf/tst-dlopen-tlsreinit2.c +@@ -0,0 +1,39 @@ ++/* Test that dlopen preserves already accessed TLS (bug 31717). ++ Variant with initially-linked modules. ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++#include ++#include ++#include ++ ++ ++static int ++do_test (void) ++{ ++ /* Defined in tst-dlopen-tlsreinitmod3.so. */ ++ extern bool tlsreinitmod3_tested; ++ TEST_VERIFY (tlsreinitmod3_tested); ++ ++ /* This crashes if the libc.so.6 TLS image has been reverted. */ ++ TEST_VERIFY (!isupper ('@')); ++ ++ return 0; ++} ++ ++#include +diff --git a/elf/tst-dlopen-tlsreinit3.c b/elf/tst-dlopen-tlsreinit3.c +new file mode 100644 +index 0000000000000000..79bd585afff66d0b +--- /dev/null ++++ b/elf/tst-dlopen-tlsreinit3.c +@@ -0,0 +1,2 @@ ++/* Same code, but run with LD_AUDIT=tst-auditmod1.so. */ ++#include "tst-dlopen-tlsreinit1.c" +diff --git a/elf/tst-dlopen-tlsreinit4.c b/elf/tst-dlopen-tlsreinit4.c +new file mode 100644 +index 0000000000000000..344c9211abe553e6 +--- /dev/null ++++ b/elf/tst-dlopen-tlsreinit4.c +@@ -0,0 +1,2 @@ ++/* Same code, but run with LD_AUDIT=tst-auditmod1.so. */ ++#include "tst-dlopen-tlsreinit2.c" +diff --git a/elf/tst-dlopen-tlsreinitmod1.c b/elf/tst-dlopen-tlsreinitmod1.c +new file mode 100644 +index 0000000000000000..354cc3de5131423d +--- /dev/null ++++ b/elf/tst-dlopen-tlsreinitmod1.c +@@ -0,0 +1,20 @@ ++/* Test that dlopen preserves already accessed TLS (bug 31717), module 1. ++ Copyright (C) 2024 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 ++ . */ ++ ++/* This module triggers loading of tst-dlopen-tlsreinitmod2.so and ++ tst-dlopen-tlsreinitmod3.so. */ +diff --git a/elf/tst-dlopen-tlsreinitmod2.c b/elf/tst-dlopen-tlsreinitmod2.c +new file mode 100644 +index 0000000000000000..677e69bd35e57dfa +--- /dev/null ++++ b/elf/tst-dlopen-tlsreinitmod2.c +@@ -0,0 +1,30 @@ ++/* Test that dlopen preserves already accessed TLS (bug 31717), module 2. ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++ ++/* Defined in tst-dlopen-tlsreinitmod3.so. This an underlinked symbol ++ dependency. */ ++extern void call_tlsreinitmod3 (void); ++ ++static void __attribute__ ((constructor)) ++tlsreinitmod2_init (void) ++{ ++ puts ("info: constructor of tst-dlopen-tlsreinitmod2.so invoked"); ++ call_tlsreinitmod3 (); ++} +diff --git a/elf/tst-dlopen-tlsreinitmod3.c b/elf/tst-dlopen-tlsreinitmod3.c +new file mode 100644 +index 0000000000000000..ef769c51313a234f +--- /dev/null ++++ b/elf/tst-dlopen-tlsreinitmod3.c +@@ -0,0 +1,102 @@ ++/* Test that dlopen preserves already accessed TLS (bug 31717), module 3. ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++#include ++#include ++#include ++ ++/* Used to verify from the main program that the test ran. */ ++bool tlsreinitmod3_tested; ++ ++/* This TLS variable must not revert back to the initial state after ++ dlopen. */ ++static __thread int tlsreinitmod3_state = 1; ++ ++/* Set from the ELF constructor during dlopen. */ ++static bool tlsreinitmod3_constructed; ++ ++/* Second half of test, behind a compiler barrier. The compiler ++ barrier is necessary to prevent carrying over TLS address ++ information from call_tlsreinitmod3 to call_tlsreinitmod3_tail. */ ++void call_tlsreinitmod3_tail (void *self) __attribute__ ((weak)); ++ ++/* Called from tst-dlopen-tlsreinitmod2.so. */ ++void ++call_tlsreinitmod3 (void) ++{ ++ printf ("info: call_tlsreinitmod3 invoked (state=%d)\n", ++ tlsreinitmod3_state); ++ ++ if (tlsreinitmod3_constructed) ++ { ++ puts ("error: call_tlsreinitmod3 called after ELF constructor"); ++ fflush (stdout); ++ /* Cannot rely on test harness due to dynamic linking. */ ++ _exit (1); ++ } ++ ++ tlsreinitmod3_state = 2; ++ ++ /* Self-dlopen. This will run the ELF constructor. */ ++ void *self = dlopen ("tst-dlopen-tlsreinitmod3.so", RTLD_NOW); ++ if (self == NULL) ++ { ++ printf ("error: dlopen: %s\n", dlerror ()); ++ fflush (stdout); ++ /* Cannot rely on test harness due to dynamic linking. */ ++ _exit (1); ++ } ++ ++ call_tlsreinitmod3_tail (self); ++} ++ ++void ++call_tlsreinitmod3_tail (void *self) ++{ ++ printf ("info: dlopen returned in tlsreinitmod3 (state=%d)\n", ++ tlsreinitmod3_state); ++ ++ if (!tlsreinitmod3_constructed) ++ { ++ puts ("error: dlopen did not call tlsreinitmod3 ELF constructor"); ++ fflush (stdout); ++ /* Cannot rely on test harness due to dynamic linking. */ ++ _exit (1); ++ } ++ ++ if (tlsreinitmod3_state != 2) ++ { ++ puts ("error: TLS state reverted in tlsreinitmod3"); ++ fflush (stdout); ++ /* Cannot rely on test harness due to dynamic linking. */ ++ _exit (1); ++ } ++ ++ dlclose (self); ++ ++ /* Signal test completion to the main program. */ ++ tlsreinitmod3_tested = true; ++} ++ ++static void __attribute__ ((constructor)) ++tlsreinitmod3_init (void) ++{ ++ puts ("info: constructor of tst-dlopen-tlsreinitmod3.so invoked"); ++ tlsreinitmod3_constructed = true; ++} +diff --git a/include/link.h b/include/link.h +index cb0d7d8e2fc32687..5ed445d5a6cdf12d 100644 +--- a/include/link.h ++++ b/include/link.h +@@ -212,6 +212,7 @@ struct link_map + unsigned int l_find_object_processed:1; /* Zero if _dl_find_object_update + needs to process this + lt_library map. */ ++ unsigned int l_tls_in_slotinfo:1; /* TLS slotinfo updated in dlopen. */ + + /* NODELETE status of the map. Only valid for maps of type + lt_loaded. Lazy binding sets l_nodelete_active directly, +diff --git a/sysdeps/generic/ldsodefs.h b/sysdeps/generic/ldsodefs.h +index 154efb0e1985e907..259ce2e7d6e8ff31 100644 +--- a/sysdeps/generic/ldsodefs.h ++++ b/sysdeps/generic/ldsodefs.h +@@ -1239,13 +1239,7 @@ extern void *_dl_open (const char *name, int mode, const void *caller, + extern int _dl_scope_free (void *) attribute_hidden; + + +-/* Add module to slot information data. If DO_ADD is false, only the +- required memory is allocated. Must be called with GL +- (dl_load_tls_lock) acquired. If the function has already been called +- for the link map L with !do_add, then this function will not raise +- an exception, otherwise it is possible that it encounters a memory +- allocation failure. */ +-extern void _dl_add_to_slotinfo (struct link_map *l, bool do_add) ++extern bool _dl_add_to_slotinfo (struct link_map *l, bool do_add) + attribute_hidden; + + /* Update slot information data for at least the generation of the diff --git a/SOURCES/glibc-upstream-2.39-120.patch b/SOURCES/glibc-upstream-2.39-120.patch new file mode 100644 index 0000000..0506252 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-120.patch @@ -0,0 +1,27 @@ +commit 7f5027995f45337a3fc4bb6d0b2039ee1e685f2e +Author: Florian Weimer +Date: Mon Sep 9 21:10:23 2024 +0200 + + elf: Fix tst-dlopen-tlsreinit1.out test dependency + + Fixes commit 5097cd344fd243fb8deb6dec96e8073753f962f9 + ("elf: Avoid re-initializing already allocated TLS in dlopen + (bug 31717)"). + + Reported-by: Patsy Griffin + Reviewed-by: Patsy Griffin + (cherry picked from commit e82a7cb1622bff08d8e3a144d7c5516a088f1cbc) + +diff --git a/elf/Makefile b/elf/Makefile +index a90305d39b68fb5e..8a5678aa63736812 100644 +--- a/elf/Makefile ++++ b/elf/Makefile +@@ -3113,7 +3113,7 @@ $(objpfx)tst-dlopen-tlsreinit4: \ + # tst-dlopen-tlsreinitmod3.so. The dependency is provided via + # $(objpfx)tst-dlopen-tlsreinitmod1.so. + tst-dlopen-tlsreinitmod2.so-no-z-defs = yes +-$(objpfx)tst-dlopen-tlsreinit.out: $(objpfx)tst-dlopen-tlsreinitmod1.so \ ++$(objpfx)tst-dlopen-tlsreinit1.out: $(objpfx)tst-dlopen-tlsreinitmod1.so \ + $(objpfx)tst-dlopen-tlsreinitmod2.so $(objpfx)tst-dlopen-tlsreinitmod3.so + # Reuse an audit module which provides ample debug logging. + $(objpfx)tst-dlopen-tlsreinit3.out: $(objpfx)tst-auditmod1.so diff --git a/SOURCES/glibc-upstream-2.39-121.patch b/SOURCES/glibc-upstream-2.39-121.patch new file mode 100644 index 0000000..12a3b35 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-121.patch @@ -0,0 +1,140 @@ +commit 4e382ce01cce1ef2ab8548dc1dda2ad3046662d8 +Author: Florian Weimer +Date: Tue Sep 10 12:40:27 2024 +0200 + + debug: Fix read error handling in pcprofiledump + + The reading loops did not check for read failures. Addresses + a static analysis report. + + Manually tested by compiling a program with the GCC's + -finstrument-functions option, running it with + “LD_PRELOAD=debug/libpcprofile.so PCPROFILE_OUTPUT=output-file”, + and reviewing the output of “debug/pcprofiledump output-file”. + + (cherry picked from commit 89b088bf70c651c231bf27e644270d093b8f144a) + +diff --git a/debug/pcprofiledump.c b/debug/pcprofiledump.c +index 049a9c2744df739a..94530f0cf92f0652 100644 +--- a/debug/pcprofiledump.c ++++ b/debug/pcprofiledump.c +@@ -75,6 +75,44 @@ static struct argp argp = + options, parse_opt, args_doc, doc, NULL, more_help + }; + ++/* Try to read SIZE bytes from FD and store them on BUF. Terminate ++ the process upon read error. Also terminate the process if less ++ than SIZE bytes are remaining in the file. If !IN_HEADER, do not ++ terminate the process if the end of the file is encountered ++ immediately, before any bytes are read. ++ ++ Returns true if SIZE bytes have been read, and false if no bytes ++ have been read due to an end-of-file condition. */ ++static bool ++read_exactly (int fd, void *buffer, size_t size, bool in_header) ++{ ++ char *p = buffer; ++ char *end = p + size; ++ while (p < end) ++ { ++ ssize_t ret = TEMP_FAILURE_RETRY (read (fd, p, end - p)); ++ if (ret < 0) ++ { ++ if (in_header) ++ error (EXIT_FAILURE, errno, _("cannot read header")); ++ else ++ error (EXIT_FAILURE, errno, _("cannot read pointer pair")); ++ } ++ if (ret == 0) ++ { ++ if (p == buffer && !in_header) ++ /* Nothing has been read. */ ++ return false; ++ if (in_header) ++ error (EXIT_FAILURE, 0, _("unexpected end of file in header")); ++ else ++ error (EXIT_FAILURE, 0, ++ _("unexpected end of file in pointer pair")); ++ } ++ p += ret; ++ } ++ return true; ++} + + int + main (int argc, char *argv[]) +@@ -110,8 +148,7 @@ main (int argc, char *argv[]) + /* Read the first 4-byte word. It contains the information about + the word size and the endianness. */ + uint32_t word; +- if (TEMP_FAILURE_RETRY (read (fd, &word, 4)) != 4) +- error (EXIT_FAILURE, errno, _("cannot read header")); ++ read_exactly (fd, &word, sizeof (word), true); + + /* Check whether we have to swap the byte order. */ + int must_swap = (word & 0x0fffffff) == bswap_32 (0xdeb00000); +@@ -121,56 +158,30 @@ main (int argc, char *argv[]) + /* We have two loops, one for 32 bit pointers, one for 64 bit pointers. */ + if (word == 0xdeb00004) + { +- union +- { +- uint32_t ptrs[2]; +- char bytes[8]; +- } pair; ++ uint32_t ptrs[2]; + + while (1) + { +- size_t len = sizeof (pair); +- size_t n; +- +- while (len > 0 +- && (n = TEMP_FAILURE_RETRY (read (fd, &pair.bytes[8 - len], +- len))) != 0) +- len -= n; +- +- if (len != 0) +- /* Nothing to read. */ ++ if (!read_exactly (fd, ptrs, sizeof (ptrs), false)) + break; + + printf ("this = %#010" PRIx32 ", caller = %#010" PRIx32 "\n", +- must_swap ? bswap_32 (pair.ptrs[0]) : pair.ptrs[0], +- must_swap ? bswap_32 (pair.ptrs[1]) : pair.ptrs[1]); ++ must_swap ? bswap_32 (ptrs[0]) : ptrs[0], ++ must_swap ? bswap_32 (ptrs[1]) : ptrs[1]); + } + } + else if (word == 0xdeb00008) + { +- union +- { +- uint64_t ptrs[2]; +- char bytes[16]; +- } pair; ++ uint64_t ptrs[2]; + + while (1) + { +- size_t len = sizeof (pair); +- size_t n; +- +- while (len > 0 +- && (n = TEMP_FAILURE_RETRY (read (fd, &pair.bytes[8 - len], +- len))) != 0) +- len -= n; +- +- if (len != 0) +- /* Nothing to read. */ ++ if (!read_exactly (fd, ptrs, sizeof (ptrs), false)) + break; + + printf ("this = %#018" PRIx64 ", caller = %#018" PRIx64 "\n", +- must_swap ? bswap_64 (pair.ptrs[0]) : pair.ptrs[0], +- must_swap ? bswap_64 (pair.ptrs[1]) : pair.ptrs[1]); ++ must_swap ? bswap_64 (ptrs[0]) : ptrs[0], ++ must_swap ? bswap_64 (ptrs[1]) : ptrs[1]); + } + } + else diff --git a/SOURCES/glibc-upstream-2.39-122.patch b/SOURCES/glibc-upstream-2.39-122.patch new file mode 100644 index 0000000..4e2c60c --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-122.patch @@ -0,0 +1,28 @@ +commit 84f6bfce2c37e32b9888321fc3131ffbbe6deeba +Author: Siddhesh Poyarekar +Date: Tue Sep 3 14:58:33 2024 -0400 + + libio: Attempt wide backup free only for non-legacy code + + _wide_data and _mode are not available in legacy code, so do not attempt + to free the wide backup buffer in legacy code. + + Resolves: BZ #32137 and BZ #27821 + + Signed-off-by: Siddhesh Poyarekar + Reviewed-by: Florian Weimer + (cherry picked from commit ae4d44b1d501421ad9a3af95279b8f4d1546f1ce) + +diff --git a/libio/genops.c b/libio/genops.c +index bb1d9594ebb60375..02292beed9bc3668 100644 +--- a/libio/genops.c ++++ b/libio/genops.c +@@ -792,7 +792,7 @@ _IO_unbuffer_all (void) + /* Free up the backup area if it was ever allocated. */ + if (_IO_have_backup (fp)) + _IO_free_backup_area (fp); +- if (fp->_mode > 0 && _IO_have_wbackup (fp)) ++ if (!legacy && fp->_mode > 0 && _IO_have_wbackup (fp)) + _IO_free_wbackup_area (fp); + + if (! (fp->_flags & _IO_UNBUFFERED) diff --git a/SOURCES/glibc-upstream-2.39-123.patch b/SOURCES/glibc-upstream-2.39-123.patch new file mode 100644 index 0000000..8eadabd --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-123.patch @@ -0,0 +1,275 @@ +commit 373aab3e52e1c764cf8d86ae14bc4b14e064d623 +Author: Sergey Kolosov +Date: Wed Sep 25 15:51:23 2024 +0200 + + stdio-common: Add new test for fdopen + + This commit adds fdopen test with all modes. + Reviewed-by: DJ Delorie + + (cherry picked from commit 1d72fa3cfa046f7293421a7e58f2a272474ea901) + +diff --git a/stdio-common/Makefile b/stdio-common/Makefile +index b9c38ce6b3b2f43a..5f3bd4662340eee9 100644 +--- a/stdio-common/Makefile ++++ b/stdio-common/Makefile +@@ -206,6 +206,7 @@ tests := \ + tst-cookie \ + tst-dprintf-length \ + tst-fdopen \ ++ tst-fdopen2 \ + tst-ferror \ + tst-fgets \ + tst-fileno \ +diff --git a/stdio-common/tst-fdopen2.c b/stdio-common/tst-fdopen2.c +new file mode 100644 +index 0000000000000000..0c6625f25853aed5 +--- /dev/null ++++ b/stdio-common/tst-fdopen2.c +@@ -0,0 +1,246 @@ ++/* Test the fdopen function. ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++char *tmp_dir; ++char *path_to_file; ++ ++void ++prepare_tmp_dir (void) ++{ ++ tmp_dir = support_create_temp_directory ("tst-fdopen2"); ++ path_to_file = xasprintf ("%s/tst-fdopen2.txt", tmp_dir); ++} ++ ++/* open temp file descriptor with mode. */ ++int ++open_tmp_fd (int mode) ++{ ++ int fd = xopen (path_to_file, mode, 0644); ++ return fd; ++} ++ ++ ++/* close and remove temp file with close. */ ++void ++close_tmp_fd (int fd) ++{ ++ xclose (fd); ++ xunlink (path_to_file); ++} ++ ++/* close and remove temp file with fclose. */ ++void ++close_tmp_fp (FILE *fp) ++{ ++ fclose (fp); ++ xunlink (path_to_file); ++} ++ ++/* test "w" fdopen mode. */ ++void ++do_test_fdopen_w (void) ++{ ++ int fd, ret; ++ FILE *fp; ++ fd = open_tmp_fd (O_WRONLY | O_CREAT | O_TRUNC); ++ ++ /* test mode mismatch. */ ++ fp = fdopen (fd, "r"); ++ if (fp != NULL || errno != EINVAL) ++ { ++ close_tmp_fd (fd); ++ FAIL_EXIT1 ("fdopen (%d, r) should fail with EINVAL: %m", fd); ++ } ++ ++ fp = fdopen (fd, "w"); ++ if (fp == NULL) ++ { ++ close_tmp_fd (fd); ++ FAIL_EXIT1 ("fdopen (%d, w): %m", fd); ++ } ++ ++ const void *buf = "AAAA"; ++ ret = fwrite (buf, 1, 4, fp); ++ if (ret != 4) ++ { ++ close_tmp_fp (fp); ++ FAIL_EXIT1 ("fwrite (): %m"); ++ } ++ ++ unsigned char buf2[4]; ++ rewind (fp); ++ clearerr (fp); ++ /* fread should fail in "w" mode */ ++ ret = fread (buf2, 1, 4, fp); ++ if (ret != 0 || ferror (fp) == 0) ++ { ++ close_tmp_fp (fp); ++ FAIL_EXIT1 ("fread should fail in \"w\" mode"); ++ } ++ ++ fclose (fp); ++} ++ ++/* test "r" fdopen mode. */ ++void ++do_test_fdopen_r (void) ++{ ++ int fd, ret; ++ FILE *fp; ++ fd = open_tmp_fd (O_RDONLY); ++ ++ /* test mode mismatch. */ ++ fp = fdopen (fd, "w"); ++ if (fp != NULL || errno != EINVAL) ++ { ++ close_tmp_fd (fd); ++ FAIL_EXIT1 ("fdopen (%d, w) should fail with EINVAL: %m", fd); ++ } ++ ++ fp = fdopen (fd, "r"); ++ if (fp == NULL) ++ { ++ close_tmp_fd (fd); ++ FAIL_EXIT1 ("fdopen (%d, w): %m", fd); ++ } ++ ++ const void *buf = "BBBB"; ++ /* fwrite should fail in "r" mode. */ ++ ret = fwrite (buf, 1, 4, fp); ++ if (ret != 0 || ferror (fp) == 0) ++ { ++ close_tmp_fp (fp); ++ FAIL_EXIT1 ("fwrite should fail in \"r\" mode"); ++ } ++ ++ unsigned char buf2[4]; ++ ret = fread (buf2, 1, 4, fp); ++ if (ret != 4) ++ { ++ close_tmp_fp (fp); ++ FAIL_EXIT1 ("fread (): %m"); ++ } ++ ++ fclose (fp); ++} ++ ++/* test "a" fdopen mode. */ ++void ++do_test_fdopen_a (void) ++{ ++ int fd, ret; ++ FILE *fp; ++ fd = open_tmp_fd (O_WRONLY | O_CREAT | O_APPEND); ++ ++ /* test mode mismatch. */ ++ fp = fdopen (fd, "r+"); ++ if (fp != NULL || errno != EINVAL) ++ { ++ close_tmp_fd (fd); ++ FAIL_EXIT1 ("fdopen (%d, \"r+\") should fail with EINVAL: %m", fd); ++ } ++ ++ fp = fdopen (fd, "a"); ++ if (fp == NULL) ++ { ++ close_tmp_fd (fd); ++ FAIL_EXIT1 ("fdopen (%d, w): %m", fd); ++ } ++ ++ const void *buf = "CCCC"; ++ ret = fwrite (buf, 1, 4, fp); ++ if (ret != 4) ++ { ++ close_tmp_fp (fp); ++ FAIL_EXIT1 ("fwrite (): %m"); ++ } ++ ++ /* fread should fail in "a" mode. */ ++ unsigned char buf2[4]; ++ clearerr (fp); ++ ret = fread (buf2, 1, 4, fp); ++ if (ret != 0 || ferror (fp) == 0) ++ { ++ close_tmp_fp (fp); ++ FAIL_EXIT1 ("fread should fail \"a\" mode"); ++ } ++ ++ fclose (fp); ++} ++ ++void ++do_test_fdopen_mode (int mode, const char *fmode) ++{ ++ int fd, ret; ++ FILE *fp; ++ fd = open_tmp_fd (mode); ++ ++ fp = fdopen (fd, fmode); ++ if (fp == NULL) ++ { ++ close_tmp_fd (fd); ++ FAIL_EXIT1 ("fdopen (%d, %s): %m", fd, fmode); ++ } ++ ++ const void *buf = "EEEE"; ++ ret = fwrite (buf, 1, 4, fp); ++ if (ret != 4) ++ { ++ close_tmp_fp (fp); ++ FAIL_EXIT1 ("fwrite () in mode:%s returns %d: %m", fmode, ret); ++ } ++ ++ rewind (fp); ++ unsigned char buf2[4]; ++ ret = fread (buf2, 1, 4, fp); ++ if (ret != 4) ++ { ++ close_tmp_fp (fp); ++ FAIL_EXIT1 ("fread () in mode:%s returns %d: %m", fmode, ret); ++ } ++ ++ fclose (fp); ++} ++ ++static int ++do_test (void) ++{ ++ ++ prepare_tmp_dir (); ++ ++ do_test_fdopen_w (); ++ do_test_fdopen_r (); ++ do_test_fdopen_a (); ++ ++ /* test r+ w+ a+ fdopen modes. */ ++ do_test_fdopen_mode (O_RDWR, "r+"); ++ do_test_fdopen_mode (O_RDWR | O_CREAT | O_TRUNC, "w+"); ++ do_test_fdopen_mode (O_RDWR | O_CREAT | O_APPEND, "a+"); ++ xunlink (path_to_file); ++ return 0; ++} ++ ++#include diff --git a/SOURCES/glibc-upstream-2.39-124.patch b/SOURCES/glibc-upstream-2.39-124.patch new file mode 100644 index 0000000..6c86939 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-124.patch @@ -0,0 +1,165 @@ +commit d8b4fc3653ca08912a6dec57a3ba36a2db779488 +Author: Joseph Myers +Date: Tue Sep 24 14:06:22 2024 +0000 + + Add tests of fread + + There seem to be no glibc tests specifically for the fread function. + Add basic tests of that function. + + Tested for x86_64. + + (cherry picked from commit d14c977c65aac7db35bb59380ef99d6582c4f930) + +diff --git a/stdio-common/Makefile b/stdio-common/Makefile +index 5f3bd4662340eee9..c822434293b7e809 100644 +--- a/stdio-common/Makefile ++++ b/stdio-common/Makefile +@@ -216,6 +216,7 @@ tests := \ + tst-fmemopen4 \ + tst-fphex \ + tst-fphex-wide \ ++ tst-fread \ + tst-fseek \ + tst-fwrite \ + tst-gets \ +diff --git a/stdio-common/tst-fread.c b/stdio-common/tst-fread.c +new file mode 100644 +index 0000000000000000..4d9a7895f66a7980 +--- /dev/null ++++ b/stdio-common/tst-fread.c +@@ -0,0 +1,134 @@ ++/* Test fread. ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++#include ++#include ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++int ++do_test (void) ++{ ++ char *temp_dir = support_create_temp_directory ("tst-fread"); ++ char *file1 = xasprintf ("%s/file1", temp_dir); ++ support_write_file_string (file1, "file1"); ++ add_temp_file (file1); ++ FILE *fp; ++ size_t ret; ++ char buf[1024]; ++ ++ verbose_printf ("test single-byte reads\n"); ++ fp = xfopen (file1, "r"); ++ memset (buf, 0, sizeof buf); ++ ret = fread (buf, 1, 2, fp); ++ TEST_COMPARE (ret, 2); ++ TEST_COMPARE (buf[0], 'f'); ++ TEST_COMPARE (buf[1], 'i'); ++ TEST_COMPARE (feof (fp), 0); ++ TEST_COMPARE (ftell (fp), 2); ++ memset (buf, 0, sizeof buf); ++ ret = fread (buf, 1, 3, fp); ++ TEST_COMPARE (ret, 3); ++ TEST_COMPARE (buf[0], 'l'); ++ TEST_COMPARE (buf[1], 'e'); ++ TEST_COMPARE (buf[2], '1'); ++ TEST_COMPARE (ftell (fp), 5); ++ TEST_COMPARE (feof (fp), 0); ++ memset (buf, 0, sizeof buf); ++ ret = fread (buf, 1, 1, fp); ++ TEST_COMPARE (ret, 0); ++ TEST_COMPARE (!!feof (fp), 1); ++ TEST_COMPARE (ferror (fp), 0); ++ TEST_COMPARE (ftell (fp), 5); ++ xfclose (fp); ++ ++ verbose_printf ("test single-byte reads, EOF part way through\n"); ++ fp = xfopen (file1, "r"); ++ memset (buf, 0, sizeof buf); ++ ret = fread (buf, 1, sizeof buf, fp); ++ TEST_COMPARE (ret, 5); ++ TEST_COMPARE (buf[0], 'f'); ++ TEST_COMPARE (buf[1], 'i'); ++ TEST_COMPARE (buf[2], 'l'); ++ TEST_COMPARE (buf[3], 'e'); ++ TEST_COMPARE (buf[4], '1'); ++ TEST_COMPARE (!!feof (fp), 1); ++ TEST_COMPARE (ferror (fp), 0); ++ TEST_COMPARE (ftell (fp), 5); ++ xfclose (fp); ++ ++ verbose_printf ("test multi-byte reads\n"); ++ fp = xfopen (file1, "r"); ++ memset (buf, 0, sizeof buf); ++ ret = fread (buf, 2, 2, fp); ++ TEST_COMPARE (ret, 2); ++ TEST_COMPARE (buf[0], 'f'); ++ TEST_COMPARE (buf[1], 'i'); ++ TEST_COMPARE (buf[2], 'l'); ++ TEST_COMPARE (buf[3], 'e'); ++ TEST_COMPARE (feof (fp), 0); ++ TEST_COMPARE (ftell (fp), 4); ++ memset (buf, 0, sizeof buf); ++ ret = fread (buf, 3, 3, fp); ++ TEST_COMPARE (ret, 0); ++ /* The bytes written for a partial element read are unspecified. */ ++ TEST_COMPARE (!!feof (fp), 1); ++ TEST_COMPARE (ferror (fp), 0); ++ TEST_COMPARE (ftell (fp), 5); ++ xfclose (fp); ++ ++ verbose_printf ("test read error\n"); ++ fp = xfopen (file1, "r"); ++ xclose (fileno (fp)); ++ memset (buf, 0, sizeof buf); ++ ret = fread (buf, 1, sizeof buf, fp); ++ TEST_COMPARE (ret, 0); ++ TEST_COMPARE (feof (fp), 0); ++ TEST_COMPARE (!!ferror (fp), 1); ++ fclose (fp); ++ ++ verbose_printf ("test zero size\n"); ++ fp = xfopen (file1, "r"); ++ ret = fread (buf, 0, SIZE_MAX, fp); ++ TEST_COMPARE (ret, 0); ++ TEST_COMPARE (feof (fp), 0); ++ TEST_COMPARE (ferror (fp), 0); ++ TEST_COMPARE (ftell (fp), 0); ++ xfclose (fp); ++ ++ verbose_printf ("test zero items\n"); ++ fp = xfopen (file1, "r"); ++ ret = fread (buf, SIZE_MAX, 0, fp); ++ TEST_COMPARE (ret, 0); ++ TEST_COMPARE (feof (fp), 0); ++ TEST_COMPARE (ferror (fp), 0); ++ TEST_COMPARE (ftell (fp), 0); ++ xfclose (fp); ++ ++ free (temp_dir); ++ free (file1); ++ return 0; ++} ++ ++#include diff --git a/SOURCES/glibc-upstream-2.39-125.patch b/SOURCES/glibc-upstream-2.39-125.patch new file mode 100644 index 0000000..cb7d2e0 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-125.patch @@ -0,0 +1,51 @@ +commit 293e4e3c90e390fa0b839c66f388a723ac6787e2 +Author: Joseph Myers +Date: Wed Aug 14 17:15:46 2024 +0000 + + Test errno setting on strtod overflow in tst-strtod-round + + We have no tests that errno is set to ERANGE on overflow of + strtod-family functions (we do have some tests for underflow, in + tst-strtod-underflow). Add such tests to tst-strtod-round. + + Tested for x86_64. + + (cherry picked from commit 207d64feb26279e152c50744e3c37e68491aca99) + +diff --git a/stdlib/tst-strtod-round-skeleton.c b/stdlib/tst-strtod-round-skeleton.c +index 6fba4b522862cbb9..c3cc0201d4b1a062 100644 +--- a/stdlib/tst-strtod-round-skeleton.c ++++ b/stdlib/tst-strtod-round-skeleton.c +@@ -21,6 +21,7 @@ + declared in the headers. */ + #define _LIBC_TEST 1 + #define __STDC_WANT_IEC_60559_TYPES_EXT__ ++#include + #include + #include + #include +@@ -205,7 +206,9 @@ struct test { + #define GEN_ONE_TEST(FSUF, FTYPE, FTOSTR, LSUF, CSUF) \ + { \ + feclearexcept (FE_ALL_EXCEPT); \ ++ errno = 0; \ + FTYPE f = STRTO (FSUF) (s, NULL); \ ++ int new_errno = errno; \ + if (f != expected->FSUF \ + || (copysign ## CSUF) (1.0 ## LSUF, f) \ + != (copysign ## CSUF) (1.0 ## LSUF, expected->FSUF)) \ +@@ -254,6 +257,14 @@ struct test { + printf ("ignoring this exception error\n"); \ + } \ + } \ ++ if (overflow->FSUF && new_errno != ERANGE) \ ++ { \ ++ printf (FNPFXS "to" #FSUF \ ++ " (" STRM ") left errno == %d," \ ++ " not %d (ERANGE)\n", \ ++ s, new_errno, ERANGE); \ ++ result = 1; \ ++ } \ + } \ + } + diff --git a/SOURCES/glibc-upstream-2.39-126.patch b/SOURCES/glibc-upstream-2.39-126.patch new file mode 100644 index 0000000..e53d7b0 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-126.patch @@ -0,0 +1,16725 @@ +commit 9cfeccf65ab8aedb2353d89a1ef8b4e775d6f925 +Author: Joseph Myers +Date: Tue Aug 27 12:38:01 2024 +0000 + + More thoroughly test underflow / errno in tst-strtod-round + + Add tests of underflow in tst-strtod-round, and thus also test for + errno being unchanged when there is neither overflow nor underflow. + The errno setting before the function call to test for being unchanged + is adjusted to set errno to 12345 instead of 0, so that any bugs where + strtod sets errno to 0 would be detected. + + This doesn't add any new test inputs for tst-strtod-round, and in + particular doesn't cover the edge cases of underflow the way + tst-strtod-underflow does (none of the existing test inputs for + tst-strtod-round actually exercise cases that have underflow with + before-rounding tininess detection but not with after-rounding + tininess detection), but at least it provides some coverage (as per + the recent discussions) that ordinary non-overflowing non-underflowing + inputs to these functions do not set errno. + + Tested for x86_64. + + (cherry picked from commit d73ed2601b7c3c93c3529149a3d7f7b6177900a8) + +diff --git a/stdlib/gen-tst-strtod-round.c b/stdlib/gen-tst-strtod-round.c +index e48bf4d6ea0dfaea..7ce735f81dedba1a 100644 +--- a/stdlib/gen-tst-strtod-round.c ++++ b/stdlib/gen-tst-strtod-round.c +@@ -46,6 +46,7 @@ static int + string_to_fp (mpfr_t f, const char *s, mpfr_rnd_t rnd) + { + mpfr_clear_overflow (); ++ mpfr_clear_underflow (); + #ifdef WORKAROUND + mpfr_t f2; + mpfr_init2 (f2, 100000); +@@ -53,12 +54,16 @@ string_to_fp (mpfr_t f, const char *s, mpfr_rnd_t rnd) + int r = mpfr_set (f, f2, rnd); + r |= mpfr_subnormalize (f, r, rnd); + mpfr_clear (f2); +- return r0 | r; ++ r |= r0; + #else + int r = mpfr_strtofr (f, s, NULL, 0, rnd); + r |= mpfr_subnormalize (f, r, rnd); +- return r; + #endif ++ if (r == 0) ++ /* The MPFR underflow flag is set for exact subnormal results, ++ which is not wanted here. */ ++ mpfr_clear_underflow (); ++ return r; + } + + void +@@ -70,6 +75,21 @@ print_fp (FILE *fout, mpfr_t f, const char *suffix) + mpfr_fprintf (fout, "\t%Ra%s", f, suffix); + } + ++static const char * ++suffix_to_print (bool overflow, bool underflow, bool underflow_before_rounding, ++ bool with_comma) ++{ ++ if (overflow) ++ return with_comma ? ", true, false,\n" : ", true, false"; ++ if (underflow) ++ return with_comma ? ", false, true,\n" : ", false, true"; ++ if (underflow_before_rounding) ++ return (with_comma ++ ? ", false, !TININESS_AFTER_ROUNDING,\n" ++ : ", false, !TININESS_AFTER_ROUNDING"); ++ return with_comma ? ", false, false,\n" : ", false, false"; ++} ++ + static void + round_str (FILE *fout, const char *s, int prec, int emin, int emax, + bool ibm_ld) +@@ -80,8 +100,11 @@ round_str (FILE *fout, const char *s, int prec, int emin, int emax, + mpfr_set_emin (emin); + mpfr_set_emax (emax); + mpfr_init (f); ++ string_to_fp (f, s, MPFR_RNDZ); ++ bool underflow_before_rounding = mpfr_underflow_p () != 0; + int r = string_to_fp (f, s, MPFR_RNDD); + bool overflow = mpfr_overflow_p () != 0; ++ bool underflow = mpfr_underflow_p () != 0; + if (ibm_ld) + { + assert (prec == 106 && emin == -1073 && emax == 1024); +@@ -97,19 +120,27 @@ round_str (FILE *fout, const char *s, int prec, int emin, int emax, + } + } + mpfr_fprintf (fout, "\t%s,\n", r ? "false" : "true"); +- print_fp (fout, f, overflow ? ", true,\n" : ", false,\n"); ++ print_fp (fout, f, ++ suffix_to_print (overflow, underflow, underflow_before_rounding, ++ true)); + string_to_fp (f, s, MPFR_RNDN); + overflow = (mpfr_overflow_p () != 0 + || (ibm_ld && mpfr_cmpabs (f, max_value) > 0)); +- print_fp (fout, f, overflow ? ", true,\n" : ", false,\n"); ++ print_fp (fout, f, ++ suffix_to_print (overflow, underflow, underflow_before_rounding, ++ true)); + string_to_fp (f, s, MPFR_RNDZ); + overflow = (mpfr_overflow_p () != 0 + || (ibm_ld && mpfr_cmpabs (f, max_value) > 0)); +- print_fp (fout, f, overflow ? ", true,\n" : ", false,\n"); ++ print_fp (fout, f, ++ suffix_to_print (overflow, underflow, underflow_before_rounding, ++ true)); + string_to_fp (f, s, MPFR_RNDU); + overflow = (mpfr_overflow_p () != 0 + || (ibm_ld && mpfr_cmpabs (f, max_value) > 0)); +- print_fp (fout, f, overflow ? ", true" : ", false"); ++ print_fp (fout, f, ++ suffix_to_print (overflow, underflow, underflow_before_rounding, ++ false)); + mpfr_clear (f); + if (ibm_ld) + mpfr_clear (max_value); +diff --git a/stdlib/tst-strtod-round-data.h b/stdlib/tst-strtod-round-data.h +index 8899d15f9b8a810d..13e62dd2b0588a16 100644 +--- a/stdlib/tst-strtod-round-data.h ++++ b/stdlib/tst-strtod-round-data.h +@@ -2,1852 +2,1852 @@ + static const struct test tests[] = { + TEST ("3.518437208883201171875E+013", + false, +- 0x2p+44, false, +- 0x2p+44, false, +- 0x2p+44, false, +- 0x2.000004p+44, false, +- false, +- 0x2.0000000000002p+44, false, +- 0x2.0000000000004p+44, false, +- 0x2.0000000000002p+44, false, +- 0x2.0000000000004p+44, false, +- true, +- 0x2.0000000000003p+44, false, +- 0x2.0000000000003p+44, false, +- 0x2.0000000000003p+44, false, +- 0x2.0000000000003p+44, false, +- true, +- 0x2.0000000000003p+44, false, +- 0x2.0000000000003p+44, false, +- 0x2.0000000000003p+44, false, +- 0x2.0000000000003p+44, false, +- true, +- 0x2.0000000000003p+44, false, +- 0x2.0000000000003p+44, false, +- 0x2.0000000000003p+44, false, +- 0x2.0000000000003p+44, false, +- true, +- 0x2.0000000000003p+44, false, +- 0x2.0000000000003p+44, false, +- 0x2.0000000000003p+44, false, +- 0x2.0000000000003p+44, false), ++ 0x2p+44, false, false, ++ 0x2p+44, false, false, ++ 0x2p+44, false, false, ++ 0x2.000004p+44, false, false, ++ false, ++ 0x2.0000000000002p+44, false, false, ++ 0x2.0000000000004p+44, false, false, ++ 0x2.0000000000002p+44, false, false, ++ 0x2.0000000000004p+44, false, false, ++ true, ++ 0x2.0000000000003p+44, false, false, ++ 0x2.0000000000003p+44, false, false, ++ 0x2.0000000000003p+44, false, false, ++ 0x2.0000000000003p+44, false, false, ++ true, ++ 0x2.0000000000003p+44, false, false, ++ 0x2.0000000000003p+44, false, false, ++ 0x2.0000000000003p+44, false, false, ++ 0x2.0000000000003p+44, false, false, ++ true, ++ 0x2.0000000000003p+44, false, false, ++ 0x2.0000000000003p+44, false, false, ++ 0x2.0000000000003p+44, false, false, ++ 0x2.0000000000003p+44, false, false, ++ true, ++ 0x2.0000000000003p+44, false, false, ++ 0x2.0000000000003p+44, false, false, ++ 0x2.0000000000003p+44, false, false, ++ 0x2.0000000000003p+44, false, false), + TEST ("1.00000005960464477550", + false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.0000010000001p+0, false, +- false, +- 0x1.0000010000000002p+0, false, +- 0x1.0000010000000002p+0, false, +- 0x1.0000010000000002p+0, false, +- 0x1.0000010000000004p+0, false, +- false, +- 0x1.0000010000000002p+0, false, +- 0x1.0000010000000002p+0, false, +- 0x1.0000010000000002p+0, false, +- 0x1.0000010000000004p+0, false, +- false, +- 0x1.0000010000000002048242f2ffp+0, false, +- 0x1.0000010000000002048242f2ff8p+0, false, +- 0x1.0000010000000002048242f2ffp+0, false, +- 0x1.0000010000000002048242f2ff8p+0, false, +- false, +- 0x1.0000010000000002048242f2ff66p+0, false, +- 0x1.0000010000000002048242f2ff67p+0, false, +- 0x1.0000010000000002048242f2ff66p+0, false, +- 0x1.0000010000000002048242f2ff67p+0, false), ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.0000010000001p+0, false, false, ++ false, ++ 0x1.0000010000000002p+0, false, false, ++ 0x1.0000010000000002p+0, false, false, ++ 0x1.0000010000000002p+0, false, false, ++ 0x1.0000010000000004p+0, false, false, ++ false, ++ 0x1.0000010000000002p+0, false, false, ++ 0x1.0000010000000002p+0, false, false, ++ 0x1.0000010000000002p+0, false, false, ++ 0x1.0000010000000004p+0, false, false, ++ false, ++ 0x1.0000010000000002048242f2ffp+0, false, false, ++ 0x1.0000010000000002048242f2ff8p+0, false, false, ++ 0x1.0000010000000002048242f2ffp+0, false, false, ++ 0x1.0000010000000002048242f2ff8p+0, false, false, ++ false, ++ 0x1.0000010000000002048242f2ff66p+0, false, false, ++ 0x1.0000010000000002048242f2ff67p+0, false, false, ++ 0x1.0000010000000002048242f2ff66p+0, false, false, ++ 0x1.0000010000000002048242f2ff67p+0, false, false), + TEST ("1.0000000596046447755", + false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.0000010000001p+0, false, +- false, +- 0x1.0000010000000002p+0, false, +- 0x1.0000010000000002p+0, false, +- 0x1.0000010000000002p+0, false, +- 0x1.0000010000000004p+0, false, +- false, +- 0x1.0000010000000002p+0, false, +- 0x1.0000010000000002p+0, false, +- 0x1.0000010000000002p+0, false, +- 0x1.0000010000000004p+0, false, +- false, +- 0x1.0000010000000002048242f2ffp+0, false, +- 0x1.0000010000000002048242f2ff8p+0, false, +- 0x1.0000010000000002048242f2ffp+0, false, +- 0x1.0000010000000002048242f2ff8p+0, false, +- false, +- 0x1.0000010000000002048242f2ff66p+0, false, +- 0x1.0000010000000002048242f2ff67p+0, false, +- 0x1.0000010000000002048242f2ff66p+0, false, +- 0x1.0000010000000002048242f2ff67p+0, false), ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.0000010000001p+0, false, false, ++ false, ++ 0x1.0000010000000002p+0, false, false, ++ 0x1.0000010000000002p+0, false, false, ++ 0x1.0000010000000002p+0, false, false, ++ 0x1.0000010000000004p+0, false, false, ++ false, ++ 0x1.0000010000000002p+0, false, false, ++ 0x1.0000010000000002p+0, false, false, ++ 0x1.0000010000000002p+0, false, false, ++ 0x1.0000010000000004p+0, false, false, ++ false, ++ 0x1.0000010000000002048242f2ffp+0, false, false, ++ 0x1.0000010000000002048242f2ff8p+0, false, false, ++ 0x1.0000010000000002048242f2ffp+0, false, false, ++ 0x1.0000010000000002048242f2ff8p+0, false, false, ++ false, ++ 0x1.0000010000000002048242f2ff66p+0, false, false, ++ 0x1.0000010000000002048242f2ff67p+0, false, false, ++ 0x1.0000010000000002048242f2ff66p+0, false, false, ++ 0x1.0000010000000002048242f2ff67p+0, false, false), + TEST ("1.000000059604644776", + false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.0000010000001p+0, false, +- false, +- 0x1.000001000000000ap+0, false, +- 0x1.000001000000000cp+0, false, +- 0x1.000001000000000ap+0, false, +- 0x1.000001000000000cp+0, false, +- false, +- 0x1.000001000000000ap+0, false, +- 0x1.000001000000000cp+0, false, +- 0x1.000001000000000ap+0, false, +- 0x1.000001000000000cp+0, false, +- false, +- 0x1.000001000000000b3db12bdc21p+0, false, +- 0x1.000001000000000b3db12bdc21p+0, false, +- 0x1.000001000000000b3db12bdc21p+0, false, +- 0x1.000001000000000b3db12bdc218p+0, false, +- false, +- 0x1.000001000000000b3db12bdc213cp+0, false, +- 0x1.000001000000000b3db12bdc213dp+0, false, +- 0x1.000001000000000b3db12bdc213cp+0, false, +- 0x1.000001000000000b3db12bdc213dp+0, false), ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.0000010000001p+0, false, false, ++ false, ++ 0x1.000001000000000ap+0, false, false, ++ 0x1.000001000000000cp+0, false, false, ++ 0x1.000001000000000ap+0, false, false, ++ 0x1.000001000000000cp+0, false, false, ++ false, ++ 0x1.000001000000000ap+0, false, false, ++ 0x1.000001000000000cp+0, false, false, ++ 0x1.000001000000000ap+0, false, false, ++ 0x1.000001000000000cp+0, false, false, ++ false, ++ 0x1.000001000000000b3db12bdc21p+0, false, false, ++ 0x1.000001000000000b3db12bdc21p+0, false, false, ++ 0x1.000001000000000b3db12bdc21p+0, false, false, ++ 0x1.000001000000000b3db12bdc218p+0, false, false, ++ false, ++ 0x1.000001000000000b3db12bdc213cp+0, false, false, ++ 0x1.000001000000000b3db12bdc213dp+0, false, false, ++ 0x1.000001000000000b3db12bdc213cp+0, false, false, ++ 0x1.000001000000000b3db12bdc213dp+0, false, false), + TEST ("1.000000059604644775", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.000000fffffffp+0, false, +- 0x1.000001p+0, false, +- 0x1.000000fffffffp+0, false, +- 0x1.000001p+0, false, +- false, +- 0x1.000000fffffffff8p+0, false, +- 0x1.000000fffffffff8p+0, false, +- 0x1.000000fffffffff8p+0, false, +- 0x1.000000fffffffffap+0, false, +- false, +- 0x1.000000fffffffff8p+0, false, +- 0x1.000000fffffffff8p+0, false, +- 0x1.000000fffffffff8p+0, false, +- 0x1.000000fffffffffap+0, false, +- false, +- 0x1.000000fffffffff8cb535a09dd8p+0, false, +- 0x1.000000fffffffff8cb535a09dd8p+0, false, +- 0x1.000000fffffffff8cb535a09dd8p+0, false, +- 0x1.000000fffffffff8cb535a09dep+0, false, +- false, +- 0x1.000000fffffffff8cb535a09dd9p+0, false, +- 0x1.000000fffffffff8cb535a09dd91p+0, false, +- 0x1.000000fffffffff8cb535a09dd9p+0, false, +- 0x1.000000fffffffff8cb535a09dd91p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.000000fffffffp+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000000fffffffp+0, false, false, ++ 0x1.000001p+0, false, false, ++ false, ++ 0x1.000000fffffffff8p+0, false, false, ++ 0x1.000000fffffffff8p+0, false, false, ++ 0x1.000000fffffffff8p+0, false, false, ++ 0x1.000000fffffffffap+0, false, false, ++ false, ++ 0x1.000000fffffffff8p+0, false, false, ++ 0x1.000000fffffffff8p+0, false, false, ++ 0x1.000000fffffffff8p+0, false, false, ++ 0x1.000000fffffffffap+0, false, false, ++ false, ++ 0x1.000000fffffffff8cb535a09dd8p+0, false, false, ++ 0x1.000000fffffffff8cb535a09dd8p+0, false, false, ++ 0x1.000000fffffffff8cb535a09dd8p+0, false, false, ++ 0x1.000000fffffffff8cb535a09dep+0, false, false, ++ false, ++ 0x1.000000fffffffff8cb535a09dd9p+0, false, false, ++ 0x1.000000fffffffff8cb535a09dd91p+0, false, false, ++ 0x1.000000fffffffff8cb535a09dd9p+0, false, false, ++ 0x1.000000fffffffff8cb535a09dd91p+0, false, false), + TEST ("1.00000005960464478", + false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.0000010000001p+0, false, +- false, +- 0x1.0000010000000054p+0, false, +- 0x1.0000010000000056p+0, false, +- 0x1.0000010000000054p+0, false, +- 0x1.0000010000000056p+0, false, +- false, +- 0x1.0000010000000054p+0, false, +- 0x1.0000010000000056p+0, false, +- 0x1.0000010000000054p+0, false, +- 0x1.0000010000000056p+0, false, +- false, +- 0x1.0000010000000055072873252f8p+0, false, +- 0x1.0000010000000055072873253p+0, false, +- 0x1.0000010000000055072873252f8p+0, false, +- 0x1.0000010000000055072873253p+0, false, +- false, +- 0x1.0000010000000055072873252febp+0, false, +- 0x1.0000010000000055072873252febp+0, false, +- 0x1.0000010000000055072873252febp+0, false, +- 0x1.0000010000000055072873252fecp+0, false), ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.0000010000001p+0, false, false, ++ false, ++ 0x1.0000010000000054p+0, false, false, ++ 0x1.0000010000000056p+0, false, false, ++ 0x1.0000010000000054p+0, false, false, ++ 0x1.0000010000000056p+0, false, false, ++ false, ++ 0x1.0000010000000054p+0, false, false, ++ 0x1.0000010000000056p+0, false, false, ++ 0x1.0000010000000054p+0, false, false, ++ 0x1.0000010000000056p+0, false, false, ++ false, ++ 0x1.0000010000000055072873252f8p+0, false, false, ++ 0x1.0000010000000055072873253p+0, false, false, ++ 0x1.0000010000000055072873252f8p+0, false, false, ++ 0x1.0000010000000055072873253p+0, false, false, ++ false, ++ 0x1.0000010000000055072873252febp+0, false, false, ++ 0x1.0000010000000055072873252febp+0, false, false, ++ 0x1.0000010000000055072873252febp+0, false, false, ++ 0x1.0000010000000055072873252fecp+0, false, false), + TEST ("1.0000000596046448", + false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.0000010000001p+0, false, +- false, +- 0x1.00000100000001c4p+0, false, +- 0x1.00000100000001c6p+0, false, +- 0x1.00000100000001c4p+0, false, +- 0x1.00000100000001c6p+0, false, +- false, +- 0x1.00000100000001c4p+0, false, +- 0x1.00000100000001c6p+0, false, +- 0x1.00000100000001c4p+0, false, +- 0x1.00000100000001c6p+0, false, +- false, +- 0x1.00000100000001c5f67cd79279p+0, false, +- 0x1.00000100000001c5f67cd792798p+0, false, +- 0x1.00000100000001c5f67cd79279p+0, false, +- 0x1.00000100000001c5f67cd792798p+0, false, +- false, +- 0x1.00000100000001c5f67cd7927953p+0, false, +- 0x1.00000100000001c5f67cd7927954p+0, false, +- 0x1.00000100000001c5f67cd7927953p+0, false, +- 0x1.00000100000001c5f67cd7927954p+0, false), ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.0000010000001p+0, false, false, ++ false, ++ 0x1.00000100000001c4p+0, false, false, ++ 0x1.00000100000001c6p+0, false, false, ++ 0x1.00000100000001c4p+0, false, false, ++ 0x1.00000100000001c6p+0, false, false, ++ false, ++ 0x1.00000100000001c4p+0, false, false, ++ 0x1.00000100000001c6p+0, false, false, ++ 0x1.00000100000001c4p+0, false, false, ++ 0x1.00000100000001c6p+0, false, false, ++ false, ++ 0x1.00000100000001c5f67cd79279p+0, false, false, ++ 0x1.00000100000001c5f67cd792798p+0, false, false, ++ 0x1.00000100000001c5f67cd79279p+0, false, false, ++ 0x1.00000100000001c5f67cd792798p+0, false, false, ++ false, ++ 0x1.00000100000001c5f67cd7927953p+0, false, false, ++ 0x1.00000100000001c5f67cd7927954p+0, false, false, ++ 0x1.00000100000001c5f67cd7927953p+0, false, false, ++ 0x1.00000100000001c5f67cd7927954p+0, false, false), + TEST ("1.000000059604645", + false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.0000010000001p+0, false, +- 0x1.0000010000001p+0, false, +- 0x1.0000010000001p+0, false, +- 0x1.0000010000002p+0, false, +- false, +- 0x1.000001000000102ep+0, false, +- 0x1.000001000000103p+0, false, +- 0x1.000001000000102ep+0, false, +- 0x1.000001000000103p+0, false, +- false, +- 0x1.000001000000102ep+0, false, +- 0x1.000001000000103p+0, false, +- 0x1.000001000000102ep+0, false, +- 0x1.000001000000103p+0, false, +- false, +- 0x1.000001000000102f4fc8c3d757p+0, false, +- 0x1.000001000000102f4fc8c3d7578p+0, false, +- 0x1.000001000000102f4fc8c3d757p+0, false, +- 0x1.000001000000102f4fc8c3d7578p+0, false, +- false, +- 0x1.000001000000102f4fc8c3d75769p+0, false, +- 0x1.000001000000102f4fc8c3d75769p+0, false, +- 0x1.000001000000102f4fc8c3d75769p+0, false, +- 0x1.000001000000102f4fc8c3d7576ap+0, false), ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.0000010000001p+0, false, false, ++ 0x1.0000010000001p+0, false, false, ++ 0x1.0000010000001p+0, false, false, ++ 0x1.0000010000002p+0, false, false, ++ false, ++ 0x1.000001000000102ep+0, false, false, ++ 0x1.000001000000103p+0, false, false, ++ 0x1.000001000000102ep+0, false, false, ++ 0x1.000001000000103p+0, false, false, ++ false, ++ 0x1.000001000000102ep+0, false, false, ++ 0x1.000001000000103p+0, false, false, ++ 0x1.000001000000102ep+0, false, false, ++ 0x1.000001000000103p+0, false, false, ++ false, ++ 0x1.000001000000102f4fc8c3d757p+0, false, false, ++ 0x1.000001000000102f4fc8c3d7578p+0, false, false, ++ 0x1.000001000000102f4fc8c3d757p+0, false, false, ++ 0x1.000001000000102f4fc8c3d7578p+0, false, false, ++ false, ++ 0x1.000001000000102f4fc8c3d75769p+0, false, false, ++ 0x1.000001000000102f4fc8c3d75769p+0, false, false, ++ 0x1.000001000000102f4fc8c3d75769p+0, false, false, ++ 0x1.000001000000102f4fc8c3d7576ap+0, false, false), + TEST ("1.00000005960464", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.000000fffffeap+0, false, +- 0x1.000000fffffeap+0, false, +- 0x1.000000fffffeap+0, false, +- 0x1.000000fffffebp+0, false, +- false, +- 0x1.000000fffffea7e4p+0, false, +- 0x1.000000fffffea7e6p+0, false, +- 0x1.000000fffffea7e4p+0, false, +- 0x1.000000fffffea7e6p+0, false, +- false, +- 0x1.000000fffffea7e4p+0, false, +- 0x1.000000fffffea7e6p+0, false, +- 0x1.000000fffffea7e4p+0, false, +- 0x1.000000fffffea7e6p+0, false, +- false, +- 0x1.000000fffffea7e5975eb11da7p+0, false, +- 0x1.000000fffffea7e5975eb11da78p+0, false, +- 0x1.000000fffffea7e5975eb11da7p+0, false, +- 0x1.000000fffffea7e5975eb11da78p+0, false, +- false, +- 0x1.000000fffffea7e5975eb11da74ap+0, false, +- 0x1.000000fffffea7e5975eb11da74bp+0, false, +- 0x1.000000fffffea7e5975eb11da74ap+0, false, +- 0x1.000000fffffea7e5975eb11da74bp+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.000000fffffeap+0, false, false, ++ 0x1.000000fffffeap+0, false, false, ++ 0x1.000000fffffeap+0, false, false, ++ 0x1.000000fffffebp+0, false, false, ++ false, ++ 0x1.000000fffffea7e4p+0, false, false, ++ 0x1.000000fffffea7e6p+0, false, false, ++ 0x1.000000fffffea7e4p+0, false, false, ++ 0x1.000000fffffea7e6p+0, false, false, ++ false, ++ 0x1.000000fffffea7e4p+0, false, false, ++ 0x1.000000fffffea7e6p+0, false, false, ++ 0x1.000000fffffea7e4p+0, false, false, ++ 0x1.000000fffffea7e6p+0, false, false, ++ false, ++ 0x1.000000fffffea7e5975eb11da7p+0, false, false, ++ 0x1.000000fffffea7e5975eb11da78p+0, false, false, ++ 0x1.000000fffffea7e5975eb11da7p+0, false, false, ++ 0x1.000000fffffea7e5975eb11da78p+0, false, false, ++ false, ++ 0x1.000000fffffea7e5975eb11da74ap+0, false, false, ++ 0x1.000000fffffea7e5975eb11da74bp+0, false, false, ++ 0x1.000000fffffea7e5975eb11da74ap+0, false, false, ++ 0x1.000000fffffea7e5975eb11da74bp+0, false, false), + TEST ("1.0000000596046", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.000000fffff36p+0, false, +- 0x1.000000fffff36p+0, false, +- 0x1.000000fffff36p+0, false, +- 0x1.000000fffff37p+0, false, +- false, +- 0x1.000000fffff36596p+0, false, +- 0x1.000000fffff36598p+0, false, +- 0x1.000000fffff36596p+0, false, +- 0x1.000000fffff36598p+0, false, +- false, +- 0x1.000000fffff36596p+0, false, +- 0x1.000000fffff36598p+0, false, +- 0x1.000000fffff36596p+0, false, +- 0x1.000000fffff36598p+0, false, +- false, +- 0x1.000000fffff36597d40e1b5026p+0, false, +- 0x1.000000fffff36597d40e1b50268p+0, false, +- 0x1.000000fffff36597d40e1b5026p+0, false, +- 0x1.000000fffff36597d40e1b50268p+0, false, +- false, +- 0x1.000000fffff36597d40e1b502655p+0, false, +- 0x1.000000fffff36597d40e1b502656p+0, false, +- 0x1.000000fffff36597d40e1b502655p+0, false, +- 0x1.000000fffff36597d40e1b502656p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.000000fffff36p+0, false, false, ++ 0x1.000000fffff36p+0, false, false, ++ 0x1.000000fffff36p+0, false, false, ++ 0x1.000000fffff37p+0, false, false, ++ false, ++ 0x1.000000fffff36596p+0, false, false, ++ 0x1.000000fffff36598p+0, false, false, ++ 0x1.000000fffff36596p+0, false, false, ++ 0x1.000000fffff36598p+0, false, false, ++ false, ++ 0x1.000000fffff36596p+0, false, false, ++ 0x1.000000fffff36598p+0, false, false, ++ 0x1.000000fffff36596p+0, false, false, ++ 0x1.000000fffff36598p+0, false, false, ++ false, ++ 0x1.000000fffff36597d40e1b5026p+0, false, false, ++ 0x1.000000fffff36597d40e1b50268p+0, false, false, ++ 0x1.000000fffff36597d40e1b5026p+0, false, false, ++ 0x1.000000fffff36597d40e1b50268p+0, false, false, ++ false, ++ 0x1.000000fffff36597d40e1b502655p+0, false, false, ++ 0x1.000000fffff36597d40e1b502656p+0, false, false, ++ 0x1.000000fffff36597d40e1b502655p+0, false, false, ++ 0x1.000000fffff36597d40e1b502656p+0, false, false), + TEST ("1.000000059605", + false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.000001000063fp+0, false, +- 0x1.000001000064p+0, false, +- 0x1.000001000063fp+0, false, +- 0x1.000001000064p+0, false, +- false, +- 0x1.000001000063fcap+0, false, +- 0x1.000001000063fca2p+0, false, +- 0x1.000001000063fcap+0, false, +- 0x1.000001000063fca2p+0, false, +- false, +- 0x1.000001000063fcap+0, false, +- 0x1.000001000063fca2p+0, false, +- 0x1.000001000063fcap+0, false, +- 0x1.000001000063fca2p+0, false, +- false, +- 0x1.000001000063fca17533f5572f8p+0, false, +- 0x1.000001000063fca17533f5573p+0, false, +- 0x1.000001000063fca17533f5572f8p+0, false, +- 0x1.000001000063fca17533f5573p+0, false, +- false, +- 0x1.000001000063fca17533f5572fe9p+0, false, +- 0x1.000001000063fca17533f5572feap+0, false, +- 0x1.000001000063fca17533f5572fe9p+0, false, +- 0x1.000001000063fca17533f5572feap+0, false), ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.000001000063fp+0, false, false, ++ 0x1.000001000064p+0, false, false, ++ 0x1.000001000063fp+0, false, false, ++ 0x1.000001000064p+0, false, false, ++ false, ++ 0x1.000001000063fcap+0, false, false, ++ 0x1.000001000063fca2p+0, false, false, ++ 0x1.000001000063fcap+0, false, false, ++ 0x1.000001000063fca2p+0, false, false, ++ false, ++ 0x1.000001000063fcap+0, false, false, ++ 0x1.000001000063fca2p+0, false, false, ++ 0x1.000001000063fcap+0, false, false, ++ 0x1.000001000063fca2p+0, false, false, ++ false, ++ 0x1.000001000063fca17533f5572f8p+0, false, false, ++ 0x1.000001000063fca17533f5573p+0, false, false, ++ 0x1.000001000063fca17533f5572f8p+0, false, false, ++ 0x1.000001000063fca17533f5573p+0, false, false, ++ false, ++ 0x1.000001000063fca17533f5572fe9p+0, false, false, ++ 0x1.000001000063fca17533f5572feap+0, false, false, ++ 0x1.000001000063fca17533f5572fe9p+0, false, false, ++ 0x1.000001000063fca17533f5572feap+0, false, false), + TEST ("1.00000005960", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.000000fffae49p+0, false, +- 0x1.000000fffae4ap+0, false, +- 0x1.000000fffae49p+0, false, +- 0x1.000000fffae4ap+0, false, +- false, +- 0x1.000000fffae49ca8p+0, false, +- 0x1.000000fffae49caap+0, false, +- 0x1.000000fffae49ca8p+0, false, +- 0x1.000000fffae49caap+0, false, +- false, +- 0x1.000000fffae49ca8p+0, false, +- 0x1.000000fffae49caap+0, false, +- 0x1.000000fffae49ca8p+0, false, +- 0x1.000000fffae49caap+0, false, +- false, +- 0x1.000000fffae49ca916dacfff38p+0, false, +- 0x1.000000fffae49ca916dacfff38p+0, false, +- 0x1.000000fffae49ca916dacfff38p+0, false, +- 0x1.000000fffae49ca916dacfff388p+0, false, +- false, +- 0x1.000000fffae49ca916dacfff382dp+0, false, +- 0x1.000000fffae49ca916dacfff382dp+0, false, +- 0x1.000000fffae49ca916dacfff382dp+0, false, +- 0x1.000000fffae49ca916dacfff382ep+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.000000fffae49p+0, false, false, ++ 0x1.000000fffae4ap+0, false, false, ++ 0x1.000000fffae49p+0, false, false, ++ 0x1.000000fffae4ap+0, false, false, ++ false, ++ 0x1.000000fffae49ca8p+0, false, false, ++ 0x1.000000fffae49caap+0, false, false, ++ 0x1.000000fffae49ca8p+0, false, false, ++ 0x1.000000fffae49caap+0, false, false, ++ false, ++ 0x1.000000fffae49ca8p+0, false, false, ++ 0x1.000000fffae49caap+0, false, false, ++ 0x1.000000fffae49ca8p+0, false, false, ++ 0x1.000000fffae49caap+0, false, false, ++ false, ++ 0x1.000000fffae49ca916dacfff38p+0, false, false, ++ 0x1.000000fffae49ca916dacfff38p+0, false, false, ++ 0x1.000000fffae49ca916dacfff38p+0, false, false, ++ 0x1.000000fffae49ca916dacfff388p+0, false, false, ++ false, ++ 0x1.000000fffae49ca916dacfff382dp+0, false, false, ++ 0x1.000000fffae49ca916dacfff382dp+0, false, false, ++ 0x1.000000fffae49ca916dacfff382dp+0, false, false, ++ 0x1.000000fffae49ca916dacfff382ep+0, false, false), + TEST ("1.0000000596", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.000000fffae49p+0, false, +- 0x1.000000fffae4ap+0, false, +- 0x1.000000fffae49p+0, false, +- 0x1.000000fffae4ap+0, false, +- false, +- 0x1.000000fffae49ca8p+0, false, +- 0x1.000000fffae49caap+0, false, +- 0x1.000000fffae49ca8p+0, false, +- 0x1.000000fffae49caap+0, false, +- false, +- 0x1.000000fffae49ca8p+0, false, +- 0x1.000000fffae49caap+0, false, +- 0x1.000000fffae49ca8p+0, false, +- 0x1.000000fffae49caap+0, false, +- false, +- 0x1.000000fffae49ca916dacfff38p+0, false, +- 0x1.000000fffae49ca916dacfff38p+0, false, +- 0x1.000000fffae49ca916dacfff38p+0, false, +- 0x1.000000fffae49ca916dacfff388p+0, false, +- false, +- 0x1.000000fffae49ca916dacfff382dp+0, false, +- 0x1.000000fffae49ca916dacfff382dp+0, false, +- 0x1.000000fffae49ca916dacfff382dp+0, false, +- 0x1.000000fffae49ca916dacfff382ep+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.000000fffae49p+0, false, false, ++ 0x1.000000fffae4ap+0, false, false, ++ 0x1.000000fffae49p+0, false, false, ++ 0x1.000000fffae4ap+0, false, false, ++ false, ++ 0x1.000000fffae49ca8p+0, false, false, ++ 0x1.000000fffae49caap+0, false, false, ++ 0x1.000000fffae49ca8p+0, false, false, ++ 0x1.000000fffae49caap+0, false, false, ++ false, ++ 0x1.000000fffae49ca8p+0, false, false, ++ 0x1.000000fffae49caap+0, false, false, ++ 0x1.000000fffae49ca8p+0, false, false, ++ 0x1.000000fffae49caap+0, false, false, ++ false, ++ 0x1.000000fffae49ca916dacfff38p+0, false, false, ++ 0x1.000000fffae49ca916dacfff38p+0, false, false, ++ 0x1.000000fffae49ca916dacfff38p+0, false, false, ++ 0x1.000000fffae49ca916dacfff388p+0, false, false, ++ false, ++ 0x1.000000fffae49ca916dacfff382dp+0, false, false, ++ 0x1.000000fffae49ca916dacfff382dp+0, false, false, ++ 0x1.000000fffae49ca916dacfff382dp+0, false, false, ++ 0x1.000000fffae49ca916dacfff382ep+0, false, false), + TEST ("1.000000060", + false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.00000101b2b29p+0, false, +- 0x1.00000101b2b2ap+0, false, +- 0x1.00000101b2b29p+0, false, +- 0x1.00000101b2b2ap+0, false, +- false, +- 0x1.00000101b2b29a46p+0, false, +- 0x1.00000101b2b29a46p+0, false, +- 0x1.00000101b2b29a46p+0, false, +- 0x1.00000101b2b29a48p+0, false, +- false, +- 0x1.00000101b2b29a46p+0, false, +- 0x1.00000101b2b29a46p+0, false, +- 0x1.00000101b2b29a46p+0, false, +- 0x1.00000101b2b29a48p+0, false, +- false, +- 0x1.00000101b2b29a4692b67b7ca3p+0, false, +- 0x1.00000101b2b29a4692b67b7ca3p+0, false, +- 0x1.00000101b2b29a4692b67b7ca3p+0, false, +- 0x1.00000101b2b29a4692b67b7ca38p+0, false, +- false, +- 0x1.00000101b2b29a4692b67b7ca313p+0, false, +- 0x1.00000101b2b29a4692b67b7ca314p+0, false, +- 0x1.00000101b2b29a4692b67b7ca313p+0, false, +- 0x1.00000101b2b29a4692b67b7ca314p+0, false), ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.00000101b2b29p+0, false, false, ++ 0x1.00000101b2b2ap+0, false, false, ++ 0x1.00000101b2b29p+0, false, false, ++ 0x1.00000101b2b2ap+0, false, false, ++ false, ++ 0x1.00000101b2b29a46p+0, false, false, ++ 0x1.00000101b2b29a46p+0, false, false, ++ 0x1.00000101b2b29a46p+0, false, false, ++ 0x1.00000101b2b29a48p+0, false, false, ++ false, ++ 0x1.00000101b2b29a46p+0, false, false, ++ 0x1.00000101b2b29a46p+0, false, false, ++ 0x1.00000101b2b29a46p+0, false, false, ++ 0x1.00000101b2b29a48p+0, false, false, ++ false, ++ 0x1.00000101b2b29a4692b67b7ca3p+0, false, false, ++ 0x1.00000101b2b29a4692b67b7ca3p+0, false, false, ++ 0x1.00000101b2b29a4692b67b7ca3p+0, false, false, ++ 0x1.00000101b2b29a4692b67b7ca38p+0, false, false, ++ false, ++ 0x1.00000101b2b29a4692b67b7ca313p+0, false, false, ++ 0x1.00000101b2b29a4692b67b7ca314p+0, false, false, ++ 0x1.00000101b2b29a4692b67b7ca313p+0, false, false, ++ 0x1.00000101b2b29a4692b67b7ca314p+0, false, false), + TEST ("1.00000006", + false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.00000101b2b29p+0, false, +- 0x1.00000101b2b2ap+0, false, +- 0x1.00000101b2b29p+0, false, +- 0x1.00000101b2b2ap+0, false, +- false, +- 0x1.00000101b2b29a46p+0, false, +- 0x1.00000101b2b29a46p+0, false, +- 0x1.00000101b2b29a46p+0, false, +- 0x1.00000101b2b29a48p+0, false, +- false, +- 0x1.00000101b2b29a46p+0, false, +- 0x1.00000101b2b29a46p+0, false, +- 0x1.00000101b2b29a46p+0, false, +- 0x1.00000101b2b29a48p+0, false, +- false, +- 0x1.00000101b2b29a4692b67b7ca3p+0, false, +- 0x1.00000101b2b29a4692b67b7ca3p+0, false, +- 0x1.00000101b2b29a4692b67b7ca3p+0, false, +- 0x1.00000101b2b29a4692b67b7ca38p+0, false, +- false, +- 0x1.00000101b2b29a4692b67b7ca313p+0, false, +- 0x1.00000101b2b29a4692b67b7ca314p+0, false, +- 0x1.00000101b2b29a4692b67b7ca313p+0, false, +- 0x1.00000101b2b29a4692b67b7ca314p+0, false), ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.00000101b2b29p+0, false, false, ++ 0x1.00000101b2b2ap+0, false, false, ++ 0x1.00000101b2b29p+0, false, false, ++ 0x1.00000101b2b2ap+0, false, false, ++ false, ++ 0x1.00000101b2b29a46p+0, false, false, ++ 0x1.00000101b2b29a46p+0, false, false, ++ 0x1.00000101b2b29a46p+0, false, false, ++ 0x1.00000101b2b29a48p+0, false, false, ++ false, ++ 0x1.00000101b2b29a46p+0, false, false, ++ 0x1.00000101b2b29a46p+0, false, false, ++ 0x1.00000101b2b29a46p+0, false, false, ++ 0x1.00000101b2b29a48p+0, false, false, ++ false, ++ 0x1.00000101b2b29a4692b67b7ca3p+0, false, false, ++ 0x1.00000101b2b29a4692b67b7ca3p+0, false, false, ++ 0x1.00000101b2b29a4692b67b7ca3p+0, false, false, ++ 0x1.00000101b2b29a4692b67b7ca38p+0, false, false, ++ false, ++ 0x1.00000101b2b29a4692b67b7ca313p+0, false, false, ++ 0x1.00000101b2b29a4692b67b7ca314p+0, false, false, ++ 0x1.00000101b2b29a4692b67b7ca313p+0, false, false, ++ 0x1.00000101b2b29a4692b67b7ca314p+0, false, false), + TEST ("1.0000001", + false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.000001ad7f29ap+0, false, +- 0x1.000001ad7f29bp+0, false, +- 0x1.000001ad7f29ap+0, false, +- 0x1.000001ad7f29bp+0, false, +- false, +- 0x1.000001ad7f29abcap+0, false, +- 0x1.000001ad7f29abcap+0, false, +- 0x1.000001ad7f29abcap+0, false, +- 0x1.000001ad7f29abccp+0, false, +- false, +- 0x1.000001ad7f29abcap+0, false, +- 0x1.000001ad7f29abcap+0, false, +- 0x1.000001ad7f29abcap+0, false, +- 0x1.000001ad7f29abccp+0, false, +- false, +- 0x1.000001ad7f29abcaf485787a65p+0, false, +- 0x1.000001ad7f29abcaf485787a65p+0, false, +- 0x1.000001ad7f29abcaf485787a65p+0, false, +- 0x1.000001ad7f29abcaf485787a658p+0, false, +- false, +- 0x1.000001ad7f29abcaf485787a652p+0, false, +- 0x1.000001ad7f29abcaf485787a6521p+0, false, +- 0x1.000001ad7f29abcaf485787a652p+0, false, +- 0x1.000001ad7f29abcaf485787a6521p+0, false), ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.000001ad7f29ap+0, false, false, ++ 0x1.000001ad7f29bp+0, false, false, ++ 0x1.000001ad7f29ap+0, false, false, ++ 0x1.000001ad7f29bp+0, false, false, ++ false, ++ 0x1.000001ad7f29abcap+0, false, false, ++ 0x1.000001ad7f29abcap+0, false, false, ++ 0x1.000001ad7f29abcap+0, false, false, ++ 0x1.000001ad7f29abccp+0, false, false, ++ false, ++ 0x1.000001ad7f29abcap+0, false, false, ++ 0x1.000001ad7f29abcap+0, false, false, ++ 0x1.000001ad7f29abcap+0, false, false, ++ 0x1.000001ad7f29abccp+0, false, false, ++ false, ++ 0x1.000001ad7f29abcaf485787a65p+0, false, false, ++ 0x1.000001ad7f29abcaf485787a65p+0, false, false, ++ 0x1.000001ad7f29abcaf485787a65p+0, false, false, ++ 0x1.000001ad7f29abcaf485787a658p+0, false, false, ++ false, ++ 0x1.000001ad7f29abcaf485787a652p+0, false, false, ++ 0x1.000001ad7f29abcaf485787a6521p+0, false, false, ++ 0x1.000001ad7f29abcaf485787a652p+0, false, false, ++ 0x1.000001ad7f29abcaf485787a6521p+0, false, false), + TEST ("1.000000", + true, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- true, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- true, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- true, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- true, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- true, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ true, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ true, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ true, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ true, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ true, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false), + TEST ("1.00000000000000011113", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1.00000000000008p+0, false, +- 0x1.0000000000000802p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.0000000000000802p+0, false, +- false, +- 0x1.00000000000008p+0, false, +- 0x1.0000000000000802p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.0000000000000802p+0, false, +- false, +- 0x1.0000000000000801fc96557232p+0, false, +- 0x1.0000000000000801fc96557232p+0, false, +- 0x1.0000000000000801fc96557232p+0, false, +- 0x1.0000000000000801fc965572328p+0, false, +- false, +- 0x1.0000000000000801fc9655723222p+0, false, +- 0x1.0000000000000801fc9655723222p+0, false, +- 0x1.0000000000000801fc9655723222p+0, false, +- 0x1.0000000000000801fc9655723223p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.0000000000000802p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.0000000000000802p+0, false, false, ++ false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.0000000000000802p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.0000000000000802p+0, false, false, ++ false, ++ 0x1.0000000000000801fc96557232p+0, false, false, ++ 0x1.0000000000000801fc96557232p+0, false, false, ++ 0x1.0000000000000801fc96557232p+0, false, false, ++ 0x1.0000000000000801fc965572328p+0, false, false, ++ false, ++ 0x1.0000000000000801fc9655723222p+0, false, false, ++ 0x1.0000000000000801fc9655723222p+0, false, false, ++ 0x1.0000000000000801fc9655723222p+0, false, false, ++ 0x1.0000000000000801fc9655723223p+0, false, false), + TEST ("1.00000000000000011103", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.0000000000000802p+0, false, +- false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.0000000000000802p+0, false, +- false, +- 0x1.00000000000008002459c076c48p+0, false, +- 0x1.00000000000008002459c076c5p+0, false, +- 0x1.00000000000008002459c076c48p+0, false, +- 0x1.00000000000008002459c076c5p+0, false, +- false, +- 0x1.00000000000008002459c076c4f7p+0, false, +- 0x1.00000000000008002459c076c4f8p+0, false, +- 0x1.00000000000008002459c076c4f7p+0, false, +- 0x1.00000000000008002459c076c4f8p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.0000000000000802p+0, false, false, ++ false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.0000000000000802p+0, false, false, ++ false, ++ 0x1.00000000000008002459c076c48p+0, false, false, ++ 0x1.00000000000008002459c076c5p+0, false, false, ++ 0x1.00000000000008002459c076c48p+0, false, false, ++ 0x1.00000000000008002459c076c5p+0, false, false, ++ false, ++ 0x1.00000000000008002459c076c4f7p+0, false, false, ++ 0x1.00000000000008002459c076c4f8p+0, false, false, ++ 0x1.00000000000008002459c076c4f7p+0, false, false, ++ 0x1.00000000000008002459c076c4f8p+0, false, false), + TEST ("1.00000000000000011102", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1.00000000000007fep+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000007fep+0, false, +- 0x1.00000000000008p+0, false, +- false, +- 0x1.00000000000007fep+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000007fep+0, false, +- 0x1.00000000000008p+0, false, +- false, +- 0x1.00000000000007fff5207e5dap+0, false, +- 0x1.00000000000007fff5207e5da08p+0, false, +- 0x1.00000000000007fff5207e5dap+0, false, +- 0x1.00000000000007fff5207e5da08p+0, false, +- false, +- 0x1.00000000000007fff5207e5da073p+0, false, +- 0x1.00000000000007fff5207e5da073p+0, false, +- 0x1.00000000000007fff5207e5da073p+0, false, +- 0x1.00000000000007fff5207e5da074p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1.00000000000007fep+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000007fep+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ false, ++ 0x1.00000000000007fep+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000007fep+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ false, ++ 0x1.00000000000007fff5207e5dap+0, false, false, ++ 0x1.00000000000007fff5207e5da08p+0, false, false, ++ 0x1.00000000000007fff5207e5dap+0, false, false, ++ 0x1.00000000000007fff5207e5da08p+0, false, false, ++ false, ++ 0x1.00000000000007fff5207e5da073p+0, false, false, ++ 0x1.00000000000007fff5207e5da073p+0, false, false, ++ 0x1.00000000000007fff5207e5da073p+0, false, false, ++ 0x1.00000000000007fff5207e5da074p+0, false, false), + TEST ("1.00000000000000011101", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1.00000000000007fep+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000007fep+0, false, +- 0x1.00000000000008p+0, false, +- false, +- 0x1.00000000000007fep+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000007fep+0, false, +- 0x1.00000000000008p+0, false, +- false, +- 0x1.00000000000007ffc5e73c447b8p+0, false, +- 0x1.00000000000007ffc5e73c447cp+0, false, +- 0x1.00000000000007ffc5e73c447b8p+0, false, +- 0x1.00000000000007ffc5e73c447cp+0, false, +- false, +- 0x1.00000000000007ffc5e73c447befp+0, false, +- 0x1.00000000000007ffc5e73c447befp+0, false, +- 0x1.00000000000007ffc5e73c447befp+0, false, +- 0x1.00000000000007ffc5e73c447bfp+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1.00000000000007fep+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000007fep+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ false, ++ 0x1.00000000000007fep+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000007fep+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ false, ++ 0x1.00000000000007ffc5e73c447b8p+0, false, false, ++ 0x1.00000000000007ffc5e73c447cp+0, false, false, ++ 0x1.00000000000007ffc5e73c447b8p+0, false, false, ++ 0x1.00000000000007ffc5e73c447cp+0, false, false, ++ false, ++ 0x1.00000000000007ffc5e73c447befp+0, false, false, ++ 0x1.00000000000007ffc5e73c447befp+0, false, false, ++ 0x1.00000000000007ffc5e73c447befp+0, false, false, ++ 0x1.00000000000007ffc5e73c447bfp+0, false, false), + TEST ("1.0000000000000001111", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1.00000000000008p+0, false, +- 0x1.0000000000000802p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.0000000000000802p+0, false, +- false, +- 0x1.00000000000008p+0, false, +- 0x1.0000000000000802p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.0000000000000802p+0, false, +- false, +- 0x1.00000000000008016eea8f26c48p+0, false, +- 0x1.00000000000008016eea8f26c48p+0, false, +- 0x1.00000000000008016eea8f26c48p+0, false, +- 0x1.00000000000008016eea8f26c5p+0, false, +- false, +- 0x1.00000000000008016eea8f26c495p+0, false, +- 0x1.00000000000008016eea8f26c496p+0, false, +- 0x1.00000000000008016eea8f26c495p+0, false, +- 0x1.00000000000008016eea8f26c496p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.0000000000000802p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.0000000000000802p+0, false, false, ++ false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.0000000000000802p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.0000000000000802p+0, false, false, ++ false, ++ 0x1.00000000000008016eea8f26c48p+0, false, false, ++ 0x1.00000000000008016eea8f26c48p+0, false, false, ++ 0x1.00000000000008016eea8f26c48p+0, false, false, ++ 0x1.00000000000008016eea8f26c5p+0, false, false, ++ false, ++ 0x1.00000000000008016eea8f26c495p+0, false, false, ++ 0x1.00000000000008016eea8f26c496p+0, false, false, ++ 0x1.00000000000008016eea8f26c495p+0, false, false, ++ 0x1.00000000000008016eea8f26c496p+0, false, false), + TEST ("1.000000000000000111", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1.00000000000007fep+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000007fep+0, false, +- 0x1.00000000000008p+0, false, +- false, +- 0x1.00000000000007fep+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000007fep+0, false, +- 0x1.00000000000008p+0, false, +- false, +- 0x1.00000000000007ff96adfa2b57p+0, false, +- 0x1.00000000000007ff96adfa2b578p+0, false, +- 0x1.00000000000007ff96adfa2b57p+0, false, +- 0x1.00000000000007ff96adfa2b578p+0, false, +- false, +- 0x1.00000000000007ff96adfa2b576ap+0, false, +- 0x1.00000000000007ff96adfa2b576bp+0, false, +- 0x1.00000000000007ff96adfa2b576ap+0, false, +- 0x1.00000000000007ff96adfa2b576bp+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1.00000000000007fep+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000007fep+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ false, ++ 0x1.00000000000007fep+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000007fep+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ false, ++ 0x1.00000000000007ff96adfa2b57p+0, false, false, ++ 0x1.00000000000007ff96adfa2b578p+0, false, false, ++ 0x1.00000000000007ff96adfa2b57p+0, false, false, ++ 0x1.00000000000007ff96adfa2b578p+0, false, false, ++ false, ++ 0x1.00000000000007ff96adfa2b576ap+0, false, false, ++ 0x1.00000000000007ff96adfa2b576bp+0, false, false, ++ 0x1.00000000000007ff96adfa2b576ap+0, false, false, ++ 0x1.00000000000007ff96adfa2b576bp+0, false, false), + TEST ("1.00000000000000011", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1.00000000000007ecp+0, false, +- 0x1.00000000000007eep+0, false, +- 0x1.00000000000007ecp+0, false, +- 0x1.00000000000007eep+0, false, +- false, +- 0x1.00000000000007ecp+0, false, +- 0x1.00000000000007eep+0, false, +- 0x1.00000000000007ecp+0, false, +- 0x1.00000000000007eep+0, false, +- false, +- 0x1.00000000000007ed24502859138p+0, false, +- 0x1.00000000000007ed24502859138p+0, false, +- 0x1.00000000000007ed24502859138p+0, false, +- 0x1.00000000000007ed2450285914p+0, false, +- false, +- 0x1.00000000000007ed2450285913bfp+0, false, +- 0x1.00000000000007ed2450285913bfp+0, false, +- 0x1.00000000000007ed2450285913bfp+0, false, +- 0x1.00000000000007ed2450285913cp+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1.00000000000007ecp+0, false, false, ++ 0x1.00000000000007eep+0, false, false, ++ 0x1.00000000000007ecp+0, false, false, ++ 0x1.00000000000007eep+0, false, false, ++ false, ++ 0x1.00000000000007ecp+0, false, false, ++ 0x1.00000000000007eep+0, false, false, ++ 0x1.00000000000007ecp+0, false, false, ++ 0x1.00000000000007eep+0, false, false, ++ false, ++ 0x1.00000000000007ed24502859138p+0, false, false, ++ 0x1.00000000000007ed24502859138p+0, false, false, ++ 0x1.00000000000007ed24502859138p+0, false, false, ++ 0x1.00000000000007ed2450285914p+0, false, false, ++ false, ++ 0x1.00000000000007ed2450285913bfp+0, false, false, ++ 0x1.00000000000007ed2450285913bfp+0, false, false, ++ 0x1.00000000000007ed2450285913bfp+0, false, false, ++ 0x1.00000000000007ed2450285913cp+0, false, false), + TEST ("1.0000000000000001", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1.0000000000000734p+0, false, +- 0x1.0000000000000734p+0, false, +- 0x1.0000000000000734p+0, false, +- 0x1.0000000000000736p+0, false, +- false, +- 0x1.0000000000000734p+0, false, +- 0x1.0000000000000734p+0, false, +- 0x1.0000000000000734p+0, false, +- 0x1.0000000000000736p+0, false, +- false, +- 0x1.0000000000000734aca5f6226fp+0, false, +- 0x1.0000000000000734aca5f6226fp+0, false, +- 0x1.0000000000000734aca5f6226fp+0, false, +- 0x1.0000000000000734aca5f6226f8p+0, false, +- false, +- 0x1.0000000000000734aca5f6226f0ap+0, false, +- 0x1.0000000000000734aca5f6226f0bp+0, false, +- 0x1.0000000000000734aca5f6226f0ap+0, false, +- 0x1.0000000000000734aca5f6226f0bp+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1.0000000000000734p+0, false, false, ++ 0x1.0000000000000734p+0, false, false, ++ 0x1.0000000000000734p+0, false, false, ++ 0x1.0000000000000736p+0, false, false, ++ false, ++ 0x1.0000000000000734p+0, false, false, ++ 0x1.0000000000000734p+0, false, false, ++ 0x1.0000000000000734p+0, false, false, ++ 0x1.0000000000000736p+0, false, false, ++ false, ++ 0x1.0000000000000734aca5f6226fp+0, false, false, ++ 0x1.0000000000000734aca5f6226fp+0, false, false, ++ 0x1.0000000000000734aca5f6226fp+0, false, false, ++ 0x1.0000000000000734aca5f6226f8p+0, false, false, ++ false, ++ 0x1.0000000000000734aca5f6226f0ap+0, false, false, ++ 0x1.0000000000000734aca5f6226f0bp+0, false, false, ++ 0x1.0000000000000734aca5f6226f0ap+0, false, false, ++ 0x1.0000000000000734aca5f6226f0bp+0, false, false), + TEST ("3929201589819414e-25", + false, +- 0x1.b0053p-32, false, +- 0x1.b00532p-32, false, +- 0x1.b0053p-32, false, +- 0x1.b00532p-32, false, +- false, +- 0x1.b005314e2421ep-32, false, +- 0x1.b005314e2421ep-32, false, +- 0x1.b005314e2421ep-32, false, +- 0x1.b005314e2421fp-32, false, +- false, +- 0x1.b005314e2421e7fep-32, false, +- 0x1.b005314e2421e8p-32, false, +- 0x1.b005314e2421e7fep-32, false, +- 0x1.b005314e2421e8p-32, false, +- false, +- 0x1.b005314e2421e7fep-32, false, +- 0x1.b005314e2421e8p-32, false, +- 0x1.b005314e2421e7fep-32, false, +- 0x1.b005314e2421e8p-32, false, +- false, +- 0x1.b005314e2421e7ffb472840c5ap-32, false, +- 0x1.b005314e2421e7ffb472840c5a8p-32, false, +- 0x1.b005314e2421e7ffb472840c5ap-32, false, +- 0x1.b005314e2421e7ffb472840c5a8p-32, false, +- false, +- 0x1.b005314e2421e7ffb472840c5a6ep-32, false, +- 0x1.b005314e2421e7ffb472840c5a6fp-32, false, +- 0x1.b005314e2421e7ffb472840c5a6ep-32, false, +- 0x1.b005314e2421e7ffb472840c5a6fp-32, false), ++ 0x1.b0053p-32, false, false, ++ 0x1.b00532p-32, false, false, ++ 0x1.b0053p-32, false, false, ++ 0x1.b00532p-32, false, false, ++ false, ++ 0x1.b005314e2421ep-32, false, false, ++ 0x1.b005314e2421ep-32, false, false, ++ 0x1.b005314e2421ep-32, false, false, ++ 0x1.b005314e2421fp-32, false, false, ++ false, ++ 0x1.b005314e2421e7fep-32, false, false, ++ 0x1.b005314e2421e8p-32, false, false, ++ 0x1.b005314e2421e7fep-32, false, false, ++ 0x1.b005314e2421e8p-32, false, false, ++ false, ++ 0x1.b005314e2421e7fep-32, false, false, ++ 0x1.b005314e2421e8p-32, false, false, ++ 0x1.b005314e2421e7fep-32, false, false, ++ 0x1.b005314e2421e8p-32, false, false, ++ false, ++ 0x1.b005314e2421e7ffb472840c5ap-32, false, false, ++ 0x1.b005314e2421e7ffb472840c5a8p-32, false, false, ++ 0x1.b005314e2421e7ffb472840c5ap-32, false, false, ++ 0x1.b005314e2421e7ffb472840c5a8p-32, false, false, ++ false, ++ 0x1.b005314e2421e7ffb472840c5a6ep-32, false, false, ++ 0x1.b005314e2421e7ffb472840c5a6fp-32, false, false, ++ 0x1.b005314e2421e7ffb472840c5a6ep-32, false, false, ++ 0x1.b005314e2421e7ffb472840c5a6fp-32, false, false), + TEST ("0.0000000000000000000000000000000000000000000021019476964872" + "256063855943749348741969203929128147736576356024258346866240" + "28790902229957282543182373046875", + false, +- 0x8p-152, false, +- 0x1p-148, false, +- 0x8p-152, false, +- 0x1p-148, false, +- true, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- true, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- true, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- true, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- true, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false), ++ 0x8p-152, false, true, ++ 0x1p-148, false, true, ++ 0x8p-152, false, true, ++ 0x1p-148, false, true, ++ true, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ true, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ true, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ true, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ true, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false), + TEST ("1.00000005960464477539062499", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.000000fffffffp+0, false, +- 0x1.000001p+0, false, +- 0x1.000000fffffffp+0, false, +- 0x1.000001p+0, false, +- false, +- 0x1.000000fffffffffep+0, false, +- 0x1.000001p+0, false, +- 0x1.000000fffffffffep+0, false, +- 0x1.000001p+0, false, +- false, +- 0x1.000000fffffffffep+0, false, +- 0x1.000001p+0, false, +- 0x1.000000fffffffffep+0, false, +- 0x1.000001p+0, false, +- false, +- 0x1.000000fffffffffffffffce7b78p+0, false, +- 0x1.000000fffffffffffffffce7b8p+0, false, +- 0x1.000000fffffffffffffffce7b78p+0, false, +- 0x1.000000fffffffffffffffce7b8p+0, false, +- false, +- 0x1.000000fffffffffffffffce7b7e7p+0, false, +- 0x1.000000fffffffffffffffce7b7e7p+0, false, +- 0x1.000000fffffffffffffffce7b7e7p+0, false, +- 0x1.000000fffffffffffffffce7b7e8p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.000000fffffffp+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000000fffffffp+0, false, false, ++ 0x1.000001p+0, false, false, ++ false, ++ 0x1.000000fffffffffep+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000000fffffffffep+0, false, false, ++ 0x1.000001p+0, false, false, ++ false, ++ 0x1.000000fffffffffep+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000000fffffffffep+0, false, false, ++ 0x1.000001p+0, false, false, ++ false, ++ 0x1.000000fffffffffffffffce7b78p+0, false, false, ++ 0x1.000000fffffffffffffffce7b8p+0, false, false, ++ 0x1.000000fffffffffffffffce7b78p+0, false, false, ++ 0x1.000000fffffffffffffffce7b8p+0, false, false, ++ false, ++ 0x1.000000fffffffffffffffce7b7e7p+0, false, false, ++ 0x1.000000fffffffffffffffce7b7e7p+0, false, false, ++ 0x1.000000fffffffffffffffce7b7e7p+0, false, false, ++ 0x1.000000fffffffffffffffce7b7e8p+0, false, false), + TEST ("1.000000059604644775390625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- true, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- true, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- true, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- true, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ true, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ true, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ true, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ true, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false), + TEST ("1.00000005960464477539062501", + false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.0000010000001p+0, false, +- false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.0000010000000002p+0, false, +- false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.000001p+0, false, +- 0x1.0000010000000002p+0, false, +- false, +- 0x1.00000100000000000000031848p+0, false, +- 0x1.00000100000000000000031848p+0, false, +- 0x1.00000100000000000000031848p+0, false, +- 0x1.000001000000000000000318488p+0, false, +- false, +- 0x1.0000010000000000000003184818p+0, false, +- 0x1.0000010000000000000003184819p+0, false, +- 0x1.0000010000000000000003184818p+0, false, +- 0x1.0000010000000000000003184819p+0, false), ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.0000010000001p+0, false, false, ++ false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.0000010000000002p+0, false, false, ++ false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.000001p+0, false, false, ++ 0x1.0000010000000002p+0, false, false, ++ false, ++ 0x1.00000100000000000000031848p+0, false, false, ++ 0x1.00000100000000000000031848p+0, false, false, ++ 0x1.00000100000000000000031848p+0, false, false, ++ 0x1.000001000000000000000318488p+0, false, false, ++ false, ++ 0x1.0000010000000000000003184818p+0, false, false, ++ 0x1.0000010000000000000003184819p+0, false, false, ++ 0x1.0000010000000000000003184818p+0, false, false, ++ 0x1.0000010000000000000003184819p+0, false, false), + TEST ("1.00000011920928955078125", + true, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false), ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false), + TEST ("1.00000017881393432617187499", + false, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- 0x1.000002p+0, false, +- 0x1.000004p+0, false, +- false, +- 0x1.000002fffffffp+0, false, +- 0x1.000003p+0, false, +- 0x1.000002fffffffp+0, false, +- 0x1.000003p+0, false, +- false, +- 0x1.000002fffffffffep+0, false, +- 0x1.000003p+0, false, +- 0x1.000002fffffffffep+0, false, +- 0x1.000003p+0, false, +- false, +- 0x1.000002fffffffffep+0, false, +- 0x1.000003p+0, false, +- 0x1.000002fffffffffep+0, false, +- 0x1.000003p+0, false, +- false, +- 0x1.000002fffffffffffffffce7b78p+0, false, +- 0x1.000002fffffffffffffffce7b8p+0, false, +- 0x1.000002fffffffffffffffce7b78p+0, false, +- 0x1.000002fffffffffffffffce7b8p+0, false, +- false, +- 0x1.000002fffffffffffffffce7b7e7p+0, false, +- 0x1.000002fffffffffffffffce7b7e7p+0, false, +- 0x1.000002fffffffffffffffce7b7e7p+0, false, +- 0x1.000002fffffffffffffffce7b7e8p+0, false), ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000004p+0, false, false, ++ false, ++ 0x1.000002fffffffp+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000002fffffffp+0, false, false, ++ 0x1.000003p+0, false, false, ++ false, ++ 0x1.000002fffffffffep+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000002fffffffffep+0, false, false, ++ 0x1.000003p+0, false, false, ++ false, ++ 0x1.000002fffffffffep+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000002fffffffffep+0, false, false, ++ 0x1.000003p+0, false, false, ++ false, ++ 0x1.000002fffffffffffffffce7b78p+0, false, false, ++ 0x1.000002fffffffffffffffce7b8p+0, false, false, ++ 0x1.000002fffffffffffffffce7b78p+0, false, false, ++ 0x1.000002fffffffffffffffce7b8p+0, false, false, ++ false, ++ 0x1.000002fffffffffffffffce7b7e7p+0, false, false, ++ 0x1.000002fffffffffffffffce7b7e7p+0, false, false, ++ 0x1.000002fffffffffffffffce7b7e7p+0, false, false, ++ 0x1.000002fffffffffffffffce7b7e8p+0, false, false), + TEST ("1.000000178813934326171875", + false, +- 0x1.000002p+0, false, +- 0x1.000004p+0, false, +- 0x1.000002p+0, false, +- 0x1.000004p+0, false, +- true, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- true, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- true, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- true, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- true, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false), ++ 0x1.000002p+0, false, false, ++ 0x1.000004p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000004p+0, false, false, ++ true, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ true, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ true, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ true, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ true, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false), + TEST ("1.00000017881393432617187501", + false, +- 0x1.000002p+0, false, +- 0x1.000004p+0, false, +- 0x1.000002p+0, false, +- 0x1.000004p+0, false, +- false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.0000030000001p+0, false, +- false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.0000030000000002p+0, false, +- false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.000003p+0, false, +- 0x1.0000030000000002p+0, false, +- false, +- 0x1.00000300000000000000031848p+0, false, +- 0x1.00000300000000000000031848p+0, false, +- 0x1.00000300000000000000031848p+0, false, +- 0x1.000003000000000000000318488p+0, false, +- false, +- 0x1.0000030000000000000003184818p+0, false, +- 0x1.0000030000000000000003184819p+0, false, +- 0x1.0000030000000000000003184818p+0, false, +- 0x1.0000030000000000000003184819p+0, false), ++ 0x1.000002p+0, false, false, ++ 0x1.000004p+0, false, false, ++ 0x1.000002p+0, false, false, ++ 0x1.000004p+0, false, false, ++ false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.0000030000001p+0, false, false, ++ false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.0000030000000002p+0, false, false, ++ false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.000003p+0, false, false, ++ 0x1.0000030000000002p+0, false, false, ++ false, ++ 0x1.00000300000000000000031848p+0, false, false, ++ 0x1.00000300000000000000031848p+0, false, false, ++ 0x1.00000300000000000000031848p+0, false, false, ++ 0x1.000003000000000000000318488p+0, false, false, ++ false, ++ 0x1.0000030000000000000003184818p+0, false, false, ++ 0x1.0000030000000000000003184819p+0, false, false, ++ 0x1.0000030000000000000003184818p+0, false, false, ++ 0x1.0000030000000000000003184819p+0, false, false), + TEST ("1.0000002384185791015625", + true, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- true, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- true, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- true, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- true, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- true, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false, +- 0x1.000004p+0, false), ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ true, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ true, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ true, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ true, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ true, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false, ++ 0x1.000004p+0, false, false), + TEST ("1.08420217248550443400745280086994171142578125e-19", + true, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2p-64, false, +- true, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2p-64, false, +- true, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2p-64, false, +- true, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2p-64, false, +- true, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2p-64, false, +- true, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2p-64, false), ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ true, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ true, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ true, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ true, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ true, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false), + TEST ("1.0842022371089897897127399001987457793916291848290711641311" + "645507812499e-19", + false, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2.000004p-64, false, +- false, +- 0x2.000001ffffffep-64, false, +- 0x2.000002p-64, false, +- 0x2.000001ffffffep-64, false, +- 0x2.000002p-64, false, +- false, +- 0x2.000001fffffffffcp-64, false, +- 0x2.000002p-64, false, +- 0x2.000001fffffffffcp-64, false, +- 0x2.000002p-64, false, +- false, +- 0x2.000001fffffffffcp-64, false, +- 0x2.000002p-64, false, +- 0x2.000001fffffffffcp-64, false, +- 0x2.000002p-64, false, +- false, +- 0x2.000001ffffffffffffffffffffp-64, false, +- 0x2.000002p-64, false, +- 0x2.000001ffffffffffffffffffffp-64, false, +- 0x2.000002p-64, false, +- false, +- 0x2.000001fffffffffffffffffffffep-64, false, +- 0x2.000002p-64, false, +- 0x2.000001fffffffffffffffffffffep-64, false, +- 0x2.000002p-64, false), ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2.000004p-64, false, false, ++ false, ++ 0x2.000001ffffffep-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000001ffffffep-64, false, false, ++ 0x2.000002p-64, false, false, ++ false, ++ 0x2.000001fffffffffcp-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000001fffffffffcp-64, false, false, ++ 0x2.000002p-64, false, false, ++ false, ++ 0x2.000001fffffffffcp-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000001fffffffffcp-64, false, false, ++ 0x2.000002p-64, false, false, ++ false, ++ 0x2.000001ffffffffffffffffffffp-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000001ffffffffffffffffffffp-64, false, false, ++ 0x2.000002p-64, false, false, ++ false, ++ 0x2.000001fffffffffffffffffffffep-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000001fffffffffffffffffffffep-64, false, false, ++ 0x2.000002p-64, false, false), + TEST ("1.0842022371089897897127399001987457793916291848290711641311" + "6455078125e-19", + false, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2p-64, false, +- 0x2.000004p-64, false, +- true, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- true, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- true, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- true, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- true, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false), ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2.000004p-64, false, false, ++ true, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ true, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ true, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ true, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ true, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false), + TEST ("1.0842022371089897897127399001987457793916291848290711641311" + "645507812501e-19", + false, +- 0x2p-64, false, +- 0x2.000004p-64, false, +- 0x2p-64, false, +- 0x2.000004p-64, false, +- false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.0000020000002p-64, false, +- false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.0000020000000004p-64, false, +- false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.0000020000000004p-64, false, +- false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.00000200000000000000000001p-64, false, +- false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.000002p-64, false, +- 0x2.0000020000000000000000000002p-64, false), ++ 0x2p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2p-64, false, false, ++ 0x2.000004p-64, false, false, ++ false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.0000020000002p-64, false, false, ++ false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.0000020000000004p-64, false, false, ++ false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.0000020000000004p-64, false, false, ++ false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.00000200000000000000000001p-64, false, false, ++ false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.000002p-64, false, false, ++ 0x2.0000020000000000000000000002p-64, false, false), + TEST ("1.0842023017324751454180269995275498473574771196581423282623" + "291015625e-19", + true, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- true, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- true, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- true, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- true, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- true, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false), ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ true, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ true, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ true, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ true, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ true, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false), + TEST ("1.0842023663559605011233140988563539153233250544872134923934" + "936523437499e-19", + false, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- 0x2.000004p-64, false, +- 0x2.000008p-64, false, +- false, +- 0x2.000005ffffffep-64, false, +- 0x2.000006p-64, false, +- 0x2.000005ffffffep-64, false, +- 0x2.000006p-64, false, +- false, +- 0x2.000005fffffffffcp-64, false, +- 0x2.000006p-64, false, +- 0x2.000005fffffffffcp-64, false, +- 0x2.000006p-64, false, +- false, +- 0x2.000005fffffffffcp-64, false, +- 0x2.000006p-64, false, +- 0x2.000005fffffffffcp-64, false, +- 0x2.000006p-64, false, +- false, +- 0x2.000005ffffffffffffffffffffp-64, false, +- 0x2.000006p-64, false, +- 0x2.000005ffffffffffffffffffffp-64, false, +- 0x2.000006p-64, false, +- false, +- 0x2.000005fffffffffffffffffffffep-64, false, +- 0x2.000006p-64, false, +- 0x2.000005fffffffffffffffffffffep-64, false, +- 0x2.000006p-64, false), ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000008p-64, false, false, ++ false, ++ 0x2.000005ffffffep-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000005ffffffep-64, false, false, ++ 0x2.000006p-64, false, false, ++ false, ++ 0x2.000005fffffffffcp-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000005fffffffffcp-64, false, false, ++ 0x2.000006p-64, false, false, ++ false, ++ 0x2.000005fffffffffcp-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000005fffffffffcp-64, false, false, ++ 0x2.000006p-64, false, false, ++ false, ++ 0x2.000005ffffffffffffffffffffp-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000005ffffffffffffffffffffp-64, false, false, ++ 0x2.000006p-64, false, false, ++ false, ++ 0x2.000005fffffffffffffffffffffep-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000005fffffffffffffffffffffep-64, false, false, ++ 0x2.000006p-64, false, false), + TEST ("1.0842023663559605011233140988563539153233250544872134923934" + "9365234375e-19", + false, +- 0x2.000004p-64, false, +- 0x2.000008p-64, false, +- 0x2.000004p-64, false, +- 0x2.000008p-64, false, +- true, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- true, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- true, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- true, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- true, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false), ++ 0x2.000004p-64, false, false, ++ 0x2.000008p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000008p-64, false, false, ++ true, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ true, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ true, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ true, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ true, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false), + TEST ("1.0842023663559605011233140988563539153233250544872134923934" + "936523437501e-19", + false, +- 0x2.000004p-64, false, +- 0x2.000008p-64, false, +- 0x2.000004p-64, false, +- 0x2.000008p-64, false, +- false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.0000060000002p-64, false, +- false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.0000060000000004p-64, false, +- false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.0000060000000004p-64, false, +- false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.00000600000000000000000001p-64, false, +- false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.000006p-64, false, +- 0x2.0000060000000000000000000002p-64, false), ++ 0x2.000004p-64, false, false, ++ 0x2.000008p-64, false, false, ++ 0x2.000004p-64, false, false, ++ 0x2.000008p-64, false, false, ++ false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.0000060000002p-64, false, false, ++ false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.0000060000000004p-64, false, false, ++ false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.0000060000000004p-64, false, false, ++ false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.00000600000000000000000001p-64, false, false, ++ false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.000006p-64, false, false, ++ 0x2.0000060000000000000000000002p-64, false, false), + TEST ("1.0842024309794458568286011981851579832891729893162846565246" + "58203125e-19", + true, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- true, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- true, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- true, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- true, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- true, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false, +- 0x2.000008p-64, false), ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ true, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ true, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ true, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ true, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ true, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false, ++ 0x2.000008p-64, false, false), + TEST ("7.5231638452626400509999138382223723380394595633413601376560" + "1092018187046051025390625e-37", + true, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1p-120, false, +- true, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1p-120, false, +- true, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1p-120, false, +- true, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1p-120, false, +- true, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1p-120, false, +- true, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1p-120, false), ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ true, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ true, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ true, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ true, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ true, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false), + TEST ("7.5231642936781486349413765338158389908126215730251815381410" + "578824437213052434003657253924757242202758789062499e-37", + false, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1.000002p-120, false, +- false, +- 0x1.000000fffffffp-120, false, +- 0x1.000001p-120, false, +- 0x1.000000fffffffp-120, false, +- 0x1.000001p-120, false, +- false, +- 0x1.000000fffffffffep-120, false, +- 0x1.000001p-120, false, +- 0x1.000000fffffffffep-120, false, +- 0x1.000001p-120, false, +- false, +- 0x1.000000fffffffffep-120, false, +- 0x1.000001p-120, false, +- 0x1.000000fffffffffep-120, false, +- 0x1.000001p-120, false, +- false, +- 0x1.000000ffffffffffffffffffff8p-120, false, +- 0x1.000001p-120, false, +- 0x1.000000ffffffffffffffffffff8p-120, false, +- 0x1.000001p-120, false, +- false, +- 0x1.000000ffffffffffffffffffffffp-120, false, +- 0x1.000001p-120, false, +- 0x1.000000ffffffffffffffffffffffp-120, false, +- 0x1.000001p-120, false), ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1.000002p-120, false, false, ++ false, ++ 0x1.000000fffffffp-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000000fffffffp-120, false, false, ++ 0x1.000001p-120, false, false, ++ false, ++ 0x1.000000fffffffffep-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000000fffffffffep-120, false, false, ++ 0x1.000001p-120, false, false, ++ false, ++ 0x1.000000fffffffffep-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000000fffffffffep-120, false, false, ++ 0x1.000001p-120, false, false, ++ false, ++ 0x1.000000ffffffffffffffffffff8p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000000ffffffffffffffffffff8p-120, false, false, ++ 0x1.000001p-120, false, false, ++ false, ++ 0x1.000000ffffffffffffffffffffffp-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000000ffffffffffffffffffffffp-120, false, false, ++ 0x1.000001p-120, false, false), + TEST ("7.5231642936781486349413765338158389908126215730251815381410" + "5788244372130524340036572539247572422027587890625e-37", + false, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1p-120, false, +- 0x1.000002p-120, false, +- true, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- true, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- true, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- true, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- true, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false), ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1.000002p-120, false, false, ++ true, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ true, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ true, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ true, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ true, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false), + TEST ("7.5231642936781486349413765338158389908126215730251815381410" + "578824437213052434003657253924757242202758789062501e-37", + false, +- 0x1p-120, false, +- 0x1.000002p-120, false, +- 0x1p-120, false, +- 0x1.000002p-120, false, +- false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.0000010000001p-120, false, +- false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.0000010000000002p-120, false, +- false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.0000010000000002p-120, false, +- false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001000000000000000000008p-120, false, +- false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.000001p-120, false, +- 0x1.0000010000000000000000000001p-120, false), ++ 0x1p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1p-120, false, false, ++ 0x1.000002p-120, false, false, ++ false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.0000010000001p-120, false, false, ++ false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.0000010000000002p-120, false, false, ++ false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.0000010000000002p-120, false, false, ++ false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001000000000000000000008p-120, false, false, ++ false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.000001p-120, false, false, ++ 0x1.0000010000000000000000000001p-120, false, false), + TEST ("7.5231647420936572188828392294093056435857835827090029386261" + "048447055721499765468252007849514484405517578125e-37", + true, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- true, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- true, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- true, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- true, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- true, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false), ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ true, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ true, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ true, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ true, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ true, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false), + TEST ("7.5231651905091658028243019250027722963589455923928243391111" + "518069674229947096932846761774271726608276367187499e-37", + false, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- 0x1.000002p-120, false, +- 0x1.000004p-120, false, +- false, +- 0x1.000002fffffffp-120, false, +- 0x1.000003p-120, false, +- 0x1.000002fffffffp-120, false, +- 0x1.000003p-120, false, +- false, +- 0x1.000002fffffffffep-120, false, +- 0x1.000003p-120, false, +- 0x1.000002fffffffffep-120, false, +- 0x1.000003p-120, false, +- false, +- 0x1.000002fffffffffep-120, false, +- 0x1.000003p-120, false, +- 0x1.000002fffffffffep-120, false, +- 0x1.000003p-120, false, +- false, +- 0x1.000002ffffffffffffffffffff8p-120, false, +- 0x1.000003p-120, false, +- 0x1.000002ffffffffffffffffffff8p-120, false, +- 0x1.000003p-120, false, +- false, +- 0x1.000002ffffffffffffffffffffffp-120, false, +- 0x1.000003p-120, false, +- 0x1.000002ffffffffffffffffffffffp-120, false, +- 0x1.000003p-120, false), ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000004p-120, false, false, ++ false, ++ 0x1.000002fffffffp-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000002fffffffp-120, false, false, ++ 0x1.000003p-120, false, false, ++ false, ++ 0x1.000002fffffffffep-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000002fffffffffep-120, false, false, ++ 0x1.000003p-120, false, false, ++ false, ++ 0x1.000002fffffffffep-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000002fffffffffep-120, false, false, ++ 0x1.000003p-120, false, false, ++ false, ++ 0x1.000002ffffffffffffffffffff8p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000002ffffffffffffffffffff8p-120, false, false, ++ 0x1.000003p-120, false, false, ++ false, ++ 0x1.000002ffffffffffffffffffffffp-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000002ffffffffffffffffffffffp-120, false, false, ++ 0x1.000003p-120, false, false), + TEST ("7.5231651905091658028243019250027722963589455923928243391111" + "5180696742299470969328467617742717266082763671875e-37", + false, +- 0x1.000002p-120, false, +- 0x1.000004p-120, false, +- 0x1.000002p-120, false, +- 0x1.000004p-120, false, +- true, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- true, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- true, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- true, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- true, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false), ++ 0x1.000002p-120, false, false, ++ 0x1.000004p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000004p-120, false, false, ++ true, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ true, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ true, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ true, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ true, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false), + TEST ("7.5231651905091658028243019250027722963589455923928243391111" + "518069674229947096932846761774271726608276367187501e-37", + false, +- 0x1.000002p-120, false, +- 0x1.000004p-120, false, +- 0x1.000002p-120, false, +- 0x1.000004p-120, false, +- false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.0000030000001p-120, false, +- false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.0000030000000002p-120, false, +- false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.0000030000000002p-120, false, +- false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003000000000000000000008p-120, false, +- false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.000003p-120, false, +- 0x1.0000030000000000000000000001p-120, false), ++ 0x1.000002p-120, false, false, ++ 0x1.000004p-120, false, false, ++ 0x1.000002p-120, false, false, ++ 0x1.000004p-120, false, false, ++ false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.0000030000001p-120, false, false, ++ false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.0000030000000002p-120, false, false, ++ false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.0000030000000002p-120, false, false, ++ false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003000000000000000000008p-120, false, false, ++ false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.000003p-120, false, false, ++ 0x1.0000030000000000000000000001p-120, false, false), + TEST ("7.5231656389246743867657646205962389491321076020766457395961" + "98769229273839442839744151569902896881103515625e-37", + true, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- true, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- true, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- true, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- true, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- true, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false, +- 0x1.000004p-120, false), ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ true, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ true, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ true, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ true, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ true, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false, ++ 0x1.000004p-120, false, false), + TEST ("340282356779733661637539395458142568447.999", + false, +- 0xf.fffffp+124, false, +- 0xf.fffffp+124, false, +- 0xf.fffffp+124, false, +- INF, true, +- false, +- 0xf.fffff7ffffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff7ffffff8p+124, false, +- 0xf.fffff8p+124, false, +- false, +- 0xf.fffff7fffffffffp+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff7fffffffffp+124, false, +- 0xf.fffff8p+124, false, +- false, +- 0xf.fffff7fffffffffp+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff7fffffffffp+124, false, +- 0xf.fffff8p+124, false, +- false, +- 0xf.fffff7fffffffffffffffffffcp+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff7fffffffffffffffffffcp+124, false, +- 0xf.fffff8p+124, false, +- false, +- 0xf.fffff7fffffffffffffffffffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff7fffffffffffffffffffff8p+124, false, +- 0xf.fffff8p+124, false), ++ 0xf.fffffp+124, false, false, ++ 0xf.fffffp+124, false, false, ++ 0xf.fffffp+124, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffff7ffffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff7ffffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ false, ++ 0xf.fffff7fffffffffp+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff7fffffffffp+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ false, ++ 0xf.fffff7fffffffffp+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff7fffffffffp+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ false, ++ 0xf.fffff7fffffffffffffffffffcp+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff7fffffffffffffffffffcp+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ false, ++ 0xf.fffff7fffffffffffffffffffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff7fffffffffffffffffffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false), + TEST ("340282356779733661637539395458142568448", + false, +- 0xf.fffffp+124, false, +- INF, true, +- 0xf.fffffp+124, false, +- INF, true, +- true, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- true, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- true, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- true, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- true, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false), ++ 0xf.fffffp+124, false, false, ++ INF, true, false, ++ 0xf.fffffp+124, false, false, ++ INF, true, false, ++ true, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ true, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ true, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ true, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ true, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false), + TEST ("340282356779733661637539395458142568448.001", + false, +- 0xf.fffffp+124, false, +- INF, true, +- 0xf.fffffp+124, false, +- INF, true, +- false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff80000008p+124, false, +- false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8000000001p+124, false, +- false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8000000001p+124, false, +- false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff800000000000000000004p+124, false, +- false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff8p+124, false, +- 0xf.fffff80000000000000000000008p+124, false), ++ 0xf.fffffp+124, false, false, ++ INF, true, false, ++ 0xf.fffffp+124, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff80000008p+124, false, false, ++ false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8000000001p+124, false, false, ++ false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8000000001p+124, false, false, ++ false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff800000000000000000004p+124, false, false, ++ false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff8p+124, false, false, ++ 0xf.fffff80000000000000000000008p+124, false, false), + TEST ("-340282356779733661637539395458142568447.999", + false, +- -INF, true, +- -0xf.fffffp+124, false, +- -0xf.fffffp+124, false, +- -0xf.fffffp+124, false, +- false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff7ffffff8p+124, false, +- -0xf.fffff7ffffff8p+124, false, +- false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff7fffffffffp+124, false, +- -0xf.fffff7fffffffffp+124, false, +- false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff7fffffffffp+124, false, +- -0xf.fffff7fffffffffp+124, false, +- false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff7fffffffffffffffffffcp+124, false, +- -0xf.fffff7fffffffffffffffffffcp+124, false, +- false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff7fffffffffffffffffffff8p+124, false, +- -0xf.fffff7fffffffffffffffffffff8p+124, false), ++ -INF, true, false, ++ -0xf.fffffp+124, false, false, ++ -0xf.fffffp+124, false, false, ++ -0xf.fffffp+124, false, false, ++ false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff7ffffff8p+124, false, false, ++ -0xf.fffff7ffffff8p+124, false, false, ++ false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff7fffffffffp+124, false, false, ++ -0xf.fffff7fffffffffp+124, false, false, ++ false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff7fffffffffp+124, false, false, ++ -0xf.fffff7fffffffffp+124, false, false, ++ false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff7fffffffffffffffffffcp+124, false, false, ++ -0xf.fffff7fffffffffffffffffffcp+124, false, false, ++ false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff7fffffffffffffffffffff8p+124, false, false, ++ -0xf.fffff7fffffffffffffffffffff8p+124, false, false), + TEST ("-340282356779733661637539395458142568448", + false, +- -INF, true, +- -INF, true, +- -0xf.fffffp+124, false, +- -0xf.fffffp+124, false, +- true, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- true, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- true, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- true, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- true, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false), ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffp+124, false, false, ++ -0xf.fffffp+124, false, false, ++ true, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ true, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ true, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ true, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ true, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false), + TEST ("-340282356779733661637539395458142568448.001", + false, +- -INF, true, +- -INF, true, +- -0xf.fffffp+124, false, +- -0xf.fffffp+124, false, +- false, +- -0xf.fffff80000008p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- false, +- -0xf.fffff8000000001p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- false, +- -0xf.fffff8000000001p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- false, +- -0xf.fffff800000000000000000004p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- false, +- -0xf.fffff80000000000000000000008p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false, +- -0xf.fffff8p+124, false), ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffp+124, false, false, ++ -0xf.fffffp+124, false, false, ++ false, ++ -0xf.fffff80000008p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ false, ++ -0xf.fffff8000000001p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ false, ++ -0xf.fffff8000000001p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ false, ++ -0xf.fffff800000000000000000004p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ false, ++ -0xf.fffff80000000000000000000008p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false, ++ -0xf.fffff8p+124, false, false), + TEST ("179769313486231580793728971405303415079934132710037826936173" + "778980444968292764750946649017977587207096330286416692887910" + "946555547851940402630657488671505820681908902000708383676273" +@@ -1855,35 +1855,35 @@ static const struct test tests[] = { + "936475292719074168444365510704342711559699508093042880177904" + "174497791.999", + false, +- 0xf.fffffp+124, true, +- INF, true, +- 0xf.fffffp+124, true, +- INF, true, +- false, +- 0xf.ffffffffffff8p+1020, false, +- 0xf.ffffffffffff8p+1020, false, +- 0xf.ffffffffffff8p+1020, false, +- INF, true, +- false, +- 0xf.ffffffffffffbffp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffbffp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- false, +- 0xf.ffffffffffffbffp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffbffp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- false, +- 0xf.ffffffffffffbffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, true, +- 0xf.ffffffffffffbffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, true, +- false, +- 0xf.ffffffffffffbffffffffffffff8p+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffbffffffffffffff8p+1020, false, +- 0xf.ffffffffffffcp+1020, false), ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffff8p+1020, false, false, ++ 0xf.ffffffffffff8p+1020, false, false, ++ 0xf.ffffffffffff8p+1020, false, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffffbffp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffbffp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ false, ++ 0xf.ffffffffffffbffp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffbffp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ false, ++ 0xf.ffffffffffffbffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, true, false, ++ 0xf.ffffffffffffbffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, true, false, ++ false, ++ 0xf.ffffffffffffbffffffffffffff8p+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffbffffffffffffff8p+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false), + TEST ("179769313486231580793728971405303415079934132710037826936173" + "778980444968292764750946649017977587207096330286416692887910" + "946555547851940402630657488671505820681908902000708383676273" +@@ -1891,35 +1891,35 @@ static const struct test tests[] = { + "936475292719074168444365510704342711559699508093042880177904" + "174497792", + false, +- 0xf.fffffp+124, true, +- INF, true, +- 0xf.fffffp+124, true, +- INF, true, +- false, +- 0xf.ffffffffffff8p+1020, false, +- INF, true, +- 0xf.ffffffffffff8p+1020, false, +- INF, true, +- true, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- true, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- false, +- 0xf.ffffffffffffcp+1020, true, +- 0xf.ffffffffffffcp+1020, true, +- 0xf.ffffffffffffcp+1020, true, +- 0xf.ffffffffffffcp+1020, true, +- true, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false), ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffff8p+1020, false, false, ++ INF, true, false, ++ 0xf.ffffffffffff8p+1020, false, false, ++ INF, true, false, ++ true, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ true, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ false, ++ 0xf.ffffffffffffcp+1020, true, false, ++ 0xf.ffffffffffffcp+1020, true, false, ++ 0xf.ffffffffffffcp+1020, true, false, ++ 0xf.ffffffffffffcp+1020, true, false, ++ true, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false), + TEST ("179769313486231580793728971405303415079934132710037826936173" + "778980444968292764750946649017977587207096330286416692887910" + "946555547851940402630657488671505820681908902000708383676273" +@@ -1927,35 +1927,35 @@ static const struct test tests[] = { + "936475292719074168444365510704342711559699508093042880177904" + "174497792.001", + false, +- 0xf.fffffp+124, true, +- INF, true, +- 0xf.fffffp+124, true, +- INF, true, +- false, +- 0xf.ffffffffffff8p+1020, false, +- INF, true, +- 0xf.ffffffffffff8p+1020, false, +- INF, true, +- false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffc01p+1020, false, +- false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffc01p+1020, false, +- false, +- 0xf.ffffffffffffcp+1020, true, +- 0xf.ffffffffffffcp+1020, true, +- 0xf.ffffffffffffcp+1020, true, +- 0xf.ffffffffffffc0000000000004p+1020, true, +- false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffcp+1020, false, +- 0xf.ffffffffffffc000000000000008p+1020, false), ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffff8p+1020, false, false, ++ INF, true, false, ++ 0xf.ffffffffffff8p+1020, false, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffc01p+1020, false, false, ++ false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffc01p+1020, false, false, ++ false, ++ 0xf.ffffffffffffcp+1020, true, false, ++ 0xf.ffffffffffffcp+1020, true, false, ++ 0xf.ffffffffffffcp+1020, true, false, ++ 0xf.ffffffffffffc0000000000004p+1020, true, false, ++ false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffcp+1020, false, false, ++ 0xf.ffffffffffffc000000000000008p+1020, false, false), + TEST ("-17976931348623158079372897140530341507993413271003782693617" + "377898044496829276475094664901797758720709633028641669288791" + "094655554785194040263065748867150582068190890200070838367627" +@@ -1963,35 +1963,35 @@ static const struct test tests[] = { + "493647529271907416844436551070434271155969950809304288017790" + "4174497791.999", + false, +- -INF, true, +- -INF, true, +- -0xf.fffffp+124, true, +- -0xf.fffffp+124, true, +- false, +- -INF, true, +- -0xf.ffffffffffff8p+1020, false, +- -0xf.ffffffffffff8p+1020, false, +- -0xf.ffffffffffff8p+1020, false, +- false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffbffp+1020, false, +- -0xf.ffffffffffffbffp+1020, false, +- false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffbffp+1020, false, +- -0xf.ffffffffffffbffp+1020, false, +- false, +- -0xf.ffffffffffffcp+1020, true, +- -0xf.ffffffffffffcp+1020, true, +- -0xf.ffffffffffffbffffffffffffcp+1020, false, +- -0xf.ffffffffffffbffffffffffffcp+1020, false, +- false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffbffffffffffffff8p+1020, false, +- -0xf.ffffffffffffbffffffffffffff8p+1020, false), ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffp+124, true, false, ++ -0xf.fffffp+124, true, false, ++ false, ++ -INF, true, false, ++ -0xf.ffffffffffff8p+1020, false, false, ++ -0xf.ffffffffffff8p+1020, false, false, ++ -0xf.ffffffffffff8p+1020, false, false, ++ false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffbffp+1020, false, false, ++ -0xf.ffffffffffffbffp+1020, false, false, ++ false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffbffp+1020, false, false, ++ -0xf.ffffffffffffbffp+1020, false, false, ++ false, ++ -0xf.ffffffffffffcp+1020, true, false, ++ -0xf.ffffffffffffcp+1020, true, false, ++ -0xf.ffffffffffffbffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffbffffffffffffcp+1020, false, false, ++ false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffbffffffffffffff8p+1020, false, false, ++ -0xf.ffffffffffffbffffffffffffff8p+1020, false, false), + TEST ("-17976931348623158079372897140530341507993413271003782693617" + "377898044496829276475094664901797758720709633028641669288791" + "094655554785194040263065748867150582068190890200070838367627" +@@ -1999,35 +1999,35 @@ static const struct test tests[] = { + "493647529271907416844436551070434271155969950809304288017790" + "4174497792", + false, +- -INF, true, +- -INF, true, +- -0xf.fffffp+124, true, +- -0xf.fffffp+124, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.ffffffffffff8p+1020, false, +- -0xf.ffffffffffff8p+1020, false, +- true, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- true, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- false, +- -0xf.ffffffffffffcp+1020, true, +- -0xf.ffffffffffffcp+1020, true, +- -0xf.ffffffffffffcp+1020, true, +- -0xf.ffffffffffffcp+1020, true, +- true, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false), ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffp+124, true, false, ++ -0xf.fffffp+124, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.ffffffffffff8p+1020, false, false, ++ -0xf.ffffffffffff8p+1020, false, false, ++ true, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ true, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ false, ++ -0xf.ffffffffffffcp+1020, true, false, ++ -0xf.ffffffffffffcp+1020, true, false, ++ -0xf.ffffffffffffcp+1020, true, false, ++ -0xf.ffffffffffffcp+1020, true, false, ++ true, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false), + TEST ("-17976931348623158079372897140530341507993413271003782693617" + "377898044496829276475094664901797758720709633028641669288791" + "094655554785194040263065748867150582068190890200070838367627" +@@ -2035,35 +2035,35 @@ static const struct test tests[] = { + "493647529271907416844436551070434271155969950809304288017790" + "4174497792.001", + false, +- -INF, true, +- -INF, true, +- -0xf.fffffp+124, true, +- -0xf.fffffp+124, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.ffffffffffff8p+1020, false, +- -0xf.ffffffffffff8p+1020, false, +- false, +- -0xf.ffffffffffffc01p+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- false, +- -0xf.ffffffffffffc01p+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- false, +- -0xf.ffffffffffffc0000000000004p+1020, true, +- -0xf.ffffffffffffcp+1020, true, +- -0xf.ffffffffffffcp+1020, true, +- -0xf.ffffffffffffcp+1020, true, +- false, +- -0xf.ffffffffffffc000000000000008p+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false, +- -0xf.ffffffffffffcp+1020, false), ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffp+124, true, false, ++ -0xf.fffffp+124, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.ffffffffffff8p+1020, false, false, ++ -0xf.ffffffffffff8p+1020, false, false, ++ false, ++ -0xf.ffffffffffffc01p+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ false, ++ -0xf.ffffffffffffc01p+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ false, ++ -0xf.ffffffffffffc0000000000004p+1020, true, false, ++ -0xf.ffffffffffffcp+1020, true, false, ++ -0xf.ffffffffffffcp+1020, true, false, ++ -0xf.ffffffffffffcp+1020, true, false, ++ false, ++ -0xf.ffffffffffffc000000000000008p+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false, ++ -0xf.ffffffffffffcp+1020, false, false), + TEST ("118973149535723176505351158982948866796625400469556721895649" + "927756249918185172720476044944290457046138433056764616744328" + "666255526748948793023632513609765434237723241753648908036202" +@@ -2148,35 +2148,35 @@ static const struct test tests[] = { + "578031503869424406179027994752890226443351619365453243328968" + "8740976918527.999", + false, +- 0xf.fffffp+124, true, +- INF, true, +- 0xf.fffffp+124, true, +- INF, true, +- false, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- false, +- 0xf.fffffffffffffffp+16380, false, +- 0xf.fffffffffffffffp+16380, false, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- false, +- 0xf.fffffffffffffffp+16380, false, +- 0xf.fffffffffffffffp+16380, false, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- false, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- false, +- 0xf.fffffffffffffff7fffffffffff8p+16380, false, +- 0xf.fffffffffffffff8p+16380, false, +- 0xf.fffffffffffffff7fffffffffff8p+16380, false, +- 0xf.fffffffffffffff8p+16380, false), ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffff7fffffffffff8p+16380, false, false, ++ 0xf.fffffffffffffff8p+16380, false, false, ++ 0xf.fffffffffffffff7fffffffffff8p+16380, false, false, ++ 0xf.fffffffffffffff8p+16380, false, false), + TEST ("118973149535723176505351158982948866796625400469556721895649" + "927756249918185172720476044944290457046138433056764616744328" + "666255526748948793023632513609765434237723241753648908036202" +@@ -2261,35 +2261,35 @@ static const struct test tests[] = { + "578031503869424406179027994752890226443351619365453243328968" + "8740976918528", + false, +- 0xf.fffffp+124, true, +- INF, true, +- 0xf.fffffp+124, true, +- INF, true, +- false, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- false, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- false, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- false, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- true, +- 0xf.fffffffffffffff8p+16380, false, +- 0xf.fffffffffffffff8p+16380, false, +- 0xf.fffffffffffffff8p+16380, false, +- 0xf.fffffffffffffff8p+16380, false), ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ true, ++ 0xf.fffffffffffffff8p+16380, false, false, ++ 0xf.fffffffffffffff8p+16380, false, false, ++ 0xf.fffffffffffffff8p+16380, false, false, ++ 0xf.fffffffffffffff8p+16380, false, false), + TEST ("118973149535723176505351158982948866796625400469556721895649" + "927756249918185172720476044944290457046138433056764616744328" + "666255526748948793023632513609765434237723241753648908036202" +@@ -2374,35 +2374,35 @@ static const struct test tests[] = { + "578031503869424406179027994752890226443351619365453243328968" + "8740976918528.001", + false, +- 0xf.fffffp+124, true, +- INF, true, +- 0xf.fffffp+124, true, +- INF, true, +- false, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- false, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- false, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- false, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- false, +- 0xf.fffffffffffffff8p+16380, false, +- 0xf.fffffffffffffff8p+16380, false, +- 0xf.fffffffffffffff8p+16380, false, +- 0xf.fffffffffffffff8000000000008p+16380, false), ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffff8p+16380, false, false, ++ 0xf.fffffffffffffff8p+16380, false, false, ++ 0xf.fffffffffffffff8p+16380, false, false, ++ 0xf.fffffffffffffff8000000000008p+16380, false, false), + TEST ("-11897314953572317650535115898294886679662540046955672189564" + "992775624991818517272047604494429045704613843305676461674432" + "866625552674894879302363251360976543423772324175364890803620" +@@ -2487,35 +2487,35 @@ static const struct test tests[] = { + "557803150386942440617902799475289022644335161936545324332896" + "88740976918527.999", + false, +- -INF, true, +- -INF, true, +- -0xf.fffffp+124, true, +- -0xf.fffffp+124, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.ffffffffffff8p+1020, true, +- -0xf.ffffffffffff8p+1020, true, +- false, +- -INF, true, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- false, +- -INF, true, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- false, +- -0xf.fffffffffffffff8p+16380, false, +- -0xf.fffffffffffffff8p+16380, false, +- -0xf.fffffffffffffff7fffffffffff8p+16380, false, +- -0xf.fffffffffffffff7fffffffffff8p+16380, false), ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffp+124, true, false, ++ -0xf.fffffp+124, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.ffffffffffff8p+1020, true, false, ++ -0xf.ffffffffffff8p+1020, true, false, ++ false, ++ -INF, true, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ false, ++ -INF, true, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ false, ++ -0xf.fffffffffffffff8p+16380, false, false, ++ -0xf.fffffffffffffff8p+16380, false, false, ++ -0xf.fffffffffffffff7fffffffffff8p+16380, false, false, ++ -0xf.fffffffffffffff7fffffffffff8p+16380, false, false), + TEST ("-11897314953572317650535115898294886679662540046955672189564" + "992775624991818517272047604494429045704613843305676461674432" + "866625552674894879302363251360976543423772324175364890803620" +@@ -2600,35 +2600,35 @@ static const struct test tests[] = { + "557803150386942440617902799475289022644335161936545324332896" + "88740976918528", + false, +- -INF, true, +- -INF, true, +- -0xf.fffffp+124, true, +- -0xf.fffffp+124, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.ffffffffffff8p+1020, true, +- -0xf.ffffffffffff8p+1020, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- true, +- -0xf.fffffffffffffff8p+16380, false, +- -0xf.fffffffffffffff8p+16380, false, +- -0xf.fffffffffffffff8p+16380, false, +- -0xf.fffffffffffffff8p+16380, false), ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffp+124, true, false, ++ -0xf.fffffp+124, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.ffffffffffff8p+1020, true, false, ++ -0xf.ffffffffffff8p+1020, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ true, ++ -0xf.fffffffffffffff8p+16380, false, false, ++ -0xf.fffffffffffffff8p+16380, false, false, ++ -0xf.fffffffffffffff8p+16380, false, false, ++ -0xf.fffffffffffffff8p+16380, false, false), + TEST ("-11897314953572317650535115898294886679662540046955672189564" + "992775624991818517272047604494429045704613843305676461674432" + "866625552674894879302363251360976543423772324175364890803620" +@@ -2713,35 +2713,35 @@ static const struct test tests[] = { + "557803150386942440617902799475289022644335161936545324332896" + "88740976918528.001", + false, +- -INF, true, +- -INF, true, +- -0xf.fffffp+124, true, +- -0xf.fffffp+124, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.ffffffffffff8p+1020, true, +- -0xf.ffffffffffff8p+1020, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- false, +- -0xf.fffffffffffffff8000000000008p+16380, false, +- -0xf.fffffffffffffff8p+16380, false, +- -0xf.fffffffffffffff8p+16380, false, +- -0xf.fffffffffffffff8p+16380, false), ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffp+124, true, false, ++ -0xf.fffffp+124, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.ffffffffffff8p+1020, true, false, ++ -0xf.ffffffffffff8p+1020, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ false, ++ -0xf.fffffffffffffff8000000000008p+16380, false, false, ++ -0xf.fffffffffffffff8p+16380, false, false, ++ -0xf.fffffffffffffff8p+16380, false, false, ++ -0xf.fffffffffffffff8p+16380, false, false), + TEST ("118973149535723176508575932662800707347995686986910214150118" + "685272271246896789803961473130416053705672050873552479421805" + "932646640744124594447361172514341324846716679654551308018400" +@@ -2826,35 +2826,35 @@ static const struct test tests[] = { + "972233447491583165728635513802591543441145939539353470970452" + "5536550715391.999", + false, +- 0xf.fffffp+124, true, +- INF, true, +- 0xf.fffffp+124, true, +- INF, true, +- false, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- false, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- false, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- false, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- false, +- 0xf.fffffffffffffffffffffffffff8p+16380, false, +- 0xf.fffffffffffffffffffffffffff8p+16380, false, +- 0xf.fffffffffffffffffffffffffff8p+16380, false, +- INF, true), ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffffffffffffff8p+16380, false, false, ++ 0xf.fffffffffffffffffffffffffff8p+16380, false, false, ++ 0xf.fffffffffffffffffffffffffff8p+16380, false, false, ++ INF, true, false), + TEST ("118973149535723176508575932662800707347995686986910214150118" + "685272271246896789803961473130416053705672050873552479421805" + "932646640744124594447361172514341324846716679654551308018400" +@@ -2939,35 +2939,35 @@ static const struct test tests[] = { + "972233447491583165728635513802591543441145939539353470970452" + "5536550715392", + false, +- 0xf.fffffp+124, true, +- INF, true, +- 0xf.fffffp+124, true, +- INF, true, +- false, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- false, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- false, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- false, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- false, +- 0xf.fffffffffffffffffffffffffff8p+16380, false, +- INF, true, +- 0xf.fffffffffffffffffffffffffff8p+16380, false, +- INF, true), ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffffffffffffff8p+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffffffffffffff8p+16380, false, false, ++ INF, true, false), + TEST ("118973149535723176508575932662800707347995686986910214150118" + "685272271246896789803961473130416053705672050873552479421805" + "932646640744124594447361172514341324846716679654551308018400" +@@ -3052,35 +3052,35 @@ static const struct test tests[] = { + "972233447491583165728635513802591543441145939539353470970452" + "5536550715392.001", + false, +- 0xf.fffffp+124, true, +- INF, true, +- 0xf.fffffp+124, true, +- INF, true, +- false, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- false, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- false, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- false, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- false, +- 0xf.fffffffffffffffffffffffffff8p+16380, false, +- INF, true, +- 0xf.fffffffffffffffffffffffffff8p+16380, false, +- INF, true), ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffffffffffffff8p+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffffffffffffff8p+16380, false, false, ++ INF, true, false), + TEST ("-11897314953572317650857593266280070734799568698691021415011" + "868527227124689678980396147313041605370567205087355247942180" + "593264664074412459444736117251434132484671667965455130801840" +@@ -3165,35 +3165,35 @@ static const struct test tests[] = { + "097223344749158316572863551380259154344114593953935347097045" + "25536550715391.999", + false, +- -INF, true, +- -INF, true, +- -0xf.fffffp+124, true, +- -0xf.fffffp+124, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.ffffffffffff8p+1020, true, +- -0xf.ffffffffffff8p+1020, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- false, +- -INF, true, +- -0xf.fffffffffffffffffffffffffff8p+16380, false, +- -0xf.fffffffffffffffffffffffffff8p+16380, false, +- -0xf.fffffffffffffffffffffffffff8p+16380, false), ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffp+124, true, false, ++ -0xf.fffffp+124, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.ffffffffffff8p+1020, true, false, ++ -0xf.ffffffffffff8p+1020, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ false, ++ -INF, true, false, ++ -0xf.fffffffffffffffffffffffffff8p+16380, false, false, ++ -0xf.fffffffffffffffffffffffffff8p+16380, false, false, ++ -0xf.fffffffffffffffffffffffffff8p+16380, false, false), + TEST ("-11897314953572317650857593266280070734799568698691021415011" + "868527227124689678980396147313041605370567205087355247942180" + "593264664074412459444736117251434132484671667965455130801840" +@@ -3278,35 +3278,35 @@ static const struct test tests[] = { + "097223344749158316572863551380259154344114593953935347097045" + "25536550715392", + false, +- -INF, true, +- -INF, true, +- -0xf.fffffp+124, true, +- -0xf.fffffp+124, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.ffffffffffff8p+1020, true, +- -0xf.ffffffffffff8p+1020, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffffffffffffff8p+16380, false, +- -0xf.fffffffffffffffffffffffffff8p+16380, false), ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffp+124, true, false, ++ -0xf.fffffp+124, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.ffffffffffff8p+1020, true, false, ++ -0xf.ffffffffffff8p+1020, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffffffffffffff8p+16380, false, false, ++ -0xf.fffffffffffffffffffffffffff8p+16380, false, false), + TEST ("-11897314953572317650857593266280070734799568698691021415011" + "868527227124689678980396147313041605370567205087355247942180" + "593264664074412459444736117251434132484671667965455130801840" +@@ -3391,419 +3391,419 @@ static const struct test tests[] = { + "097223344749158316572863551380259154344114593953935347097045" + "25536550715392.001", + false, +- -INF, true, +- -INF, true, +- -0xf.fffffp+124, true, +- -0xf.fffffp+124, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.ffffffffffff8p+1020, true, +- -0xf.ffffffffffff8p+1020, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffffffffffffff8p+16380, false, +- -0xf.fffffffffffffffffffffffffff8p+16380, false), ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffp+124, true, false, ++ -0xf.fffffp+124, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.ffffffffffff8p+1020, true, false, ++ -0xf.ffffffffffff8p+1020, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffffffffffffff8p+16380, false, false, ++ -0xf.fffffffffffffffffffffffffff8p+16380, false, false), + TEST ("2.1019476964872256063855943749348741969203929128147736576356" + "0242583468662402879090222995728254318237304687499e-45", + false, +- 0x8p-152, false, +- 0x8p-152, false, +- 0x8p-152, false, +- 0x1p-148, false, +- false, +- 0xb.ffffffffffff8p-152, false, +- 0xcp-152, false, +- 0xb.ffffffffffff8p-152, false, +- 0xcp-152, false, +- false, +- 0xb.fffffffffffffffp-152, false, +- 0xcp-152, false, +- 0xb.fffffffffffffffp-152, false, +- 0xcp-152, false, +- false, +- 0xb.fffffffffffffffp-152, false, +- 0xcp-152, false, +- 0xb.fffffffffffffffp-152, false, +- 0xcp-152, false, +- false, +- 0xb.fffffffffffffffffffffffffcp-152, false, +- 0xcp-152, false, +- 0xb.fffffffffffffffffffffffffcp-152, false, +- 0xcp-152, false, +- false, +- 0xb.fffffffffffffffffffffffffff8p-152, false, +- 0xcp-152, false, +- 0xb.fffffffffffffffffffffffffff8p-152, false, +- 0xcp-152, false), ++ 0x8p-152, false, true, ++ 0x8p-152, false, true, ++ 0x8p-152, false, true, ++ 0x1p-148, false, true, ++ false, ++ 0xb.ffffffffffff8p-152, false, false, ++ 0xcp-152, false, false, ++ 0xb.ffffffffffff8p-152, false, false, ++ 0xcp-152, false, false, ++ false, ++ 0xb.fffffffffffffffp-152, false, false, ++ 0xcp-152, false, false, ++ 0xb.fffffffffffffffp-152, false, false, ++ 0xcp-152, false, false, ++ false, ++ 0xb.fffffffffffffffp-152, false, false, ++ 0xcp-152, false, false, ++ 0xb.fffffffffffffffp-152, false, false, ++ 0xcp-152, false, false, ++ false, ++ 0xb.fffffffffffffffffffffffffcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xb.fffffffffffffffffffffffffcp-152, false, false, ++ 0xcp-152, false, false, ++ false, ++ 0xb.fffffffffffffffffffffffffff8p-152, false, false, ++ 0xcp-152, false, false, ++ 0xb.fffffffffffffffffffffffffff8p-152, false, false, ++ 0xcp-152, false, false), + TEST ("2.1019476964872256063855943749348741969203929128147736576356" + "02425834686624028790902229957282543182373046875e-45", + false, +- 0x8p-152, false, +- 0x1p-148, false, +- 0x8p-152, false, +- 0x1p-148, false, +- true, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- true, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- true, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- true, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- true, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false), ++ 0x8p-152, false, true, ++ 0x1p-148, false, true, ++ 0x8p-152, false, true, ++ 0x1p-148, false, true, ++ true, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ true, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ true, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ true, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ true, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false), + TEST ("2.1019476964872256063855943749348741969203929128147736576356" + "0242583468662402879090222995728254318237304687501e-45", + false, +- 0x8p-152, false, +- 0x1p-148, false, +- 0x8p-152, false, +- 0x1p-148, false, +- false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xc.0000000000008p-152, false, +- false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xc.000000000000001p-152, false, +- false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xc.000000000000001p-152, false, +- false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xc.00000000000000000000000004p-152, false, +- false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xcp-152, false, +- 0xc.0000000000000000000000000008p-152, false), ++ 0x8p-152, false, true, ++ 0x1p-148, false, true, ++ 0x8p-152, false, true, ++ 0x1p-148, false, true, ++ false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xc.0000000000008p-152, false, false, ++ false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xc.000000000000001p-152, false, false, ++ false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xc.000000000000001p-152, false, false, ++ false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xc.00000000000000000000000004p-152, false, false, ++ false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xcp-152, false, false, ++ 0xc.0000000000000000000000000008p-152, false, false), + TEST ("-2.101947696487225606385594374934874196920392912814773657635" + "60242583468662402879090222995728254318237304687499e-45", + false, +- -0x1p-148, false, +- -0x8p-152, false, +- -0x8p-152, false, +- -0x8p-152, false, +- false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xb.ffffffffffff8p-152, false, +- -0xb.ffffffffffff8p-152, false, +- false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xb.fffffffffffffffp-152, false, +- -0xb.fffffffffffffffp-152, false, +- false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xb.fffffffffffffffp-152, false, +- -0xb.fffffffffffffffp-152, false, +- false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xb.fffffffffffffffffffffffffcp-152, false, +- -0xb.fffffffffffffffffffffffffcp-152, false, +- false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xb.fffffffffffffffffffffffffff8p-152, false, +- -0xb.fffffffffffffffffffffffffff8p-152, false), ++ -0x1p-148, false, true, ++ -0x8p-152, false, true, ++ -0x8p-152, false, true, ++ -0x8p-152, false, true, ++ false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xb.ffffffffffff8p-152, false, false, ++ -0xb.ffffffffffff8p-152, false, false, ++ false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xb.fffffffffffffffp-152, false, false, ++ -0xb.fffffffffffffffp-152, false, false, ++ false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xb.fffffffffffffffp-152, false, false, ++ -0xb.fffffffffffffffp-152, false, false, ++ false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xb.fffffffffffffffffffffffffcp-152, false, false, ++ -0xb.fffffffffffffffffffffffffcp-152, false, false, ++ false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xb.fffffffffffffffffffffffffff8p-152, false, false, ++ -0xb.fffffffffffffffffffffffffff8p-152, false, false), + TEST ("-2.101947696487225606385594374934874196920392912814773657635" + "602425834686624028790902229957282543182373046875e-45", + false, +- -0x1p-148, false, +- -0x1p-148, false, +- -0x8p-152, false, +- -0x8p-152, false, +- true, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- true, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- true, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- true, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- true, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false), ++ -0x1p-148, false, true, ++ -0x1p-148, false, true, ++ -0x8p-152, false, true, ++ -0x8p-152, false, true, ++ true, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ true, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ true, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ true, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ true, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false), + TEST ("-2.101947696487225606385594374934874196920392912814773657635" + "60242583468662402879090222995728254318237304687501e-45", + false, +- -0x1p-148, false, +- -0x1p-148, false, +- -0x8p-152, false, +- -0x8p-152, false, +- false, +- -0xc.0000000000008p-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- false, +- -0xc.000000000000001p-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- false, +- -0xc.000000000000001p-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- false, +- -0xc.00000000000000000000000004p-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- false, +- -0xc.0000000000000000000000000008p-152, false, +- -0xcp-152, false, +- -0xcp-152, false, +- -0xcp-152, false), ++ -0x1p-148, false, true, ++ -0x1p-148, false, true, ++ -0x8p-152, false, true, ++ -0x8p-152, false, true, ++ false, ++ -0xc.0000000000008p-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ false, ++ -0xc.000000000000001p-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ false, ++ -0xc.000000000000001p-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ false, ++ -0xc.00000000000000000000000004p-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ false, ++ -0xc.0000000000000000000000000008p-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false, ++ -0xcp-152, false, false), + TEST ("3.5032461608120426773093239582247903282006548546912894293926" + "7070972447770671465150371659547090530395507812499e-45", + false, +- 0x1p-148, false, +- 0x1p-148, false, +- 0x1p-148, false, +- 0x1.8p-148, false, +- false, +- 0x1.3ffffffffffffp-148, false, +- 0x1.4p-148, false, +- 0x1.3ffffffffffffp-148, false, +- 0x1.4p-148, false, +- false, +- 0x1.3ffffffffffffffep-148, false, +- 0x1.4p-148, false, +- 0x1.3ffffffffffffffep-148, false, +- 0x1.4p-148, false, +- false, +- 0x1.3ffffffffffffffep-148, false, +- 0x1.4p-148, false, +- 0x1.3ffffffffffffffep-148, false, +- 0x1.4p-148, false, +- false, +- 0x1.3fffffffffffffffffffffffff8p-148, false, +- 0x1.4p-148, false, +- 0x1.3fffffffffffffffffffffffff8p-148, false, +- 0x1.4p-148, false, +- false, +- 0x1.3fffffffffffffffffffffffffffp-148, false, +- 0x1.4p-148, false, +- 0x1.3fffffffffffffffffffffffffffp-148, false, +- 0x1.4p-148, false), ++ 0x1p-148, false, true, ++ 0x1p-148, false, true, ++ 0x1p-148, false, true, ++ 0x1.8p-148, false, true, ++ false, ++ 0x1.3ffffffffffffp-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.3ffffffffffffp-148, false, false, ++ 0x1.4p-148, false, false, ++ false, ++ 0x1.3ffffffffffffffep-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.3ffffffffffffffep-148, false, false, ++ 0x1.4p-148, false, false, ++ false, ++ 0x1.3ffffffffffffffep-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.3ffffffffffffffep-148, false, false, ++ 0x1.4p-148, false, false, ++ false, ++ 0x1.3fffffffffffffffffffffffff8p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.3fffffffffffffffffffffffff8p-148, false, false, ++ 0x1.4p-148, false, false, ++ false, ++ 0x1.3fffffffffffffffffffffffffffp-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.3fffffffffffffffffffffffffffp-148, false, false, ++ 0x1.4p-148, false, false), + TEST ("3.5032461608120426773093239582247903282006548546912894293926" + "70709724477706714651503716595470905303955078125e-45", + false, +- 0x1p-148, false, +- 0x1p-148, false, +- 0x1p-148, false, +- 0x1.8p-148, false, +- true, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- true, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- true, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- true, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- true, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false), ++ 0x1p-148, false, true, ++ 0x1p-148, false, true, ++ 0x1p-148, false, true, ++ 0x1.8p-148, false, true, ++ true, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ true, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ true, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ true, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ true, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false), + TEST ("3.5032461608120426773093239582247903282006548546912894293926" + "7070972447770671465150371659547090530395507812501e-45", + false, +- 0x1p-148, false, +- 0x1.8p-148, false, +- 0x1p-148, false, +- 0x1.8p-148, false, +- false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4000000000001p-148, false, +- false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4000000000000002p-148, false, +- false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4000000000000002p-148, false, +- false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.400000000000000000000000008p-148, false, +- false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4p-148, false, +- 0x1.4000000000000000000000000001p-148, false), ++ 0x1p-148, false, true, ++ 0x1.8p-148, false, true, ++ 0x1p-148, false, true, ++ 0x1.8p-148, false, true, ++ false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4000000000001p-148, false, false, ++ false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4000000000000002p-148, false, false, ++ false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4000000000000002p-148, false, false, ++ false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.400000000000000000000000008p-148, false, false, ++ false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4p-148, false, false, ++ 0x1.4000000000000000000000000001p-148, false, false), + TEST ("-3.503246160812042677309323958224790328200654854691289429392" + "67070972447770671465150371659547090530395507812499e-45", + false, +- -0x1.8p-148, false, +- -0x1p-148, false, +- -0x1p-148, false, +- -0x1p-148, false, +- false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.3ffffffffffffp-148, false, +- -0x1.3ffffffffffffp-148, false, +- false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.3ffffffffffffffep-148, false, +- -0x1.3ffffffffffffffep-148, false, +- false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.3ffffffffffffffep-148, false, +- -0x1.3ffffffffffffffep-148, false, +- false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.3fffffffffffffffffffffffff8p-148, false, +- -0x1.3fffffffffffffffffffffffff8p-148, false, +- false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.3fffffffffffffffffffffffffffp-148, false, +- -0x1.3fffffffffffffffffffffffffffp-148, false), ++ -0x1.8p-148, false, true, ++ -0x1p-148, false, true, ++ -0x1p-148, false, true, ++ -0x1p-148, false, true, ++ false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.3ffffffffffffp-148, false, false, ++ -0x1.3ffffffffffffp-148, false, false, ++ false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.3ffffffffffffffep-148, false, false, ++ -0x1.3ffffffffffffffep-148, false, false, ++ false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.3ffffffffffffffep-148, false, false, ++ -0x1.3ffffffffffffffep-148, false, false, ++ false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.3fffffffffffffffffffffffff8p-148, false, false, ++ -0x1.3fffffffffffffffffffffffff8p-148, false, false, ++ false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.3fffffffffffffffffffffffffffp-148, false, false, ++ -0x1.3fffffffffffffffffffffffffffp-148, false, false), + TEST ("-3.503246160812042677309323958224790328200654854691289429392" + "670709724477706714651503716595470905303955078125e-45", + false, +- -0x1.8p-148, false, +- -0x1p-148, false, +- -0x1p-148, false, +- -0x1p-148, false, +- true, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- true, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- true, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- true, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- true, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false), ++ -0x1.8p-148, false, true, ++ -0x1p-148, false, true, ++ -0x1p-148, false, true, ++ -0x1p-148, false, true, ++ true, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ true, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ true, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ true, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ true, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false), + TEST ("-3.503246160812042677309323958224790328200654854691289429392" + "67070972447770671465150371659547090530395507812501e-45", + false, +- -0x1.8p-148, false, +- -0x1.8p-148, false, +- -0x1p-148, false, +- -0x1p-148, false, +- false, +- -0x1.4000000000001p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- false, +- -0x1.4000000000000002p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- false, +- -0x1.4000000000000002p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- false, +- -0x1.400000000000000000000000008p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- false, +- -0x1.4000000000000000000000000001p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false, +- -0x1.4p-148, false), ++ -0x1.8p-148, false, true, ++ -0x1.8p-148, false, true, ++ -0x1p-148, false, true, ++ -0x1p-148, false, true, ++ false, ++ -0x1.4000000000001p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ false, ++ -0x1.4000000000000002p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ false, ++ -0x1.4000000000000002p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ false, ++ -0x1.400000000000000000000000008p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ false, ++ -0x1.4000000000000000000000000001p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false, ++ -0x1.4p-148, false, false), + TEST ("7.4109846876186981626485318930233205854758970392148714663837" + "852375101326090531312779794975454245398856969484704316857659" + "638998506553390969459816219401617281718945106978546710679176" +@@ -3818,35 +3818,35 @@ static const struct test tests[] = { + "337560846003984904972149117463085539556354188641513168478436" + "31308023759629577398300170898437499e-324", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x4p-1076, false, +- 0x4p-1076, false, +- 0x4p-1076, false, +- 0x8p-1076, false, +- false, +- 0x5.fffffffffffffff8p-1076, false, +- 0x6p-1076, false, +- 0x5.fffffffffffffff8p-1076, false, +- 0x6p-1076, false, +- false, +- 0x5.fffffffffffffff8p-1076, false, +- 0x6p-1076, false, +- 0x5.fffffffffffffff8p-1076, false, +- 0x6p-1076, false, +- false, +- 0x4p-1076, false, +- 0x4p-1076, false, +- 0x4p-1076, false, +- 0x8p-1076, false, +- false, +- 0x5.fffffffffffffffffffffffffffcp-1076, false, +- 0x6p-1076, false, +- 0x5.fffffffffffffffffffffffffffcp-1076, false, +- 0x6p-1076, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x4p-1076, false, true, ++ 0x4p-1076, false, true, ++ 0x4p-1076, false, true, ++ 0x8p-1076, false, true, ++ false, ++ 0x5.fffffffffffffff8p-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x5.fffffffffffffff8p-1076, false, false, ++ 0x6p-1076, false, false, ++ false, ++ 0x5.fffffffffffffff8p-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x5.fffffffffffffff8p-1076, false, false, ++ 0x6p-1076, false, false, ++ false, ++ 0x4p-1076, false, true, ++ 0x4p-1076, false, true, ++ 0x4p-1076, false, true, ++ 0x8p-1076, false, true, ++ false, ++ 0x5.fffffffffffffffffffffffffffcp-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x5.fffffffffffffffffffffffffffcp-1076, false, false, ++ 0x6p-1076, false, false), + TEST ("7.4109846876186981626485318930233205854758970392148714663837" + "852375101326090531312779794975454245398856969484704316857659" + "638998506553390969459816219401617281718945106978546710679176" +@@ -3861,35 +3861,35 @@ static const struct test tests[] = { + "337560846003984904972149117463085539556354188641513168478436" + "313080237596295773983001708984375e-324", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x4p-1076, false, +- 0x8p-1076, false, +- 0x4p-1076, false, +- 0x8p-1076, false, +- true, +- 0x6p-1076, false, +- 0x6p-1076, false, +- 0x6p-1076, false, +- 0x6p-1076, false, +- true, +- 0x6p-1076, false, +- 0x6p-1076, false, +- 0x6p-1076, false, +- 0x6p-1076, false, +- false, +- 0x4p-1076, false, +- 0x8p-1076, false, +- 0x4p-1076, false, +- 0x8p-1076, false, +- true, +- 0x6p-1076, false, +- 0x6p-1076, false, +- 0x6p-1076, false, +- 0x6p-1076, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x4p-1076, false, true, ++ 0x8p-1076, false, true, ++ 0x4p-1076, false, true, ++ 0x8p-1076, false, true, ++ true, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false, ++ true, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false, ++ false, ++ 0x4p-1076, false, true, ++ 0x8p-1076, false, true, ++ 0x4p-1076, false, true, ++ 0x8p-1076, false, true, ++ true, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false), + TEST ("7.4109846876186981626485318930233205854758970392148714663837" + "852375101326090531312779794975454245398856969484704316857659" + "638998506553390969459816219401617281718945106978546710679176" +@@ -3904,35 +3904,35 @@ static const struct test tests[] = { + "337560846003984904972149117463085539556354188641513168478436" + "31308023759629577398300170898437501e-324", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x4p-1076, false, +- 0x8p-1076, false, +- 0x4p-1076, false, +- 0x8p-1076, false, +- false, +- 0x6p-1076, false, +- 0x6p-1076, false, +- 0x6p-1076, false, +- 0x6.0000000000000008p-1076, false, +- false, +- 0x6p-1076, false, +- 0x6p-1076, false, +- 0x6p-1076, false, +- 0x6.0000000000000008p-1076, false, +- false, +- 0x4p-1076, false, +- 0x8p-1076, false, +- 0x4p-1076, false, +- 0x8p-1076, false, +- false, +- 0x6p-1076, false, +- 0x6p-1076, false, +- 0x6p-1076, false, +- 0x6.0000000000000000000000000004p-1076, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x4p-1076, false, true, ++ 0x8p-1076, false, true, ++ 0x4p-1076, false, true, ++ 0x8p-1076, false, true, ++ false, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x6.0000000000000008p-1076, false, false, ++ false, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x6.0000000000000008p-1076, false, false, ++ false, ++ 0x4p-1076, false, true, ++ 0x8p-1076, false, true, ++ 0x4p-1076, false, true, ++ 0x8p-1076, false, true, ++ false, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x6p-1076, false, false, ++ 0x6.0000000000000000000000000004p-1076, false, false), + TEST ("-7.410984687618698162648531893023320585475897039214871466383" + "785237510132609053131277979497545424539885696948470431685765" + "963899850655339096945981621940161728171894510697854671067917" +@@ -3947,35 +3947,35 @@ static const struct test tests[] = { + "433756084600398490497214911746308553955635418864151316847843" + "631308023759629577398300170898437499e-324", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-1076, false, +- -0x4p-1076, false, +- -0x4p-1076, false, +- -0x4p-1076, false, +- false, +- -0x6p-1076, false, +- -0x6p-1076, false, +- -0x5.fffffffffffffff8p-1076, false, +- -0x5.fffffffffffffff8p-1076, false, +- false, +- -0x6p-1076, false, +- -0x6p-1076, false, +- -0x5.fffffffffffffff8p-1076, false, +- -0x5.fffffffffffffff8p-1076, false, +- false, +- -0x8p-1076, false, +- -0x4p-1076, false, +- -0x4p-1076, false, +- -0x4p-1076, false, +- false, +- -0x6p-1076, false, +- -0x6p-1076, false, +- -0x5.fffffffffffffffffffffffffffcp-1076, false, +- -0x5.fffffffffffffffffffffffffffcp-1076, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-1076, false, true, ++ -0x4p-1076, false, true, ++ -0x4p-1076, false, true, ++ -0x4p-1076, false, true, ++ false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x5.fffffffffffffff8p-1076, false, false, ++ -0x5.fffffffffffffff8p-1076, false, false, ++ false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x5.fffffffffffffff8p-1076, false, false, ++ -0x5.fffffffffffffff8p-1076, false, false, ++ false, ++ -0x8p-1076, false, true, ++ -0x4p-1076, false, true, ++ -0x4p-1076, false, true, ++ -0x4p-1076, false, true, ++ false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x5.fffffffffffffffffffffffffffcp-1076, false, false, ++ -0x5.fffffffffffffffffffffffffffcp-1076, false, false), + TEST ("-7.410984687618698162648531893023320585475897039214871466383" + "785237510132609053131277979497545424539885696948470431685765" + "963899850655339096945981621940161728171894510697854671067917" +@@ -3990,35 +3990,35 @@ static const struct test tests[] = { + "433756084600398490497214911746308553955635418864151316847843" + "6313080237596295773983001708984375e-324", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-1076, false, +- -0x8p-1076, false, +- -0x4p-1076, false, +- -0x4p-1076, false, +- true, +- -0x6p-1076, false, +- -0x6p-1076, false, +- -0x6p-1076, false, +- -0x6p-1076, false, +- true, +- -0x6p-1076, false, +- -0x6p-1076, false, +- -0x6p-1076, false, +- -0x6p-1076, false, +- false, +- -0x8p-1076, false, +- -0x8p-1076, false, +- -0x4p-1076, false, +- -0x4p-1076, false, +- true, +- -0x6p-1076, false, +- -0x6p-1076, false, +- -0x6p-1076, false, +- -0x6p-1076, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-1076, false, true, ++ -0x8p-1076, false, true, ++ -0x4p-1076, false, true, ++ -0x4p-1076, false, true, ++ true, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ true, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ false, ++ -0x8p-1076, false, true, ++ -0x8p-1076, false, true, ++ -0x4p-1076, false, true, ++ -0x4p-1076, false, true, ++ true, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false), + TEST ("-7.410984687618698162648531893023320585475897039214871466383" + "785237510132609053131277979497545424539885696948470431685765" + "963899850655339096945981621940161728171894510697854671067917" +@@ -4033,35 +4033,35 @@ static const struct test tests[] = { + "433756084600398490497214911746308553955635418864151316847843" + "631308023759629577398300170898437501e-324", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-1076, false, +- -0x8p-1076, false, +- -0x4p-1076, false, +- -0x4p-1076, false, +- false, +- -0x6.0000000000000008p-1076, false, +- -0x6p-1076, false, +- -0x6p-1076, false, +- -0x6p-1076, false, +- false, +- -0x6.0000000000000008p-1076, false, +- -0x6p-1076, false, +- -0x6p-1076, false, +- -0x6p-1076, false, +- false, +- -0x8p-1076, false, +- -0x8p-1076, false, +- -0x4p-1076, false, +- -0x4p-1076, false, +- false, +- -0x6.0000000000000000000000000004p-1076, false, +- -0x6p-1076, false, +- -0x6p-1076, false, +- -0x6p-1076, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-1076, false, true, ++ -0x8p-1076, false, true, ++ -0x4p-1076, false, true, ++ -0x4p-1076, false, true, ++ false, ++ -0x6.0000000000000008p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ false, ++ -0x6.0000000000000008p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ false, ++ -0x8p-1076, false, true, ++ -0x8p-1076, false, true, ++ -0x4p-1076, false, true, ++ -0x4p-1076, false, true, ++ false, ++ -0x6.0000000000000000000000000004p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false, ++ -0x6p-1076, false, false), + TEST ("5.4677992978237119037926089004291297245985762235403450155814" + "707305425575329500966052143410629387408077958710210208052966" + "529504784489330482549602621133847135082257338717668975178538" +@@ -4255,35 +4255,35 @@ static const struct test tests[] = { + "866268925981702690270202829595794350800918257913991744455922" + "683343374046671669930219650268554687499e-4951", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x8p-16448, false, +- 0x8p-16448, false, +- 0x8p-16448, false, +- 0x1p-16444, false, +- false, +- 0x8p-16448, false, +- 0xcp-16448, false, +- 0x8p-16448, false, +- 0xcp-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0xb.fffffffffffcp-16448, false, +- 0xcp-16448, false, +- 0xb.fffffffffffcp-16448, false, +- 0xcp-16448, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x8p-16448, false, true, ++ 0x8p-16448, false, true, ++ 0x8p-16448, false, true, ++ 0x1p-16444, false, true, ++ false, ++ 0x8p-16448, false, true, ++ 0xcp-16448, false, true, ++ 0x8p-16448, false, true, ++ 0xcp-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0xb.fffffffffffcp-16448, false, true, ++ 0xcp-16448, false, true, ++ 0xb.fffffffffffcp-16448, false, true, ++ 0xcp-16448, false, true), + TEST ("5.4677992978237119037926089004291297245985762235403450155814" + "707305425575329500966052143410629387408077958710210208052966" + "529504784489330482549602621133847135082257338717668975178538" +@@ -4477,35 +4477,35 @@ static const struct test tests[] = { + "866268925981702690270202829595794350800918257913991744455922" + "6833433740466716699302196502685546875e-4951", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x8p-16448, false, +- 0x1p-16444, false, +- 0x8p-16448, false, +- 0x1p-16444, false, +- true, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0xcp-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- true, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0xcp-16448, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x8p-16448, false, true, ++ 0x1p-16444, false, true, ++ 0x8p-16448, false, true, ++ 0x1p-16444, false, true, ++ true, ++ 0xcp-16448, false, false, ++ 0xcp-16448, false, false, ++ 0xcp-16448, false, false, ++ 0xcp-16448, false, false, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ true, ++ 0xcp-16448, false, false, ++ 0xcp-16448, false, false, ++ 0xcp-16448, false, false, ++ 0xcp-16448, false, false), + TEST ("5.4677992978237119037926089004291297245985762235403450155814" + "707305425575329500966052143410629387408077958710210208052966" + "529504784489330482549602621133847135082257338717668975178538" +@@ -4699,35 +4699,35 @@ static const struct test tests[] = { + "866268925981702690270202829595794350800918257913991744455922" + "683343374046671669930219650268554687501e-4951", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x8p-16448, false, +- 0x1p-16444, false, +- 0x8p-16448, false, +- 0x1p-16444, false, +- false, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0x1p-16444, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0xc.000000000004p-16448, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x8p-16448, false, true, ++ 0x1p-16444, false, true, ++ 0x8p-16448, false, true, ++ 0x1p-16444, false, true, ++ false, ++ 0xcp-16448, false, true, ++ 0xcp-16448, false, true, ++ 0xcp-16448, false, true, ++ 0x1p-16444, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0xcp-16448, false, true, ++ 0xcp-16448, false, true, ++ 0xcp-16448, false, true, ++ 0xc.000000000004p-16448, false, true), + TEST ("-5.467799297823711903792608900429129724598576223540345015581" + "470730542557532950096605214341062938740807795871021020805296" + "652950478448933048254960262113384713508225733871766897517853" +@@ -4921,35 +4921,35 @@ static const struct test tests[] = { + "386626892598170269027020282959579435080091825791399174445592" + "2683343374046671669930219650268554687499e-4951", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x1p-16444, false, +- -0x8p-16448, false, +- -0x8p-16448, false, +- -0x8p-16448, false, +- false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0x8p-16448, false, +- -0x8p-16448, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0xb.fffffffffffcp-16448, false, +- -0xb.fffffffffffcp-16448, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x1p-16444, false, true, ++ -0x8p-16448, false, true, ++ -0x8p-16448, false, true, ++ -0x8p-16448, false, true, ++ false, ++ -0xcp-16448, false, true, ++ -0xcp-16448, false, true, ++ -0x8p-16448, false, true, ++ -0x8p-16448, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0xcp-16448, false, true, ++ -0xcp-16448, false, true, ++ -0xb.fffffffffffcp-16448, false, true, ++ -0xb.fffffffffffcp-16448, false, true), + TEST ("-5.467799297823711903792608900429129724598576223540345015581" + "470730542557532950096605214341062938740807795871021020805296" + "652950478448933048254960262113384713508225733871766897517853" +@@ -5143,35 +5143,35 @@ static const struct test tests[] = { + "386626892598170269027020282959579435080091825791399174445592" + "26833433740466716699302196502685546875e-4951", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x1p-16444, false, +- -0x1p-16444, false, +- -0x8p-16448, false, +- -0x8p-16448, false, +- true, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0xcp-16448, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x1p-16444, false, true, ++ -0x1p-16444, false, true, ++ -0x8p-16448, false, true, ++ -0x8p-16448, false, true, ++ true, ++ -0xcp-16448, false, false, ++ -0xcp-16448, false, false, ++ -0xcp-16448, false, false, ++ -0xcp-16448, false, false, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0xcp-16448, false, false, ++ -0xcp-16448, false, false, ++ -0xcp-16448, false, false, ++ -0xcp-16448, false, false), + TEST ("-5.467799297823711903792608900429129724598576223540345015581" + "470730542557532950096605214341062938740807795871021020805296" + "652950478448933048254960262113384713508225733871766897517853" +@@ -5365,35 +5365,35 @@ static const struct test tests[] = { + "386626892598170269027020282959579435080091825791399174445592" + "2683343374046671669930219650268554687501e-4951", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x1p-16444, false, +- -0x1p-16444, false, +- -0x8p-16448, false, +- -0x8p-16448, false, +- false, +- -0x1p-16444, false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0xc.000000000004p-16448, false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0xcp-16448, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x1p-16444, false, true, ++ -0x1p-16444, false, true, ++ -0x8p-16448, false, true, ++ -0x8p-16448, false, true, ++ false, ++ -0x1p-16444, false, true, ++ -0xcp-16448, false, true, ++ -0xcp-16448, false, true, ++ -0xcp-16448, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0xc.000000000004p-16448, false, true, ++ -0xcp-16448, false, true, ++ -0xcp-16448, false, true, ++ -0xcp-16448, false, true), + TEST ("5.4677992978237119037926089004291297245985762235403450155814" + "707305425575329500966052143410629387408077958710210208052966" + "529504784489330482549602621133847135082257338717668975178538" +@@ -5587,35 +5587,35 @@ static const struct test tests[] = { + "866268925981702690270202829595794350800918257913991744455922" + "683343374046671669930219650268554687499e-4951", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x8p-16448, false, +- 0x8p-16448, false, +- 0x8p-16448, false, +- 0x1p-16444, false, +- false, +- 0x8p-16448, false, +- 0xcp-16448, false, +- 0x8p-16448, false, +- 0xcp-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0xb.fffffffffffcp-16448, false, +- 0xcp-16448, false, +- 0xb.fffffffffffcp-16448, false, +- 0xcp-16448, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x8p-16448, false, true, ++ 0x8p-16448, false, true, ++ 0x8p-16448, false, true, ++ 0x1p-16444, false, true, ++ false, ++ 0x8p-16448, false, true, ++ 0xcp-16448, false, true, ++ 0x8p-16448, false, true, ++ 0xcp-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0xb.fffffffffffcp-16448, false, true, ++ 0xcp-16448, false, true, ++ 0xb.fffffffffffcp-16448, false, true, ++ 0xcp-16448, false, true), + TEST ("5.4677992978237119037926089004291297245985762235403450155814" + "707305425575329500966052143410629387408077958710210208052966" + "529504784489330482549602621133847135082257338717668975178538" +@@ -5809,35 +5809,35 @@ static const struct test tests[] = { + "866268925981702690270202829595794350800918257913991744455922" + "6833433740466716699302196502685546875e-4951", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x8p-16448, false, +- 0x1p-16444, false, +- 0x8p-16448, false, +- 0x1p-16444, false, +- true, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0xcp-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- true, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0xcp-16448, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x8p-16448, false, true, ++ 0x1p-16444, false, true, ++ 0x8p-16448, false, true, ++ 0x1p-16444, false, true, ++ true, ++ 0xcp-16448, false, false, ++ 0xcp-16448, false, false, ++ 0xcp-16448, false, false, ++ 0xcp-16448, false, false, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ true, ++ 0xcp-16448, false, false, ++ 0xcp-16448, false, false, ++ 0xcp-16448, false, false, ++ 0xcp-16448, false, false), + TEST ("5.4677992978237119037926089004291297245985762235403450155814" + "707305425575329500966052143410629387408077958710210208052966" + "529504784489330482549602621133847135082257338717668975178538" +@@ -6031,35 +6031,35 @@ static const struct test tests[] = { + "866268925981702690270202829595794350800918257913991744455922" + "683343374046671669930219650268554687501e-4951", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x8p-16448, false, +- 0x1p-16444, false, +- 0x8p-16448, false, +- 0x1p-16444, false, +- false, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0x1p-16444, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0xcp-16448, false, +- 0xc.000000000004p-16448, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x8p-16448, false, true, ++ 0x1p-16444, false, true, ++ 0x8p-16448, false, true, ++ 0x1p-16444, false, true, ++ false, ++ 0xcp-16448, false, true, ++ 0xcp-16448, false, true, ++ 0xcp-16448, false, true, ++ 0x1p-16444, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0xcp-16448, false, true, ++ 0xcp-16448, false, true, ++ 0xcp-16448, false, true, ++ 0xc.000000000004p-16448, false, true), + TEST ("-5.467799297823711903792608900429129724598576223540345015581" + "470730542557532950096605214341062938740807795871021020805296" + "652950478448933048254960262113384713508225733871766897517853" +@@ -6253,35 +6253,35 @@ static const struct test tests[] = { + "386626892598170269027020282959579435080091825791399174445592" + "2683343374046671669930219650268554687499e-4951", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x1p-16444, false, +- -0x8p-16448, false, +- -0x8p-16448, false, +- -0x8p-16448, false, +- false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0x8p-16448, false, +- -0x8p-16448, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0xb.fffffffffffcp-16448, false, +- -0xb.fffffffffffcp-16448, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x1p-16444, false, true, ++ -0x8p-16448, false, true, ++ -0x8p-16448, false, true, ++ -0x8p-16448, false, true, ++ false, ++ -0xcp-16448, false, true, ++ -0xcp-16448, false, true, ++ -0x8p-16448, false, true, ++ -0x8p-16448, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0xcp-16448, false, true, ++ -0xcp-16448, false, true, ++ -0xb.fffffffffffcp-16448, false, true, ++ -0xb.fffffffffffcp-16448, false, true), + TEST ("-5.467799297823711903792608900429129724598576223540345015581" + "470730542557532950096605214341062938740807795871021020805296" + "652950478448933048254960262113384713508225733871766897517853" +@@ -6475,35 +6475,35 @@ static const struct test tests[] = { + "386626892598170269027020282959579435080091825791399174445592" + "26833433740466716699302196502685546875e-4951", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x1p-16444, false, +- -0x1p-16444, false, +- -0x8p-16448, false, +- -0x8p-16448, false, +- true, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0xcp-16448, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x1p-16444, false, true, ++ -0x1p-16444, false, true, ++ -0x8p-16448, false, true, ++ -0x8p-16448, false, true, ++ true, ++ -0xcp-16448, false, false, ++ -0xcp-16448, false, false, ++ -0xcp-16448, false, false, ++ -0xcp-16448, false, false, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0xcp-16448, false, false, ++ -0xcp-16448, false, false, ++ -0xcp-16448, false, false, ++ -0xcp-16448, false, false), + TEST ("-5.467799297823711903792608900429129724598576223540345015581" + "470730542557532950096605214341062938740807795871021020805296" + "652950478448933048254960262113384713508225733871766897517853" +@@ -6697,630 +6697,630 @@ static const struct test tests[] = { + "386626892598170269027020282959579435080091825791399174445592" + "2683343374046671669930219650268554687501e-4951", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x1p-16444, false, +- -0x1p-16444, false, +- -0x8p-16448, false, +- -0x8p-16448, false, +- false, +- -0x1p-16444, false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0xc.000000000004p-16448, false, +- -0xcp-16448, false, +- -0xcp-16448, false, +- -0xcp-16448, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x1p-16444, false, true, ++ -0x1p-16444, false, true, ++ -0x8p-16448, false, true, ++ -0x8p-16448, false, true, ++ false, ++ -0x1p-16444, false, true, ++ -0xcp-16448, false, true, ++ -0xcp-16448, false, true, ++ -0xcp-16448, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0xc.000000000004p-16448, false, true, ++ -0xcp-16448, false, true, ++ -0xcp-16448, false, true, ++ -0xcp-16448, false, true), + TEST ("-0x0.7p-149", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x3.8p-152, false, +- -0x3.8p-152, false, +- -0x3.8p-152, false, +- -0x3.8p-152, false, +- true, +- -0x3.8p-152, false, +- -0x3.8p-152, false, +- -0x3.8p-152, false, +- -0x3.8p-152, false, +- true, +- -0x3.8p-152, false, +- -0x3.8p-152, false, +- -0x3.8p-152, false, +- -0x3.8p-152, false, +- true, +- -0x3.8p-152, false, +- -0x3.8p-152, false, +- -0x3.8p-152, false, +- -0x3.8p-152, false, +- true, +- -0x3.8p-152, false, +- -0x3.8p-152, false, +- -0x3.8p-152, false, +- -0x3.8p-152, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false, ++ true, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false, ++ true, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false, ++ true, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false, ++ true, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false, ++ -0x3.8p-152, false, false), + TEST ("-0x0.7p-1074", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x1.cp-1076, false, +- -0x1.cp-1076, false, +- -0x1.cp-1076, false, +- -0x1.cp-1076, false, +- true, +- -0x1.cp-1076, false, +- -0x1.cp-1076, false, +- -0x1.cp-1076, false, +- -0x1.cp-1076, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x1.cp-1076, false, +- -0x1.cp-1076, false, +- -0x1.cp-1076, false, +- -0x1.cp-1076, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x1.cp-1076, false, false, ++ -0x1.cp-1076, false, false, ++ -0x1.cp-1076, false, false, ++ -0x1.cp-1076, false, false, ++ true, ++ -0x1.cp-1076, false, false, ++ -0x1.cp-1076, false, false, ++ -0x1.cp-1076, false, false, ++ -0x1.cp-1076, false, false, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x1.cp-1076, false, false, ++ -0x1.cp-1076, false, false, ++ -0x1.cp-1076, false, false, ++ -0x1.cp-1076, false, false), + TEST ("-0x0.7p-16445", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16448, false, +- -0x4p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x3.8p-16448, false, +- -0x3.8p-16448, false, +- -0x3.8p-16448, false, +- -0x3.8p-16448, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16448, false, true, ++ -0x4p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x3.8p-16448, false, false, ++ -0x3.8p-16448, false, false, ++ -0x3.8p-16448, false, false, ++ -0x3.8p-16448, false, false), + TEST ("-0x0.7p-16494", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16496, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16496, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true), + TEST ("0x1p-150", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- true, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- true, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- true, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- true, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- true, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ true, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ true, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ true, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ true, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ true, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false), + TEST ("0x1p-1075", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- true, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- true, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- true, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ true, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ true, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ true, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false), + TEST ("0x1p-16446", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-16448, false, +- true, +- 0x4p-16448, false, +- 0x4p-16448, false, +- 0x4p-16448, false, +- 0x4p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- true, +- 0x4p-16448, false, +- 0x4p-16448, false, +- 0x4p-16448, false, +- 0x4p-16448, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-16448, false, true, ++ true, ++ 0x4p-16448, false, false, ++ 0x4p-16448, false, false, ++ 0x4p-16448, false, false, ++ 0x4p-16448, false, false, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ true, ++ 0x4p-16448, false, false, ++ 0x4p-16448, false, false, ++ 0x4p-16448, false, false, ++ 0x4p-16448, false, false), + TEST ("0x1p-16495", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-16496, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-16496, false, true), + TEST ("-0x1p-150", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- true, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- true, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- true, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- true, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ true, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ true, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ true, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ true, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false), + TEST ("-0x1p-1075", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- true, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ true, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false), + TEST ("-0x1p-16446", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x4p-16448, false, +- -0x4p-16448, false, +- -0x4p-16448, false, +- -0x4p-16448, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x4p-16448, false, +- -0x4p-16448, false, +- -0x4p-16448, false, +- -0x4p-16448, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x4p-16448, false, false, ++ -0x4p-16448, false, false, ++ -0x4p-16448, false, false, ++ -0x4p-16448, false, false, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x4p-16448, false, false, ++ -0x4p-16448, false, false, ++ -0x4p-16448, false, false, ++ -0x4p-16448, false, false), + TEST ("-0x1p-16495", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16496, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16496, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true), + TEST (".70064923216240853546186479164495807e-45", + false, +- 0x0p+0, false, +- 0x8p-152, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4.0000000000004p-152, false, +- false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4.0000000000000008p-152, false, +- false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4.0000000000000008p-152, false, +- false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4.00000000000000000000000002p-152, false, +- false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4.0000000000000000000000000004p-152, false), ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4.0000000000004p-152, false, false, ++ false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4.0000000000000008p-152, false, false, ++ false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4.0000000000000008p-152, false, false, ++ false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4.00000000000000000000000002p-152, false, false, ++ false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4.0000000000000000000000000004p-152, false, false), + TEST ("7.0064923216240853546186479164495806564013097093825788587853" + "4141944895541342930300743319094181060791015624e-46", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x3.ffffffffffffep-152, false, +- 0x4p-152, false, +- 0x3.ffffffffffffep-152, false, +- 0x4p-152, false, +- false, +- 0x3.fffffffffffffffcp-152, false, +- 0x4p-152, false, +- 0x3.fffffffffffffffcp-152, false, +- 0x4p-152, false, +- false, +- 0x3.fffffffffffffffcp-152, false, +- 0x4p-152, false, +- 0x3.fffffffffffffffcp-152, false, +- 0x4p-152, false, +- false, +- 0x3.ffffffffffffffffffffffffffp-152, false, +- 0x4p-152, false, +- 0x3.ffffffffffffffffffffffffffp-152, false, +- 0x4p-152, false, +- false, +- 0x3.fffffffffffffffffffffffffffep-152, false, +- 0x4p-152, false, +- 0x3.fffffffffffffffffffffffffffep-152, false, +- 0x4p-152, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x3.ffffffffffffep-152, false, false, ++ 0x4p-152, false, false, ++ 0x3.ffffffffffffep-152, false, false, ++ 0x4p-152, false, false, ++ false, ++ 0x3.fffffffffffffffcp-152, false, false, ++ 0x4p-152, false, false, ++ 0x3.fffffffffffffffcp-152, false, false, ++ 0x4p-152, false, false, ++ false, ++ 0x3.fffffffffffffffcp-152, false, false, ++ 0x4p-152, false, false, ++ 0x3.fffffffffffffffcp-152, false, false, ++ 0x4p-152, false, false, ++ false, ++ 0x3.ffffffffffffffffffffffffffp-152, false, false, ++ 0x4p-152, false, false, ++ 0x3.ffffffffffffffffffffffffffp-152, false, false, ++ 0x4p-152, false, false, ++ false, ++ 0x3.fffffffffffffffffffffffffffep-152, false, false, ++ 0x4p-152, false, false, ++ 0x3.fffffffffffffffffffffffffffep-152, false, false, ++ 0x4p-152, false, false), + TEST ("7.0064923216240853546186479164495806564013097093825788587853" + "4141944895541342930300743319094181060791015625e-46", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- true, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- true, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- true, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- true, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- true, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ true, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ true, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ true, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ true, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ true, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false), + TEST ("7.0064923216240853546186479164495806564013097093825788587853" + "4141944895541342930300743319094181060791015626e-46", + false, +- 0x0p+0, false, +- 0x8p-152, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4.0000000000004p-152, false, +- false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4.0000000000000008p-152, false, +- false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4.0000000000000008p-152, false, +- false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4.00000000000000000000000002p-152, false, +- false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4p-152, false, +- 0x4.0000000000000000000000000004p-152, false), ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4.0000000000004p-152, false, false, ++ false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4.0000000000000008p-152, false, false, ++ false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4.0000000000000008p-152, false, false, ++ false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4.00000000000000000000000002p-152, false, false, ++ false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4p-152, false, false, ++ 0x4.0000000000000000000000000004p-152, false, false), + TEST ("-7.006492321624085354618647916449580656401309709382578858785" + "34141944895541342930300743319094181060791015624e-46", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x3.ffffffffffffep-152, false, +- -0x3.ffffffffffffep-152, false, +- false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x3.fffffffffffffffcp-152, false, +- -0x3.fffffffffffffffcp-152, false, +- false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x3.fffffffffffffffcp-152, false, +- -0x3.fffffffffffffffcp-152, false, +- false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x3.ffffffffffffffffffffffffffp-152, false, +- -0x3.ffffffffffffffffffffffffffp-152, false, +- false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x3.fffffffffffffffffffffffffffep-152, false, +- -0x3.fffffffffffffffffffffffffffep-152, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x3.ffffffffffffep-152, false, false, ++ -0x3.ffffffffffffep-152, false, false, ++ false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x3.fffffffffffffffcp-152, false, false, ++ -0x3.fffffffffffffffcp-152, false, false, ++ false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x3.fffffffffffffffcp-152, false, false, ++ -0x3.fffffffffffffffcp-152, false, false, ++ false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x3.ffffffffffffffffffffffffffp-152, false, false, ++ -0x3.ffffffffffffffffffffffffffp-152, false, false, ++ false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x3.fffffffffffffffffffffffffffep-152, false, false, ++ -0x3.fffffffffffffffffffffffffffep-152, false, false), + TEST ("-7.006492321624085354618647916449580656401309709382578858785" + "34141944895541342930300743319094181060791015625e-46", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- true, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- true, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- true, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- true, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ true, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ true, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ true, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ true, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false), + TEST ("-7.006492321624085354618647916449580656401309709382578858785" + "34141944895541342930300743319094181060791015626e-46", + false, +- -0x8p-152, false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4.0000000000004p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- false, +- -0x4.0000000000000008p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- false, +- -0x4.0000000000000008p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- false, +- -0x4.00000000000000000000000002p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- false, +- -0x4.0000000000000000000000000004p-152, false, +- -0x4p-152, false, +- -0x4p-152, false, +- -0x4p-152, false), ++ -0x8p-152, false, true, ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4.0000000000004p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ false, ++ -0x4.0000000000000008p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ false, ++ -0x4.0000000000000008p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ false, ++ -0x4.00000000000000000000000002p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ false, ++ -0x4.0000000000000000000000000004p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false, ++ -0x4p-152, false, false), + TEST ("2.4703282292062327208828439643411068618252990130716238221279" + "284125033775363510437593264991818081799618989828234772285886" + "546332835517796989819938739800539093906315035659515570226392" +@@ -7335,35 +7335,35 @@ static const struct test tests[] = { + "779186948667994968324049705821028513185451396213837722826145" + "437693412532098591327667236328124e-324", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x1.fffffffffffffffep-1076, false, +- 0x2p-1076, false, +- 0x1.fffffffffffffffep-1076, false, +- 0x2p-1076, false, +- false, +- 0x1.fffffffffffffffep-1076, false, +- 0x2p-1076, false, +- 0x1.fffffffffffffffep-1076, false, +- 0x2p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x1.ffffffffffffffffffffffffffffp-1076, false, +- 0x2p-1076, false, +- 0x1.ffffffffffffffffffffffffffffp-1076, false, +- 0x2p-1076, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x1.fffffffffffffffep-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x1.fffffffffffffffep-1076, false, false, ++ 0x2p-1076, false, false, ++ false, ++ 0x1.fffffffffffffffep-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x1.fffffffffffffffep-1076, false, false, ++ 0x2p-1076, false, false, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x1.ffffffffffffffffffffffffffffp-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x1.ffffffffffffffffffffffffffffp-1076, false, false, ++ 0x2p-1076, false, false), + TEST ("2.4703282292062327208828439643411068618252990130716238221279" + "284125033775363510437593264991818081799618989828234772285886" + "546332835517796989819938739800539093906315035659515570226392" +@@ -7378,35 +7378,35 @@ static const struct test tests[] = { + "779186948667994968324049705821028513185451396213837722826145" + "437693412532098591327667236328125e-324", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- true, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- true, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- true, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ true, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ true, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ true, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false), + TEST ("2.4703282292062327208828439643411068618252990130716238221279" + "284125033775363510437593264991818081799618989828234772285886" + "546332835517796989819938739800539093906315035659515570226392" +@@ -7421,35 +7421,35 @@ static const struct test tests[] = { + "779186948667994968324049705821028513185451396213837722826145" + "437693412532098591327667236328126e-324", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x4p-1076, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2.0000000000000004p-1076, false, +- false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2.0000000000000004p-1076, false, +- false, +- 0x0p+0, false, +- 0x4p-1076, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2p-1076, false, +- 0x2.0000000000000000000000000002p-1076, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2.0000000000000004p-1076, false, false, ++ false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2.0000000000000004p-1076, false, false, ++ false, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2p-1076, false, false, ++ 0x2.0000000000000000000000000002p-1076, false, false), + TEST ("-2.470328229206232720882843964341106861825299013071623822127" + "928412503377536351043759326499181808179961898982823477228588" + "654633283551779698981993873980053909390631503565951557022639" +@@ -7464,35 +7464,35 @@ static const struct test tests[] = { + "477918694866799496832404970582102851318545139621383772282614" + "5437693412532098591327667236328124e-324", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x1.fffffffffffffffep-1076, false, +- -0x1.fffffffffffffffep-1076, false, +- false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x1.fffffffffffffffep-1076, false, +- -0x1.fffffffffffffffep-1076, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x1.ffffffffffffffffffffffffffffp-1076, false, +- -0x1.ffffffffffffffffffffffffffffp-1076, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x1.fffffffffffffffep-1076, false, false, ++ -0x1.fffffffffffffffep-1076, false, false, ++ false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x1.fffffffffffffffep-1076, false, false, ++ -0x1.fffffffffffffffep-1076, false, false, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x1.ffffffffffffffffffffffffffffp-1076, false, false, ++ -0x1.ffffffffffffffffffffffffffffp-1076, false, false), + TEST ("-2.470328229206232720882843964341106861825299013071623822127" + "928412503377536351043759326499181808179961898982823477228588" + "654633283551779698981993873980053909390631503565951557022639" +@@ -7507,35 +7507,35 @@ static const struct test tests[] = { + "477918694866799496832404970582102851318545139621383772282614" + "5437693412532098591327667236328125e-324", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- true, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ true, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false), + TEST ("-2.470328229206232720882843964341106861825299013071623822127" + "928412503377536351043759326499181808179961898982823477228588" + "654633283551779698981993873980053909390631503565951557022639" +@@ -7550,35 +7550,35 @@ static const struct test tests[] = { + "477918694866799496832404970582102851318545139621383772282614" + "5437693412532098591327667236328126e-324", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x2.0000000000000004p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- false, +- -0x2.0000000000000004p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- false, +- -0x4p-1076, false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x2.0000000000000000000000000002p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false, +- -0x2p-1076, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x2.0000000000000004p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ false, ++ -0x2.0000000000000004p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ false, ++ -0x4p-1076, false, true, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x2.0000000000000000000000000002p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false, ++ -0x2p-1076, false, false), + TEST ("1.8225997659412373012642029668097099081995254078467816718604" + "902435141858443166988684047803543129136025986236736736017655" + "509834928163110160849867540377949045027419112905889658392846" +@@ -7772,35 +7772,35 @@ static const struct test tests[] = { + "622089641993900896756734276531931450266972752637997248151974" + "2277811246822238899767398834228515624e-4951", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-16448, false, +- false, +- 0x0p+0, false, +- 0x4p-16448, false, +- 0x0p+0, false, +- 0x4p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x3.fffffffffffcp-16448, false, +- 0x4p-16448, false, +- 0x3.fffffffffffcp-16448, false, +- 0x4p-16448, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x4p-16448, false, true, ++ 0x0p+0, false, true, ++ 0x4p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x3.fffffffffffcp-16448, false, true, ++ 0x4p-16448, false, true, ++ 0x3.fffffffffffcp-16448, false, true, ++ 0x4p-16448, false, true), + TEST ("1.8225997659412373012642029668097099081995254078467816718604" + "902435141858443166988684047803543129136025986236736736017655" + "509834928163110160849867540377949045027419112905889658392846" +@@ -7994,35 +7994,35 @@ static const struct test tests[] = { + "622089641993900896756734276531931450266972752637997248151974" + "2277811246822238899767398834228515625e-4951", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-16448, false, +- true, +- 0x4p-16448, false, +- 0x4p-16448, false, +- 0x4p-16448, false, +- 0x4p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- true, +- 0x4p-16448, false, +- 0x4p-16448, false, +- 0x4p-16448, false, +- 0x4p-16448, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-16448, false, true, ++ true, ++ 0x4p-16448, false, false, ++ 0x4p-16448, false, false, ++ 0x4p-16448, false, false, ++ 0x4p-16448, false, false, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ true, ++ 0x4p-16448, false, false, ++ 0x4p-16448, false, false, ++ 0x4p-16448, false, false, ++ 0x4p-16448, false, false), + TEST ("1.8225997659412373012642029668097099081995254078467816718604" + "902435141858443166988684047803543129136025986236736736017655" + "509834928163110160849867540377949045027419112905889658392846" +@@ -8216,35 +8216,35 @@ static const struct test tests[] = { + "622089641993900896756734276531931450266972752637997248151974" + "2277811246822238899767398834228515626e-4951", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x8p-16448, false, +- 0x0p+0, false, +- 0x8p-16448, false, +- false, +- 0x4p-16448, false, +- 0x4p-16448, false, +- 0x4p-16448, false, +- 0x8p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x4p-16448, false, +- 0x4p-16448, false, +- 0x4p-16448, false, +- 0x4.000000000004p-16448, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x8p-16448, false, true, ++ 0x0p+0, false, true, ++ 0x8p-16448, false, true, ++ false, ++ 0x4p-16448, false, true, ++ 0x4p-16448, false, true, ++ 0x4p-16448, false, true, ++ 0x8p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x4p-16448, false, true, ++ 0x4p-16448, false, true, ++ 0x4p-16448, false, true, ++ 0x4.000000000004p-16448, false, true), + TEST ("-1.822599765941237301264202966809709908199525407846781671860" + "490243514185844316698868404780354312913602598623673673601765" + "550983492816311016084986754037794904502741911290588965839284" +@@ -8438,35 +8438,35 @@ static const struct test tests[] = { + "462208964199390089675673427653193145026697275263799724815197" + "42277811246822238899767398834228515624e-4951", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16448, false, +- -0x4p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16448, false, +- -0x4p-16448, false, +- -0x3.fffffffffffcp-16448, false, +- -0x3.fffffffffffcp-16448, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16448, false, true, ++ -0x4p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16448, false, true, ++ -0x4p-16448, false, true, ++ -0x3.fffffffffffcp-16448, false, true, ++ -0x3.fffffffffffcp-16448, false, true), + TEST ("-1.822599765941237301264202966809709908199525407846781671860" + "490243514185844316698868404780354312913602598623673673601765" + "550983492816311016084986754037794904502741911290588965839284" +@@ -8660,35 +8660,35 @@ static const struct test tests[] = { + "462208964199390089675673427653193145026697275263799724815197" + "42277811246822238899767398834228515625e-4951", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x4p-16448, false, +- -0x4p-16448, false, +- -0x4p-16448, false, +- -0x4p-16448, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x4p-16448, false, +- -0x4p-16448, false, +- -0x4p-16448, false, +- -0x4p-16448, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x4p-16448, false, false, ++ -0x4p-16448, false, false, ++ -0x4p-16448, false, false, ++ -0x4p-16448, false, false, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x4p-16448, false, false, ++ -0x4p-16448, false, false, ++ -0x4p-16448, false, false, ++ -0x4p-16448, false, false), + TEST ("-1.822599765941237301264202966809709908199525407846781671860" + "490243514185844316698868404780354312913602598623673673601765" + "550983492816311016084986754037794904502741911290588965839284" +@@ -8882,35 +8882,35 @@ static const struct test tests[] = { + "462208964199390089675673427653193145026697275263799724815197" + "42277811246822238899767398834228515626e-4951", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-16448, false, +- -0x8p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-16448, false, +- -0x4p-16448, false, +- -0x4p-16448, false, +- -0x4p-16448, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4.000000000004p-16448, false, +- -0x4p-16448, false, +- -0x4p-16448, false, +- -0x4p-16448, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-16448, false, true, ++ -0x8p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-16448, false, true, ++ -0x4p-16448, false, true, ++ -0x4p-16448, false, true, ++ -0x4p-16448, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4.000000000004p-16448, false, true, ++ -0x4p-16448, false, true, ++ -0x4p-16448, false, true, ++ -0x4p-16448, false, true), + TEST ("9.1129988297061865063210148340485495409976270392339083593024" + "512175709292215834943420239017715645680129931183683680088277" + "549174640815550804249337701889745225137095564529448291964230" +@@ -9104,35 +9104,35 @@ static const struct test tests[] = { + "110448209969504483783671382659657251334863763189986240759871" + "1389056234111194498836994171142578124e-4952", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x1.fffffffffffcp-16448, false, +- 0x2p-16448, false, +- 0x1.fffffffffffcp-16448, false, +- 0x2p-16448, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x1.fffffffffffcp-16448, false, true, ++ 0x2p-16448, false, true, ++ 0x1.fffffffffffcp-16448, false, true, ++ 0x2p-16448, false, true), + TEST ("9.1129988297061865063210148340485495409976270392339083593024" + "512175709292215834943420239017715645680129931183683680088277" + "549174640815550804249337701889745225137095564529448291964230" +@@ -9326,35 +9326,35 @@ static const struct test tests[] = { + "110448209969504483783671382659657251334863763189986240759871" + "1389056234111194498836994171142578125e-4952", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- true, +- 0x2p-16448, false, +- 0x2p-16448, false, +- 0x2p-16448, false, +- 0x2p-16448, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ true, ++ 0x2p-16448, false, false, ++ 0x2p-16448, false, false, ++ 0x2p-16448, false, false, ++ 0x2p-16448, false, false), + TEST ("9.1129988297061865063210148340485495409976270392339083593024" + "512175709292215834943420239017715645680129931183683680088277" + "549174640815550804249337701889745225137095564529448291964230" +@@ -9548,35 +9548,35 @@ static const struct test tests[] = { + "110448209969504483783671382659657251334863763189986240759871" + "1389056234111194498836994171142578126e-4952", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-16448, false, +- false, +- 0x0p+0, false, +- 0x4p-16448, false, +- 0x0p+0, false, +- 0x4p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x2p-16448, false, +- 0x2p-16448, false, +- 0x2p-16448, false, +- 0x2.000000000004p-16448, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x4p-16448, false, true, ++ 0x0p+0, false, true, ++ 0x4p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x2p-16448, false, true, ++ 0x2p-16448, false, true, ++ 0x2p-16448, false, true, ++ 0x2.000000000004p-16448, false, true), + TEST ("-9.112998829706186506321014834048549540997627039233908359302" + "451217570929221583494342023901771564568012993118368368008827" + "754917464081555080424933770188974522513709556452944829196423" +@@ -9770,35 +9770,35 @@ static const struct test tests[] = { + "311044820996950448378367138265965725133486376318998624075987" + "11389056234111194498836994171142578124e-4952", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x2p-16448, false, +- -0x2p-16448, false, +- -0x1.fffffffffffcp-16448, false, +- -0x1.fffffffffffcp-16448, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x2p-16448, false, true, ++ -0x2p-16448, false, true, ++ -0x1.fffffffffffcp-16448, false, true, ++ -0x1.fffffffffffcp-16448, false, true), + TEST ("-9.112998829706186506321014834048549540997627039233908359302" + "451217570929221583494342023901771564568012993118368368008827" + "754917464081555080424933770188974522513709556452944829196423" +@@ -9992,35 +9992,35 @@ static const struct test tests[] = { + "311044820996950448378367138265965725133486376318998624075987" + "11389056234111194498836994171142578125e-4952", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- true, +- -0x2p-16448, false, +- -0x2p-16448, false, +- -0x2p-16448, false, +- -0x2p-16448, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ true, ++ -0x2p-16448, false, false, ++ -0x2p-16448, false, false, ++ -0x2p-16448, false, false, ++ -0x2p-16448, false, false), + TEST ("-9.112998829706186506321014834048549540997627039233908359302" + "451217570929221583494342023901771564568012993118368368008827" + "754917464081555080424933770188974522513709556452944829196423" +@@ -10214,35 +10214,35 @@ static const struct test tests[] = { + "311044820996950448378367138265965725133486376318998624075987" + "11389056234111194498836994171142578126e-4952", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16448, false, +- -0x4p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x2.000000000004p-16448, false, +- -0x2p-16448, false, +- -0x2p-16448, false, +- -0x2p-16448, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16448, false, true, ++ -0x4p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x2.000000000004p-16448, false, true, ++ -0x2p-16448, false, true, ++ -0x2p-16448, false, true, ++ -0x2p-16448, false, true), + TEST ("3.2375875597190125554622194791138232762497846690173405048449" + "421945985197700620596855088357456383249701279390707384240598" + "382936099431912710233425550359863089915213963553756674672083" +@@ -10437,35 +10437,35 @@ static const struct test tests[] = { + "182358152808745703724362178773168996492870519432472065091133" + "11767578124e-4966", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-16496, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-16496, false, true), + TEST ("3.2375875597190125554622194791138232762497846690173405048449" + "421945985197700620596855088357456383249701279390707384240598" + "382936099431912710233425550359863089915213963553756674672083" +@@ -10660,35 +10660,35 @@ static const struct test tests[] = { + "182358152808745703724362178773168996492870519432472065091133" + "11767578125e-4966", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-16496, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-16496, false, true), + TEST ("3.2375875597190125554622194791138232762497846690173405048449" + "421945985197700620596855088357456383249701279390707384240598" + "382936099431912710233425550359863089915213963553756674672083" +@@ -10883,35 +10883,35 @@ static const struct test tests[] = { + "182358152808745703724362178773168996492870519432472065091133" + "11767578126e-4966", + false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-152, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x8p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-16448, false, +- false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x0p+0, false, +- 0x4p-1076, false, +- false, +- 0x0p+0, false, +- 0x4p-16496, false, +- 0x0p+0, false, +- 0x4p-16496, false), ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-16448, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x4p-16496, false, true, ++ 0x0p+0, false, true, ++ 0x4p-16496, false, true), + TEST ("-3.237587559719012555462219479113823276249784669017340504844" + "942194598519770062059685508835745638324970127939070738424059" + "838293609943191271023342555035986308991521396355375667467208" +@@ -11106,35 +11106,35 @@ static const struct test tests[] = { + "218235815280874570372436217877316899649287051943247206509113" + "311767578124e-4966", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16496, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16496, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true), + TEST ("-3.237587559719012555462219479113823276249784669017340504844" + "942194598519770062059685508835745638324970127939070738424059" + "838293609943191271023342555035986308991521396355375667467208" +@@ -11329,35 +11329,35 @@ static const struct test tests[] = { + "218235815280874570372436217877316899649287051943247206509113" + "311767578125e-4966", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16496, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16496, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true), + TEST ("-3.237587559719012555462219479113823276249784669017340504844" + "942194598519770062059685508835745638324970127939070738424059" + "838293609943191271023342555035986308991521396355375667467208" +@@ -11552,66 +11552,66 @@ static const struct test tests[] = { + "218235815280874570372436217877316899649287051943247206509113" + "311767578126e-4966", + false, +- -0x8p-152, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x8p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16448, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-1076, false, +- -0x0p+0, false, +- -0x0p+0, false, +- -0x0p+0, false, +- false, +- -0x4p-16496, false, +- -0x4p-16496, false, +- -0x0p+0, false, +- -0x0p+0, false), ++ -0x8p-152, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x8p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16448, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-1076, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true, ++ false, ++ -0x4p-16496, false, true, ++ -0x4p-16496, false, true, ++ -0x0p+0, false, true, ++ -0x0p+0, false, true), + TEST ("340282366920938463463374607431768211455", + false, +- 0xf.fffffp+124, false, +- INF, true, +- 0xf.fffffp+124, false, +- INF, true, +- false, +- 0xf.ffffffffffff8p+124, false, +- 0x1p+128, false, +- 0xf.ffffffffffff8p+124, false, +- 0x1p+128, false, +- false, +- 0xf.fffffffffffffffp+124, false, +- 0x1p+128, false, +- 0xf.fffffffffffffffp+124, false, +- 0x1p+128, false, +- false, +- 0xf.fffffffffffffffp+124, false, +- 0x1p+128, false, +- 0xf.fffffffffffffffp+124, false, +- 0x1p+128, false, +- false, +- 0xf.fffffffffffffffffffffffffcp+124, false, +- 0x1p+128, false, +- 0xf.fffffffffffffffffffffffffcp+124, false, +- 0x1p+128, false, +- false, +- 0xf.fffffffffffffffffffffffffff8p+124, false, +- 0x1p+128, false, +- 0xf.fffffffffffffffffffffffffff8p+124, false, +- 0x1p+128, false), ++ 0xf.fffffp+124, false, false, ++ INF, true, false, ++ 0xf.fffffp+124, false, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffff8p+124, false, false, ++ 0x1p+128, false, false, ++ 0xf.ffffffffffff8p+124, false, false, ++ 0x1p+128, false, false, ++ false, ++ 0xf.fffffffffffffffp+124, false, false, ++ 0x1p+128, false, false, ++ 0xf.fffffffffffffffp+124, false, false, ++ 0x1p+128, false, false, ++ false, ++ 0xf.fffffffffffffffp+124, false, false, ++ 0x1p+128, false, false, ++ 0xf.fffffffffffffffp+124, false, false, ++ 0x1p+128, false, false, ++ false, ++ 0xf.fffffffffffffffffffffffffcp+124, false, false, ++ 0x1p+128, false, false, ++ 0xf.fffffffffffffffffffffffffcp+124, false, false, ++ 0x1p+128, false, false, ++ false, ++ 0xf.fffffffffffffffffffffffffff8p+124, false, false, ++ 0x1p+128, false, false, ++ 0xf.fffffffffffffffffffffffffff8p+124, false, false, ++ 0x1p+128, false, false), + TEST ("179769313486231590772930519078902473361797697894230657273430" + "081157732675805500963132708477322407536021120113879871393357" + "658789768814416622492847430639474124377767893424865485276302" +@@ -11619,35 +11619,35 @@ static const struct test tests[] = { + "540827237163350510684586298239947245938479716304835356329624" + "224137215", + false, +- 0xf.fffffp+124, true, +- INF, true, +- 0xf.fffffp+124, true, +- INF, true, +- false, +- 0xf.ffffffffffff8p+1020, false, +- INF, true, +- 0xf.ffffffffffff8p+1020, false, +- INF, true, +- false, +- 0xf.fffffffffffffffp+1020, false, +- 0x1p+1024, false, +- 0xf.fffffffffffffffp+1020, false, +- 0x1p+1024, false, +- false, +- 0xf.fffffffffffffffp+1020, false, +- 0x1p+1024, false, +- 0xf.fffffffffffffffp+1020, false, +- 0x1p+1024, false, +- false, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- false, +- 0xf.fffffffffffffffffffffffffff8p+1020, false, +- 0x1p+1024, false, +- 0xf.fffffffffffffffffffffffffff8p+1020, false, +- 0x1p+1024, false), ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffff8p+1020, false, false, ++ INF, true, false, ++ 0xf.ffffffffffff8p+1020, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+1020, false, false, ++ 0x1p+1024, false, false, ++ 0xf.fffffffffffffffp+1020, false, false, ++ 0x1p+1024, false, false, ++ false, ++ 0xf.fffffffffffffffp+1020, false, false, ++ 0x1p+1024, false, false, ++ 0xf.fffffffffffffffp+1020, false, false, ++ 0x1p+1024, false, false, ++ false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffffffffffffff8p+1020, false, false, ++ 0x1p+1024, false, false, ++ 0xf.fffffffffffffffffffffffffff8p+1020, false, false, ++ 0x1p+1024, false, false), + TEST ("118973149535723176508575932662800713076344468709651023747267" + "482123326135818048368690448859547261203991511543748483930925" + "889766738130868742627452469834156500608087163436600489752214" +@@ -11732,66 +11732,66 @@ static const struct test tests[] = { + "047398248889922809181821393428829567971736994315246044702729" + "0669964066815", + false, +- 0xf.fffffp+124, true, +- INF, true, +- 0xf.fffffp+124, true, +- INF, true, +- false, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- false, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- false, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- 0xf.fffffffffffffffp+16380, false, +- INF, true, +- false, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- false, +- 0xf.fffffffffffffffffffffffffff8p+16380, false, +- INF, true, +- 0xf.fffffffffffffffffffffffffff8p+16380, false, +- INF, true), ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffp+16380, false, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ false, ++ 0xf.fffffffffffffffffffffffffff8p+16380, false, false, ++ INF, true, false, ++ 0xf.fffffffffffffffffffffffffff8p+16380, false, false, ++ INF, true, false), + TEST ("-340282366920938463463374607431768211455", + false, +- -INF, true, +- -INF, true, +- -0xf.fffffp+124, false, +- -0xf.fffffp+124, false, +- false, +- -0x1p+128, false, +- -0x1p+128, false, +- -0xf.ffffffffffff8p+124, false, +- -0xf.ffffffffffff8p+124, false, +- false, +- -0x1p+128, false, +- -0x1p+128, false, +- -0xf.fffffffffffffffp+124, false, +- -0xf.fffffffffffffffp+124, false, +- false, +- -0x1p+128, false, +- -0x1p+128, false, +- -0xf.fffffffffffffffp+124, false, +- -0xf.fffffffffffffffp+124, false, +- false, +- -0x1p+128, false, +- -0x1p+128, false, +- -0xf.fffffffffffffffffffffffffcp+124, false, +- -0xf.fffffffffffffffffffffffffcp+124, false, +- false, +- -0x1p+128, false, +- -0x1p+128, false, +- -0xf.fffffffffffffffffffffffffff8p+124, false, +- -0xf.fffffffffffffffffffffffffff8p+124, false), ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffp+124, false, false, ++ -0xf.fffffp+124, false, false, ++ false, ++ -0x1p+128, false, false, ++ -0x1p+128, false, false, ++ -0xf.ffffffffffff8p+124, false, false, ++ -0xf.ffffffffffff8p+124, false, false, ++ false, ++ -0x1p+128, false, false, ++ -0x1p+128, false, false, ++ -0xf.fffffffffffffffp+124, false, false, ++ -0xf.fffffffffffffffp+124, false, false, ++ false, ++ -0x1p+128, false, false, ++ -0x1p+128, false, false, ++ -0xf.fffffffffffffffp+124, false, false, ++ -0xf.fffffffffffffffp+124, false, false, ++ false, ++ -0x1p+128, false, false, ++ -0x1p+128, false, false, ++ -0xf.fffffffffffffffffffffffffcp+124, false, false, ++ -0xf.fffffffffffffffffffffffffcp+124, false, false, ++ false, ++ -0x1p+128, false, false, ++ -0x1p+128, false, false, ++ -0xf.fffffffffffffffffffffffffff8p+124, false, false, ++ -0xf.fffffffffffffffffffffffffff8p+124, false, false), + TEST ("-17976931348623159077293051907890247336179769789423065727343" + "008115773267580550096313270847732240753602112011387987139335" + "765878976881441662249284743063947412437776789342486548527630" +@@ -11799,35 +11799,35 @@ static const struct test tests[] = { + "054082723716335051068458629823994724593847971630483535632962" + "4224137215", + false, +- -INF, true, +- -INF, true, +- -0xf.fffffp+124, true, +- -0xf.fffffp+124, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.ffffffffffff8p+1020, false, +- -0xf.ffffffffffff8p+1020, false, +- false, +- -0x1p+1024, false, +- -0x1p+1024, false, +- -0xf.fffffffffffffffp+1020, false, +- -0xf.fffffffffffffffp+1020, false, +- false, +- -0x1p+1024, false, +- -0x1p+1024, false, +- -0xf.fffffffffffffffp+1020, false, +- -0xf.fffffffffffffffp+1020, false, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- false, +- -0x1p+1024, false, +- -0x1p+1024, false, +- -0xf.fffffffffffffffffffffffffff8p+1020, false, +- -0xf.fffffffffffffffffffffffffff8p+1020, false), ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffp+124, true, false, ++ -0xf.fffffp+124, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.ffffffffffff8p+1020, false, false, ++ -0xf.ffffffffffff8p+1020, false, false, ++ false, ++ -0x1p+1024, false, false, ++ -0x1p+1024, false, false, ++ -0xf.fffffffffffffffp+1020, false, false, ++ -0xf.fffffffffffffffp+1020, false, false, ++ false, ++ -0x1p+1024, false, false, ++ -0x1p+1024, false, false, ++ -0xf.fffffffffffffffp+1020, false, false, ++ -0xf.fffffffffffffffp+1020, false, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ false, ++ -0x1p+1024, false, false, ++ -0x1p+1024, false, false, ++ -0xf.fffffffffffffffffffffffffff8p+1020, false, false, ++ -0xf.fffffffffffffffffffffffffff8p+1020, false, false), + TEST ("-11897314953572317650857593266280071307634446870965102374726" + "748212332613581804836869044885954726120399151154374848393092" + "588976673813086874262745246983415650060808716343660048975221" +@@ -11912,3529 +11912,3529 @@ static const struct test tests[] = { + "904739824888992280918182139342882956797173699431524604470272" + "90669964066815", + false, +- -INF, true, +- -INF, true, +- -0xf.fffffp+124, true, +- -0xf.fffffp+124, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.ffffffffffff8p+1020, true, +- -0xf.ffffffffffff8p+1020, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffp+16380, false, +- -0xf.fffffffffffffffp+16380, false, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- -0xf.fffffffffffffffffffffffffcp+1020, true, +- false, +- -INF, true, +- -INF, true, +- -0xf.fffffffffffffffffffffffffff8p+16380, false, +- -0xf.fffffffffffffffffffffffffff8p+16380, false), ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffp+124, true, false, ++ -0xf.fffffp+124, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.ffffffffffff8p+1020, true, false, ++ -0xf.ffffffffffff8p+1020, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ -0xf.fffffffffffffffp+16380, false, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ -0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ false, ++ -INF, true, false, ++ -INF, true, false, ++ -0xf.fffffffffffffffffffffffffff8p+16380, false, false, ++ -0xf.fffffffffffffffffffffffffff8p+16380, false, false), + TEST ("+0x.80000000000000000000000000000001p1025", + false, +- 0xf.fffffp+124, true, +- INF, true, +- 0xf.fffffp+124, true, +- INF, true, +- false, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- 0xf.ffffffffffff8p+1020, true, +- INF, true, +- false, +- 0x1p+1024, false, +- 0x1p+1024, false, +- 0x1p+1024, false, +- 0x1.0000000000000002p+1024, false, +- false, +- 0x1p+1024, false, +- 0x1p+1024, false, +- 0x1p+1024, false, +- 0x1.0000000000000002p+1024, false, +- false, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- 0xf.fffffffffffffffffffffffffcp+1020, true, +- INF, true, +- false, +- 0x1p+1024, false, +- 0x1p+1024, false, +- 0x1p+1024, false, +- 0x1.0000000000000000000000000001p+1024, false), ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ 0xf.fffffp+124, true, false, ++ INF, true, false, ++ false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ 0xf.ffffffffffff8p+1020, true, false, ++ INF, true, false, ++ false, ++ 0x1p+1024, false, false, ++ 0x1p+1024, false, false, ++ 0x1p+1024, false, false, ++ 0x1.0000000000000002p+1024, false, false, ++ false, ++ 0x1p+1024, false, false, ++ 0x1p+1024, false, false, ++ 0x1p+1024, false, false, ++ 0x1.0000000000000002p+1024, false, false, ++ false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ 0xf.fffffffffffffffffffffffffcp+1020, true, false, ++ INF, true, false, ++ false, ++ 0x1p+1024, false, false, ++ 0x1p+1024, false, false, ++ 0x1p+1024, false, false, ++ 0x1.0000000000000000000000000001p+1024, false, false), + TEST ("1.5", + true, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- true, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- true, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- true, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- true, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- true, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- 0x1.8p+0, false, +- 0x1.8p+0, false), ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ true, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ true, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ true, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ true, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ true, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false, ++ 0x1.8p+0, false, false), + TEST ("1.25", + true, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- true, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- true, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- true, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- true, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- true, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- 0x1.4p+0, false, +- 0x1.4p+0, false), ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ true, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ true, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ true, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ true, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ true, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false, ++ 0x1.4p+0, false, false), + TEST ("1.125", + true, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- true, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- true, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- true, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- true, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- true, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- 0x1.2p+0, false, +- 0x1.2p+0, false), ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ true, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ true, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ true, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ true, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ true, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false, ++ 0x1.2p+0, false, false), + TEST ("1.0625", + true, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- true, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- true, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- true, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- true, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- true, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- 0x1.1p+0, false, +- 0x1.1p+0, false), ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ true, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ true, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ true, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ true, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ true, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false, ++ 0x1.1p+0, false, false), + TEST ("1.03125", + true, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- true, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- true, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- true, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- true, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- true, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- 0x1.08p+0, false, +- 0x1.08p+0, false), ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ true, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ true, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ true, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ true, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ true, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false, ++ 0x1.08p+0, false, false), + TEST ("1.015625", + true, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- true, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- true, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- true, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- true, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- true, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- 0x1.04p+0, false, +- 0x1.04p+0, false), ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ true, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ true, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ true, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ true, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ true, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false, ++ 0x1.04p+0, false, false), + TEST ("1.0078125", + true, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- true, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- true, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- true, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- true, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- true, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- 0x1.02p+0, false, +- 0x1.02p+0, false), ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ true, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ true, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ true, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ true, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ true, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false, ++ 0x1.02p+0, false, false), + TEST ("1.00390625", + true, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- true, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- true, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- true, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- true, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- true, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- 0x1.01p+0, false, +- 0x1.01p+0, false), ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ true, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ true, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ true, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ true, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ true, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false, ++ 0x1.01p+0, false, false), + TEST ("1.001953125", + true, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- true, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- true, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- true, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- true, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- true, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- 0x1.008p+0, false, +- 0x1.008p+0, false), ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ true, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ true, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ true, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ true, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ true, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false, ++ 0x1.008p+0, false, false), + TEST ("1.0009765625", + true, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- true, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- true, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- true, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- true, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- true, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- 0x1.004p+0, false, +- 0x1.004p+0, false), ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ true, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ true, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ true, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ true, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ true, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false, ++ 0x1.004p+0, false, false), + TEST ("1.00048828125", + true, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- true, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- true, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- true, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- true, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- true, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- 0x1.002p+0, false, +- 0x1.002p+0, false), ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ true, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ true, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ true, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ true, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ true, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false, ++ 0x1.002p+0, false, false), + TEST ("1.000244140625", + true, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- true, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- true, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- true, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- true, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- true, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- 0x1.001p+0, false, +- 0x1.001p+0, false), ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ true, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ true, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ true, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ true, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ true, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false, ++ 0x1.001p+0, false, false), + TEST ("1.0001220703125", + true, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- true, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- true, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- true, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- true, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- true, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false, +- 0x1.0008p+0, false), ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ true, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ true, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ true, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ true, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ true, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false, ++ 0x1.0008p+0, false, false), + TEST ("1.00006103515625", + true, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- true, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- true, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- true, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- true, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- true, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false, +- 0x1.0004p+0, false), ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ true, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ true, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ true, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ true, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ true, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false, ++ 0x1.0004p+0, false, false), + TEST ("1.000030517578125", + true, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- true, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- true, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- true, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- true, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- true, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false, +- 0x1.0002p+0, false), ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ true, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ true, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ true, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ true, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ true, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false, ++ 0x1.0002p+0, false, false), + TEST ("1.0000152587890625", + true, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- true, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- true, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- true, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- true, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- true, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false, +- 0x1.0001p+0, false), ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ true, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ true, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ true, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ true, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ true, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false, ++ 0x1.0001p+0, false, false), + TEST ("1.00000762939453125", + true, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- true, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- true, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- true, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- true, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- true, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false, +- 0x1.00008p+0, false), ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ true, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ true, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ true, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ true, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ true, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false, ++ 0x1.00008p+0, false, false), + TEST ("1.000003814697265625", + true, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- true, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- true, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- true, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- true, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- true, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false, +- 0x1.00004p+0, false), ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ true, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ true, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ true, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ true, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ true, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false, ++ 0x1.00004p+0, false, false), + TEST ("1.0000019073486328125", + true, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- true, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- true, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- true, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- true, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- true, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false, +- 0x1.00002p+0, false), ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ true, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ true, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ true, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ true, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ true, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false, ++ 0x1.00002p+0, false, false), + TEST ("1.00000095367431640625", + true, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- true, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- true, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- true, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- true, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- true, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false, +- 0x1.00001p+0, false), ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ true, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ true, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ true, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ true, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ true, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false, ++ 0x1.00001p+0, false, false), + TEST ("1.000000476837158203125", + true, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- true, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- true, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- true, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- true, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- true, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false, +- 0x1.000008p+0, false), ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ true, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ true, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ true, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ true, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ true, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false, ++ 0x1.000008p+0, false, false), + TEST ("1.0000000298023223876953125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false, +- true, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false, +- true, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false, +- true, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false, +- true, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false, +- 0x1.0000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false, ++ true, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false, ++ true, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false, ++ true, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false, ++ true, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false, ++ 0x1.0000008p+0, false, false), + TEST ("1.00000001490116119384765625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false, +- true, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false, +- true, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false, +- true, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false, +- true, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false, +- 0x1.0000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false, ++ true, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false, ++ true, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false, ++ true, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false, ++ true, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false, ++ 0x1.0000004p+0, false, false), + TEST ("1.000000007450580596923828125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false, +- true, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false, +- true, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false, +- true, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false, +- true, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false, +- 0x1.0000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false, ++ true, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false, ++ true, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false, ++ true, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false, ++ true, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false, ++ 0x1.0000002p+0, false, false), + TEST ("1.0000000037252902984619140625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false, +- true, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false, +- true, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false, +- true, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false, +- true, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false, +- 0x1.0000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false, ++ true, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false, ++ true, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false, ++ true, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false, ++ true, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false, ++ 0x1.0000001p+0, false, false), + TEST ("1.00000000186264514923095703125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false, +- true, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false, +- true, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false, +- true, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false, +- true, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false, +- 0x1.00000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false, ++ true, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false, ++ true, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false, ++ true, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false, ++ true, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false, ++ 0x1.00000008p+0, false, false), + TEST ("1.000000000931322574615478515625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false, +- true, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false, +- true, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false, +- true, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false, +- true, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false, +- 0x1.00000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false, ++ true, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false, ++ true, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false, ++ true, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false, ++ true, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false, ++ 0x1.00000004p+0, false, false), + TEST ("1.0000000004656612873077392578125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false, +- true, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false, +- true, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false, +- true, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false, +- true, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false, +- 0x1.00000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false, ++ true, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false, ++ true, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false, ++ true, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false, ++ true, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false, ++ 0x1.00000002p+0, false, false), + TEST ("1.00000000023283064365386962890625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false, +- true, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false, +- true, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false, +- true, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false, +- true, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false, +- 0x1.00000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false, ++ true, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false, ++ true, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false, ++ true, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false, ++ true, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false, ++ 0x1.00000001p+0, false, false), + TEST ("1.000000000116415321826934814453125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false, +- true, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false, +- true, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false, +- true, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false, +- true, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false, +- 0x1.000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false, ++ true, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false, ++ true, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false, ++ true, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false, ++ true, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false, ++ 0x1.000000008p+0, false, false), + TEST ("1.0000000000582076609134674072265625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false, +- true, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false, +- true, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false, +- true, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false, +- true, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false, +- 0x1.000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false, ++ true, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false, ++ true, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false, ++ true, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false, ++ true, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false, ++ 0x1.000000004p+0, false, false), + TEST ("1.00000000002910383045673370361328125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false, +- true, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false, +- true, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false, +- true, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false, +- true, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false, +- 0x1.000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false, ++ true, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false, ++ true, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false, ++ true, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false, ++ true, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false, ++ 0x1.000000002p+0, false, false), + TEST ("1.000000000014551915228366851806640625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false, +- true, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false, +- true, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false, +- true, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false, +- true, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false, +- 0x1.000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false, ++ true, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false, ++ true, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false, ++ true, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false, ++ true, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false, ++ 0x1.000000001p+0, false, false), + TEST ("1.0000000000072759576141834259033203125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false, +- true, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false, +- true, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false, +- true, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false, +- true, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false, +- 0x1.0000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false, ++ true, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false, ++ true, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false, ++ true, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false, ++ true, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false, ++ 0x1.0000000008p+0, false, false), + TEST ("1.00000000000363797880709171295166015625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false, +- true, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false, +- true, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false, +- true, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false, +- true, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false, +- 0x1.0000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false, ++ true, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false, ++ true, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false, ++ true, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false, ++ true, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false, ++ 0x1.0000000004p+0, false, false), + TEST ("1.000000000001818989403545856475830078125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false, +- true, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false, +- true, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false, +- true, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false, +- true, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false, +- 0x1.0000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false, ++ true, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false, ++ true, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false, ++ true, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false, ++ true, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false, ++ 0x1.0000000002p+0, false, false), + TEST ("1.0000000000009094947017729282379150390625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false, +- true, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false, +- true, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false, +- true, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false, +- true, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false, +- 0x1.0000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false, ++ true, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false, ++ true, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false, ++ true, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false, ++ true, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false, ++ 0x1.0000000001p+0, false, false), + TEST ("1.00000000000045474735088646411895751953125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false, +- true, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false, +- true, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false, +- true, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false, +- true, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false, +- 0x1.00000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false, ++ true, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false, ++ true, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false, ++ true, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false, ++ true, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false, ++ 0x1.00000000008p+0, false, false), + TEST ("1.000000000000227373675443232059478759765625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false, +- true, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false, +- true, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false, +- true, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false, +- true, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false, +- 0x1.00000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false, ++ true, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false, ++ true, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false, ++ true, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false, ++ true, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false, ++ 0x1.00000000004p+0, false, false), + TEST ("1.0000000000001136868377216160297393798828125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false, +- true, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false, +- true, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false, +- true, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false, +- true, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false, +- 0x1.00000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false, ++ true, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false, ++ true, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false, ++ true, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false, ++ true, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false, ++ 0x1.00000000002p+0, false, false), + TEST ("1.00000000000005684341886080801486968994140625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false, +- true, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false, +- true, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false, +- true, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false, +- true, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false, +- 0x1.00000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false, ++ true, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false, ++ true, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false, ++ true, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false, ++ true, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false, ++ 0x1.00000000001p+0, false, false), + TEST ("1.000000000000028421709430404007434844970703125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false, +- true, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false, +- true, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false, +- true, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false, +- true, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false, +- 0x1.000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false, ++ true, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false, ++ true, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false, ++ true, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false, ++ true, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false, ++ 0x1.000000000008p+0, false, false), + TEST ("1.0000000000000142108547152020037174224853515625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false, +- true, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false, +- true, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false, +- true, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false, +- true, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false, +- 0x1.000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false, ++ true, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false, ++ true, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false, ++ true, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false, ++ true, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false, ++ 0x1.000000000004p+0, false, false), + TEST ("1.00000000000000710542735760100185871124267578125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false, +- true, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false, +- true, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false, +- true, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false, +- true, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false, +- 0x1.000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false, ++ true, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false, ++ true, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false, ++ true, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false, ++ true, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false, ++ 0x1.000000000002p+0, false, false), + TEST ("1.000000000000003552713678800500929355621337890625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false, +- true, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false, +- true, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false, +- true, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false, +- true, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false, +- 0x1.000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false, ++ true, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false, ++ true, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false, ++ true, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false, ++ true, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false, ++ 0x1.000000000001p+0, false, false), + TEST ("1.0000000000000017763568394002504646778106689453125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false, +- true, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false, +- true, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false, +- true, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false, +- true, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false, +- 0x1.0000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false, ++ true, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false, ++ true, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false, ++ true, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false, ++ true, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false, ++ 0x1.0000000000008p+0, false, false), + TEST ("1.00000000000000088817841970012523233890533447265625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false, +- true, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false, +- true, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false, +- true, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false, +- true, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false, +- 0x1.0000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false, ++ true, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false, ++ true, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false, ++ true, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false, ++ true, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false, ++ 0x1.0000000000004p+0, false, false), + TEST ("1.000000000000000444089209850062616169452667236328125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false, +- true, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false, +- true, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false, +- true, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false, +- true, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false, +- 0x1.0000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false, ++ true, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false, ++ true, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false, ++ true, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false, ++ true, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false, ++ 0x1.0000000000002p+0, false, false), + TEST ("1.0000000000000002220446049250313080847263336181640625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- true, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false, +- 0x1.0000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ true, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ 0x1.0000000000001p+0, false, false), + TEST ("1.00000000000000011102230246251565404236316680908203125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- true, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- true, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- true, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false, +- 0x1.00000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ true, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ true, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ true, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false, ++ 0x1.00000000000008p+0, false, false), + TEST ("1.000000000000000055511151231257827021181583404541015625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.00000000000004p+0, false, +- 0x1.00000000000004p+0, false, +- 0x1.00000000000004p+0, false, +- 0x1.00000000000004p+0, false, +- true, +- 0x1.00000000000004p+0, false, +- 0x1.00000000000004p+0, false, +- 0x1.00000000000004p+0, false, +- 0x1.00000000000004p+0, false, +- true, +- 0x1.00000000000004p+0, false, +- 0x1.00000000000004p+0, false, +- 0x1.00000000000004p+0, false, +- 0x1.00000000000004p+0, false, +- true, +- 0x1.00000000000004p+0, false, +- 0x1.00000000000004p+0, false, +- 0x1.00000000000004p+0, false, +- 0x1.00000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.00000000000004p+0, false, false, ++ 0x1.00000000000004p+0, false, false, ++ 0x1.00000000000004p+0, false, false, ++ 0x1.00000000000004p+0, false, false, ++ true, ++ 0x1.00000000000004p+0, false, false, ++ 0x1.00000000000004p+0, false, false, ++ 0x1.00000000000004p+0, false, false, ++ 0x1.00000000000004p+0, false, false, ++ true, ++ 0x1.00000000000004p+0, false, false, ++ 0x1.00000000000004p+0, false, false, ++ 0x1.00000000000004p+0, false, false, ++ 0x1.00000000000004p+0, false, false, ++ true, ++ 0x1.00000000000004p+0, false, false, ++ 0x1.00000000000004p+0, false, false, ++ 0x1.00000000000004p+0, false, false, ++ 0x1.00000000000004p+0, false, false), + TEST ("1.0000000000000000277555756156289135105907917022705078125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.00000000000002p+0, false, +- 0x1.00000000000002p+0, false, +- 0x1.00000000000002p+0, false, +- 0x1.00000000000002p+0, false, +- true, +- 0x1.00000000000002p+0, false, +- 0x1.00000000000002p+0, false, +- 0x1.00000000000002p+0, false, +- 0x1.00000000000002p+0, false, +- true, +- 0x1.00000000000002p+0, false, +- 0x1.00000000000002p+0, false, +- 0x1.00000000000002p+0, false, +- 0x1.00000000000002p+0, false, +- true, +- 0x1.00000000000002p+0, false, +- 0x1.00000000000002p+0, false, +- 0x1.00000000000002p+0, false, +- 0x1.00000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.00000000000002p+0, false, false, ++ 0x1.00000000000002p+0, false, false, ++ 0x1.00000000000002p+0, false, false, ++ 0x1.00000000000002p+0, false, false, ++ true, ++ 0x1.00000000000002p+0, false, false, ++ 0x1.00000000000002p+0, false, false, ++ 0x1.00000000000002p+0, false, false, ++ 0x1.00000000000002p+0, false, false, ++ true, ++ 0x1.00000000000002p+0, false, false, ++ 0x1.00000000000002p+0, false, false, ++ 0x1.00000000000002p+0, false, false, ++ 0x1.00000000000002p+0, false, false, ++ true, ++ 0x1.00000000000002p+0, false, false, ++ 0x1.00000000000002p+0, false, false, ++ 0x1.00000000000002p+0, false, false, ++ 0x1.00000000000002p+0, false, false), + TEST ("1.00000000000000001387778780781445675529539585113525390625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.00000000000001p+0, false, +- 0x1.00000000000001p+0, false, +- 0x1.00000000000001p+0, false, +- 0x1.00000000000001p+0, false, +- true, +- 0x1.00000000000001p+0, false, +- 0x1.00000000000001p+0, false, +- 0x1.00000000000001p+0, false, +- 0x1.00000000000001p+0, false, +- true, +- 0x1.00000000000001p+0, false, +- 0x1.00000000000001p+0, false, +- 0x1.00000000000001p+0, false, +- 0x1.00000000000001p+0, false, +- true, +- 0x1.00000000000001p+0, false, +- 0x1.00000000000001p+0, false, +- 0x1.00000000000001p+0, false, +- 0x1.00000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.00000000000001p+0, false, false, ++ 0x1.00000000000001p+0, false, false, ++ 0x1.00000000000001p+0, false, false, ++ 0x1.00000000000001p+0, false, false, ++ true, ++ 0x1.00000000000001p+0, false, false, ++ 0x1.00000000000001p+0, false, false, ++ 0x1.00000000000001p+0, false, false, ++ 0x1.00000000000001p+0, false, false, ++ true, ++ 0x1.00000000000001p+0, false, false, ++ 0x1.00000000000001p+0, false, false, ++ 0x1.00000000000001p+0, false, false, ++ 0x1.00000000000001p+0, false, false, ++ true, ++ 0x1.00000000000001p+0, false, false, ++ 0x1.00000000000001p+0, false, false, ++ 0x1.00000000000001p+0, false, false, ++ 0x1.00000000000001p+0, false, false), + TEST ("1.000000000000000006938893903907228377647697925567626953125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.000000000000008p+0, false, +- 0x1.000000000000008p+0, false, +- 0x1.000000000000008p+0, false, +- 0x1.000000000000008p+0, false, +- true, +- 0x1.000000000000008p+0, false, +- 0x1.000000000000008p+0, false, +- 0x1.000000000000008p+0, false, +- 0x1.000000000000008p+0, false, +- true, +- 0x1.000000000000008p+0, false, +- 0x1.000000000000008p+0, false, +- 0x1.000000000000008p+0, false, +- 0x1.000000000000008p+0, false, +- true, +- 0x1.000000000000008p+0, false, +- 0x1.000000000000008p+0, false, +- 0x1.000000000000008p+0, false, +- 0x1.000000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.000000000000008p+0, false, false, ++ 0x1.000000000000008p+0, false, false, ++ 0x1.000000000000008p+0, false, false, ++ 0x1.000000000000008p+0, false, false, ++ true, ++ 0x1.000000000000008p+0, false, false, ++ 0x1.000000000000008p+0, false, false, ++ 0x1.000000000000008p+0, false, false, ++ 0x1.000000000000008p+0, false, false, ++ true, ++ 0x1.000000000000008p+0, false, false, ++ 0x1.000000000000008p+0, false, false, ++ 0x1.000000000000008p+0, false, false, ++ 0x1.000000000000008p+0, false, false, ++ true, ++ 0x1.000000000000008p+0, false, false, ++ 0x1.000000000000008p+0, false, false, ++ 0x1.000000000000008p+0, false, false, ++ 0x1.000000000000008p+0, false, false), + TEST ("1.0000000000000000034694469519536141888238489627838134765625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.000000000000004p+0, false, +- 0x1.000000000000004p+0, false, +- 0x1.000000000000004p+0, false, +- 0x1.000000000000004p+0, false, +- true, +- 0x1.000000000000004p+0, false, +- 0x1.000000000000004p+0, false, +- 0x1.000000000000004p+0, false, +- 0x1.000000000000004p+0, false, +- true, +- 0x1.000000000000004p+0, false, +- 0x1.000000000000004p+0, false, +- 0x1.000000000000004p+0, false, +- 0x1.000000000000004p+0, false, +- true, +- 0x1.000000000000004p+0, false, +- 0x1.000000000000004p+0, false, +- 0x1.000000000000004p+0, false, +- 0x1.000000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.000000000000004p+0, false, false, ++ 0x1.000000000000004p+0, false, false, ++ 0x1.000000000000004p+0, false, false, ++ 0x1.000000000000004p+0, false, false, ++ true, ++ 0x1.000000000000004p+0, false, false, ++ 0x1.000000000000004p+0, false, false, ++ 0x1.000000000000004p+0, false, false, ++ 0x1.000000000000004p+0, false, false, ++ true, ++ 0x1.000000000000004p+0, false, false, ++ 0x1.000000000000004p+0, false, false, ++ 0x1.000000000000004p+0, false, false, ++ 0x1.000000000000004p+0, false, false, ++ true, ++ 0x1.000000000000004p+0, false, false, ++ 0x1.000000000000004p+0, false, false, ++ 0x1.000000000000004p+0, false, false, ++ 0x1.000000000000004p+0, false, false), + TEST ("1.0000000000000000017347234759768070944119244813919067382812" + "5", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.000000000000002p+0, false, +- 0x1.000000000000002p+0, false, +- 0x1.000000000000002p+0, false, +- 0x1.000000000000002p+0, false, +- true, +- 0x1.000000000000002p+0, false, +- 0x1.000000000000002p+0, false, +- 0x1.000000000000002p+0, false, +- 0x1.000000000000002p+0, false, +- true, +- 0x1.000000000000002p+0, false, +- 0x1.000000000000002p+0, false, +- 0x1.000000000000002p+0, false, +- 0x1.000000000000002p+0, false, +- true, +- 0x1.000000000000002p+0, false, +- 0x1.000000000000002p+0, false, +- 0x1.000000000000002p+0, false, +- 0x1.000000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.000000000000002p+0, false, false, ++ 0x1.000000000000002p+0, false, false, ++ 0x1.000000000000002p+0, false, false, ++ 0x1.000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000002p+0, false, false, ++ 0x1.000000000000002p+0, false, false, ++ 0x1.000000000000002p+0, false, false, ++ 0x1.000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000002p+0, false, false, ++ 0x1.000000000000002p+0, false, false, ++ 0x1.000000000000002p+0, false, false, ++ 0x1.000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000002p+0, false, false, ++ 0x1.000000000000002p+0, false, false, ++ 0x1.000000000000002p+0, false, false, ++ 0x1.000000000000002p+0, false, false), + TEST ("1.0000000000000000008673617379884035472059622406959533691406" + "25", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.000000000000001p+0, false, +- 0x1.000000000000001p+0, false, +- 0x1.000000000000001p+0, false, +- 0x1.000000000000001p+0, false, +- true, +- 0x1.000000000000001p+0, false, +- 0x1.000000000000001p+0, false, +- 0x1.000000000000001p+0, false, +- 0x1.000000000000001p+0, false, +- true, +- 0x1.000000000000001p+0, false, +- 0x1.000000000000001p+0, false, +- 0x1.000000000000001p+0, false, +- 0x1.000000000000001p+0, false, +- true, +- 0x1.000000000000001p+0, false, +- 0x1.000000000000001p+0, false, +- 0x1.000000000000001p+0, false, +- 0x1.000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.000000000000001p+0, false, false, ++ 0x1.000000000000001p+0, false, false, ++ 0x1.000000000000001p+0, false, false, ++ 0x1.000000000000001p+0, false, false, ++ true, ++ 0x1.000000000000001p+0, false, false, ++ 0x1.000000000000001p+0, false, false, ++ 0x1.000000000000001p+0, false, false, ++ 0x1.000000000000001p+0, false, false, ++ true, ++ 0x1.000000000000001p+0, false, false, ++ 0x1.000000000000001p+0, false, false, ++ 0x1.000000000000001p+0, false, false, ++ 0x1.000000000000001p+0, false, false, ++ true, ++ 0x1.000000000000001p+0, false, false, ++ 0x1.000000000000001p+0, false, false, ++ 0x1.000000000000001p+0, false, false, ++ 0x1.000000000000001p+0, false, false), + TEST ("1.0000000000000000004336808689942017736029811203479766845703" + "125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.0000000000000008p+0, false, +- 0x1.0000000000000008p+0, false, +- 0x1.0000000000000008p+0, false, +- 0x1.0000000000000008p+0, false, +- true, +- 0x1.0000000000000008p+0, false, +- 0x1.0000000000000008p+0, false, +- 0x1.0000000000000008p+0, false, +- 0x1.0000000000000008p+0, false, +- true, +- 0x1.0000000000000008p+0, false, +- 0x1.0000000000000008p+0, false, +- 0x1.0000000000000008p+0, false, +- 0x1.0000000000000008p+0, false, +- true, +- 0x1.0000000000000008p+0, false, +- 0x1.0000000000000008p+0, false, +- 0x1.0000000000000008p+0, false, +- 0x1.0000000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.0000000000000008p+0, false, false, ++ 0x1.0000000000000008p+0, false, false, ++ 0x1.0000000000000008p+0, false, false, ++ 0x1.0000000000000008p+0, false, false, ++ true, ++ 0x1.0000000000000008p+0, false, false, ++ 0x1.0000000000000008p+0, false, false, ++ 0x1.0000000000000008p+0, false, false, ++ 0x1.0000000000000008p+0, false, false, ++ true, ++ 0x1.0000000000000008p+0, false, false, ++ 0x1.0000000000000008p+0, false, false, ++ 0x1.0000000000000008p+0, false, false, ++ 0x1.0000000000000008p+0, false, false, ++ true, ++ 0x1.0000000000000008p+0, false, false, ++ 0x1.0000000000000008p+0, false, false, ++ 0x1.0000000000000008p+0, false, false, ++ 0x1.0000000000000008p+0, false, false), + TEST ("1.0000000000000000002168404344971008868014905601739883422851" + "5625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.0000000000000004p+0, false, +- 0x1.0000000000000004p+0, false, +- 0x1.0000000000000004p+0, false, +- 0x1.0000000000000004p+0, false, +- true, +- 0x1.0000000000000004p+0, false, +- 0x1.0000000000000004p+0, false, +- 0x1.0000000000000004p+0, false, +- 0x1.0000000000000004p+0, false, +- true, +- 0x1.0000000000000004p+0, false, +- 0x1.0000000000000004p+0, false, +- 0x1.0000000000000004p+0, false, +- 0x1.0000000000000004p+0, false, +- true, +- 0x1.0000000000000004p+0, false, +- 0x1.0000000000000004p+0, false, +- 0x1.0000000000000004p+0, false, +- 0x1.0000000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.0000000000000004p+0, false, false, ++ 0x1.0000000000000004p+0, false, false, ++ 0x1.0000000000000004p+0, false, false, ++ 0x1.0000000000000004p+0, false, false, ++ true, ++ 0x1.0000000000000004p+0, false, false, ++ 0x1.0000000000000004p+0, false, false, ++ 0x1.0000000000000004p+0, false, false, ++ 0x1.0000000000000004p+0, false, false, ++ true, ++ 0x1.0000000000000004p+0, false, false, ++ 0x1.0000000000000004p+0, false, false, ++ 0x1.0000000000000004p+0, false, false, ++ 0x1.0000000000000004p+0, false, false, ++ true, ++ 0x1.0000000000000004p+0, false, false, ++ 0x1.0000000000000004p+0, false, false, ++ 0x1.0000000000000004p+0, false, false, ++ 0x1.0000000000000004p+0, false, false), + TEST ("1.0000000000000000001084202172485504434007452800869941711425" + "78125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- true, +- 0x1.0000000000000002p+0, false, +- 0x1.0000000000000002p+0, false, +- 0x1.0000000000000002p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000002p+0, false, +- 0x1.0000000000000002p+0, false, +- 0x1.0000000000000002p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000002p+0, false, +- 0x1.0000000000000002p+0, false, +- 0x1.0000000000000002p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000002p+0, false, +- 0x1.0000000000000002p+0, false, +- 0x1.0000000000000002p+0, false, +- 0x1.0000000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ true, ++ 0x1.0000000000000002p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000002p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000002p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000002p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ 0x1.0000000000000002p+0, false, false), + TEST ("1.0000000000000000000542101086242752217003726400434970855712" + "890625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000001p+0, false, +- 0x1.0000000000000001p+0, false, +- 0x1.0000000000000001p+0, false, +- 0x1.0000000000000001p+0, false, +- true, +- 0x1.0000000000000001p+0, false, +- 0x1.0000000000000001p+0, false, +- 0x1.0000000000000001p+0, false, +- 0x1.0000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000001p+0, false, false, ++ 0x1.0000000000000001p+0, false, false, ++ 0x1.0000000000000001p+0, false, false, ++ 0x1.0000000000000001p+0, false, false, ++ true, ++ 0x1.0000000000000001p+0, false, false, ++ 0x1.0000000000000001p+0, false, false, ++ 0x1.0000000000000001p+0, false, false, ++ 0x1.0000000000000001p+0, false, false), + TEST ("1.0000000000000000000271050543121376108501863200217485427856" + "4453125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000008p+0, false, +- 0x1.00000000000000008p+0, false, +- 0x1.00000000000000008p+0, false, +- 0x1.00000000000000008p+0, false, +- true, +- 0x1.00000000000000008p+0, false, +- 0x1.00000000000000008p+0, false, +- 0x1.00000000000000008p+0, false, +- 0x1.00000000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000008p+0, false, false, ++ 0x1.00000000000000008p+0, false, false, ++ 0x1.00000000000000008p+0, false, false, ++ 0x1.00000000000000008p+0, false, false, ++ true, ++ 0x1.00000000000000008p+0, false, false, ++ 0x1.00000000000000008p+0, false, false, ++ 0x1.00000000000000008p+0, false, false, ++ 0x1.00000000000000008p+0, false, false), + TEST ("1.0000000000000000000135525271560688054250931600108742713928" + "22265625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000004p+0, false, +- 0x1.00000000000000004p+0, false, +- 0x1.00000000000000004p+0, false, +- 0x1.00000000000000004p+0, false, +- true, +- 0x1.00000000000000004p+0, false, +- 0x1.00000000000000004p+0, false, +- 0x1.00000000000000004p+0, false, +- 0x1.00000000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000004p+0, false, false, ++ 0x1.00000000000000004p+0, false, false, ++ 0x1.00000000000000004p+0, false, false, ++ 0x1.00000000000000004p+0, false, false, ++ true, ++ 0x1.00000000000000004p+0, false, false, ++ 0x1.00000000000000004p+0, false, false, ++ 0x1.00000000000000004p+0, false, false, ++ 0x1.00000000000000004p+0, false, false), + TEST ("1.0000000000000000000067762635780344027125465800054371356964" + "111328125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000002p+0, false, +- 0x1.00000000000000002p+0, false, +- 0x1.00000000000000002p+0, false, +- 0x1.00000000000000002p+0, false, +- true, +- 0x1.00000000000000002p+0, false, +- 0x1.00000000000000002p+0, false, +- 0x1.00000000000000002p+0, false, +- 0x1.00000000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000002p+0, false, false, ++ 0x1.00000000000000002p+0, false, false, ++ 0x1.00000000000000002p+0, false, false, ++ 0x1.00000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000002p+0, false, false, ++ 0x1.00000000000000002p+0, false, false, ++ 0x1.00000000000000002p+0, false, false, ++ 0x1.00000000000000002p+0, false, false), + TEST ("1.0000000000000000000033881317890172013562732900027185678482" + "0556640625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000001p+0, false, +- 0x1.00000000000000001p+0, false, +- 0x1.00000000000000001p+0, false, +- 0x1.00000000000000001p+0, false, +- true, +- 0x1.00000000000000001p+0, false, +- 0x1.00000000000000001p+0, false, +- 0x1.00000000000000001p+0, false, +- 0x1.00000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000001p+0, false, false, ++ 0x1.00000000000000001p+0, false, false, ++ 0x1.00000000000000001p+0, false, false, ++ 0x1.00000000000000001p+0, false, false, ++ true, ++ 0x1.00000000000000001p+0, false, false, ++ 0x1.00000000000000001p+0, false, false, ++ 0x1.00000000000000001p+0, false, false, ++ 0x1.00000000000000001p+0, false, false), + TEST ("1.0000000000000000000016940658945086006781366450013592839241" + "02783203125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.000000000000000008p+0, false, +- 0x1.000000000000000008p+0, false, +- 0x1.000000000000000008p+0, false, +- 0x1.000000000000000008p+0, false, +- true, +- 0x1.000000000000000008p+0, false, +- 0x1.000000000000000008p+0, false, +- 0x1.000000000000000008p+0, false, +- 0x1.000000000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000008p+0, false, false, ++ 0x1.000000000000000008p+0, false, false, ++ 0x1.000000000000000008p+0, false, false, ++ 0x1.000000000000000008p+0, false, false, ++ true, ++ 0x1.000000000000000008p+0, false, false, ++ 0x1.000000000000000008p+0, false, false, ++ 0x1.000000000000000008p+0, false, false, ++ 0x1.000000000000000008p+0, false, false), + TEST ("1.0000000000000000000008470329472543003390683225006796419620" + "513916015625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.000000000000000004p+0, false, +- 0x1.000000000000000004p+0, false, +- 0x1.000000000000000004p+0, false, +- 0x1.000000000000000004p+0, false, +- true, +- 0x1.000000000000000004p+0, false, +- 0x1.000000000000000004p+0, false, +- 0x1.000000000000000004p+0, false, +- 0x1.000000000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000004p+0, false, false, ++ 0x1.000000000000000004p+0, false, false, ++ 0x1.000000000000000004p+0, false, false, ++ 0x1.000000000000000004p+0, false, false, ++ true, ++ 0x1.000000000000000004p+0, false, false, ++ 0x1.000000000000000004p+0, false, false, ++ 0x1.000000000000000004p+0, false, false, ++ 0x1.000000000000000004p+0, false, false), + TEST ("1.0000000000000000000004235164736271501695341612503398209810" + "2569580078125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.000000000000000002p+0, false, +- 0x1.000000000000000002p+0, false, +- 0x1.000000000000000002p+0, false, +- 0x1.000000000000000002p+0, false, +- true, +- 0x1.000000000000000002p+0, false, +- 0x1.000000000000000002p+0, false, +- 0x1.000000000000000002p+0, false, +- 0x1.000000000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000002p+0, false, false, ++ 0x1.000000000000000002p+0, false, false, ++ 0x1.000000000000000002p+0, false, false, ++ 0x1.000000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000002p+0, false, false, ++ 0x1.000000000000000002p+0, false, false, ++ 0x1.000000000000000002p+0, false, false, ++ 0x1.000000000000000002p+0, false, false), + TEST ("1.0000000000000000000002117582368135750847670806251699104905" + "12847900390625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.000000000000000001p+0, false, +- 0x1.000000000000000001p+0, false, +- 0x1.000000000000000001p+0, false, +- 0x1.000000000000000001p+0, false, +- true, +- 0x1.000000000000000001p+0, false, +- 0x1.000000000000000001p+0, false, +- 0x1.000000000000000001p+0, false, +- 0x1.000000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000001p+0, false, false, ++ 0x1.000000000000000001p+0, false, false, ++ 0x1.000000000000000001p+0, false, false, ++ 0x1.000000000000000001p+0, false, false, ++ true, ++ 0x1.000000000000000001p+0, false, false, ++ 0x1.000000000000000001p+0, false, false, ++ 0x1.000000000000000001p+0, false, false, ++ 0x1.000000000000000001p+0, false, false), + TEST ("1.0000000000000000000001058791184067875423835403125849552452" + "564239501953125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000000008p+0, false, +- 0x1.0000000000000000008p+0, false, +- 0x1.0000000000000000008p+0, false, +- 0x1.0000000000000000008p+0, false, +- true, +- 0x1.0000000000000000008p+0, false, +- 0x1.0000000000000000008p+0, false, +- 0x1.0000000000000000008p+0, false, +- 0x1.0000000000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000008p+0, false, false, ++ 0x1.0000000000000000008p+0, false, false, ++ 0x1.0000000000000000008p+0, false, false, ++ 0x1.0000000000000000008p+0, false, false, ++ true, ++ 0x1.0000000000000000008p+0, false, false, ++ 0x1.0000000000000000008p+0, false, false, ++ 0x1.0000000000000000008p+0, false, false, ++ 0x1.0000000000000000008p+0, false, false), + TEST ("1.0000000000000000000000529395592033937711917701562924776226" + "2821197509765625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000000004p+0, false, +- 0x1.0000000000000000004p+0, false, +- 0x1.0000000000000000004p+0, false, +- 0x1.0000000000000000004p+0, false, +- true, +- 0x1.0000000000000000004p+0, false, +- 0x1.0000000000000000004p+0, false, +- 0x1.0000000000000000004p+0, false, +- 0x1.0000000000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000004p+0, false, false, ++ 0x1.0000000000000000004p+0, false, false, ++ 0x1.0000000000000000004p+0, false, false, ++ 0x1.0000000000000000004p+0, false, false, ++ true, ++ 0x1.0000000000000000004p+0, false, false, ++ 0x1.0000000000000000004p+0, false, false, ++ 0x1.0000000000000000004p+0, false, false, ++ 0x1.0000000000000000004p+0, false, false), + TEST ("1.0000000000000000000000264697796016968855958850781462388113" + "14105987548828125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000000002p+0, false, +- 0x1.0000000000000000002p+0, false, +- 0x1.0000000000000000002p+0, false, +- 0x1.0000000000000000002p+0, false, +- true, +- 0x1.0000000000000000002p+0, false, +- 0x1.0000000000000000002p+0, false, +- 0x1.0000000000000000002p+0, false, +- 0x1.0000000000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000002p+0, false, false, ++ 0x1.0000000000000000002p+0, false, false, ++ 0x1.0000000000000000002p+0, false, false, ++ 0x1.0000000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000002p+0, false, false, ++ 0x1.0000000000000000002p+0, false, false, ++ 0x1.0000000000000000002p+0, false, false, ++ 0x1.0000000000000000002p+0, false, false), + TEST ("1.0000000000000000000000132348898008484427979425390731194056" + "570529937744140625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000000001p+0, false, +- 0x1.0000000000000000001p+0, false, +- 0x1.0000000000000000001p+0, false, +- 0x1.0000000000000000001p+0, false, +- true, +- 0x1.0000000000000000001p+0, false, +- 0x1.0000000000000000001p+0, false, +- 0x1.0000000000000000001p+0, false, +- 0x1.0000000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000001p+0, false, false, ++ 0x1.0000000000000000001p+0, false, false, ++ 0x1.0000000000000000001p+0, false, false, ++ 0x1.0000000000000000001p+0, false, false, ++ true, ++ 0x1.0000000000000000001p+0, false, false, ++ 0x1.0000000000000000001p+0, false, false, ++ 0x1.0000000000000000001p+0, false, false, ++ 0x1.0000000000000000001p+0, false, false), + TEST ("1.0000000000000000000000066174449004242213989712695365597028" + "2852649688720703125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000000008p+0, false, +- 0x1.00000000000000000008p+0, false, +- 0x1.00000000000000000008p+0, false, +- 0x1.00000000000000000008p+0, false, +- true, +- 0x1.00000000000000000008p+0, false, +- 0x1.00000000000000000008p+0, false, +- 0x1.00000000000000000008p+0, false, +- 0x1.00000000000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000008p+0, false, false, ++ 0x1.00000000000000000008p+0, false, false, ++ 0x1.00000000000000000008p+0, false, false, ++ 0x1.00000000000000000008p+0, false, false, ++ true, ++ 0x1.00000000000000000008p+0, false, false, ++ 0x1.00000000000000000008p+0, false, false, ++ 0x1.00000000000000000008p+0, false, false, ++ 0x1.00000000000000000008p+0, false, false), + TEST ("1.0000000000000000000000033087224502121106994856347682798514" + "14263248443603515625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000000004p+0, false, +- 0x1.00000000000000000004p+0, false, +- 0x1.00000000000000000004p+0, false, +- 0x1.00000000000000000004p+0, false, +- true, +- 0x1.00000000000000000004p+0, false, +- 0x1.00000000000000000004p+0, false, +- 0x1.00000000000000000004p+0, false, +- 0x1.00000000000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000004p+0, false, false, ++ 0x1.00000000000000000004p+0, false, false, ++ 0x1.00000000000000000004p+0, false, false, ++ 0x1.00000000000000000004p+0, false, false, ++ true, ++ 0x1.00000000000000000004p+0, false, false, ++ 0x1.00000000000000000004p+0, false, false, ++ 0x1.00000000000000000004p+0, false, false, ++ 0x1.00000000000000000004p+0, false, false), + TEST ("1.0000000000000000000000016543612251060553497428173841399257" + "071316242218017578125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000000002p+0, false, +- 0x1.00000000000000000002p+0, false, +- 0x1.00000000000000000002p+0, false, +- 0x1.00000000000000000002p+0, false, +- true, +- 0x1.00000000000000000002p+0, false, +- 0x1.00000000000000000002p+0, false, +- 0x1.00000000000000000002p+0, false, +- 0x1.00000000000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000002p+0, false, false, ++ 0x1.00000000000000000002p+0, false, false, ++ 0x1.00000000000000000002p+0, false, false, ++ 0x1.00000000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000002p+0, false, false, ++ 0x1.00000000000000000002p+0, false, false, ++ 0x1.00000000000000000002p+0, false, false, ++ 0x1.00000000000000000002p+0, false, false), + TEST ("1.0000000000000000000000008271806125530276748714086920699628" + "5356581211090087890625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000000001p+0, false, +- 0x1.00000000000000000001p+0, false, +- 0x1.00000000000000000001p+0, false, +- 0x1.00000000000000000001p+0, false, +- true, +- 0x1.00000000000000000001p+0, false, +- 0x1.00000000000000000001p+0, false, +- 0x1.00000000000000000001p+0, false, +- 0x1.00000000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000001p+0, false, false, ++ 0x1.00000000000000000001p+0, false, false, ++ 0x1.00000000000000000001p+0, false, false, ++ 0x1.00000000000000000001p+0, false, false, ++ true, ++ 0x1.00000000000000000001p+0, false, false, ++ 0x1.00000000000000000001p+0, false, false, ++ 0x1.00000000000000000001p+0, false, false, ++ 0x1.00000000000000000001p+0, false, false), + TEST ("1.0000000000000000000000004135903062765138374357043460349814" + "26782906055450439453125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.000000000000000000008p+0, false, +- 0x1.000000000000000000008p+0, false, +- 0x1.000000000000000000008p+0, false, +- 0x1.000000000000000000008p+0, false, +- true, +- 0x1.000000000000000000008p+0, false, +- 0x1.000000000000000000008p+0, false, +- 0x1.000000000000000000008p+0, false, +- 0x1.000000000000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000000008p+0, false, false, ++ 0x1.000000000000000000008p+0, false, false, ++ 0x1.000000000000000000008p+0, false, false, ++ 0x1.000000000000000000008p+0, false, false, ++ true, ++ 0x1.000000000000000000008p+0, false, false, ++ 0x1.000000000000000000008p+0, false, false, ++ 0x1.000000000000000000008p+0, false, false, ++ 0x1.000000000000000000008p+0, false, false), + TEST ("1.0000000000000000000000002067951531382569187178521730174907" + "133914530277252197265625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.000000000000000000004p+0, false, +- 0x1.000000000000000000004p+0, false, +- 0x1.000000000000000000004p+0, false, +- 0x1.000000000000000000004p+0, false, +- true, +- 0x1.000000000000000000004p+0, false, +- 0x1.000000000000000000004p+0, false, +- 0x1.000000000000000000004p+0, false, +- 0x1.000000000000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000000004p+0, false, false, ++ 0x1.000000000000000000004p+0, false, false, ++ 0x1.000000000000000000004p+0, false, false, ++ 0x1.000000000000000000004p+0, false, false, ++ true, ++ 0x1.000000000000000000004p+0, false, false, ++ 0x1.000000000000000000004p+0, false, false, ++ 0x1.000000000000000000004p+0, false, false, ++ 0x1.000000000000000000004p+0, false, false), + TEST ("1.0000000000000000000000001033975765691284593589260865087453" + "5669572651386260986328125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.000000000000000000002p+0, false, +- 0x1.000000000000000000002p+0, false, +- 0x1.000000000000000000002p+0, false, +- 0x1.000000000000000000002p+0, false, +- true, +- 0x1.000000000000000000002p+0, false, +- 0x1.000000000000000000002p+0, false, +- 0x1.000000000000000000002p+0, false, +- 0x1.000000000000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000000002p+0, false, false, ++ 0x1.000000000000000000002p+0, false, false, ++ 0x1.000000000000000000002p+0, false, false, ++ 0x1.000000000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000000002p+0, false, false, ++ 0x1.000000000000000000002p+0, false, false, ++ 0x1.000000000000000000002p+0, false, false, ++ 0x1.000000000000000000002p+0, false, false), + TEST ("1.0000000000000000000000000516987882845642296794630432543726" + "78347863256931304931640625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.000000000000000000001p+0, false, +- 0x1.000000000000000000001p+0, false, +- 0x1.000000000000000000001p+0, false, +- 0x1.000000000000000000001p+0, false, +- true, +- 0x1.000000000000000000001p+0, false, +- 0x1.000000000000000000001p+0, false, +- 0x1.000000000000000000001p+0, false, +- 0x1.000000000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000000001p+0, false, false, ++ 0x1.000000000000000000001p+0, false, false, ++ 0x1.000000000000000000001p+0, false, false, ++ 0x1.000000000000000000001p+0, false, false, ++ true, ++ 0x1.000000000000000000001p+0, false, false, ++ 0x1.000000000000000000001p+0, false, false, ++ 0x1.000000000000000000001p+0, false, false, ++ 0x1.000000000000000000001p+0, false, false), + TEST ("1.0000000000000000000000000258493941422821148397315216271863" + "391739316284656524658203125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000000000008p+0, false, +- 0x1.0000000000000000000008p+0, false, +- 0x1.0000000000000000000008p+0, false, +- 0x1.0000000000000000000008p+0, false, +- true, +- 0x1.0000000000000000000008p+0, false, +- 0x1.0000000000000000000008p+0, false, +- 0x1.0000000000000000000008p+0, false, +- 0x1.0000000000000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000008p+0, false, false, ++ true, ++ 0x1.0000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000008p+0, false, false), + TEST ("1.0000000000000000000000000129246970711410574198657608135931" + "6958696581423282623291015625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000000000004p+0, false, +- 0x1.0000000000000000000004p+0, false, +- 0x1.0000000000000000000004p+0, false, +- 0x1.0000000000000000000004p+0, false, +- true, +- 0x1.0000000000000000000004p+0, false, +- 0x1.0000000000000000000004p+0, false, +- 0x1.0000000000000000000004p+0, false, +- 0x1.0000000000000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000004p+0, false, false, ++ true, ++ 0x1.0000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000004p+0, false, false), + TEST ("1.0000000000000000000000000064623485355705287099328804067965" + "84793482907116413116455078125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000000000002p+0, false, +- 0x1.0000000000000000000002p+0, false, +- 0x1.0000000000000000000002p+0, false, +- 0x1.0000000000000000000002p+0, false, +- true, +- 0x1.0000000000000000000002p+0, false, +- 0x1.0000000000000000000002p+0, false, +- 0x1.0000000000000000000002p+0, false, +- 0x1.0000000000000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000002p+0, false, false), + TEST ("1.0000000000000000000000000032311742677852643549664402033982" + "923967414535582065582275390625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000000000001p+0, false, +- 0x1.0000000000000000000001p+0, false, +- 0x1.0000000000000000000001p+0, false, +- 0x1.0000000000000000000001p+0, false, +- true, +- 0x1.0000000000000000000001p+0, false, +- 0x1.0000000000000000000001p+0, false, +- 0x1.0000000000000000000001p+0, false, +- 0x1.0000000000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000001p+0, false, false, ++ true, ++ 0x1.0000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000001p+0, false, false), + TEST ("1.0000000000000000000000000016155871338926321774832201016991" + "4619837072677910327911376953125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000000000008p+0, false, +- 0x1.00000000000000000000008p+0, false, +- 0x1.00000000000000000000008p+0, false, +- 0x1.00000000000000000000008p+0, false, +- true, +- 0x1.00000000000000000000008p+0, false, +- 0x1.00000000000000000000008p+0, false, +- 0x1.00000000000000000000008p+0, false, +- 0x1.00000000000000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000000008p+0, false, false, ++ 0x1.00000000000000000000008p+0, false, false, ++ 0x1.00000000000000000000008p+0, false, false, ++ 0x1.00000000000000000000008p+0, false, false, ++ true, ++ 0x1.00000000000000000000008p+0, false, false, ++ 0x1.00000000000000000000008p+0, false, false, ++ 0x1.00000000000000000000008p+0, false, false, ++ 0x1.00000000000000000000008p+0, false, false), + TEST ("1.0000000000000000000000000008077935669463160887416100508495" + "73099185363389551639556884765625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000000000004p+0, false, +- 0x1.00000000000000000000004p+0, false, +- 0x1.00000000000000000000004p+0, false, +- 0x1.00000000000000000000004p+0, false, +- true, +- 0x1.00000000000000000000004p+0, false, +- 0x1.00000000000000000000004p+0, false, +- 0x1.00000000000000000000004p+0, false, +- 0x1.00000000000000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000000004p+0, false, false, ++ 0x1.00000000000000000000004p+0, false, false, ++ 0x1.00000000000000000000004p+0, false, false, ++ 0x1.00000000000000000000004p+0, false, false, ++ true, ++ 0x1.00000000000000000000004p+0, false, false, ++ 0x1.00000000000000000000004p+0, false, false, ++ 0x1.00000000000000000000004p+0, false, false, ++ 0x1.00000000000000000000004p+0, false, false), + TEST ("1.0000000000000000000000000004038967834731580443708050254247" + "865495926816947758197784423828125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000000000002p+0, false, +- 0x1.00000000000000000000002p+0, false, +- 0x1.00000000000000000000002p+0, false, +- 0x1.00000000000000000000002p+0, false, +- true, +- 0x1.00000000000000000000002p+0, false, +- 0x1.00000000000000000000002p+0, false, +- 0x1.00000000000000000000002p+0, false, +- 0x1.00000000000000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000000002p+0, false, false, ++ 0x1.00000000000000000000002p+0, false, false, ++ 0x1.00000000000000000000002p+0, false, false, ++ 0x1.00000000000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000000002p+0, false, false, ++ 0x1.00000000000000000000002p+0, false, false, ++ 0x1.00000000000000000000002p+0, false, false, ++ 0x1.00000000000000000000002p+0, false, false), + TEST ("1.0000000000000000000000000002019483917365790221854025127123" + "9327479634084738790988922119140625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000000000001p+0, false, +- 0x1.00000000000000000000001p+0, false, +- 0x1.00000000000000000000001p+0, false, +- 0x1.00000000000000000000001p+0, false, +- true, +- 0x1.00000000000000000000001p+0, false, +- 0x1.00000000000000000000001p+0, false, +- 0x1.00000000000000000000001p+0, false, +- 0x1.00000000000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000000001p+0, false, false, ++ 0x1.00000000000000000000001p+0, false, false, ++ 0x1.00000000000000000000001p+0, false, false, ++ 0x1.00000000000000000000001p+0, false, false, ++ true, ++ 0x1.00000000000000000000001p+0, false, false, ++ 0x1.00000000000000000000001p+0, false, false, ++ 0x1.00000000000000000000001p+0, false, false, ++ 0x1.00000000000000000000001p+0, false, false), + TEST ("1.0000000000000000000000000001009741958682895110927012563561" + "96637398170423693954944610595703125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.000000000000000000000008p+0, false, +- 0x1.000000000000000000000008p+0, false, +- 0x1.000000000000000000000008p+0, false, +- 0x1.000000000000000000000008p+0, false, +- true, +- 0x1.000000000000000000000008p+0, false, +- 0x1.000000000000000000000008p+0, false, +- 0x1.000000000000000000000008p+0, false, +- 0x1.000000000000000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000000000008p+0, false, false, ++ 0x1.000000000000000000000008p+0, false, false, ++ 0x1.000000000000000000000008p+0, false, false, ++ 0x1.000000000000000000000008p+0, false, false, ++ true, ++ 0x1.000000000000000000000008p+0, false, false, ++ 0x1.000000000000000000000008p+0, false, false, ++ 0x1.000000000000000000000008p+0, false, false, ++ 0x1.000000000000000000000008p+0, false, false), + TEST ("1.0000000000000000000000000000504870979341447555463506281780" + "983186990852118469774723052978515625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.000000000000000000000004p+0, false, +- 0x1.000000000000000000000004p+0, false, +- 0x1.000000000000000000000004p+0, false, +- 0x1.000000000000000000000004p+0, false, +- true, +- 0x1.000000000000000000000004p+0, false, +- 0x1.000000000000000000000004p+0, false, +- 0x1.000000000000000000000004p+0, false, +- 0x1.000000000000000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000000000004p+0, false, false, ++ 0x1.000000000000000000000004p+0, false, false, ++ 0x1.000000000000000000000004p+0, false, false, ++ 0x1.000000000000000000000004p+0, false, false, ++ true, ++ 0x1.000000000000000000000004p+0, false, false, ++ 0x1.000000000000000000000004p+0, false, false, ++ 0x1.000000000000000000000004p+0, false, false, ++ 0x1.000000000000000000000004p+0, false, false), + TEST ("1.0000000000000000000000000000252435489670723777731753140890" + "4915934954260592348873615264892578125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.000000000000000000000002p+0, false, +- 0x1.000000000000000000000002p+0, false, +- 0x1.000000000000000000000002p+0, false, +- 0x1.000000000000000000000002p+0, false, +- true, +- 0x1.000000000000000000000002p+0, false, +- 0x1.000000000000000000000002p+0, false, +- 0x1.000000000000000000000002p+0, false, +- 0x1.000000000000000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000000000002p+0, false, false, ++ 0x1.000000000000000000000002p+0, false, false, ++ 0x1.000000000000000000000002p+0, false, false, ++ 0x1.000000000000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000000000002p+0, false, false, ++ 0x1.000000000000000000000002p+0, false, false, ++ 0x1.000000000000000000000002p+0, false, false, ++ 0x1.000000000000000000000002p+0, false, false), + TEST ("1.0000000000000000000000000000126217744835361888865876570445" + "24579674771302961744368076324462890625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.000000000000000000000001p+0, false, +- 0x1.000000000000000000000001p+0, false, +- 0x1.000000000000000000000001p+0, false, +- 0x1.000000000000000000000001p+0, false, +- true, +- 0x1.000000000000000000000001p+0, false, +- 0x1.000000000000000000000001p+0, false, +- 0x1.000000000000000000000001p+0, false, +- 0x1.000000000000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000000000001p+0, false, false, ++ 0x1.000000000000000000000001p+0, false, false, ++ 0x1.000000000000000000000001p+0, false, false, ++ 0x1.000000000000000000000001p+0, false, false, ++ true, ++ 0x1.000000000000000000000001p+0, false, false, ++ 0x1.000000000000000000000001p+0, false, false, ++ 0x1.000000000000000000000001p+0, false, false, ++ 0x1.000000000000000000000001p+0, false, false), + TEST ("1.0000000000000000000000000000063108872417680944432938285222" + "622898373856514808721840381622314453125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000000000000008p+0, false, +- 0x1.0000000000000000000000008p+0, false, +- 0x1.0000000000000000000000008p+0, false, +- 0x1.0000000000000000000000008p+0, false, +- true, +- 0x1.0000000000000000000000008p+0, false, +- 0x1.0000000000000000000000008p+0, false, +- 0x1.0000000000000000000000008p+0, false, +- 0x1.0000000000000000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000000008p+0, false, false, ++ true, ++ 0x1.0000000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000000008p+0, false, false), + TEST ("1.0000000000000000000000000000031554436208840472216469142611" + "3114491869282574043609201908111572265625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000000000000004p+0, false, +- 0x1.0000000000000000000000004p+0, false, +- 0x1.0000000000000000000000004p+0, false, +- 0x1.0000000000000000000000004p+0, false, +- true, +- 0x1.0000000000000000000000004p+0, false, +- 0x1.0000000000000000000000004p+0, false, +- 0x1.0000000000000000000000004p+0, false, +- 0x1.0000000000000000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000000004p+0, false, false, ++ true, ++ 0x1.0000000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000000004p+0, false, false), + TEST ("1.0000000000000000000000000000015777218104420236108234571305" + "65572459346412870218046009540557861328125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000000000000002p+0, false, +- 0x1.0000000000000000000000002p+0, false, +- 0x1.0000000000000000000000002p+0, false, +- 0x1.0000000000000000000000002p+0, false, +- true, +- 0x1.0000000000000000000000002p+0, false, +- 0x1.0000000000000000000000002p+0, false, +- 0x1.0000000000000000000000002p+0, false, +- 0x1.0000000000000000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000000002p+0, false, false), + TEST ("1.0000000000000000000000000000007888609052210118054117285652" + "827862296732064351090230047702789306640625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.0000000000000000000000001p+0, false, +- 0x1.0000000000000000000000001p+0, false, +- 0x1.0000000000000000000000001p+0, false, +- 0x1.0000000000000000000000001p+0, false, +- true, +- 0x1.0000000000000000000000001p+0, false, +- 0x1.0000000000000000000000001p+0, false, +- 0x1.0000000000000000000000001p+0, false, +- 0x1.0000000000000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.0000000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000000001p+0, false, false, ++ true, ++ 0x1.0000000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000000001p+0, false, false), + TEST ("1.0000000000000000000000000000003944304526105059027058642826" + "4139311483660321755451150238513946533203125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000000000000008p+0, false, +- 0x1.00000000000000000000000008p+0, false, +- 0x1.00000000000000000000000008p+0, false, +- 0x1.00000000000000000000000008p+0, false, +- true, +- 0x1.00000000000000000000000008p+0, false, +- 0x1.00000000000000000000000008p+0, false, +- 0x1.00000000000000000000000008p+0, false, +- 0x1.00000000000000000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000000000008p+0, false, false, ++ 0x1.00000000000000000000000008p+0, false, false, ++ 0x1.00000000000000000000000008p+0, false, false, ++ 0x1.00000000000000000000000008p+0, false, false, ++ true, ++ 0x1.00000000000000000000000008p+0, false, false, ++ 0x1.00000000000000000000000008p+0, false, false, ++ 0x1.00000000000000000000000008p+0, false, false, ++ 0x1.00000000000000000000000008p+0, false, false), + TEST ("1.0000000000000000000000000000001972152263052529513529321413" + "20696557418301608777255751192569732666015625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000000000000004p+0, false, +- 0x1.00000000000000000000000004p+0, false, +- 0x1.00000000000000000000000004p+0, false, +- 0x1.00000000000000000000000004p+0, false, +- true, +- 0x1.00000000000000000000000004p+0, false, +- 0x1.00000000000000000000000004p+0, false, +- 0x1.00000000000000000000000004p+0, false, +- 0x1.00000000000000000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000000000004p+0, false, false, ++ 0x1.00000000000000000000000004p+0, false, false, ++ 0x1.00000000000000000000000004p+0, false, false, ++ 0x1.00000000000000000000000004p+0, false, false, ++ true, ++ 0x1.00000000000000000000000004p+0, false, false, ++ 0x1.00000000000000000000000004p+0, false, false, ++ 0x1.00000000000000000000000004p+0, false, false, ++ 0x1.00000000000000000000000004p+0, false, false), + TEST ("1.0000000000000000000000000000000986076131526264756764660706" + "603482787091508043886278755962848663330078125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000000000000002p+0, false, +- 0x1.00000000000000000000000002p+0, false, +- 0x1.00000000000000000000000002p+0, false, +- 0x1.00000000000000000000000002p+0, false, +- true, +- 0x1.00000000000000000000000002p+0, false, +- 0x1.00000000000000000000000002p+0, false, +- 0x1.00000000000000000000000002p+0, false, +- 0x1.00000000000000000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000000000002p+0, false, false, ++ 0x1.00000000000000000000000002p+0, false, false, ++ 0x1.00000000000000000000000002p+0, false, false, ++ 0x1.00000000000000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000000000002p+0, false, false, ++ 0x1.00000000000000000000000002p+0, false, false, ++ 0x1.00000000000000000000000002p+0, false, false, ++ 0x1.00000000000000000000000002p+0, false, false), + TEST ("1.0000000000000000000000000000000493038065763132378382330353" + "3017413935457540219431393779814243316650390625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.00000000000000000000000001p+0, false, +- 0x1.00000000000000000000000001p+0, false, +- 0x1.00000000000000000000000001p+0, false, +- 0x1.00000000000000000000000001p+0, false, +- true, +- 0x1.00000000000000000000000001p+0, false, +- 0x1.00000000000000000000000001p+0, false, +- 0x1.00000000000000000000000001p+0, false, +- 0x1.00000000000000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.00000000000000000000000001p+0, false, false, ++ 0x1.00000000000000000000000001p+0, false, false, ++ 0x1.00000000000000000000000001p+0, false, false, ++ 0x1.00000000000000000000000001p+0, false, false, ++ true, ++ 0x1.00000000000000000000000001p+0, false, false, ++ 0x1.00000000000000000000000001p+0, false, false, ++ 0x1.00000000000000000000000001p+0, false, false, ++ 0x1.00000000000000000000000001p+0, false, false), + TEST ("1.0000000000000000000000000000000246519032881566189191165176" + "65087069677287701097156968899071216583251953125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- true, +- 0x1.000000000000000000000000008p+0, false, +- 0x1.000000000000000000000000008p+0, false, +- 0x1.000000000000000000000000008p+0, false, +- 0x1.000000000000000000000000008p+0, false, +- true, +- 0x1.000000000000000000000000008p+0, false, +- 0x1.000000000000000000000000008p+0, false, +- 0x1.000000000000000000000000008p+0, false, +- 0x1.000000000000000000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ true, ++ 0x1.000000000000000000000000008p+0, false, false, ++ 0x1.000000000000000000000000008p+0, false, false, ++ 0x1.000000000000000000000000008p+0, false, false, ++ 0x1.000000000000000000000000008p+0, false, false, ++ true, ++ 0x1.000000000000000000000000008p+0, false, false, ++ 0x1.000000000000000000000000008p+0, false, false, ++ 0x1.000000000000000000000000008p+0, false, false, ++ 0x1.000000000000000000000000008p+0, false, false), + TEST ("1.0000000000000000000000000000000123259516440783094595582588" + "325435348386438505485784844495356082916259765625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000000000000000000000000008p+0, false, +- true, +- 0x1.000000000000000000000000004p+0, false, +- 0x1.000000000000000000000000004p+0, false, +- 0x1.000000000000000000000000004p+0, false, +- 0x1.000000000000000000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000000000000000000000000008p+0, false, false, ++ true, ++ 0x1.000000000000000000000000004p+0, false, false, ++ 0x1.000000000000000000000000004p+0, false, false, ++ 0x1.000000000000000000000000004p+0, false, false, ++ 0x1.000000000000000000000000004p+0, false, false), + TEST ("1.0000000000000000000000000000000061629758220391547297791294" + "1627176741932192527428924222476780414581298828125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000000000000000000000000008p+0, false, +- true, +- 0x1.000000000000000000000000002p+0, false, +- 0x1.000000000000000000000000002p+0, false, +- 0x1.000000000000000000000000002p+0, false, +- 0x1.000000000000000000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000000000000000000000000008p+0, false, false, ++ true, ++ 0x1.000000000000000000000000002p+0, false, false, ++ 0x1.000000000000000000000000002p+0, false, false, ++ 0x1.000000000000000000000000002p+0, false, false, ++ 0x1.000000000000000000000000002p+0, false, false), + TEST ("1.0000000000000000000000000000000030814879110195773648895647" + "08135883709660962637144621112383902072906494140625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000000000000000000000000008p+0, false, +- true, +- 0x1.000000000000000000000000001p+0, false, +- 0x1.000000000000000000000000001p+0, false, +- 0x1.000000000000000000000000001p+0, false, +- 0x1.000000000000000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000000000000000000000000008p+0, false, false, ++ true, ++ 0x1.000000000000000000000000001p+0, false, false, ++ 0x1.000000000000000000000000001p+0, false, false, ++ 0x1.000000000000000000000000001p+0, false, false, ++ 0x1.000000000000000000000000001p+0, false, false), + TEST ("1.0000000000000000000000000000000015407439555097886824447823" + "540679418548304813185723105561919510364532470703125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000000000000000000000000008p+0, false, +- true, +- 0x1.0000000000000000000000000008p+0, false, +- 0x1.0000000000000000000000000008p+0, false, +- 0x1.0000000000000000000000000008p+0, false, +- 0x1.0000000000000000000000000008p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000000000000000000000000008p+0, false, false, ++ true, ++ 0x1.0000000000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000000000008p+0, false, false, ++ 0x1.0000000000000000000000000008p+0, false, false), + TEST ("1.0000000000000000000000000000000007703719777548943412223911" + "7703397092741524065928615527809597551822662353515625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000000000000000000000000008p+0, false, +- true, +- 0x1.0000000000000000000000000004p+0, false, +- 0x1.0000000000000000000000000004p+0, false, +- 0x1.0000000000000000000000000004p+0, false, +- 0x1.0000000000000000000000000004p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000000000000000000000000008p+0, false, false, ++ true, ++ 0x1.0000000000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000000000004p+0, false, false, ++ 0x1.0000000000000000000000000004p+0, false, false), + TEST ("1.0000000000000000000000000000000003851859888774471706111955" + "88516985463707620329643077639047987759113311767578125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000000000000000000000000008p+0, false, +- true, +- 0x1.0000000000000000000000000002p+0, false, +- 0x1.0000000000000000000000000002p+0, false, +- 0x1.0000000000000000000000000002p+0, false, +- 0x1.0000000000000000000000000002p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000000000000000000000000008p+0, false, false, ++ true, ++ 0x1.0000000000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000000000002p+0, false, false, ++ 0x1.0000000000000000000000000002p+0, false, false), + TEST ("1.0000000000000000000000000000000001925929944387235853055977" + "942584927318538101648215388195239938795566558837890625", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000000000000000000000000008p+0, false, +- true, +- 0x1.0000000000000000000000000001p+0, false, +- 0x1.0000000000000000000000000001p+0, false, +- 0x1.0000000000000000000000000001p+0, false, +- 0x1.0000000000000000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000000000000000000000000008p+0, false, false, ++ true, ++ 0x1.0000000000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000000000001p+0, false, false, ++ 0x1.0000000000000000000000000001p+0, false, false), + TEST ("1.0000000000000000000000000000000000962964972193617926527988" + "9712924636592690508241076940976199693977832794189453125", + false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000001p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000002p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.000000000000000000000000008p+0, false, +- false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1p+0, false, +- 0x1.0000000000000000000000000001p+0, false), ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000001p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000002p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.000000000000000000000000008p+0, false, false, ++ false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1p+0, false, false, ++ 0x1.0000000000000000000000000001p+0, false, false), + }; +diff --git a/stdlib/tst-strtod-round-skeleton.c b/stdlib/tst-strtod-round-skeleton.c +index c3cc0201d4b1a062..be081ba416a6e900 100644 +--- a/stdlib/tst-strtod-round-skeleton.c ++++ b/stdlib/tst-strtod-round-skeleton.c +@@ -30,6 +30,7 @@ + #include + #include + #include ++#include + + #include "tst-strtod.h" + +@@ -139,16 +140,26 @@ + gen-tst-strtod-round utility to select the appropriately + rounded long double value for a given format. */ + #define TEST(s, \ +- fx, fd, fdo, fn, fno, fz, fzo, fu, fuo, \ +- dx, dd, ddo, dn, dno, dz, dzo, du, duo, \ +- ld64ix, ld64id, ld64ido, ld64in, ld64ino, \ +- ld64iz, ld64izo, ld64iu, ld64iuo, \ +- ld64mx, ld64md, ld64mdo, ld64mn, ld64mno, \ +- ld64mz, ld64mzo, ld64mu, ld64muo, \ +- ld106x, ld106d, ld106do, ld106n, ld106no, \ +- ld106z, ld106zo, ld106u, ld106uo, \ +- ld113x, ld113d, ld113do, ld113n, ld113no, \ +- ld113z, ld113zo, ld113u, ld113uo) \ ++ fx, fd, fdo, fdu, fn, fno, fnu, \ ++ fz, fzo, fzu, fu, fuo, fuu, \ ++ dx, dd, ddo, ddu, dn, dno, dnu, \ ++ dz, dzo, dzu, du, duo, duu, \ ++ ld64ix, ld64id, ld64ido, ld64idu, \ ++ ld64in, ld64ino, ld64inu, \ ++ ld64iz, ld64izo, ld64izu, \ ++ ld64iu, ld64iuo, ld64iuu, \ ++ ld64mx, ld64md, ld64mdo, ld64mdu, \ ++ ld64mn, ld64mno, ld64mnu, \ ++ ld64mz, ld64mzo, ld64mzu, \ ++ ld64mu, ld64muo, ld64muu, \ ++ ld106x, ld106d, ld106do, ld106du, \ ++ ld106n, ld106no, ld106nu, \ ++ ld106z, ld106zo, ld106zu, \ ++ ld106u, ld106uo, ld106uu, \ ++ ld113x, ld113d, ld113do, ld113du, \ ++ ld113n, ld113no, ld113nu, \ ++ ld113z, ld113zo, ld113zu, \ ++ ld113u, ld113uo, ld113uu) \ + { \ + L_ (s), \ + { XNTRY (fx, dx, ld64ix, ld64mx, ld106x, ld113x) }, \ +@@ -163,6 +174,12 @@ + { XNTRY (fdo, ddo, ld64ido, ld64mdo, ld106do, ld113do) }, \ + { XNTRY (fzo, dzo, ld64izo, ld64mzo, ld106zo, ld113zo) }, \ + { XNTRY (fuo, duo, ld64iuo, ld64muo, ld106uo, ld113uo) } \ ++ }, \ ++ { \ ++ { XNTRY (fnu, dnu, ld64inu, ld64mnu, ld106nu, ld113nu) }, \ ++ { XNTRY (fdu, ddu, ld64idu, ld64mdu, ld106du, ld113du) }, \ ++ { XNTRY (fzu, dzu, ld64izu, ld64mzu, ld106zu, ld113zu) }, \ ++ { XNTRY (fuu, duu, ld64iuu, ld64muu, ld106uu, ld113uu) } \ + } \ + } + +@@ -181,11 +198,17 @@ struct test_overflow + STRUCT_FOREACH_FLOAT_BOOL + }; + ++struct test_underflow ++ { ++ STRUCT_FOREACH_FLOAT_BOOL ++ }; ++ + struct test { + const CHAR *s; + struct test_exactness exact; + struct test_results r[4]; + struct test_overflow o[4]; ++ struct test_underflow u[4]; + }; + + /* Include the generated test data. */ +@@ -203,10 +226,14 @@ struct test { + # define FE_OVERFLOW 0 + #endif + ++#ifndef FE_UNDERFLOW ++# define FE_UNDERFLOW 0 ++#endif ++ + #define GEN_ONE_TEST(FSUF, FTYPE, FTOSTR, LSUF, CSUF) \ + { \ + feclearexcept (FE_ALL_EXCEPT); \ +- errno = 0; \ ++ errno = 12345; \ + FTYPE f = STRTO (FSUF) (s, NULL); \ + int new_errno = errno; \ + if (f != expected->FSUF \ +@@ -265,6 +292,40 @@ struct test { + s, new_errno, ERANGE); \ + result = 1; \ + } \ ++ if (FE_UNDERFLOW != 0) \ ++ { \ ++ bool underflow_raised \ ++ = fetestexcept (FE_UNDERFLOW) != 0; \ ++ if (underflow_raised != underflow->FSUF) \ ++ { \ ++ printf (FNPFXS "to" #FSUF \ ++ " (" STRM ") underflow %d " \ ++ "not %d\n", s, underflow_raised, \ ++ underflow->FSUF); \ ++ if (EXCEPTION_TESTS (FTYPE)) \ ++ result = 1; \ ++ else \ ++ printf ("ignoring this exception error\n"); \ ++ } \ ++ } \ ++ if (underflow->FSUF && new_errno != ERANGE) \ ++ { \ ++ printf (FNPFXS "to" #FSUF \ ++ " (" STRM ") left errno == %d," \ ++ " not %d (ERANGE)\n", \ ++ s, new_errno, ERANGE); \ ++ result = 1; \ ++ } \ ++ if (!overflow->FSUF \ ++ && !underflow->FSUF \ ++ && new_errno != 12345) \ ++ { \ ++ printf (FNPFXS "to" #FSUF \ ++ " (" STRM ") set errno == %d," \ ++ " should be unchanged\n", \ ++ s, new_errno); \ ++ result = 1; \ ++ } \ + } \ + } + +@@ -272,6 +333,7 @@ static int + test_in_one_mode (const CHAR *s, const struct test_results *expected, + const struct test_exactness *exact, + const struct test_overflow *overflow, ++ const struct test_underflow *underflow, + const char *mode_name, int rnd_mode) + { + int result = 0; +@@ -307,6 +369,7 @@ do_test (void) + { + result |= test_in_one_mode (tests[i].s, &tests[i].r[modes[0].rnd_i], + &tests[i].exact, &tests[i].o[modes[0].rnd_i], ++ &tests[i].u[modes[0].rnd_i], + modes[0].mode_name, modes[0].rnd_mode); + for (const struct fetestmodes *m = &modes[1]; m->mode_name != NULL; m++) + { +@@ -314,7 +377,9 @@ do_test (void) + { + result |= test_in_one_mode (tests[i].s, &tests[i].r[m->rnd_i], + &tests[i].exact, +- &tests[i].o[m->rnd_i], m->mode_name, ++ &tests[i].o[m->rnd_i], ++ &tests[i].u[m->rnd_i], ++ m->mode_name, + m->rnd_mode); + fesetround (save_round_mode); + } diff --git a/SOURCES/glibc-upstream-2.39-127.patch b/SOURCES/glibc-upstream-2.39-127.patch new file mode 100644 index 0000000..9353706 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-127.patch @@ -0,0 +1,447 @@ +commit a7be595c67d12f1a442e3f6894d67e20c7724bed +Author: Joseph Myers +Date: Tue Aug 27 12:41:02 2024 +0000 + + Fix strtod subnormal rounding (bug 30220) + + As reported in bug 30220, the implementation of strtod-family + functions has a bug in the following case: the input string would, + with infinite exponent range, take one more bit to represent than is + available in the normal precision of the return type; the value + represented is in the subnormal range; and there are no nonzero bits + in the value, below those that can be represented in subnormal + precision, other than the least significant bit and possibly the + 0.5ulp bit. In this case, round_and_return ends up discarding the + least significant bit. + + Fix by saving that bit to merge into more_bits (it can't be merged in + at the time it's computed, because more_bits mustn't include this bit + in the case of after-rounding tininess detection checking if the + result is still subnormal when rounded to normal precision, so merging + this bit into more_bits needs to take place after that check). + + Tested for x86_64. + + (cherry picked from commit 457622c2fa8f9f7435822d5287a437bc8be8090d) + +diff --git a/stdlib/strtod_l.c b/stdlib/strtod_l.c +index be515ce659b35530..beb97b3d0cf3191a 100644 +--- a/stdlib/strtod_l.c ++++ b/stdlib/strtod_l.c +@@ -222,6 +222,7 @@ round_and_return (mp_limb_t *retval, intmax_t exponent, int negative, + + mp_size_t shift = MIN_EXP - 1 - exponent; + bool is_tiny = true; ++ bool old_half_bit = (round_limb & (((mp_limb_t) 1) << round_bit)) != 0; + + more_bits |= (round_limb & ((((mp_limb_t) 1) << round_bit) - 1)) != 0; + if (shift == MANT_DIG) +@@ -292,6 +293,7 @@ round_and_return (mp_limb_t *retval, intmax_t exponent, int negative, + round_bit = shift - 1; + (void) __mpn_rshift (retval, retval, RETURN_LIMB_SIZE, shift); + } ++ more_bits |= old_half_bit; + /* This is a hook for the m68k long double format, where the + exponent bias is the same for normalized and denormalized + numbers. */ +diff --git a/stdlib/tst-strtod-round-data b/stdlib/tst-strtod-round-data +index 84ab705709b24b6c..9489fbcc9ce7eee2 100644 +--- a/stdlib/tst-strtod-round-data ++++ b/stdlib/tst-strtod-round-data +@@ -265,3 +265,15 @@ + 1.000000000000000000000000000000000385185988877447170611195588516985463707620329643077639047987759113311767578125 + 1.0000000000000000000000000000000001925929944387235853055977942584927318538101648215388195239938795566558837890625 + 1.00000000000000000000000000000000009629649721936179265279889712924636592690508241076940976199693977832794189453125 ++0x30000002222225p-1077 ++0x0.7fffffffffffeap-1022 ++0x0.7fffffffffffe9p-1022 ++0x0.7ffffd4p-126 ++0x0.7ffffffffffffffd4p-16382 ++0x0.7ffffffffffffffd4p-16383 ++0x0.7ffffffffffffffffffffffffffeap-16382 ++0x0.7000004p-126 ++0x0.70000000000002p-1022 ++0x0.70000000000000004p-16382 ++0x0.70000000000000004p-16383 ++0x0.70000000000000000000000000002p-16382 +diff --git a/stdlib/tst-strtod-round-data.h b/stdlib/tst-strtod-round-data.h +index 13e62dd2b0588a16..ed50eb2537bc175c 100644 +--- a/stdlib/tst-strtod-round-data.h ++++ b/stdlib/tst-strtod-round-data.h +@@ -15437,4 +15437,376 @@ static const struct test tests[] = { + 0x1p+0, false, false, + 0x1p+0, false, false, + 0x1.0000000000000000000000000001p+0, false, false), ++ TEST ("0x30000002222225p-1077", ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x1.800000111111p-1024, false, true, ++ 0x1.8000001111114p-1024, false, true, ++ 0x1.800000111111p-1024, false, true, ++ 0x1.8000001111114p-1024, false, true, ++ true, ++ 0x1.80000011111128p-1024, false, false, ++ 0x1.80000011111128p-1024, false, false, ++ 0x1.80000011111128p-1024, false, false, ++ 0x1.80000011111128p-1024, false, false, ++ true, ++ 0x1.80000011111128p-1024, false, false, ++ 0x1.80000011111128p-1024, false, false, ++ 0x1.80000011111128p-1024, false, false, ++ 0x1.80000011111128p-1024, false, false, ++ false, ++ 0x1.800000111111p-1024, false, true, ++ 0x1.8000001111114p-1024, false, true, ++ 0x1.800000111111p-1024, false, true, ++ 0x1.8000001111114p-1024, false, true, ++ true, ++ 0x1.80000011111128p-1024, false, false, ++ 0x1.80000011111128p-1024, false, false, ++ 0x1.80000011111128p-1024, false, false, ++ 0x1.80000011111128p-1024, false, false), ++ TEST ("0x0.7fffffffffffeap-1022", ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x1.ffffffffffff8p-1024, false, true, ++ 0x1.ffffffffffffcp-1024, false, true, ++ 0x1.ffffffffffff8p-1024, false, true, ++ 0x1.ffffffffffffcp-1024, false, true, ++ true, ++ 0x1.ffffffffffffa8p-1024, false, false, ++ 0x1.ffffffffffffa8p-1024, false, false, ++ 0x1.ffffffffffffa8p-1024, false, false, ++ 0x1.ffffffffffffa8p-1024, false, false, ++ true, ++ 0x1.ffffffffffffa8p-1024, false, false, ++ 0x1.ffffffffffffa8p-1024, false, false, ++ 0x1.ffffffffffffa8p-1024, false, false, ++ 0x1.ffffffffffffa8p-1024, false, false, ++ false, ++ 0x1.ffffffffffff8p-1024, false, true, ++ 0x1.ffffffffffffcp-1024, false, true, ++ 0x1.ffffffffffff8p-1024, false, true, ++ 0x1.ffffffffffffcp-1024, false, true, ++ true, ++ 0x1.ffffffffffffa8p-1024, false, false, ++ 0x1.ffffffffffffa8p-1024, false, false, ++ 0x1.ffffffffffffa8p-1024, false, false, ++ 0x1.ffffffffffffa8p-1024, false, false), ++ TEST ("0x0.7fffffffffffe9p-1022", ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x1.ffffffffffff8p-1024, false, true, ++ 0x1.ffffffffffffcp-1024, false, true, ++ 0x1.ffffffffffff8p-1024, false, true, ++ 0x1.ffffffffffffcp-1024, false, true, ++ true, ++ 0x1.ffffffffffffa4p-1024, false, false, ++ 0x1.ffffffffffffa4p-1024, false, false, ++ 0x1.ffffffffffffa4p-1024, false, false, ++ 0x1.ffffffffffffa4p-1024, false, false, ++ true, ++ 0x1.ffffffffffffa4p-1024, false, false, ++ 0x1.ffffffffffffa4p-1024, false, false, ++ 0x1.ffffffffffffa4p-1024, false, false, ++ 0x1.ffffffffffffa4p-1024, false, false, ++ false, ++ 0x1.ffffffffffff8p-1024, false, true, ++ 0x1.ffffffffffffcp-1024, false, true, ++ 0x1.ffffffffffff8p-1024, false, true, ++ 0x1.ffffffffffffcp-1024, false, true, ++ true, ++ 0x1.ffffffffffffa4p-1024, false, false, ++ 0x1.ffffffffffffa4p-1024, false, false, ++ 0x1.ffffffffffffa4p-1024, false, false, ++ 0x1.ffffffffffffa4p-1024, false, false), ++ TEST ("0x0.7ffffd4p-126", ++ false, ++ 0x1.fffffp-128, false, true, ++ 0x1.fffff8p-128, false, true, ++ 0x1.fffffp-128, false, true, ++ 0x1.fffff8p-128, false, true, ++ true, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false, ++ true, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false, ++ true, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false, ++ true, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false, ++ true, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false, ++ 0x1.fffff5p-128, false, false), ++ TEST ("0x0.7ffffffffffffffd4p-16382", ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x1.fffffffffffffffp-16384, false, true, ++ 0x1.fffffffffffffff8p-16384, false, true, ++ 0x1.fffffffffffffffp-16384, false, true, ++ 0x1.fffffffffffffff8p-16384, false, true, ++ false, ++ 0x1.fffffffffffffff4p-16384, false, true, ++ 0x1.fffffffffffffff4p-16384, false, true, ++ 0x1.fffffffffffffff4p-16384, false, true, ++ 0x1.fffffffffffffff8p-16384, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ true, ++ 0x1.fffffffffffffff5p-16384, false, false, ++ 0x1.fffffffffffffff5p-16384, false, false, ++ 0x1.fffffffffffffff5p-16384, false, false, ++ 0x1.fffffffffffffff5p-16384, false, false), ++ TEST ("0x0.7ffffffffffffffd4p-16383", ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0xf.ffffffffffffff8p-16388, false, true, ++ 0xf.ffffffffffffff8p-16388, false, true, ++ 0xf.ffffffffffffff8p-16388, false, true, ++ 0x1p-16384, false, true, ++ false, ++ 0xf.ffffffffffffff8p-16388, false, true, ++ 0xf.ffffffffffffffcp-16388, false, true, ++ 0xf.ffffffffffffff8p-16388, false, true, ++ 0xf.ffffffffffffffcp-16388, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ true, ++ 0xf.ffffffffffffffa8p-16388, false, false, ++ 0xf.ffffffffffffffa8p-16388, false, false, ++ 0xf.ffffffffffffffa8p-16388, false, false, ++ 0xf.ffffffffffffffa8p-16388, false, false), ++ TEST ("0x0.7ffffffffffffffffffffffffffeap-16382", ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x1.fffffffffffffff8p-16384, false, true, ++ 0x2p-16384, false, true, ++ 0x1.fffffffffffffff8p-16384, false, true, ++ 0x2p-16384, false, true, ++ false, ++ 0x1.fffffffffffffffcp-16384, false, true, ++ 0x2p-16384, false, true, ++ 0x1.fffffffffffffffcp-16384, false, true, ++ 0x2p-16384, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x1.fffffffffffffffffffffffffff8p-16384, false, true, ++ 0x1.fffffffffffffffffffffffffffcp-16384, false, true, ++ 0x1.fffffffffffffffffffffffffff8p-16384, false, true, ++ 0x1.fffffffffffffffffffffffffffcp-16384, false, true), ++ TEST ("0x0.7000004p-126", ++ false, ++ 0x1.cp-128, false, true, ++ 0x1.cp-128, false, true, ++ 0x1.cp-128, false, true, ++ 0x1.c00008p-128, false, true, ++ true, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false, ++ true, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false, ++ true, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false, ++ true, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false, ++ true, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false, ++ 0x1.c00001p-128, false, false), ++ TEST ("0x0.70000000000002p-1022", ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x1.cp-1024, false, true, ++ 0x1.cp-1024, false, true, ++ 0x1.cp-1024, false, true, ++ 0x1.c000000000004p-1024, false, true, ++ true, ++ 0x1.c0000000000008p-1024, false, false, ++ 0x1.c0000000000008p-1024, false, false, ++ 0x1.c0000000000008p-1024, false, false, ++ 0x1.c0000000000008p-1024, false, false, ++ true, ++ 0x1.c0000000000008p-1024, false, false, ++ 0x1.c0000000000008p-1024, false, false, ++ 0x1.c0000000000008p-1024, false, false, ++ 0x1.c0000000000008p-1024, false, false, ++ false, ++ 0x1.cp-1024, false, true, ++ 0x1.cp-1024, false, true, ++ 0x1.cp-1024, false, true, ++ 0x1.c000000000004p-1024, false, true, ++ true, ++ 0x1.c0000000000008p-1024, false, false, ++ 0x1.c0000000000008p-1024, false, false, ++ 0x1.c0000000000008p-1024, false, false, ++ 0x1.c0000000000008p-1024, false, false), ++ TEST ("0x0.70000000000000004p-16382", ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x1.cp-16384, false, true, ++ 0x1.cp-16384, false, true, ++ 0x1.cp-16384, false, true, ++ 0x1.c000000000000008p-16384, false, true, ++ false, ++ 0x1.cp-16384, false, true, ++ 0x1.cp-16384, false, true, ++ 0x1.cp-16384, false, true, ++ 0x1.c000000000000004p-16384, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ true, ++ 0x1.c000000000000001p-16384, false, false, ++ 0x1.c000000000000001p-16384, false, false, ++ 0x1.c000000000000001p-16384, false, false, ++ 0x1.c000000000000001p-16384, false, false), ++ TEST ("0x0.70000000000000004p-16383", ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0xep-16388, false, true, ++ 0xep-16388, false, true, ++ 0xep-16388, false, true, ++ 0xe.000000000000008p-16388, false, true, ++ false, ++ 0xep-16388, false, true, ++ 0xep-16388, false, true, ++ 0xep-16388, false, true, ++ 0xe.000000000000004p-16388, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ true, ++ 0xe.0000000000000008p-16388, false, false, ++ 0xe.0000000000000008p-16388, false, false, ++ 0xe.0000000000000008p-16388, false, false, ++ 0xe.0000000000000008p-16388, false, false), ++ TEST ("0x0.70000000000000000000000000002p-16382", ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x8p-152, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x1.cp-16384, false, true, ++ 0x1.cp-16384, false, true, ++ 0x1.cp-16384, false, true, ++ 0x1.c000000000000008p-16384, false, true, ++ false, ++ 0x1.cp-16384, false, true, ++ 0x1.cp-16384, false, true, ++ 0x1.cp-16384, false, true, ++ 0x1.c000000000000004p-16384, false, true, ++ false, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x0p+0, false, true, ++ 0x4p-1076, false, true, ++ false, ++ 0x1.cp-16384, false, true, ++ 0x1.cp-16384, false, true, ++ 0x1.cp-16384, false, true, ++ 0x1.c000000000000000000000000004p-16384, false, true), + }; diff --git a/SOURCES/glibc-upstream-2.39-128.patch b/SOURCES/glibc-upstream-2.39-128.patch new file mode 100644 index 0000000..e83ba4a --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-128.patch @@ -0,0 +1,600 @@ +commit 86369c9ee4d200527e85d240fa0ee081fdb9fb4c +Author: Joseph Myers +Date: Tue Aug 27 20:41:54 2024 +0000 + + Make __strtod_internal tests type-generic + + Some of the strtod tests use type-generic machinery in tst-strtod.h to + test the strto* functions for all floating types, while others only + test double even when the tests are in fact meaningful for all + floating types. + + Convert the tests of the internal __strtod_internal interface to cover + all floating types. I haven't tried to convert them to use newer test + interfaces in other ways, just made the changes necessary to use the + type-generic machinery. As an internal interface, there are no + aliases for different types with the same ABI (however, + __strtold_internal is defined even if long double has the same ABI as + double), so macros used by the type-generic testing code are redefined + as needed to avoid expecting such aliases to be present. + + Tested for x86_64. + + (cherry picked from commit 3fc063dee01da4f80920a14b7db637c8501d6fd4) + +diff --git a/stdlib/tst-strtod1i.c b/stdlib/tst-strtod1i.c +index 9d6bb760fb954508..44ae0264f4f99a92 100644 +--- a/stdlib/tst-strtod1i.c ++++ b/stdlib/tst-strtod1i.c +@@ -25,60 +25,91 @@ + #include + #include + +-/* Perform a few tests in a locale with thousands separators. */ +-static int +-do_test (void) +-{ +- static const struct +- { +- const char *loc; +- const char *str; +- double exp; +- ptrdiff_t nread; +- } tests[] = +- { +- { "de_DE.UTF-8", "1,5", 1.5, 3 }, +- { "de_DE.UTF-8", "1.5", 1.0, 1 }, +- { "de_DE.UTF-8", "1.500", 1500.0, 5 }, +- { "de_DE.UTF-8", "36.893.488.147.419.103.232", 0x1.0p65, 26 } +- }; +-#define ntests (sizeof (tests) / sizeof (tests[0])) +- size_t n; +- int result = 0; +- +- puts ("\nLocale tests"); ++#include "tst-strtod.h" + +- for (n = 0; n < ntests; ++n) +- { +- double d; +- char *endp; ++/* This tests internal interfaces, which are only defined for types ++ with distinct ABIs, so disable testing for types without distinct ++ ABIs. */ ++#undef IF_FLOAT32 ++#define IF_FLOAT32(x) ++#undef IF_FLOAT64 ++#define IF_FLOAT64(x) ++#undef IF_FLOAT32X ++#define IF_FLOAT32X(x) ++#undef IF_FLOAT64X ++#define IF_FLOAT64X(x) ++#if !__HAVE_DISTINCT_FLOAT128 ++# undef IF_FLOAT128 ++# define IF_FLOAT128(x) ++#endif + +- if (setlocale (LC_ALL, tests[n].loc) == NULL) +- { +- printf ("cannot set locale %s\n", tests[n].loc); +- result = 1; +- continue; +- } ++#define ntests (sizeof (tests) / sizeof (tests[0])) + +- d = __strtod_internal (tests[n].str, &endp, 1); +- if (d != tests[n].exp) +- { +- printf ("strtod(\"%s\") returns %g and not %g\n", +- tests[n].str, d, tests[n].exp); +- result = 1; +- } +- else if (endp - tests[n].str != tests[n].nread) +- { +- printf ("strtod(\"%s\") read %td bytes and not %td\n", +- tests[n].str, endp - tests[n].str, tests[n].nread); +- result = 1; +- } +- } ++/* Perform a few tests in a locale with thousands separators. */ ++#define TEST_STRTOD(FSUF, FTYPE, FTOSTR, LSUF, CSUF) \ ++static int \ ++test_strto ## FSUF (void) \ ++{ \ ++ static const struct \ ++ { \ ++ const char *loc; \ ++ const char *str; \ ++ FTYPE exp; \ ++ ptrdiff_t nread; \ ++ } tests[] = \ ++ { \ ++ { "de_DE.UTF-8", "1,5", 1.5 ## LSUF, 3 }, \ ++ { "de_DE.UTF-8", "1.5", 1.0 ## LSUF, 1 }, \ ++ { "de_DE.UTF-8", "1.500", 1500.0 ## LSUF, 5 }, \ ++ { "de_DE.UTF-8", "36.893.488.147.419.103.232", 0x1.0p65 ## LSUF, 26 } \ ++ }; \ ++ size_t n; \ ++ int result = 0; \ ++ \ ++ puts ("\nLocale tests"); \ ++ \ ++ for (n = 0; n < ntests; ++n) \ ++ { \ ++ FTYPE d; \ ++ char *endp; \ ++ \ ++ if (setlocale (LC_ALL, tests[n].loc) == NULL) \ ++ { \ ++ printf ("cannot set locale %s\n", tests[n].loc); \ ++ result = 1; \ ++ continue; \ ++ } \ ++ \ ++ d = __strto ## FSUF ## _internal (tests[n].str, &endp, 1); \ ++ if (d != tests[n].exp) \ ++ { \ ++ char buf1[FSTRLENMAX], buf2[FSTRLENMAX]; \ ++ FTOSTR (buf1, sizeof (buf1), "%g", d); \ ++ FTOSTR (buf2, sizeof (buf2), "%g", tests[n].exp); \ ++ printf ("strto" # FSUF "(\"%s\") returns %s and not %s\n", \ ++ tests[n].str, buf1, buf2); \ ++ result = 1; \ ++ } \ ++ else if (endp - tests[n].str != tests[n].nread) \ ++ { \ ++ printf ("strto" # FSUF "(\"%s\") read %td bytes and not %td\n", \ ++ tests[n].str, endp - tests[n].str, tests[n].nread); \ ++ result = 1; \ ++ } \ ++ } \ ++ \ ++ if (result == 0) \ ++ puts ("all OK"); \ ++ \ ++ return result ? EXIT_FAILURE : EXIT_SUCCESS; \ ++} + +- if (result == 0) +- puts ("all OK"); ++GEN_TEST_STRTOD_FOREACH (TEST_STRTOD) + +- return result ? EXIT_FAILURE : EXIT_SUCCESS; ++static int ++do_test (void) ++{ ++ return STRTOD_TEST_FOREACH (test_strto); + } + + #include +diff --git a/stdlib/tst-strtod3.c b/stdlib/tst-strtod3.c +index 23abec1896896276..0d662d8be83a7525 100644 +--- a/stdlib/tst-strtod3.c ++++ b/stdlib/tst-strtod3.c +@@ -3,19 +3,73 @@ + #include + #include + +-static const struct +-{ +- const char *in; +- const char *out; +- double expected; +-} tests[] = +- { +- { "000,,,e1", ",,,e1", 0.0 }, +- { "000e1", "", 0.0 }, +- { "000,1e1", ",1e1", 0.0 } +- }; +-#define NTESTS (sizeof (tests) / sizeof (tests[0])) ++#include "tst-strtod.h" ++ ++/* This tests internal interfaces, which are only defined for types ++ with distinct ABIs, so disable testing for types without distinct ++ ABIs. */ ++#undef IF_FLOAT32 ++#define IF_FLOAT32(x) ++#undef IF_FLOAT64 ++#define IF_FLOAT64(x) ++#undef IF_FLOAT32X ++#define IF_FLOAT32X(x) ++#undef IF_FLOAT64X ++#define IF_FLOAT64X(x) ++#if !__HAVE_DISTINCT_FLOAT128 ++# undef IF_FLOAT128 ++# define IF_FLOAT128(x) ++#endif + ++#define TEST_STRTOD(FSUF, FTYPE, FTOSTR, LSUF, CSUF) \ ++static const struct \ ++{ \ ++ const char *in; \ ++ const char *out; \ ++ FTYPE expected; \ ++} tests_strto ## FSUF[] = \ ++ { \ ++ { "000,,,e1", ",,,e1", 0.0 ## LSUF }, \ ++ { "000e1", "", 0.0 ## LSUF }, \ ++ { "000,1e1", ",1e1", 0.0 ## LSUF } \ ++ }; \ ++ \ ++static int \ ++test_strto ## FSUF (void) \ ++{ \ ++ int status = 0; \ ++ \ ++ for (int i = 0; \ ++ i < sizeof (tests_strto ## FSUF) / sizeof (tests_strto ## FSUF[0]); \ ++ ++i) \ ++ { \ ++ char *ep; \ ++ FTYPE r = __strto ## FSUF ## _internal (tests_strto ## FSUF[i].in, \ ++ &ep, 1); \ ++ \ ++ if (strcmp (ep, tests_strto ## FSUF[i].out) != 0) \ ++ { \ ++ printf ("%d: got rest string \"%s\", expected \"%s\"\n", \ ++ i, ep, tests_strto ## FSUF[i].out); \ ++ status = 1; \ ++ } \ ++ \ ++ if (r != tests_strto ## FSUF[i].expected) \ ++ { \ ++ char buf1[FSTRLENMAX], buf2[FSTRLENMAX]; \ ++ FTOSTR (buf1, sizeof (buf1), "%g", r); \ ++ FTOSTR (buf2, sizeof (buf2), "%g", \ ++ tests_strto ## FSUF[i].expected); \ ++ printf ("%d: got wrong results %s, expected %s\n", \ ++ i, buf1, buf2); \ ++ status = 1; \ ++ } \ ++ } \ ++ \ ++ return status; \ ++} ++ ++GEN_TEST_STRTOD_FOREACH (TEST_STRTOD) + + static int + do_test (void) +@@ -26,29 +80,7 @@ do_test (void) + return 1; + } + +- int status = 0; +- +- for (int i = 0; i < NTESTS; ++i) +- { +- char *ep; +- double r = __strtod_internal (tests[i].in, &ep, 1); +- +- if (strcmp (ep, tests[i].out) != 0) +- { +- printf ("%d: got rest string \"%s\", expected \"%s\"\n", +- i, ep, tests[i].out); +- status = 1; +- } +- +- if (r != tests[i].expected) +- { +- printf ("%d: got wrong results %g, expected %g\n", +- i, r, tests[i].expected); +- status = 1; +- } +- } +- +- return status; ++ return STRTOD_TEST_FOREACH (test_strto); + } + + #define TEST_FUNCTION do_test () +diff --git a/stdlib/tst-strtod4.c b/stdlib/tst-strtod4.c +index 6cc4e843c78a4ac0..dfd3f05027c0d3c1 100644 +--- a/stdlib/tst-strtod4.c ++++ b/stdlib/tst-strtod4.c +@@ -3,22 +3,76 @@ + #include + #include + ++#include "tst-strtod.h" ++ ++/* This tests internal interfaces, which are only defined for types ++ with distinct ABIs, so disable testing for types without distinct ++ ABIs. */ ++#undef IF_FLOAT32 ++#define IF_FLOAT32(x) ++#undef IF_FLOAT64 ++#define IF_FLOAT64(x) ++#undef IF_FLOAT32X ++#define IF_FLOAT32X(x) ++#undef IF_FLOAT64X ++#define IF_FLOAT64X(x) ++#if !__HAVE_DISTINCT_FLOAT128 ++# undef IF_FLOAT128 ++# define IF_FLOAT128(x) ++#endif ++ + #define NNBSP "\xe2\x80\xaf" + +-static const struct +-{ +- const char *in; +- const char *out; +- double expected; +-} tests[] = +- { +- { "000"NNBSP"000"NNBSP"000", "", 0.0 }, +- { "1"NNBSP"000"NNBSP"000,5x", "x", 1000000.5 }, +- /* Bug 30964 */ +- { "10"NNBSP NNBSP"200", NNBSP NNBSP"200", 10.0 } +- }; +-#define NTESTS (sizeof (tests) / sizeof (tests[0])) ++#define TEST_STRTOD(FSUF, FTYPE, FTOSTR, LSUF, CSUF) \ ++static const struct \ ++{ \ ++ const char *in; \ ++ const char *out; \ ++ FTYPE expected; \ ++} tests_strto ## FSUF[] = \ ++ { \ ++ { "000"NNBSP"000"NNBSP"000", "", 0.0 ## LSUF }, \ ++ { "1"NNBSP"000"NNBSP"000,5x", "x", 1000000.5 ## LSUF }, \ ++ /* Bug 30964 */ \ ++ { "10"NNBSP NNBSP"200", NNBSP NNBSP"200", 10.0 ## LSUF } \ ++ }; \ ++ \ ++static int \ ++test_strto ## FSUF (void) \ ++{ \ ++ int status = 0; \ ++ \ ++ for (int i = 0; \ ++ i < sizeof (tests_strto ## FSUF) / sizeof (tests_strto ## FSUF[0]); \ ++ ++i) \ ++ { \ ++ char *ep; \ ++ FTYPE r = __strto ## FSUF ## _internal (tests_strto ## FSUF[i].in, \ ++ &ep, 1); \ ++ \ ++ if (strcmp (ep, tests_strto ## FSUF[i].out) != 0) \ ++ { \ ++ printf ("%d: got rest string \"%s\", expected \"%s\"\n", \ ++ i, ep, tests_strto ## FSUF[i].out); \ ++ status = 1; \ ++ } \ ++ \ ++ if (r != tests_strto ## FSUF[i].expected) \ ++ { \ ++ char buf1[FSTRLENMAX], buf2[FSTRLENMAX]; \ ++ FTOSTR (buf1, sizeof (buf1), "%g", r); \ ++ FTOSTR (buf2, sizeof (buf2), "%g", \ ++ tests_strto ## FSUF[i].expected); \ ++ printf ("%d: got wrong results %s, expected %s\n", \ ++ i, buf1, buf2); \ ++ status = 1; \ ++ } \ ++ } \ ++ \ ++ return status; \ ++} + ++GEN_TEST_STRTOD_FOREACH (TEST_STRTOD) + + static int + do_test (void) +@@ -29,29 +83,7 @@ do_test (void) + return 1; + } + +- int status = 0; +- +- for (int i = 0; i < NTESTS; ++i) +- { +- char *ep; +- double r = __strtod_internal (tests[i].in, &ep, 1); +- +- if (strcmp (ep, tests[i].out) != 0) +- { +- printf ("%d: got rest string \"%s\", expected \"%s\"\n", +- i, ep, tests[i].out); +- status = 1; +- } +- +- if (r != tests[i].expected) +- { +- printf ("%d: got wrong results %g, expected %g\n", +- i, r, tests[i].expected); +- status = 1; +- } +- } +- +- return status; ++ return STRTOD_TEST_FOREACH (test_strto); + } + + #define TEST_FUNCTION do_test () +diff --git a/stdlib/tst-strtod5i.c b/stdlib/tst-strtod5i.c +index ee54e3404c6e56c1..136aedea68745dd6 100644 +--- a/stdlib/tst-strtod5i.c ++++ b/stdlib/tst-strtod5i.c +@@ -16,52 +16,112 @@ + License along with the GNU C Library; if not, see + . */ + ++/* Defining _LIBC_TEST ensures long double math functions are ++ declared in the headers. */ ++#define _LIBC_TEST 1 + #include + #include + #include + #include + #include + ++#include "tst-strtod.h" ++ ++/* This tests internal interfaces, which are only defined for types ++ with distinct ABIs, so disable testing for types without distinct ++ ABIs. */ ++#undef IF_FLOAT32 ++#define IF_FLOAT32(x) ++#undef IF_FLOAT64 ++#define IF_FLOAT64(x) ++#undef IF_FLOAT32X ++#define IF_FLOAT32X(x) ++#undef IF_FLOAT64X ++#define IF_FLOAT64X(x) ++#if !__HAVE_DISTINCT_FLOAT128 ++# undef IF_FLOAT128 ++# define IF_FLOAT128(x) ++#endif ++ + #define NNBSP "\xe2\x80\xaf" + +-static const struct +-{ +- const char *in; +- int group; +- double expected; +-} tests[] = +- { +- { "0", 0, 0.0 }, +- { "000", 0, 0.0 }, +- { "-0", 0, -0.0 }, +- { "-000", 0, -0.0 }, +- { "0,", 0, 0.0 }, +- { "-0,", 0, -0.0 }, +- { "0,0", 0, 0.0 }, +- { "-0,0", 0, -0.0 }, +- { "0e-10", 0, 0.0 }, +- { "-0e-10", 0, -0.0 }, +- { "0,e-10", 0, 0.0 }, +- { "-0,e-10", 0, -0.0 }, +- { "0,0e-10", 0, 0.0 }, +- { "-0,0e-10", 0, -0.0 }, +- { "0e-1000000", 0, 0.0 }, +- { "-0e-1000000", 0, -0.0 }, +- { "0,0e-1000000", 0, 0.0 }, +- { "-0,0e-1000000", 0, -0.0 }, +- { "0", 1, 0.0 }, +- { "000", 1, 0.0 }, +- { "-0", 1, -0.0 }, +- { "-000", 1, -0.0 }, +- { "0e-10", 1, 0.0 }, +- { "-0e-10", 1, -0.0 }, +- { "0e-1000000", 1, 0.0 }, +- { "-0e-1000000", 1, -0.0 }, +- { "000"NNBSP"000"NNBSP"000", 1, 0.0 }, +- { "-000"NNBSP"000"NNBSP"000", 1, -0.0 } +- }; +-#define NTESTS (sizeof (tests) / sizeof (tests[0])) ++#define TEST_STRTOD(FSUF, FTYPE, FTOSTR, LSUF, CSUF) \ ++static const struct \ ++{ \ ++ const char *in; \ ++ int group; \ ++ FTYPE expected; \ ++} tests_strto ## FSUF[] = \ ++ { \ ++ { "0", 0, 0.0 ## LSUF }, \ ++ { "000", 0, 0.0 ## LSUF }, \ ++ { "-0", 0, -0.0 ## LSUF }, \ ++ { "-000", 0, -0.0 ## LSUF }, \ ++ { "0,", 0, 0.0 ## LSUF }, \ ++ { "-0,", 0, -0.0 ## LSUF }, \ ++ { "0,0", 0, 0.0 ## LSUF }, \ ++ { "-0,0", 0, -0.0 ## LSUF }, \ ++ { "0e-10", 0, 0.0 ## LSUF }, \ ++ { "-0e-10", 0, -0.0 ## LSUF }, \ ++ { "0,e-10", 0, 0.0 ## LSUF }, \ ++ { "-0,e-10", 0, -0.0 ## LSUF }, \ ++ { "0,0e-10", 0, 0.0 ## LSUF }, \ ++ { "-0,0e-10", 0, -0.0 ## LSUF }, \ ++ { "0e-1000000", 0, 0.0 ## LSUF }, \ ++ { "-0e-1000000", 0, -0.0 ## LSUF }, \ ++ { "0,0e-1000000", 0, 0.0 ## LSUF }, \ ++ { "-0,0e-1000000", 0, -0.0 ## LSUF }, \ ++ { "0", 1, 0.0 ## LSUF }, \ ++ { "000", 1, 0.0 ## LSUF }, \ ++ { "-0", 1, -0.0 ## LSUF }, \ ++ { "-000", 1, -0.0 ## LSUF }, \ ++ { "0e-10", 1, 0.0 ## LSUF }, \ ++ { "-0e-10", 1, -0.0 ## LSUF }, \ ++ { "0e-1000000", 1, 0.0 ## LSUF }, \ ++ { "-0e-1000000", 1, -0.0 ## LSUF }, \ ++ { "000"NNBSP"000"NNBSP"000", 1, 0.0 ## LSUF }, \ ++ { "-000"NNBSP"000"NNBSP"000", 1, -0.0 ## LSUF } \ ++ }; \ ++ \ ++static int \ ++test_strto ## FSUF (void) \ ++{ \ ++ int status = 0; \ ++ \ ++ for (int i = 0; \ ++ i < sizeof (tests_strto ## FSUF) / sizeof (tests_strto ## FSUF[0]); \ ++ ++i) \ ++ { \ ++ char *ep; \ ++ FTYPE r = __strto ## FSUF ## _internal (tests_strto ## FSUF[i].in, \ ++ &ep, \ ++ tests_strto ## FSUF[i].group); \ ++ \ ++ if (*ep != '\0') \ ++ { \ ++ printf ("%d: got rest string \"%s\", expected \"\"\n", i, ep); \ ++ status = 1; \ ++ } \ ++ \ ++ if (r != tests_strto ## FSUF[i].expected \ ++ || (copysign ## CSUF (10.0 ## LSUF, r) \ ++ != copysign ## CSUF (10.0 ## LSUF, \ ++ tests_strto ## FSUF[i].expected))) \ ++ { \ ++ char buf1[FSTRLENMAX], buf2[FSTRLENMAX]; \ ++ FTOSTR (buf1, sizeof (buf1), "%g", r); \ ++ FTOSTR (buf2, sizeof (buf2), "%g", \ ++ tests_strto ## FSUF[i].expected); \ ++ printf ("%d: got wrong results %s, expected %s\n", \ ++ i, buf1, buf2); \ ++ status = 1; \ ++ } \ ++ } \ ++ \ ++ return status; \ ++} + ++GEN_TEST_STRTOD_FOREACH (TEST_STRTOD) + + static int + do_test (void) +@@ -72,29 +132,7 @@ do_test (void) + return 1; + } + +- int status = 0; +- +- for (int i = 0; i < NTESTS; ++i) +- { +- char *ep; +- double r = __strtod_internal (tests[i].in, &ep, tests[i].group); +- +- if (*ep != '\0') +- { +- printf ("%d: got rest string \"%s\", expected \"\"\n", i, ep); +- status = 1; +- } +- +- if (r != tests[i].expected +- || copysign (10.0, r) != copysign (10.0, tests[i].expected)) +- { +- printf ("%d: got wrong results %g, expected %g\n", +- i, r, tests[i].expected); +- status = 1; +- } +- } +- +- return status; ++ return STRTOD_TEST_FOREACH (test_strto); + } + + #include diff --git a/SOURCES/glibc-upstream-2.39-129.patch b/SOURCES/glibc-upstream-2.39-129.patch new file mode 100644 index 0000000..0288cb1 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-129.patch @@ -0,0 +1,142 @@ +commit 63bcc017446d14e64aed8511845400fc661f2828 +Author: Joseph Myers +Date: Wed Sep 4 13:20:18 2024 +0000 + + Improve NaN payload testing + + There are two separate sets of tests of NaN payloads in glibc: + + * libm-test-{get,set}payload* verify that getpayload, setpayload, + setpayloadsig and __builtin_nan functions are consistent in their + payload handling. + + * test-nan-payload verifies that strtod-family functions and the + not-built-in nan functions are consistent in their payload handling. + + Nothing, however, connects the two sets of functions (i.e., verifies + that strtod / nan are consistent with getpayload / setpayload / + __builtin_nan). + + Improve test-nan-payload to check actual payload value with getpayload + rather than just verifying that the strtod and nan functions produce + the same NaN. Also check that the NaNs produced aren't signaling and + extend the tests to cover _FloatN / _FloatNx. + + Tested for x86_64. + + (cherry picked from commit be77d5ae417236883c02d3d67c0716e3f669fa41) + +diff --git a/math/test-nan-payload.c b/math/test-nan-payload.c +index 4a81dc348bac0691..55c13de14eb6a4d0 100644 +--- a/math/test-nan-payload.c ++++ b/math/test-nan-payload.c +@@ -16,6 +16,8 @@ + License along with the GNU C Library; if not, see + . */ + ++#define _LIBC_TEST 1 ++#define __STDC_WANT_IEC_60559_TYPES_EXT__ + #include + #include + #include +@@ -31,7 +33,7 @@ + #define CHECK_IS_NAN(TYPE, A) \ + do \ + { \ +- if (isnan (A)) \ ++ if (isnan (A) && !issignaling (A)) \ + puts ("PASS: " #TYPE " " #A); \ + else \ + { \ +@@ -41,6 +43,19 @@ + } \ + while (0) + ++#define CHECK_PAYLOAD(TYPE, FUNC, A, P) \ ++ do \ ++ { \ ++ if (FUNC (&(A)) == (P)) \ ++ puts ("PASS: " #TYPE " payload " #A); \ ++ else \ ++ { \ ++ puts ("FAIL: " #TYPE " payload " #A); \ ++ result = 1; \ ++ } \ ++ } \ ++ while (0) ++ + #define CHECK_SAME_NAN(TYPE, A, B) \ + do \ + { \ +@@ -71,7 +86,7 @@ + bits. */ + #define CAN_TEST_EQ(MANT_DIG) ((MANT_DIG) != 64 && (MANT_DIG) != 106) + +-#define RUN_TESTS(TYPE, SFUNC, FUNC, MANT_DIG) \ ++#define RUN_TESTS(TYPE, SFUNC, FUNC, PLFUNC, MANT_DIG) \ + do \ + { \ + TYPE n123 = WRAP_NAN (FUNC, "123"); \ +@@ -82,6 +97,10 @@ + CHECK_IS_NAN (TYPE, n456); \ + TYPE s456 = WRAP_STRTO (SFUNC, "NAN(456)"); \ + CHECK_IS_NAN (TYPE, s456); \ ++ TYPE nh123 = WRAP_NAN (FUNC, "0x123"); \ ++ CHECK_IS_NAN (TYPE, nh123); \ ++ TYPE sh123 = WRAP_STRTO (SFUNC, "NAN(0x123)"); \ ++ CHECK_IS_NAN (TYPE, sh123); \ + TYPE n123x = WRAP_NAN (FUNC, "123)"); \ + CHECK_IS_NAN (TYPE, n123x); \ + TYPE nemp = WRAP_NAN (FUNC, ""); \ +@@ -92,8 +111,16 @@ + CHECK_IS_NAN (TYPE, sx); \ + if (CAN_TEST_EQ (MANT_DIG)) \ + CHECK_SAME_NAN (TYPE, n123, s123); \ ++ CHECK_PAYLOAD (TYPE, PLFUNC, n123, 123); \ ++ CHECK_PAYLOAD (TYPE, PLFUNC, s123, 123); \ + if (CAN_TEST_EQ (MANT_DIG)) \ + CHECK_SAME_NAN (TYPE, n456, s456); \ ++ CHECK_PAYLOAD (TYPE, PLFUNC, n456, 456); \ ++ CHECK_PAYLOAD (TYPE, PLFUNC, s456, 456); \ ++ if (CAN_TEST_EQ (MANT_DIG)) \ ++ CHECK_SAME_NAN (TYPE, nh123, sh123); \ ++ CHECK_PAYLOAD (TYPE, PLFUNC, nh123, 0x123); \ ++ CHECK_PAYLOAD (TYPE, PLFUNC, sh123, 0x123); \ + if (CAN_TEST_EQ (MANT_DIG)) \ + CHECK_SAME_NAN (TYPE, nemp, semp); \ + if (CAN_TEST_EQ (MANT_DIG)) \ +@@ -110,9 +137,31 @@ static int + do_test (void) + { + int result = 0; +- RUN_TESTS (float, strtof, nanf, FLT_MANT_DIG); +- RUN_TESTS (double, strtod, nan, DBL_MANT_DIG); +- RUN_TESTS (long double, strtold, nanl, LDBL_MANT_DIG); ++ RUN_TESTS (float, strtof, nanf, getpayloadf, FLT_MANT_DIG); ++ RUN_TESTS (double, strtod, nan, getpayload, DBL_MANT_DIG); ++ RUN_TESTS (long double, strtold, nanl, getpayloadl, LDBL_MANT_DIG); ++#if __HAVE_FLOAT16 ++ RUN_TESTS (_Float16, strtof16, nanf16, getpayloadf16, FLT16_MANT_DIG); ++#endif ++#if __HAVE_FLOAT32 ++ RUN_TESTS (_Float32, strtof32, nanf32, getpayloadf32, FLT32_MANT_DIG); ++#endif ++#if __HAVE_FLOAT64 ++ RUN_TESTS (_Float64, strtof64, nanf64, getpayloadf64, FLT64_MANT_DIG); ++#endif ++#if __HAVE_FLOAT128 ++ RUN_TESTS (_Float128, strtof128, nanf128, getpayloadf128, FLT128_MANT_DIG); ++#endif ++#if __HAVE_FLOAT32X ++ RUN_TESTS (_Float32x, strtof32x, nanf32x, getpayloadf32x, FLT32X_MANT_DIG); ++#endif ++#if __HAVE_FLOAT64X ++ RUN_TESTS (_Float64x, strtof64x, nanf64x, getpayloadf64x, FLT64X_MANT_DIG); ++#endif ++#if __HAVE_FLOAT128X ++ RUN_TESTS (_Float128x, strtof128x, nanf128x, getpayloadf128x, ++ FLT128X_MANT_DIG); ++#endif + return result; + } + diff --git a/SOURCES/glibc-upstream-2.39-130.patch b/SOURCES/glibc-upstream-2.39-130.patch new file mode 100644 index 0000000..3f5c953 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-130.patch @@ -0,0 +1,149 @@ +commit 6624318c89185fe8b9d1f61e7a6841a843b8f9f3 +Author: Joseph Myers +Date: Wed Sep 4 13:21:23 2024 +0000 + + Do not set errno for overflowing NaN payload in strtod/nan (bug 32045) + + As reported in bug 32045, it's incorrect for strtod/nan functions to + set errno based on overflowing payload (strtod should only set errno + for overflow / underflow of its actual result, and potentially if + nothing in the string can be parsed as a number at all; nan should be + a pure function that never sets it). Save and restore errno around + the internal strtoull call and add associated test coverage. + + Tested for x86_64. + + (cherry picked from commit 64f62c47e9c350f353336f2df6714e1d48ec50d8) + +diff --git a/math/Makefile b/math/Makefile +index 79ef4ebb65cd40ea..14107855e88bc96b 100644 +--- a/math/Makefile ++++ b/math/Makefile +@@ -462,6 +462,7 @@ CFLAGS-test-flt-eval-method.c += -fexcess-precision=standard + CFLAGS-test-fe-snans-always-signal.c += $(config-cflags-signaling-nans) + + CFLAGS-test-nan-const.c += -fno-builtin ++CFLAGS-test-nan-payload.c += -fno-builtin + + include ../Rules + +diff --git a/math/test-nan-payload.c b/math/test-nan-payload.c +index 55c13de14eb6a4d0..413791e09f8b348d 100644 +--- a/math/test-nan-payload.c ++++ b/math/test-nan-payload.c +@@ -18,6 +18,7 @@ + + #define _LIBC_TEST 1 + #define __STDC_WANT_IEC_60559_TYPES_EXT__ ++#include + #include + #include + #include +@@ -82,6 +83,26 @@ + } \ + while (0) + ++#define CLEAR_ERRNO \ ++ do \ ++ { \ ++ errno = 12345; \ ++ } \ ++ while (0) ++ ++#define CHECK_ERRNO(TYPE, A) \ ++ do \ ++ { \ ++ if (errno == 12345) \ ++ puts ("PASS: " #TYPE " " #A " errno"); \ ++ else \ ++ { \ ++ puts ("FAIL: " #TYPE " " #A " errno"); \ ++ result = 1; \ ++ } \ ++ } \ ++ while (0) ++ + /* Cannot test payloads by memcmp for formats where NaNs have padding + bits. */ + #define CAN_TEST_EQ(MANT_DIG) ((MANT_DIG) != 64 && (MANT_DIG) != 106) +@@ -89,26 +110,58 @@ + #define RUN_TESTS(TYPE, SFUNC, FUNC, PLFUNC, MANT_DIG) \ + do \ + { \ ++ CLEAR_ERRNO; \ + TYPE n123 = WRAP_NAN (FUNC, "123"); \ ++ CHECK_ERRNO (TYPE, n123); \ + CHECK_IS_NAN (TYPE, n123); \ ++ CLEAR_ERRNO; \ + TYPE s123 = WRAP_STRTO (SFUNC, "NAN(123)"); \ ++ CHECK_ERRNO (TYPE, s123); \ + CHECK_IS_NAN (TYPE, s123); \ ++ CLEAR_ERRNO; \ + TYPE n456 = WRAP_NAN (FUNC, "456"); \ ++ CHECK_ERRNO (TYPE, n456); \ + CHECK_IS_NAN (TYPE, n456); \ ++ CLEAR_ERRNO; \ + TYPE s456 = WRAP_STRTO (SFUNC, "NAN(456)"); \ ++ CHECK_ERRNO (TYPE, s456); \ + CHECK_IS_NAN (TYPE, s456); \ ++ CLEAR_ERRNO; \ + TYPE nh123 = WRAP_NAN (FUNC, "0x123"); \ ++ CHECK_ERRNO (TYPE, nh123); \ + CHECK_IS_NAN (TYPE, nh123); \ ++ CLEAR_ERRNO; \ + TYPE sh123 = WRAP_STRTO (SFUNC, "NAN(0x123)"); \ ++ CHECK_ERRNO (TYPE, sh123); \ + CHECK_IS_NAN (TYPE, sh123); \ ++ CLEAR_ERRNO; \ + TYPE n123x = WRAP_NAN (FUNC, "123)"); \ ++ CHECK_ERRNO (TYPE, n123x); \ + CHECK_IS_NAN (TYPE, n123x); \ ++ CLEAR_ERRNO; \ + TYPE nemp = WRAP_NAN (FUNC, ""); \ ++ CHECK_ERRNO (TYPE, nemp); \ + CHECK_IS_NAN (TYPE, nemp); \ ++ CLEAR_ERRNO; \ + TYPE semp = WRAP_STRTO (SFUNC, "NAN()"); \ ++ CHECK_ERRNO (TYPE, semp); \ + CHECK_IS_NAN (TYPE, semp); \ ++ CLEAR_ERRNO; \ + TYPE sx = WRAP_STRTO (SFUNC, "NAN"); \ ++ CHECK_ERRNO (TYPE, sx); \ + CHECK_IS_NAN (TYPE, sx); \ ++ CLEAR_ERRNO; \ ++ TYPE novf = WRAP_NAN (FUNC, "9999999999" \ ++ "99999999999999999999" \ ++ "9999999999"); \ ++ CHECK_ERRNO (TYPE, novf); \ ++ CHECK_IS_NAN (TYPE, novf); \ ++ CLEAR_ERRNO; \ ++ TYPE sovf = WRAP_STRTO (SFUNC, "NAN(9999999999" \ ++ "99999999999999999999" \ ++ "9999999999)"); \ ++ CHECK_ERRNO (TYPE, sovf); \ ++ CHECK_IS_NAN (TYPE, sovf); \ + if (CAN_TEST_EQ (MANT_DIG)) \ + CHECK_SAME_NAN (TYPE, n123, s123); \ + CHECK_PAYLOAD (TYPE, PLFUNC, n123, 123); \ +diff --git a/stdlib/strtod_nan_main.c b/stdlib/strtod_nan_main.c +index 4cb286d2b3fb0676..39fb7e9f75bc5dbd 100644 +--- a/stdlib/strtod_nan_main.c ++++ b/stdlib/strtod_nan_main.c +@@ -16,6 +16,7 @@ + License along with the GNU C Library; if not, see + . */ + ++#include + #include + #include + #include +@@ -50,7 +51,9 @@ STRTOD_NAN (const STRING_TYPE *str, STRING_TYPE **endptr, STRING_TYPE endc) + STRING_TYPE *endp; + unsigned long long int mant; + ++ int save_errno = errno; + mant = STRTOULL (str, &endp, 0); ++ __set_errno (save_errno); + if (endp == cp) + SET_NAN_PAYLOAD (retval, mant); + diff --git a/SOURCES/glibc-upstream-2.39-131.patch b/SOURCES/glibc-upstream-2.39-131.patch new file mode 100644 index 0000000..6a38b42 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-131.patch @@ -0,0 +1,77 @@ +commit a2f7087237e77122c2c08b15efc3cee5f475cd46 +Author: Florian Weimer +Date: Thu Sep 5 21:18:23 2024 +0200 + + powerpc64le: Build new strtod tests with long double ABI flags (bug 32145) + + This fixes several test failures: + + =====FAIL: stdlib/tst-strtod1i.out===== + Locale tests + all OK + Locale tests + all OK + Locale tests + strtold("1,5") returns -6,38643e+367 and not 1,5 + strtold("1.5") returns 1,5 and not 1 + strtold("1.500") returns 1 and not 1500 + strtold("36.893.488.147.419.103.232") returns 1500 and not 3,68935e+19 + Locale tests + all OK + + =====FAIL: stdlib/tst-strtod3.out===== + 0: got wrong results -2.5937e+4826, expected 0 + + =====FAIL: stdlib/tst-strtod4.out===== + 0: got wrong results -6,38643e+367, expected 0 + 1: got wrong results 0, expected 1e+06 + 2: got wrong results 1e+06, expected 10 + + =====FAIL: stdlib/tst-strtod5i.out===== + 0: got wrong results -6,38643e+367, expected 0 + 2: got wrong results 0, expected -0 + 4: got wrong results -0, expected 0 + 5: got wrong results 0, expected -0 + 6: got wrong results -0, expected 0 + 7: got wrong results 0, expected -0 + 8: got wrong results -0, expected 0 + 9: got wrong results 0, expected -0 + 10: got wrong results -0, expected 0 + 11: got wrong results 0, expected -0 + 12: got wrong results -0, expected 0 + 13: got wrong results 0, expected -0 + 14: got wrong results -0, expected 0 + 15: got wrong results 0, expected -0 + 16: got wrong results -0, expected 0 + 17: got wrong results 0, expected -0 + 18: got wrong results -0, expected 0 + 20: got wrong results 0, expected -0 + 22: got wrong results -0, expected 0 + 23: got wrong results 0, expected -0 + 24: got wrong results -0, expected 0 + 25: got wrong results 0, expected -0 + 26: got wrong results -0, expected 0 + 27: got wrong results 0, expected -0 + + Fixes commit 3fc063dee01da4f80920a14b7db637c8501d6fd4 + ("Make __strtod_internal tests type-generic"). + + Suggested-by: Joseph Myers + Reviewed-by: Carlos O'Donell + (cherry picked from commit cc3e743fc09ee6fca45767629df9cbcbe1feba82) + +diff --git a/sysdeps/powerpc/powerpc64/le/Makefile b/sysdeps/powerpc/powerpc64/le/Makefile +index 5214eb40adbdf25d..ca5e395f8db6c83e 100644 +--- a/sysdeps/powerpc/powerpc64/le/Makefile ++++ b/sysdeps/powerpc/powerpc64/le/Makefile +@@ -129,6 +129,10 @@ CFLAGS-tst-strtod-round.c += $(type-float128-CFLAGS) + CFLAGS-tst-wcstod-round.c += $(type-float128-CFLAGS) + CFLAGS-tst-strtod-nan-locale.c += $(type-float128-CFLAGS) + CFLAGS-tst-wcstod-nan-locale.c += $(type-float128-CFLAGS) ++CFLAGS-tst-strtod1i.c += $(type-float128-CFLAGS) ++CFLAGS-tst-strtod3.c += $(type-float128-CFLAGS) ++CFLAGS-tst-strtod4.c += $(type-float128-CFLAGS) ++CFLAGS-tst-strtod5i.c += $(type-float128-CFLAGS) + CFLAGS-tst-strtod6.c += $(type-float128-CFLAGS) + CFLAGS-tst-strfrom.c += $(type-float128-CFLAGS) + CFLAGS-tst-strfrom-locale.c += $(type-float128-CFLAGS) diff --git a/SOURCES/glibc-upstream-2.39-132.patch b/SOURCES/glibc-upstream-2.39-132.patch new file mode 100644 index 0000000..5dfe9f8 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-132.patch @@ -0,0 +1,256 @@ +commit 988de945389e22460a2f75e677d55ac5f96408f3 +Author: Joseph Myers +Date: Fri Sep 20 23:23:13 2024 +0000 + + Make tst-strtod2 and tst-strtod5 type-generic + + Some of the strtod tests use type-generic machinery in tst-strtod.h to + test the strto* functions for all floating types, while others only + test double even when the tests are in fact meaningful for all + floating types. + + Convert tst-strtod2 and tst-strtod5 to use the type-generic machinery + so they test all floating types. I haven't tried to convert them to + use newer test interfaces in other ways, just made the changes + necessary to use the type-generic machinery. + + Tested for x86_64. + + (cherry picked from commit 8de031bcb9adfa736c0caed2c79d10947b8d8f48) + +diff --git a/stdlib/tst-strtod2.c b/stdlib/tst-strtod2.c +index a7df82ebbde14c5f..2cb0953fa911efd0 100644 +--- a/stdlib/tst-strtod2.c ++++ b/stdlib/tst-strtod2.c +@@ -1,43 +1,61 @@ + #include + #include + +-struct test +-{ +- const char *str; +- double result; +- size_t offset; +-} tests[] = +-{ +- { "0xy", 0.0, 1 }, +- { "0x.y", 0.0, 1 }, +- { "0x0.y", 0.0, 4 }, +- { "0x.0y", 0.0, 4 }, +- { ".y", 0.0, 0 }, +- { "0.y", 0.0, 2 }, +- { ".0y", 0.0, 2 } +-}; ++#include "tst-strtod.h" ++ ++#define TEST_STRTOD(FSUF, FTYPE, FTOSTR, LSUF, CSUF) \ ++struct test_strto ## FSUF \ ++{ \ ++ const char *str; \ ++ FTYPE result; \ ++ size_t offset; \ ++} tests_strto ## FSUF[] = \ ++{ \ ++ { "0xy", 0.0 ## LSUF, 1 }, \ ++ { "0x.y", 0.0 ## LSUF, 1 }, \ ++ { "0x0.y", 0.0 ## LSUF, 4 }, \ ++ { "0x.0y", 0.0 ## LSUF, 4 }, \ ++ { ".y", 0.0 ## LSUF, 0 }, \ ++ { "0.y", 0.0 ## LSUF, 2 }, \ ++ { ".0y", 0.0 ## LSUF, 2 } \ ++}; \ ++ \ ++static int \ ++test_strto ## FSUF (void) \ ++{ \ ++ int status = 0; \ ++ for (size_t i = 0; \ ++ i < sizeof (tests_strto ## FSUF) / sizeof (tests_strto ## FSUF[0]); \ ++ ++i) \ ++ { \ ++ char *ep; \ ++ FTYPE r = strto ## FSUF (tests_strto ## FSUF[i].str, &ep); \ ++ if (r != tests_strto ## FSUF[i].result) \ ++ { \ ++ char buf1[FSTRLENMAX], buf2[FSTRLENMAX]; \ ++ FTOSTR (buf1, sizeof (buf1), "%g", r); \ ++ FTOSTR (buf2, sizeof (buf2), "%g", tests_strto ## FSUF[i].result); \ ++ printf ("test %zu r = %s, expect %s\n", i, buf1, buf2); \ ++ status = 1; \ ++ } \ ++ if (ep != tests_strto ## FSUF[i].str + tests_strto ## FSUF[i].offset) \ ++ { \ ++ printf ("test %zu strto" #FSUF \ ++ " parsed %tu characters, expected %zu\n", \ ++ i, ep - tests_strto ## FSUF[i].str, \ ++ tests_strto ## FSUF[i].offset); \ ++ status = 1; \ ++ } \ ++ } \ ++ return status; \ ++} ++ ++GEN_TEST_STRTOD_FOREACH (TEST_STRTOD) + + static int + do_test (void) + { +- int status = 0; +- for (size_t i = 0; i < sizeof (tests) / sizeof (tests[0]); ++i) +- { +- char *ep; +- double r = strtod (tests[i].str, &ep); +- if (r != tests[i].result) +- { +- printf ("test %zu r = %g, expect %g\n", i, r, tests[i].result); +- status = 1; +- } +- if (ep != tests[i].str + tests[i].offset) +- { +- printf ("test %zu strtod parsed %tu characters, expected %zu\n", +- i, ep - tests[i].str, tests[i].offset); +- status = 1; +- } +- } +- return status; ++ return STRTOD_TEST_FOREACH (test_strto); + } + + #define TEST_FUNCTION do_test () +diff --git a/stdlib/tst-strtod5.c b/stdlib/tst-strtod5.c +index 29153ec0057178e9..7eb9b3a2d7f31b2a 100644 +--- a/stdlib/tst-strtod5.c ++++ b/stdlib/tst-strtod5.c +@@ -22,35 +22,75 @@ + #include + #include + ++#include "tst-strtod.h" ++ + #define NBSP "\xc2\xa0" + +-static const struct +-{ +- const char *in; +- double expected; +-} tests[] = +- { +- { "0", 0.0 }, +- { "000", 0.0 }, +- { "-0", -0.0 }, +- { "-000", -0.0 }, +- { "0,", 0.0 }, +- { "-0,", -0.0 }, +- { "0,0", 0.0 }, +- { "-0,0", -0.0 }, +- { "0e-10", 0.0 }, +- { "-0e-10", -0.0 }, +- { "0,e-10", 0.0 }, +- { "-0,e-10", -0.0 }, +- { "0,0e-10", 0.0 }, +- { "-0,0e-10", -0.0 }, +- { "0e-1000000", 0.0 }, +- { "-0e-1000000", -0.0 }, +- { "0,0e-1000000", 0.0 }, +- { "-0,0e-1000000", -0.0 }, +- }; +-#define NTESTS (sizeof (tests) / sizeof (tests[0])) ++#define TEST_STRTOD(FSUF, FTYPE, FTOSTR, LSUF, CSUF) \ ++static const struct \ ++{ \ ++ const char *in; \ ++ FTYPE expected; \ ++} tests_strto ## FSUF[] = \ ++ { \ ++ { "0", 0.0 ## LSUF }, \ ++ { "000", 0.0 ## LSUF }, \ ++ { "-0", -0.0 ## LSUF }, \ ++ { "-000", -0.0 ## LSUF }, \ ++ { "0,", 0.0 ## LSUF }, \ ++ { "-0,", -0.0 ## LSUF }, \ ++ { "0,0", 0.0 ## LSUF }, \ ++ { "-0,0", -0.0 ## LSUF }, \ ++ { "0e-10", 0.0 ## LSUF }, \ ++ { "-0e-10", -0.0 ## LSUF }, \ ++ { "0,e-10", 0.0 ## LSUF }, \ ++ { "-0,e-10", -0.0 ## LSUF }, \ ++ { "0,0e-10", 0.0 ## LSUF }, \ ++ { "-0,0e-10", -0.0 ## LSUF }, \ ++ { "0e-1000000", 0.0 ## LSUF }, \ ++ { "-0e-1000000", -0.0 ## LSUF }, \ ++ { "0,0e-1000000", 0.0 ## LSUF }, \ ++ { "-0,0e-1000000", -0.0 ## LSUF }, \ ++ }; \ ++ \ ++ \ ++static int \ ++test_strto ## FSUF (void) \ ++{ \ ++ int status = 0; \ ++ \ ++ for (int i = 0; \ ++ i < sizeof (tests_strto ## FSUF) / sizeof (tests_strto ## FSUF[0]); \ ++ ++i) \ ++ { \ ++ char *ep; \ ++ FTYPE r = strto ## FSUF (tests_strto ## FSUF[i].in, &ep); \ ++ \ ++ if (*ep != '\0') \ ++ { \ ++ printf ("%d: got rest string \"%s\", expected \"\"\n", i, ep); \ ++ status = 1; \ ++ } \ ++ \ ++ if (r != tests_strto ## FSUF[i].expected \ ++ || (copysign ## CSUF (10.0 ## LSUF, r) \ ++ != copysign ## CSUF (10.0 ## LSUF, \ ++ tests_strto ## FSUF[i].expected))) \ ++ { \ ++ char buf1[FSTRLENMAX], buf2[FSTRLENMAX]; \ ++ FTOSTR (buf1, sizeof (buf1), "%g", r); \ ++ FTOSTR (buf2, sizeof (buf2), "%g", \ ++ tests_strto ## FSUF[i].expected); \ ++ printf ("%d: got wrong results %s, expected %s\n", \ ++ i, buf1, buf2); \ ++ status = 1; \ ++ } \ ++ } \ ++ \ ++ return status; \ ++} + ++GEN_TEST_STRTOD_FOREACH (TEST_STRTOD) + + static int + do_test (void) +@@ -61,29 +101,7 @@ do_test (void) + return 1; + } + +- int status = 0; +- +- for (int i = 0; i < NTESTS; ++i) +- { +- char *ep; +- double r = strtod (tests[i].in, &ep); +- +- if (*ep != '\0') +- { +- printf ("%d: got rest string \"%s\", expected \"\"\n", i, ep); +- status = 1; +- } +- +- if (r != tests[i].expected +- || copysign (10.0, r) != copysign (10.0, tests[i].expected)) +- { +- printf ("%d: got wrong results %g, expected %g\n", +- i, r, tests[i].expected); +- status = 1; +- } +- } +- +- return status; ++ return STRTOD_TEST_FOREACH (test_strto); + } + + #include diff --git a/SOURCES/glibc-upstream-2.39-133.patch b/SOURCES/glibc-upstream-2.39-133.patch new file mode 100644 index 0000000..e0cf207 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-133.patch @@ -0,0 +1,81 @@ +commit 3edc0f22a620fdda6eda69cfd47d96142132943f +Author: Joseph Myers +Date: Fri Sep 20 23:24:02 2024 +0000 + + Add more tests of strtod end pointer + + Although there are some tests in tst-strtod2 and tst-strtod3 for the + end pointer provided by strtod when it doesn't parse the whole string, + they aren't very thorough. Add tests of more such cases to + tst-strtod2. + + Tested for x86_64. + + (cherry picked from commit b5d3737b305525315e0c7c93ca49eadc868eabd5) + +diff --git a/stdlib/tst-strtod2.c b/stdlib/tst-strtod2.c +index 2cb0953fa911efd0..c84bd792c1a3f511 100644 +--- a/stdlib/tst-strtod2.c ++++ b/stdlib/tst-strtod2.c +@@ -1,3 +1,4 @@ ++#include + #include + #include + +@@ -17,10 +18,46 @@ struct test_strto ## FSUF \ + { "0x.0y", 0.0 ## LSUF, 4 }, \ + { ".y", 0.0 ## LSUF, 0 }, \ + { "0.y", 0.0 ## LSUF, 2 }, \ +- { ".0y", 0.0 ## LSUF, 2 } \ ++ { ".0y", 0.0 ## LSUF, 2 }, \ ++ { "1.0e", 1.0 ## LSUF, 3 }, \ ++ { "1.0e+", 1.0 ## LSUF, 3 }, \ ++ { "1.0e-", 1.0 ## LSUF, 3 }, \ ++ { "1.0ex", 1.0 ## LSUF, 3 }, \ ++ { "1.0e+x", 1.0 ## LSUF, 3 }, \ ++ { "1.0e-x", 1.0 ## LSUF, 3 }, \ ++ { "0x1p", 1.0 ## LSUF, 3 }, \ ++ { "0x1p+", 1.0 ## LSUF, 3 }, \ ++ { "0x1p-", 1.0 ## LSUF, 3 }, \ ++ { "0x1px", 1.0 ## LSUF, 3 }, \ ++ { "0x1p+x", 1.0 ## LSUF, 3 }, \ ++ { "0x1p-x", 1.0 ## LSUF, 3 }, \ ++ { "INFx", INFINITY, 3 }, \ ++ { "infx", INFINITY, 3 }, \ ++ { "INFINITx", INFINITY, 3 }, \ ++ { "infinitx", INFINITY, 3 }, \ ++ { "INFINITYY", INFINITY, 8 }, \ ++ { "infinityy", INFINITY, 8 }, \ ++ { "NANx", NAN, 3 }, \ ++ { "nanx", NAN, 3 }, \ ++ { "NAN(", NAN, 3 }, \ ++ { "nan(", NAN, 3 }, \ ++ { "NAN(x", NAN, 3 }, \ ++ { "nan(x", NAN, 3 }, \ ++ { "NAN(x)y", NAN, 6 }, \ ++ { "nan(x)y", NAN, 6 }, \ ++ { "NAN(*)y", NAN, 3 }, \ ++ { "nan(*)y", NAN, 3 } \ + }; \ + \ + static int \ ++compare_strto ## FSUF (FTYPE x, FTYPE y) \ ++{ \ ++ if (isnan (x) && isnan (y)) \ ++ return 1; \ ++ return x == y; \ ++} \ ++ \ ++static int \ + test_strto ## FSUF (void) \ + { \ + int status = 0; \ +@@ -30,7 +67,7 @@ test_strto ## FSUF (void) \ + { \ + char *ep; \ + FTYPE r = strto ## FSUF (tests_strto ## FSUF[i].str, &ep); \ +- if (r != tests_strto ## FSUF[i].result) \ ++ if (!compare_strto ## FSUF (r, tests_strto ## FSUF[i].result)) \ + { \ + char buf1[FSTRLENMAX], buf2[FSTRLENMAX]; \ + FTOSTR (buf1, sizeof (buf1), "%g", r); \ diff --git a/SOURCES/glibc-upstream-2.39-134.patch b/SOURCES/glibc-upstream-2.39-134.patch new file mode 100644 index 0000000..d0cbb12 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-134.patch @@ -0,0 +1,40 @@ +commit fcdf98f38c16ea5c7296b20db2e9f60e9e6ed39e +Author: Joseph Myers +Date: Fri Sep 20 23:24:45 2024 +0000 + + Add tests of more strtod special cases + + There is very little test coverage of inputs to strtod-family + functions that don't contain anything that can be parsed as a number + (one test of ".y" in tst-strtod2), and none that I can see of skipping + initial whitespace. Add some tests of these things to tst-strtod2. + + Tested for x86_64. + + (cherry picked from commit 378039ca578c2ea93095a1e710d96f58c68a3997) + +diff --git a/stdlib/tst-strtod2.c b/stdlib/tst-strtod2.c +index c84bd792c1a3f511..d00bc13323c50622 100644 +--- a/stdlib/tst-strtod2.c ++++ b/stdlib/tst-strtod2.c +@@ -31,6 +31,20 @@ struct test_strto ## FSUF \ + { "0x1px", 1.0 ## LSUF, 3 }, \ + { "0x1p+x", 1.0 ## LSUF, 3 }, \ + { "0x1p-x", 1.0 ## LSUF, 3 }, \ ++ { "", 0.0 ## LSUF, 0 }, \ ++ { ".", 0.0 ## LSUF, 0 }, \ ++ { "-", 0.0 ## LSUF, 0 }, \ ++ { "-.", 0.0 ## LSUF, 0 }, \ ++ { ".e", 0.0 ## LSUF, 0 }, \ ++ { "-.e", 0.0 ## LSUF, 0 }, \ ++ { " \t", 0.0 ## LSUF, 0 }, \ ++ { " \t.", 0.0 ## LSUF, 0 }, \ ++ { " \t-", 0.0 ## LSUF, 0 }, \ ++ { " \t-.", 0.0 ## LSUF, 0 }, \ ++ { " \t.e", 0.0 ## LSUF, 0 }, \ ++ { " \t-.e", 0.0 ## LSUF, 0 }, \ ++ { " \t\f\r\n\v1", 1.0 ## LSUF, 7 }, \ ++ { " \t\f\r\n\v-1.5e2", -150.0 ## LSUF, 12 }, \ + { "INFx", INFINITY, 3 }, \ + { "infx", INFINITY, 3 }, \ + { "INFINITx", INFINITY, 3 }, \ diff --git a/SOURCES/glibc-upstream-2.39-135.patch b/SOURCES/glibc-upstream-2.39-135.patch new file mode 100644 index 0000000..46e16fb --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-135.patch @@ -0,0 +1,219 @@ +commit b74be22f65c017c6f980e608127c260497d7f3c2 +Author: H.J. Lu +Date: Tue Apr 30 09:57:12 2024 -0700 + + Add crt1-2.0.o for glibc 2.0 compatibility tests + + Starting from glibc 2.1, crt1.o contains _IO_stdin_used which is checked + by _IO_check_libio to provide binary compatibility for glibc 2.0. Add + crt1-2.0.o for tests against glibc 2.0. Define tests-2.0 for glibc 2.0 + compatibility tests. Add and update glibc 2.0 compatibility tests for + stderr, matherr and pthread_kill. + Reviewed-by: Carlos O'Donell + + (cherry picked from commit 5f245f3bfbe61b2182964dafb94907e38284b806) + +diff --git a/Makeconfig b/Makeconfig +index 522182abdc426e70..a6cbb0c6f3149ca8 100644 +--- a/Makeconfig ++++ b/Makeconfig +@@ -360,6 +360,8 @@ whole-archive = -Wl,--whole-archive + # Installed name of the startup code. + # The ELF convention is that the startfile is called crt1.o + start-installed-name = crt1.o ++# Similar to crt1.o, but without _IO_stdin_used. ++start-name-2.0 = crt1-2.0.o + # On systems that do not need a special startfile for statically linked + # binaries, simply set it to the normal name. + ifndef static-start-installed-name +@@ -537,6 +539,25 @@ else # build-static + endif # build-shared + endif # +link + ++# Command for linking test programs with crt1.o from glibc 2.0. +++link-2.0-before-inputs = -nostdlib -nostartfiles $(no-pie-ldflag) \ ++ $(sysdep-LDFLAGS) $(LDFLAGS) $(LDFLAGS-$(@F)) \ ++ $(relro-LDFLAGS) $(hashstyle-LDFLAGS) \ ++ $(firstword $(CRT-$(@F)) $(csu-objpfx)$(start-name-2.0)) \ ++ $(+preinit) $(+prector) +++link-2.0-before-libc = -o $@ $(+link-2.0-before-inputs) \ ++ $(filter-out $(addprefix $(csu-objpfx),start.o \ ++ $(start-name-2.0))\ ++ $(+preinit) $(link-extra-libs) \ ++ $(common-objpfx)libc% $(+postinit),$^) \ ++ $(link-extra-libs) +++link-after-libc = $(+postctor) $(+postinit) ++define +link-2.0-tests ++$(CC) $(+link-2.0-before-libc) $(rtld-tests-LDFLAGS) $(link-libc-tests) \ ++ $(+link-after-libc) ++$(call after-link,$@) ++endef ++ + # The pretty printer test programs need to be compiled without optimizations + # so they won't confuse gdb. We could use either the 'GCC optimize' pragma + # or the 'optimize' function attribute to achieve this; however, at least on +diff --git a/Rules b/Rules +index dd7dae4a49466e5d..713c225d2ebf5506 100644 +--- a/Rules ++++ b/Rules +@@ -197,6 +197,7 @@ binaries-all = $(binaries-all-notests) $(binaries-all-tests) + binaries-static-notests = $(others-static) + binaries-static-tests = $(tests-static) $(xtests-static) + binaries-static = $(binaries-static-notests) $(binaries-static-tests) ++binaries-shared-2.0-tests = $(tests-2.0) + ifeq (yesyes,$(have-fpie)$(build-shared)) + binaries-pie-tests = $(tests-pie) $(xtests-pie) + binaries-pie-notests = $(others-pie) +@@ -224,7 +225,8 @@ binaries-malloc-hugetlb2-tests = + endif + + binaries-pie = $(binaries-pie-tests) $(binaries-pie-notests) +-binaries-shared-tests = $(filter-out $(binaries-pie) $(binaries-static), \ ++binaries-shared-tests = $(filter-out $(binaries-pie) $(binaries-static) \ ++ $(binaries-shared-2.0-tests), \ + $(binaries-all-tests)) + binaries-shared-notests = $(filter-out $(binaries-pie) $(binaries-static), \ + $(binaries-all-notests)) +@@ -244,6 +246,15 @@ $(addprefix $(objpfx),$(binaries-shared-tests)): %: %.o \ + $(+link-tests) + endif + ++# Linking test programs with crt1.o from glibc 2.0. ++ifneq "$(strip $(binaries-shared-2.0-tests))" "" ++$(addprefix $(objpfx),$(binaries-shared-2.0-tests)): %: %.o \ ++ $(link-extra-libs-tests) \ ++ $(sort $(filter $(common-objpfx)lib%,$(link-libc))) \ ++ $(addprefix $(csu-objpfx),start.o) $(+preinit) $(+postinit) ++ $(+link-2.0-tests) ++endif ++ + ifneq "$(strip $(binaries-mcheck-tests))" "" + $(addprefix $(objpfx),$(binaries-mcheck-tests)): %-mcheck: %.o \ + $(link-extra-libs-tests) \ +diff --git a/csu/Makefile b/csu/Makefile +index ac05ab24d5df478b..34a8d74971e83885 100644 +--- a/csu/Makefile ++++ b/csu/Makefile +@@ -33,7 +33,7 @@ elide-routines.os = libc-tls + csu-dummies = $(filter-out $(start-installed-name),crt1.o Mcrt1.o) + extra-objs = start.o \ + $(start-installed-name) g$(start-installed-name) $(csu-dummies) \ +- S$(start-installed-name) ++ S$(start-installed-name) $(start-name-2.0) + omit-deps = $(patsubst %.o,%,$(start-installed-name) g$(start-installed-name) \ + b$(start-installed-name) $(csu-dummies) \ + S$(start-installed-name) \ +@@ -138,6 +138,9 @@ ifndef start-installed-name-rule + $(objpfx)$(start-installed-name): $(objpfx)start.o $(objpfx)abi-note.o \ + $(objpfx)init.o $(objpfx)static-reloc.o + $(link-relocatable) ++$(objpfx)$(start-name-2.0): $(objpfx)start.o $(objpfx)abi-note.o \ ++ $(objpfx)static-reloc.o ++ $(link-relocatable) + $(objpfx)r$(start-installed-name): $(objpfx)start.o $(objpfx)abi-note.o \ + $(objpfx)init.o + $(link-relocatable) +diff --git a/libio/Makefile b/libio/Makefile +index 27623c92a941fd05..b92aeaf62634f1cb 100644 +--- a/libio/Makefile ++++ b/libio/Makefile +@@ -212,6 +212,12 @@ aux := fileops genops stdfiles stdio strops + ifeq ($(build-shared),yes) + generated += tst-bz24228.mtrace tst-bz24228.check + aux += oldfileops oldstdfiles ++tests += \ ++ tst-stderr-compat \ ++# tests ++tests-2.0 += \ ++ tst-stderr-compat \ ++# tests-2.0 + endif + + shared-only-routines = oldiofopen oldiofdopen oldiofclose oldfileops \ +diff --git a/libio/tst-stderr-compat.c b/libio/tst-stderr-compat.c +new file mode 100644 +index 0000000000000000..8221415cd47f25ef +--- /dev/null ++++ b/libio/tst-stderr-compat.c +@@ -0,0 +1,52 @@ ++/* Test that fclose works on stderr from glibc 2.0. ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++ ++#if TEST_COMPAT (libc, GLIBC_2_0, GLIBC_2_1) ++# define _LIBC ++# define _IO_USE_OLD_IO_FILE ++# include ++# include ++ ++extern FILE _IO_stderr_; ++compat_symbol_reference (libc, _IO_stderr_, _IO_stderr_, GLIBC_2_0); ++compat_symbol_reference (libc, fclose, fclose, GLIBC_2_0); ++ ++__attribute__ ((weak, noclone, noinline)) ++void ++do_fclose (FILE *fp) ++{ ++ TEST_VERIFY_EXIT (fclose (fp) == 0); ++} ++ ++static int ++do_test (void) ++{ ++ do_fclose (&_IO_stderr_); ++ return 0; ++} ++#else ++static int ++do_test (void) ++{ ++ return 0; ++} ++#endif ++ ++#include +diff --git a/math/Makefile b/math/Makefile +index 14107855e88bc96b..c98ee4ee0c1a4022 100644 +--- a/math/Makefile ++++ b/math/Makefile +@@ -261,6 +261,9 @@ tests-static = test-fpucw-static test-fpucw-ieee-static \ + # The tested symbols matherr, _LIB_VERSION have been removed in glibc 2.27. + ifeq ($(have-GLIBC_2.26)$(build-shared),yesyes) + tests += test-matherr test-matherr-2 ++tests-2.0 += \ ++ test-matherr-2 \ ++ # tests-2.0 + endif + + # These tests use internal (unexported) GMP functions and are linked +diff --git a/sysdeps/pthread/Makefile b/sysdeps/pthread/Makefile +index f9efb5076455e07e..04ea56559ef3a79b 100644 +--- a/sysdeps/pthread/Makefile ++++ b/sysdeps/pthread/Makefile +@@ -282,6 +282,10 @@ tests += \ + tst-vfork2x \ + # tests + ++tests-2.0 += \ ++ tst-pthread_kill-exited ++ # tests-2.0 ++ + tests-time64 += \ + tst-abstime-time64 \ + tst-cnd-timedwait-time64 \ diff --git a/SOURCES/glibc-upstream-2.39-136.patch b/SOURCES/glibc-upstream-2.39-136.patch new file mode 100644 index 0000000..16babfd --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-136.patch @@ -0,0 +1,441 @@ +commit b3c51635efb532dd0544e6f4dedd6a184f0ae1a2 +Author: Joseph Myers +Date: Fri Sep 20 23:25:32 2024 +0000 + + Make tst-strtod-underflow type-generic + + The test tst-strtod-underflow covers various edge cases close to the + underflow threshold for strtod (especially cases where underflow on + architectures with after-rounding tininess detection depends on the + rounding mode). Make it use the type-generic machinery, with + corresponding test inputs for each supported floating-point format, so + that other functions in the strtod family are tested for underflow + edge cases as well. + + Tested for x86_64. + + (cherry picked from commit 94ca2c0894f0e1b62625c369cc598a2b9236622c) + +diff --git a/stdlib/tst-strtod-underflow.c b/stdlib/tst-strtod-underflow.c +index a5ced18599bbf985..8598b95b6da7fd40 100644 +--- a/stdlib/tst-strtod-underflow.c ++++ b/stdlib/tst-strtod-underflow.c +@@ -17,6 +17,10 @@ + License along with the GNU C Library; if not, see + . */ + ++/* Defining _LIBC_TEST ensures long double math functions are ++ declared in the headers. */ ++#define _LIBC_TEST 1 ++#define __STDC_WANT_IEC_60559_TYPES_EXT__ + #include + #include + #include +@@ -25,6 +29,60 @@ + #include + #include + ++#include "tst-strtod.h" ++ ++/* Logic for selecting between tests for different formats is as in ++ tst-strtod-skeleton.c, but here it is selecting string inputs with ++ different underflow properties, rather than generated test ++ data. */ ++ ++#define _CONCAT(a, b) a ## b ++#define CONCAT(a, b) _CONCAT (a, b) ++ ++#define MEMBER(FSUF, FTYPE, FTOSTR, LSUF, CSUF) \ ++ const char *s_ ## FSUF; ++ ++#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 ++# define CHOOSE_ld(f,d,...) d ++#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 && LDBL_MIN_EXP == -16381 ++# define CHOOSE_ld(f,d,ld64i,...) ld64i ++#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 && LDBL_MIN_EXP == -16382 ++# define CHOOSE_ld(f,d,ld64i,ld64m,...) ld64m ++#elif LDBL_MANT_DIG == 106 && LDBL_MAX_EXP == 1024 ++# define CHOOSE_ld(f,d,ld64i,ld64m,ld106,...) ld106 ++#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 ++# define CHOOSE_ld(f,d,ld64i,ld64m,ld106,ld113,...) ld113 ++#else ++# error "unknown long double format" ++#endif ++ ++#define CHOOSE_f(f,...) f ++#define CHOOSE_f32(f,...) f ++#define CHOOSE_d(f,d,...) d ++#define CHOOSE_f64(f,d,...) d ++#define CHOOSE_f32x(f,d,...) d ++#define CHOOSE_f128(f,d,ld64i,ld64m,ld106,ld113,...) ld113 ++ ++#if __HAVE_FLOAT64X ++# if FLT64X_MANT_DIG == 113 && FLT64X_MAX_EXP == 16384 ++# define CHOOSE_f64x(f,d,ld64i,ld64m,ld106,ld113,...) ld113 ++# elif (FLT64X_MANT_DIG == 64 \ ++ && FLT64X_MAX_EXP == 16384 \ ++ && FLT64X_MIN_EXP == -16381) ++# define CHOOSE_f64x(f,d,ld64i,...) ld64i ++# else ++# error "unknown _Float64x format" ++# endif ++#endif ++ ++#define _XNTRY(FSUF, FTYPE, FTOSTR, LSUF, CSUF, ...) \ ++ CHOOSE_ ## FSUF (__VA_ARGS__), ++#define XNTRY(...) \ ++ GEN_TEST_STRTOD_FOREACH (_XNTRY, __VA_ARGS__) ++ ++#define TEST(f, d, ld64i, ld64m, ld106, ld113, u) \ ++ { XNTRY(f, d, ld64i, ld64m, ld106, ld113) u } ++ + enum underflow_case + { + /* Result is exact or outside the subnormal range. */ +@@ -55,38 +113,194 @@ enum underflow_case + + struct test + { +- const char *s; ++ GEN_TEST_STRTOD_FOREACH (MEMBER) + enum underflow_case c; + }; + + static const struct test tests[] = + { +- { "0x1p-1022", UNDERFLOW_NONE }, +- { "-0x1p-1022", UNDERFLOW_NONE }, +- { "0x0p-10000000000000000000000000", UNDERFLOW_NONE }, +- { "-0x0p-10000000000000000000000000", UNDERFLOW_NONE }, +- { "0x1p-10000000000000000000000000", UNDERFLOW_ALWAYS }, +- { "-0x1p-10000000000000000000000000", UNDERFLOW_ALWAYS }, +- { "0x1.000000000000000000001p-1022", UNDERFLOW_NONE }, +- { "-0x1.000000000000000000001p-1022", UNDERFLOW_NONE }, +- { "0x1p-1075", UNDERFLOW_ALWAYS }, +- { "-0x1p-1075", UNDERFLOW_ALWAYS }, +- { "0x1p-1023", UNDERFLOW_NONE }, +- { "-0x1p-1023", UNDERFLOW_NONE }, +- { "0x1p-1074", UNDERFLOW_NONE }, +- { "-0x1p-1074", UNDERFLOW_NONE }, +- { "0x1.ffffffffffffep-1023", UNDERFLOW_NONE }, +- { "-0x1.ffffffffffffep-1023", UNDERFLOW_NONE }, +- { "0x1.fffffffffffffp-1023", UNDERFLOW_ALWAYS }, +- { "-0x1.fffffffffffffp-1023", UNDERFLOW_ALWAYS }, +- { "0x1.fffffffffffff0001p-1023", UNDERFLOW_EXCEPT_UPWARD }, +- { "-0x1.fffffffffffff0001p-1023", UNDERFLOW_EXCEPT_DOWNWARD }, +- { "0x1.fffffffffffff7fffp-1023", UNDERFLOW_EXCEPT_UPWARD }, +- { "-0x1.fffffffffffff7fffp-1023", UNDERFLOW_EXCEPT_DOWNWARD }, +- { "0x1.fffffffffffff8p-1023", UNDERFLOW_ONLY_DOWNWARD_ZERO }, +- { "-0x1.fffffffffffff8p-1023", UNDERFLOW_ONLY_UPWARD_ZERO }, +- { "0x1.fffffffffffffffffp-1023", UNDERFLOW_ONLY_DOWNWARD_ZERO }, +- { "-0x1.fffffffffffffffffp-1023", UNDERFLOW_ONLY_UPWARD_ZERO }, ++ TEST ("0x1p-126", ++ "0x1p-1022", ++ "0x1p-16382", ++ "0x1p-16383", ++ "0x1p-969", ++ "0x1p-16382", ++ UNDERFLOW_NONE), ++ TEST ("-0x1p-126", ++ "-0x1p-1022", ++ "-0x1p-16382", ++ "-0x1p-16383", ++ "-0x1p-969", ++ "-0x1p-16382", ++ UNDERFLOW_NONE), ++ TEST ("0x0p-10000000000000000000000000", ++ "0x0p-10000000000000000000000000", ++ "0x0p-10000000000000000000000000", ++ "0x0p-10000000000000000000000000", ++ "0x0p-10000000000000000000000000", ++ "0x0p-10000000000000000000000000", ++ UNDERFLOW_NONE), ++ TEST ("-0x0p-10000000000000000000000000", ++ "-0x0p-10000000000000000000000000", ++ "-0x0p-10000000000000000000000000", ++ "-0x0p-10000000000000000000000000", ++ "-0x0p-10000000000000000000000000", ++ "-0x0p-10000000000000000000000000", ++ UNDERFLOW_NONE), ++ TEST ("0x1p-10000000000000000000000000", ++ "0x1p-10000000000000000000000000", ++ "0x1p-10000000000000000000000000", ++ "0x1p-10000000000000000000000000", ++ "0x1p-10000000000000000000000000", ++ "0x1p-10000000000000000000000000", ++ UNDERFLOW_ALWAYS), ++ TEST ("-0x1p-10000000000000000000000000", ++ "-0x1p-10000000000000000000000000", ++ "-0x1p-10000000000000000000000000", ++ "-0x1p-10000000000000000000000000", ++ "-0x1p-10000000000000000000000000", ++ "-0x1p-10000000000000000000000000", ++ UNDERFLOW_ALWAYS), ++ TEST ("0x1.000000000000000000001p-126", ++ "0x1.000000000000000000001p-1022", ++ "0x1.000000000000000000001p-16382", ++ "0x1.000000000000000000001p-16383", ++ "0x1.000000000000000000001p-969", ++ "0x1.00000000000000000000000000000000000000001p-16382", ++ UNDERFLOW_NONE), ++ TEST ("-0x1.000000000000000000001p-126", ++ "-0x1.000000000000000000001p-1022", ++ "-0x1.000000000000000000001p-16382", ++ "-0x1.000000000000000000001p-16383", ++ "-0x1.000000000000000000001p-969", ++ "-0x1.00000000000000000000000000000000000000001p-16382", ++ UNDERFLOW_NONE), ++ TEST ("0x1p-150", ++ "0x1p-1075", ++ "0x1p-16446", ++ "0x1p-16447", ++ "0x1p-1075", ++ "0x1p-16495", ++ UNDERFLOW_ALWAYS), ++ TEST ("-0x1p-150", ++ "-0x1p-1075", ++ "-0x1p-16446", ++ "-0x1p-16447", ++ "-0x1p-1075", ++ "-0x1p-16495", ++ UNDERFLOW_ALWAYS), ++ TEST ("0x1p-127", ++ "0x1p-1023", ++ "0x1p-16383", ++ "0x1p-16384", ++ "0x1p-970", ++ "0x1p-16383", ++ UNDERFLOW_NONE), ++ TEST ("-0x1p-127", ++ "-0x1p-1023", ++ "-0x1p-16383", ++ "-0x1p-16384", ++ "-0x1p-970", ++ "-0x1p-16383", ++ UNDERFLOW_NONE), ++ TEST ("0x1p-149", ++ "0x1p-1074", ++ "0x1p-16445", ++ "0x1p-16446", ++ "0x1p-1074", ++ "0x1p-16494", ++ UNDERFLOW_NONE), ++ TEST ("-0x1p-149", ++ "-0x1p-1074", ++ "-0x1p-16445", ++ "-0x1p-16446", ++ "-0x1p-1074", ++ "-0x1p-16494", ++ UNDERFLOW_NONE), ++ TEST ("0x1.fffffcp-127", ++ "0x1.ffffffffffffep-1023", ++ "0x1.fffffffffffffffcp-16383", ++ "0x1.fffffffffffffffcp-16384", ++ "0x1.ffffffffffffffffffffffffffp-970", ++ "0x1.fffffffffffffffffffffffffffep-16383", ++ UNDERFLOW_NONE), ++ TEST ("-0x1.fffffcp-127", ++ "-0x1.ffffffffffffep-1023", ++ "-0x1.fffffffffffffffcp-16383", ++ "-0x1.fffffffffffffffcp-16384", ++ "-0x1.ffffffffffffffffffffffffffp-970", ++ "-0x1.fffffffffffffffffffffffffffep-16383", ++ UNDERFLOW_NONE), ++ TEST ("0x1.fffffep-127", ++ "0x1.fffffffffffffp-1023", ++ "0x1.fffffffffffffffep-16383", ++ "0x1.fffffffffffffffep-16384", ++ "0x1.ffffffffffffffffffffffffff8p-970", ++ "0x1.ffffffffffffffffffffffffffffp-16383", ++ UNDERFLOW_ALWAYS), ++ TEST ("-0x1.fffffep-127", ++ "-0x1.fffffffffffffp-1023", ++ "-0x1.fffffffffffffffep-16383", ++ "-0x1.fffffffffffffffep-16384", ++ "-0x1.ffffffffffffffffffffffffff8p-970", ++ "-0x1.ffffffffffffffffffffffffffffp-16383", ++ UNDERFLOW_ALWAYS), ++ TEST ("0x1.fffffe0001p-127", ++ "0x1.fffffffffffff0001p-1023", ++ "0x1.fffffffffffffffe0001p-16383", ++ "0x1.fffffffffffffffe0001p-16384", ++ "0x1.ffffffffffffffffffffffffff80001p-970", ++ "0x1.ffffffffffffffffffffffffffff0001p-16383", ++ UNDERFLOW_EXCEPT_UPWARD), ++ TEST ("-0x1.fffffe0001p-127", ++ "-0x1.fffffffffffff0001p-1023", ++ "-0x1.fffffffffffffffe0001p-16383", ++ "-0x1.fffffffffffffffe0001p-16384", ++ "-0x1.ffffffffffffffffffffffffff80001p-970", ++ "-0x1.ffffffffffffffffffffffffffff0001p-16383", ++ UNDERFLOW_EXCEPT_DOWNWARD), ++ TEST ("0x1.fffffeffffp-127", ++ "0x1.fffffffffffff7fffp-1023", ++ "0x1.fffffffffffffffeffffp-16383", ++ "0x1.fffffffffffffffeffffp-16384", ++ "0x1.ffffffffffffffffffffffffffbffffp-970", ++ "0x1.ffffffffffffffffffffffffffff7fffp-16383", ++ UNDERFLOW_EXCEPT_UPWARD), ++ TEST ("-0x1.fffffeffffp-127", ++ "-0x1.fffffffffffff7fffp-1023", ++ "-0x1.fffffffffffffffeffffp-16383", ++ "-0x1.fffffffffffffffeffffp-16384", ++ "-0x1.ffffffffffffffffffffffffffbffffp-970", ++ "-0x1.ffffffffffffffffffffffffffff7fffp-16383", ++ UNDERFLOW_EXCEPT_DOWNWARD), ++ TEST ("0x1.ffffffp-127", ++ "0x1.fffffffffffff8p-1023", ++ "0x1.ffffffffffffffffp-16383", ++ "0x1.ffffffffffffffffp-16384", ++ "0x1.ffffffffffffffffffffffffffcp-970", ++ "0x1.ffffffffffffffffffffffffffff8p-16383", ++ UNDERFLOW_ONLY_DOWNWARD_ZERO), ++ TEST ("-0x1.ffffffp-127", ++ "-0x1.fffffffffffff8p-1023", ++ "-0x1.ffffffffffffffffp-16383", ++ "-0x1.ffffffffffffffffp-16384", ++ "-0x1.ffffffffffffffffffffffffffcp-970", ++ "-0x1.ffffffffffffffffffffffffffff8p-16383", ++ UNDERFLOW_ONLY_UPWARD_ZERO), ++ TEST ("0x1.ffffffffffp-127", ++ "0x1.fffffffffffffffffp-1023", ++ "0x1.ffffffffffffffffffffp-16383", ++ "0x1.ffffffffffffffffffffp-16384", ++ "0x1.ffffffffffffffffffffffffffffffp-970", ++ "0x1.ffffffffffffffffffffffffffffffffp-16383", ++ UNDERFLOW_ONLY_DOWNWARD_ZERO), ++ TEST ("-0x1.ffffffffffp-127", ++ "-0x1.fffffffffffffffffp-1023", ++ "-0x1.ffffffffffffffffffffp-16383", ++ "-0x1.ffffffffffffffffffffp-16384", ++ "-0x1.ffffffffffffffffffffffffffffffp-970", ++ "-0x1.ffffffffffffffffffffffffffffffffp-16383", ++ UNDERFLOW_ONLY_UPWARD_ZERO), + }; + + /* Return whether to expect underflow from a particular testcase, in a +@@ -133,39 +347,62 @@ static bool support_underflow_exception = false; + volatile double d = DBL_MIN; + volatile double dd; + +-static int +-test_in_one_mode (const char *s, enum underflow_case c, int rm, +- const char *mode_name) ++static bool ++test_got_fe_underflow (void) + { +- int result = 0; +- feclearexcept (FE_ALL_EXCEPT); +- errno = 0; +- double d = strtod (s, NULL); +- int got_errno = errno; + #ifdef FE_UNDERFLOW +- bool got_fe_underflow = fetestexcept (FE_UNDERFLOW) != 0; ++ return fetestexcept (FE_UNDERFLOW) != 0; + #else +- bool got_fe_underflow = false; ++ return false; + #endif +- printf ("strtod (%s) (%s) returned %a, errno = %d, %sunderflow exception\n", +- s, mode_name, d, got_errno, got_fe_underflow ? "" : "no "); +- bool this_expect_underflow = expect_underflow (c, rm); +- if (got_errno != 0 && got_errno != ERANGE) +- { +- puts ("FAIL: errno neither 0 nor ERANGE"); +- result = 1; +- } +- else if (this_expect_underflow != (errno == ERANGE)) +- { +- puts ("FAIL: underflow from errno differs from expectations"); +- result = 1; +- } +- if (support_underflow_exception && got_fe_underflow != this_expect_underflow) +- { +- puts ("FAIL: underflow from exceptions differs from expectations"); +- result = 1; +- } +- return result; ++} ++ ++#define TEST_STRTOD(FSUF, FTYPE, FTOSTR, LSUF, CSUF) \ ++static int \ ++test_strto ## FSUF (int i, int rm, const char *mode_name) \ ++{ \ ++ const char *s = tests[i].s_ ## FSUF; \ ++ enum underflow_case c = tests[i].c; \ ++ int result = 0; \ ++ feclearexcept (FE_ALL_EXCEPT); \ ++ errno = 0; \ ++ FTYPE d = strto ## FSUF (s, NULL); \ ++ int got_errno = errno; \ ++ bool got_fe_underflow = test_got_fe_underflow (); \ ++ char buf[FSTRLENMAX]; \ ++ FTOSTR (buf, sizeof (buf), "%a", d); \ ++ printf ("strto" #FSUF \ ++ " (%s) (%s) returned %s, errno = %d, " \ ++ "%sunderflow exception\n", \ ++ s, mode_name, buf, got_errno, \ ++ got_fe_underflow ? "" : "no "); \ ++ bool this_expect_underflow = expect_underflow (c, rm); \ ++ if (got_errno != 0 && got_errno != ERANGE) \ ++ { \ ++ puts ("FAIL: errno neither 0 nor ERANGE"); \ ++ result = 1; \ ++ } \ ++ else if (this_expect_underflow != (errno == ERANGE)) \ ++ { \ ++ puts ("FAIL: underflow from errno differs from expectations"); \ ++ result = 1; \ ++ } \ ++ if (support_underflow_exception \ ++ && got_fe_underflow != this_expect_underflow) \ ++ { \ ++ puts ("FAIL: underflow from exceptions " \ ++ "differs from expectations"); \ ++ result = 1; \ ++ } \ ++ return result; \ ++} ++ ++GEN_TEST_STRTOD_FOREACH (TEST_STRTOD) ++ ++static int ++test_in_one_mode (size_t i, int rm, const char *mode_name) ++{ ++ return STRTOD_TEST_FOREACH (test_strto, i, rm, mode_name); + } + + static int +@@ -191,12 +428,12 @@ do_test (void) + #endif + for (size_t i = 0; i < sizeof (tests) / sizeof (tests[0]); i++) + { +- result |= test_in_one_mode (tests[i].s, tests[i].c, fe_tonearest, ++ result |= test_in_one_mode (i, fe_tonearest, + "default rounding mode"); + #ifdef FE_DOWNWARD + if (!fesetround (FE_DOWNWARD)) + { +- result |= test_in_one_mode (tests[i].s, tests[i].c, FE_DOWNWARD, ++ result |= test_in_one_mode (i, FE_DOWNWARD, + "FE_DOWNWARD"); + fesetround (save_round_mode); + } +@@ -204,7 +441,7 @@ do_test (void) + #ifdef FE_TOWARDZERO + if (!fesetround (FE_TOWARDZERO)) + { +- result |= test_in_one_mode (tests[i].s, tests[i].c, FE_TOWARDZERO, ++ result |= test_in_one_mode (i, FE_TOWARDZERO, + "FE_TOWARDZERO"); + fesetround (save_round_mode); + } +@@ -212,7 +449,7 @@ do_test (void) + #ifdef FE_UPWARD + if (!fesetround (FE_UPWARD)) + { +- result |= test_in_one_mode (tests[i].s, tests[i].c, FE_UPWARD, ++ result |= test_in_one_mode (i, FE_UPWARD, + "FE_UPWARD"); + fesetround (save_round_mode); + } diff --git a/SOURCES/glibc-upstream-2.39-137.patch b/SOURCES/glibc-upstream-2.39-137.patch new file mode 100644 index 0000000..03324ce --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-137.patch @@ -0,0 +1,31 @@ +commit dcaf51b41e259387602774829c45222d0507f90a +Author: Florian Weimer +Date: Mon Oct 28 14:45:30 2024 +0100 + + elf: Change ldconfig auxcache magic number (bug 32231) + + In commit c628c2296392ed3bf2cb8d8470668e64fe53389f (elf: Remove + ldconfig kernel version check), the layout of auxcache entries + changed because the osversion field was removed from + struct aux_cache_file_entry. However, AUX_CACHEMAGIC was not + changed, so existing files are still used, potentially leading + to unintended ldconfig behavior. This commit changes AUX_CACHEMAGIC, + so that the file is regenerated. + + Reported-by: DJ Delorie + Reviewed-by: Adhemerval Zanella + (cherry picked from commit 0a536f6e2f76e3ef581b3fd9af1e5cf4ddc7a5a2) + +diff --git a/elf/cache.c b/elf/cache.c +index 8a618e11fa414abb..62d681df42746d55 100644 +--- a/elf/cache.c ++++ b/elf/cache.c +@@ -820,7 +820,7 @@ struct aux_cache_entry + struct aux_cache_entry *next; + }; + +-#define AUX_CACHEMAGIC "glibc-ld.so.auxcache-1.0" ++#define AUX_CACHEMAGIC "glibc-ld.so.auxcache-2.0" + + struct aux_cache_file_entry + { diff --git a/SOURCES/glibc-upstream-2.39-95.patch b/SOURCES/glibc-upstream-2.39-95.patch new file mode 100644 index 0000000..d3299ca --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-95.patch @@ -0,0 +1,196 @@ +commit 3b25c7fa878c01f9e656701b5d59438ea2e49ba4 +Author: Florian Weimer +Date: Wed Jun 26 11:27:54 2024 +0200 + + Enhance test coverage for strnlen, wcsnlen + + This commit adds string/test-strnlen-nonarray and + wcsmbs/test-wcsnlen-nonarray. + + Reviewed-by: Noah Goldstein + (cherry picked from commit 783d4c0b81889c39a9ddf13b60d0fde4040fb1c0) + +diff --git a/string/Makefile b/string/Makefile +index 8f31fa49e621c035..2e20fc00fdd8d607 100644 +--- a/string/Makefile ++++ b/string/Makefile +@@ -184,6 +184,7 @@ tests := \ + test-strncpy \ + test-strndup \ + test-strnlen \ ++ test-strnlen-nonarray \ + test-strpbrk \ + test-strrchr \ + test-strspn \ +diff --git a/string/test-Xnlen-nonarray.c b/string/test-Xnlen-nonarray.c +new file mode 100644 +index 0000000000000000..499bef2041ac4ae1 +--- /dev/null ++++ b/string/test-Xnlen-nonarray.c +@@ -0,0 +1,133 @@ ++/* Test non-array inputs to string length functions. ++ Copyright (C) 2024 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 ++ . */ ++ ++/* This skeleton file is included from string/test-strnlen-nonarray.c ++ and wcsmbs/test-wcsnlen-nonarray.c to test that reading of the array ++ stops at the first null character. ++ ++ TEST_IDENTIFIER must be the test function identifier. TEST_NAME is ++ the same as a string. ++ ++ CHAR must be defined as the character type. */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++typedef __typeof (TEST_IDENTIFIER) *proto_t; ++ ++#define TEST_MAIN ++#include "test-string.h" ++ ++IMPL (TEST_IDENTIFIER, 1) ++ ++static int ++test_main (void) ++{ ++ enum { buffer_length = 256 }; ++ TEST_VERIFY_EXIT (sysconf (_SC_PAGESIZE) >= buffer_length); ++ ++ test_init (); ++ ++ /* Buffer layout: There are a_count 'A' character followed by ++ zero_count null character, for a total of buffer_length ++ character: ++ ++ AAAAA...AAAAA 00000 ... 00000 (unmapped page follows) ++ \ / \ / ++ (a_count) (zero_count) ++ \___ (buffer_length) ___/ ++ ^ ++ | ++ start_offset ++ ++ The buffer length does not change, but a_count (and thus _zero) ++ and start_offset vary. ++ ++ If start_offset == buffer_length, only 0 is a valid length ++ argument. The result is 0. ++ ++ Otherwwise, if zero_count > 0 (if there a null characters in the ++ buffer), then any length argument is valid. If start_offset < ++ a_count (i.e., there is a non-null character at start_offset), the ++ result is the minimum of a_count - start_offset and the length ++ argument. Otherwise the result is 0. ++ ++ Otherwise, there are no null characters before the unmapped page. ++ The length argument must not be greater than buffer_length - ++ start_offset, and the result is the length argument. */ ++ ++ struct support_next_to_fault ntf ++ = support_next_to_fault_allocate (buffer_length * sizeof (CHAR)); ++ CHAR *buffer = (CHAR *) ntf.buffer; ++ ++ FOR_EACH_IMPL (impl, 0) ++ { ++ printf ("info: testing %s\n", impl->name); ++ for (size_t i = 0; i < buffer_length; ++i) ++ buffer[i] = 'A'; ++ ++ for (int zero_count = 0; zero_count <= buffer_length; ++zero_count) ++ { ++ if (zero_count > 0) ++ buffer[buffer_length - zero_count] = 0; ++ int a_count = buffer_length - zero_count; ++ for (int start_offset = 0; start_offset <= buffer_length; ++ ++start_offset) ++ { ++ CHAR *start_pointer = buffer + start_offset; ++ if (start_offset == buffer_length) ++ TEST_COMPARE (CALL (impl, buffer + start_offset, 0), 0); ++ else if (zero_count > 0) ++ for (int length_argument = 0; ++ length_argument <= 2 * buffer_length; ++ ++length_argument) ++ { ++ if (test_verbose) ++ printf ("zero_count=%d a_count=%d start_offset=%d" ++ " length_argument=%d\n", ++ zero_count, a_count, start_offset, ++ length_argument); ++ if (start_offset < a_count) ++ TEST_COMPARE (CALL (impl, start_pointer, length_argument), ++ MIN (a_count - start_offset, ++ length_argument)); ++ else ++ TEST_COMPARE (CALL (impl, start_pointer, length_argument), ++ 0); ++ } ++ else ++ for (int length_argument = 0; ++ length_argument <= buffer_length - start_offset; ++ ++length_argument) ++ TEST_COMPARE (CALL (impl, start_pointer, length_argument), ++ length_argument); ++ } ++ } ++ } ++ ++ support_next_to_fault_free (&ntf); ++ ++ return 0; ++} ++ ++#include +diff --git a/string/test-strnlen-nonarray.c b/string/test-strnlen-nonarray.c +new file mode 100644 +index 0000000000000000..0ad05756d9a31a3d +--- /dev/null ++++ b/string/test-strnlen-nonarray.c +@@ -0,0 +1,4 @@ ++#define TEST_IDENTIFIER strnlen ++#define TEST_NAME "strnlen" ++typedef char CHAR; ++#include "test-Xnlen-nonarray.c" +diff --git a/wcsmbs/Makefile b/wcsmbs/Makefile +index 65173e28aabf9f85..23da6f0eed55d543 100644 +--- a/wcsmbs/Makefile ++++ b/wcsmbs/Makefile +@@ -160,6 +160,7 @@ tests := \ + test-wcsncmp \ + test-wcsncpy \ + test-wcsnlen \ ++ test-wcsnlen-nonarray \ + test-wcspbrk \ + test-wcsrchr \ + test-wcsspn \ +diff --git a/wcsmbs/test-wcsnlen-nonarray.c b/wcsmbs/test-wcsnlen-nonarray.c +new file mode 100644 +index 0000000000000000..a4b21fecd388448a +--- /dev/null ++++ b/wcsmbs/test-wcsnlen-nonarray.c +@@ -0,0 +1,5 @@ ++#include ++#define TEST_IDENTIFIER wcsnlen ++#define TEST_NAME "wcsnlen" ++typedef wchar_t CHAR; ++#include "../string/test-Xnlen-nonarray.c" diff --git a/SOURCES/glibc-upstream-2.39-96.patch b/SOURCES/glibc-upstream-2.39-96.patch new file mode 100644 index 0000000..a06c76c --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-96.patch @@ -0,0 +1,257 @@ +commit 127ef30c46586cfe9fa3e19ad074280b139c84c4 +Author: Florian Weimer +Date: Thu Jun 27 16:26:56 2024 +0200 + + Enhanced test coverage for strncmp, wcsncmp + + Add string/test-strncmp-nonarray and + wcsmbs/test-wcsncmp-nonarray. + + This is the test that uncovered bug 31934. Test run time + is more than one minute on a fairly current system, so turn + these into xtests that do not run automatically. + + Reviewed-by: Noah Goldstein + (cherry picked from commit 54252394c25ddf0062e288d4a6ab7a885f8ae009) + +diff --git a/string/Makefile b/string/Makefile +index 2e20fc00fdd8d607..1dff405c273d1b31 100644 +--- a/string/Makefile ++++ b/string/Makefile +@@ -236,7 +236,10 @@ tests-unsupported += $(tests-translation) + endif + + # This test allocates a lot of memory and can run for a long time. +-xtests = tst-strcoll-overflow ++xtests += tst-strcoll-overflow ++ ++# This test runs for a long time. ++xtests += test-strncmp-nonarray + + # This test needs libdl. + ifeq (yes,$(build-shared)) +diff --git a/string/test-Xncmp-nonarray.c b/string/test-Xncmp-nonarray.c +new file mode 100644 +index 0000000000000000..9f3a3ca75d0e6827 +--- /dev/null ++++ b/string/test-Xncmp-nonarray.c +@@ -0,0 +1,183 @@ ++/* Test non-array inputs to string comparison functions. ++ Copyright (C) 2024 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 ++ . */ ++ ++/* This skeleton file is included from string/test-strncmp-nonarray.c and ++ wcsmbs/test-wcsncmp-nonarray.c to test that reading of the arrays stops ++ at the first null character. ++ ++ TEST_IDENTIFIER must be the test function identifier. TEST_NAME is ++ the same as a string. ++ ++ CHAR must be defined as the character type. */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++/* Much shorter than test-Xnlen-nonarray.c because of deeply nested loops. */ ++enum { buffer_length = 80 }; ++ ++/* The test buffer layout follows what is described test-Xnlen-nonarray.c, ++ except that there two buffers, left and right. The variables ++ a_count, zero_count, start_offset are all duplicated. */ ++ ++/* Return the maximum string length for a string that starts at ++ start_offset. */ ++static int ++string_length (int a_count, int start_offset) ++{ ++ if (start_offset == buffer_length || start_offset >= a_count) ++ return 0; ++ else ++ return a_count - start_offset; ++} ++ ++/* This is the valid maximum length argument computation for ++ strnlen/wcsnlen. See text-Xnlen-nonarray.c. */ ++static int ++maximum_length (int start_offset, int zero_count) ++{ ++ if (start_offset == buffer_length) ++ return 0; ++ else if (zero_count > 0) ++ /* Effectively unbounded, but we need to stop fairly low, ++ otherwise testing takes too long. */ ++ return buffer_length + 32; ++ else ++ return buffer_length - start_offset; ++} ++ ++typedef __typeof (TEST_IDENTIFIER) *proto_t; ++ ++#define TEST_MAIN ++#include "test-string.h" ++ ++IMPL (TEST_IDENTIFIER, 1) ++ ++static int ++test_main (void) ++{ ++ TEST_VERIFY_EXIT (sysconf (_SC_PAGESIZE) >= buffer_length); ++ test_init (); ++ ++ struct support_next_to_fault left_ntf ++ = support_next_to_fault_allocate (buffer_length * sizeof (CHAR)); ++ CHAR *left_buffer = (CHAR *) left_ntf.buffer; ++ struct support_next_to_fault right_ntf ++ = support_next_to_fault_allocate (buffer_length * sizeof (CHAR)); ++ CHAR *right_buffer = (CHAR *) right_ntf.buffer; ++ ++ FOR_EACH_IMPL (impl, 0) ++ { ++ printf ("info: testing %s\n", impl->name); ++ for (size_t i = 0; i < buffer_length; ++i) ++ left_buffer[i] = 'A'; ++ ++ for (int left_zero_count = 0; left_zero_count <= buffer_length; ++ ++left_zero_count) ++ { ++ if (left_zero_count > 0) ++ left_buffer[buffer_length - left_zero_count] = 0; ++ int left_a_count = buffer_length - left_zero_count; ++ for (size_t i = 0; i < buffer_length; ++i) ++ right_buffer[i] = 'A'; ++ for (int right_zero_count = 0; right_zero_count <= buffer_length; ++ ++right_zero_count) ++ { ++ if (right_zero_count > 0) ++ right_buffer[buffer_length - right_zero_count] = 0; ++ int right_a_count = buffer_length - right_zero_count; ++ for (int left_start_offset = 0; ++ left_start_offset <= buffer_length; ++ ++left_start_offset) ++ { ++ CHAR *left_start_pointer = left_buffer + left_start_offset; ++ int left_maxlen ++ = maximum_length (left_start_offset, left_zero_count); ++ int left_length ++ = string_length (left_a_count, left_start_offset); ++ for (int right_start_offset = 0; ++ right_start_offset <= buffer_length; ++ ++right_start_offset) ++ { ++ CHAR *right_start_pointer ++ = right_buffer + right_start_offset; ++ int right_maxlen ++ = maximum_length (right_start_offset, right_zero_count); ++ int right_length ++ = string_length (right_a_count, right_start_offset); ++ ++ /* Maximum length is modelled after strnlen/wcsnlen, ++ and must be valid for both pointer arguments at ++ the same time. */ ++ int maxlen = MIN (left_maxlen, right_maxlen); ++ ++ for (int length_argument = 0; length_argument <= maxlen; ++ ++length_argument) ++ { ++ if (test_verbose) ++ { ++ printf ("left: zero_count=%d" ++ " a_count=%d start_offset=%d\n", ++ left_zero_count, left_a_count, ++ left_start_offset); ++ printf ("right: zero_count=%d" ++ " a_count=%d start_offset=%d\n", ++ right_zero_count, right_a_count, ++ right_start_offset); ++ printf ("length argument: %d\n", ++ length_argument); ++ } ++ ++ /* Effective lengths bounded by length argument. ++ The effective length determines the ++ outcome of the comparison. */ ++ int left_effective ++ = MIN (left_length, length_argument); ++ int right_effective ++ = MIN (right_length, length_argument); ++ if (left_effective == right_effective) ++ TEST_COMPARE (CALL (impl, ++ left_start_pointer, ++ right_start_pointer, ++ length_argument), 0); ++ else if (left_effective < right_effective) ++ TEST_COMPARE (CALL (impl, ++ left_start_pointer, ++ right_start_pointer, ++ length_argument) < 0, 1); ++ else ++ TEST_COMPARE (CALL (impl, ++ left_start_pointer, ++ right_start_pointer, ++ length_argument) > 0, 1); ++ } ++ } ++ } ++ } ++ } ++ } ++ ++ return 0; ++} ++ ++#include +diff --git a/string/test-strncmp-nonarray.c b/string/test-strncmp-nonarray.c +new file mode 100644 +index 0000000000000000..581e52d01b0a6ae8 +--- /dev/null ++++ b/string/test-strncmp-nonarray.c +@@ -0,0 +1,4 @@ ++#define TEST_IDENTIFIER strncmp ++#define TEST_NAME "strncmp" ++typedef char CHAR; ++#include "test-Xncmp-nonarray.c" +diff --git a/wcsmbs/Makefile b/wcsmbs/Makefile +index 23da6f0eed55d543..6eb38c2dcd7a8c95 100644 +--- a/wcsmbs/Makefile ++++ b/wcsmbs/Makefile +@@ -205,6 +205,10 @@ tests := \ + wcsmbs-tst1 \ + # tests + ++# This test runs for a long time. ++xtests += test-wcsncmp-nonarray ++ ++ + include ../Rules + + ifeq ($(run-built-tests),yes) +diff --git a/wcsmbs/test-wcsncmp-nonarray.c b/wcsmbs/test-wcsncmp-nonarray.c +new file mode 100644 +index 0000000000000000..1ad9ebd8fdf7466f +--- /dev/null ++++ b/wcsmbs/test-wcsncmp-nonarray.c +@@ -0,0 +1,5 @@ ++#include ++#define TEST_IDENTIFIER wcsncmp ++#define TEST_NAME "wcsncmp" ++typedef wchar_t CHAR; ++#include "../string/test-Xncmp-nonarray.c" diff --git a/SOURCES/glibc-upstream-2.39-97.patch b/SOURCES/glibc-upstream-2.39-97.patch new file mode 100644 index 0000000..167b979 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-97.patch @@ -0,0 +1,50 @@ +commit 9f349d02c6065f77b485526b3d76a637f6f079dc +Author: H.J. Lu +Date: Wed Jul 24 14:05:13 2024 -0700 + + linux: Update the mremap C implementation [BZ #31968] + + Update the mremap C implementation to support the optional argument for + MREMAP_DONTUNMAP added in Linux 5.7 since it may not always be correct + to implement a variadic function as a non-variadic function on all Linux + targets. Return MAP_FAILED and set errno to EINVAL for unknown flag bits. + This fixes BZ #31968. + + Note: A test must be added when a new flag bit is introduced. + + Signed-off-by: H.J. Lu + Reviewed-by: Adhemerval Zanella + (cherry picked from commit 6c40cb0e9f893d49dc7caee580a055de53562206) + +diff --git a/sysdeps/unix/sysv/linux/mremap.c b/sysdeps/unix/sysv/linux/mremap.c +index 4f770799c4f2fd18..1ada5c1f40dec1f6 100644 +--- a/sysdeps/unix/sysv/linux/mremap.c ++++ b/sysdeps/unix/sysv/linux/mremap.c +@@ -20,6 +20,12 @@ + #include + #include + #include ++#include ++ ++#define MREMAP_KNOWN_BITS \ ++ (MREMAP_MAYMOVE \ ++ | MREMAP_FIXED \ ++ | MREMAP_DONTUNMAP) + + void * + __mremap (void *addr, size_t old_len, size_t new_len, int flags, ...) +@@ -27,7 +33,13 @@ __mremap (void *addr, size_t old_len, size_t new_len, int flags, ...) + va_list va; + void *new_addr = NULL; + +- if (flags & MREMAP_FIXED) ++ if (flags & ~(MREMAP_KNOWN_BITS)) ++ { ++ __set_errno (EINVAL); ++ return MAP_FAILED; ++ } ++ ++ if (flags & (MREMAP_FIXED | MREMAP_DONTUNMAP)) + { + va_start (va, flags); + new_addr = va_arg (va, void *); diff --git a/SOURCES/glibc-upstream-2.39-98.patch b/SOURCES/glibc-upstream-2.39-98.patch new file mode 100644 index 0000000..f60c955 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-98.patch @@ -0,0 +1,83 @@ +commit a8c230c881b24af0f6f3f9105f6cd0e7bc05b0de +Author: H.J. Lu +Date: Wed Jul 24 14:05:14 2024 -0700 + + mremap: Update manual entry + + Update mremap manual entry: + + 1. Change mremap to variadic. + 2. Document MREMAP_FIXED and MREMAP_DONTUNMAP. + + Signed-off-by: H.J. Lu + Reviewed-by: Adhemerval Zanella + (cherry picked from commit cb2dee4eccf46642eef588bee64f9c875c408f1c) + +diff --git a/manual/llio.texi b/manual/llio.texi +index fae49d14332db675..a65230d612eba7bf 100644 +--- a/manual/llio.texi ++++ b/manual/llio.texi +@@ -1781,7 +1781,7 @@ There is no existing mapping in at least part of the given region. + + @end deftypefun + +-@deftypefun {void *} mremap (void *@var{address}, size_t @var{length}, size_t @var{new_length}, int @var{flag}) ++@deftypefun {void *} mremap (void *@var{address}, size_t @var{length}, size_t @var{new_length}, int @var{flag}, ... /* void *@var{new_address} */) + @standards{GNU, sys/mman.h} + @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}} + +@@ -1790,12 +1790,40 @@ area. @var{address} and @var{length} must cover a region entirely mapped + in the same @code{mmap} statement. A new mapping with the same + characteristics will be returned with the length @var{new_length}. + +-One option is possible, @code{MREMAP_MAYMOVE}. If it is given in +-@var{flags}, the system may remove the existing mapping and create a new +-one of the desired length in another location. ++Possible flags are + +-The address of the resulting mapping is returned, or @math{-1}. Possible +-error codes include: ++@table @code ++ ++@item MREMAP_MAYMOVE ++If it is given in @var{flags}, the system may remove the existing mapping ++and create a new one of the desired length in another location. ++ ++@item MREMAP_FIXED ++If it is given in @var{flags}, @code{mremap} accepts a fifth argument, ++@code{void *new_address}, which specifies a page-aligned address to ++which the mapping must be moved. Any previous mapping at the address ++range specified by @var{new_address} and @var{new_size} is unmapped. ++ ++@code{MREMAP_FIXED} must be used together with @code{MREMAP_MAYMOVE}. ++ ++@item MREMAP_DONTUNMAP ++If it is given in @var{flags}, @code{mremap} accepts a fifth argument, ++@code{void *new_address}, which specifies a page-aligned address. Any ++previous mapping at the address range specified by @var{new_address} and ++@var{new_size} is unmapped. If @var{new_address} is @code{NULL}, the ++kernel chooses the page-aligned address at which to create the mapping. ++Otherwise, the kernel takes it as a hint about where to place the mapping. ++The mapping at the address range specified by @var{old_address} and ++@var{old_size} isn't unmapped. ++ ++@code{MREMAP_DONTUNMAP} must be used together with @code{MREMAP_MAYMOVE}. ++@var{old_size} must be the same as @var{new_size}. This flag bit is ++Linux-specific. ++ ++@end table ++ ++The address of the resulting mapping is returned, or @code{MAP_FAILED}. ++Possible error codes include: + + @table @code + +@@ -1804,7 +1832,7 @@ There is no existing mapping in at least part of the original region, or + the region covers two or more distinct mappings. + + @item EINVAL +-The address given is misaligned or inappropriate. ++Any arguments are inappropriate, including unknown @var{flags} values. + + @item EAGAIN + The region has pages locked, and if extended it would exceed the diff --git a/SOURCES/glibc-upstream-2.39-99.patch b/SOURCES/glibc-upstream-2.39-99.patch new file mode 100644 index 0000000..9661d14 --- /dev/null +++ b/SOURCES/glibc-upstream-2.39-99.patch @@ -0,0 +1,286 @@ +commit 7f5ccdd8afe107502b4567af61ffc7b86a2477f7 +Author: H.J. Lu +Date: Wed Jul 24 14:05:15 2024 -0700 + + Add mremap tests + + Add tests for MREMAP_MAYMOVE and MREMAP_FIXED. On Linux, also test + MREMAP_DONTUNMAP. + + Signed-off-by: H.J. Lu + Reviewed-by: Adhemerval Zanella + (cherry picked from commit ff0320bec2810192d453c579623482fab87bfa01) + +diff --git a/misc/Makefile b/misc/Makefile +index c273ec6974a96c3f..235fc7eacb6a980d 100644 +--- a/misc/Makefile ++++ b/misc/Makefile +@@ -251,6 +251,8 @@ tests := \ + tst-mntent-blank-passno \ + tst-mntent-escape \ + tst-mntent2 \ ++ tst-mremap1 \ ++ tst-mremap2 \ + tst-preadvwritev \ + tst-preadvwritev2 \ + tst-preadvwritev64 \ +diff --git a/misc/tst-mremap1.c b/misc/tst-mremap1.c +new file mode 100644 +index 0000000000000000..0469991a6c1438b6 +--- /dev/null ++++ b/misc/tst-mremap1.c +@@ -0,0 +1,46 @@ ++/* Test mremap with MREMAP_MAYMOVE. ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++static int ++do_test (void) ++{ ++ size_t old_size = getpagesize (); ++ char *old_addr = xmmap (NULL, old_size, PROT_READ | PROT_WRITE, ++ MAP_PRIVATE | MAP_ANONYMOUS, -1); ++ old_addr[0] = 1; ++ old_addr[old_size - 1] = 2; ++ ++ /* Test MREMAP_MAYMOVE. */ ++ size_t new_size = old_size + old_size; ++ char *new_addr = mremap (old_addr, old_size, new_size, MREMAP_MAYMOVE); ++ TEST_VERIFY_EXIT (new_addr != MAP_FAILED); ++ new_addr[0] = 1; ++ new_addr[new_size - 1] = 2; ++ xmunmap (new_addr, new_size); ++ ++ return 0; ++} ++ ++#include +diff --git a/misc/tst-mremap2.c b/misc/tst-mremap2.c +new file mode 100644 +index 0000000000000000..45be7f0369c2571e +--- /dev/null ++++ b/misc/tst-mremap2.c +@@ -0,0 +1,54 @@ ++/* Test mremap with MREMAP_FIXED. ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++static int ++do_test (void) ++{ ++ size_t old_size = getpagesize (); ++ size_t new_size = old_size + old_size; ++ char *old_addr = xmmap (NULL, old_size, PROT_READ | PROT_WRITE, ++ MAP_PRIVATE | MAP_ANONYMOUS, -1); ++ old_addr[0] = 1; ++ old_addr[old_size - 1] = 2; ++ ++ char *fixed_addr = xmmap (NULL, new_size, PROT_READ | PROT_WRITE, ++ MAP_PRIVATE | MAP_ANONYMOUS, -1); ++ fixed_addr[0] = 1; ++ fixed_addr[new_size - 1] = 2; ++ ++ /* Test MREMAP_FIXED. */ ++ char *new_addr = mremap (old_addr, old_size, new_size, ++ MREMAP_FIXED | MREMAP_MAYMOVE, ++ fixed_addr); ++ if (new_addr == MAP_FAILED) ++ return mremap_failure_exit (errno); ++ new_addr[0] = 1; ++ new_addr[new_size - 1] = 2; ++ xmunmap (new_addr, new_size); ++ ++ return 0; ++} ++ ++#include +diff --git a/sysdeps/generic/mremap-failure.h b/sysdeps/generic/mremap-failure.h +new file mode 100644 +index 0000000000000000..bc0d476368050c2c +--- /dev/null ++++ b/sysdeps/generic/mremap-failure.h +@@ -0,0 +1,25 @@ ++/* mremap failure handling. Generic version. ++ Copyright (C) 2024 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 ++ . */ ++ ++/* Return exit value on mremap failure with errno ERR. */ ++ ++static int ++mremap_failure_exit (int err) ++{ ++ return EXIT_FAILURE; ++} +diff --git a/sysdeps/unix/sysv/linux/Makefile b/sysdeps/unix/sysv/linux/Makefile +index 6ab9b901234dc72e..eee91c7b64d79fe7 100644 +--- a/sysdeps/unix/sysv/linux/Makefile ++++ b/sysdeps/unix/sysv/linux/Makefile +@@ -205,6 +205,7 @@ tests += \ + tst-getauxval \ + tst-gettid \ + tst-gettid-kill \ ++ tst-linux-mremap1 \ + tst-memfd_create \ + tst-misalign-clone \ + tst-mlock2 \ +diff --git a/sysdeps/unix/sysv/linux/mremap-failure.h b/sysdeps/unix/sysv/linux/mremap-failure.h +new file mode 100644 +index 0000000000000000..c99ab30ca9ea796f +--- /dev/null ++++ b/sysdeps/unix/sysv/linux/mremap-failure.h +@@ -0,0 +1,30 @@ ++/* mremap failure handling. Linux version. ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++ ++/* Return exit value on mremap failure with errno ERR. */ ++ ++static int ++mremap_failure_exit (int err) ++{ ++ if (err != EINVAL) ++ return EXIT_FAILURE; ++ ++ return EXIT_UNSUPPORTED; ++} +diff --git a/sysdeps/unix/sysv/linux/tst-linux-mremap1.c b/sysdeps/unix/sysv/linux/tst-linux-mremap1.c +new file mode 100644 +index 0000000000000000..408e8af2abe59033 +--- /dev/null ++++ b/sysdeps/unix/sysv/linux/tst-linux-mremap1.c +@@ -0,0 +1,63 @@ ++/* Test mremap with MREMAP_DONTUNMAP. ++ Copyright (C) 2024 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 ++ . */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++static int ++do_test (void) ++{ ++ size_t old_size = getpagesize (); ++ size_t new_size = old_size; ++ char *old_addr = xmmap (NULL, old_size, PROT_READ | PROT_WRITE, ++ MAP_PRIVATE | MAP_ANONYMOUS, -1); ++ old_addr[0] = 1; ++ old_addr[old_size - 1] = 2; ++ ++ /* Create an available 64-page mmap region. */ ++ size_t fixed_size = old_size * 64; ++ char *fixed_addr = xmmap (NULL, fixed_size, PROT_READ | PROT_WRITE, ++ MAP_PRIVATE | MAP_ANONYMOUS, -1); ++ xmunmap (fixed_addr, fixed_size); ++ ++ /* Add 3 * pagesize. */ ++ fixed_size += 3 * old_size; ++ ++ /* Test MREMAP_DONTUNMAP. It should return FIXED_ADDR created above. */ ++ char *new_addr = mremap (old_addr, old_size, new_size, ++ MREMAP_DONTUNMAP | MREMAP_MAYMOVE, ++ fixed_addr); ++ if (new_addr == MAP_FAILED) ++ return mremap_failure_exit (errno); ++ TEST_VERIFY_EXIT (fixed_addr == new_addr); ++ old_addr[0] = 3; ++ old_addr[old_size - 1] = 4; ++ new_addr[0] = 1; ++ new_addr[new_size - 1] = 2; ++ xmunmap (new_addr, new_size); ++ xmunmap (old_addr, old_size); ++ ++ return 0; ++} ++ ++#include diff --git a/SPECS/glibc.spec b/SPECS/glibc.spec index f3158f5..d822b1d 100644 --- a/SPECS/glibc.spec +++ b/SPECS/glibc.spec @@ -80,31 +80,6 @@ # glibc_shell_* below. %undefine _auto_set_build_flags -############################################################################## -# Any architecture/kernel combination that supports running 32-bit and 64-bit -# code in userspace is considered a biarch arch. -%global biarcharches %{ix86} x86_64 s390 s390x - -# Avoid generating a glibc-headers package on architectures which are -# not biarch. -%ifarch %{biarcharches} -%global need_headers_package 1 -%if 0%{?rhel} > 0 -%global headers_package_name glibc-headers -%else -%ifarch %{ix86} x86_64 -%global headers_package_name glibc-headers-x86 -%endif -%ifarch s390 s390x -%global headers_package_name glibc-headers-s390 -%endif -%dnl !rhel -%endif -%else -%global need_headers_package 0 -%dnl !biarcharches -%endif - ############################################################################## # Utility functions for pre/post scripts. Stick them at the beginning of # any lua %pre, %post, %postun, etc. sections to have them expand into @@ -170,7 +145,7 @@ Version: %{glibcversion} # - It allows using the Release number without the %%dist tag in the dependency # generator to make the generated requires interchangeable between Rawhide # and ELN (.elnYY < .fcXX). -%global baserelease 23 +%global baserelease 31 Release: %{baserelease}%{?dist} # Licenses: @@ -240,42 +215,72 @@ Source12: ChangeLog.old # glibc_ldso: ABI-specific program interpreter name. Used for debuginfo # extraction (wrap-find-debuginfo.sh) and smoke testing ($run_ldso below). # +# glibc_has_libnldbl: -lnldbl is supported for long double as double. +# +# glibc_has_libmvec: libmvec is available. +# # glibc_rtld_early_cflags: The ABI baseline for architectures with # potentially a later baseline. The --with-rtld-early-cflags= # configure option is passed to the main glibc build if this macro is # defined. %ifarch %{ix86} %global glibc_ldso /lib/ld-linux.so.2 +%global glibc_has_libnldbl 0 +%global glibc_has_libmvec 0 %endif %ifarch aarch64 %global glibc_ldso /lib/ld-linux-aarch64.so.1 +%global glibc_has_libnldbl 0 +%global glibc_has_libmvec 1 %endif %ifarch ppc %global glibc_ldso /lib/ld.so.1 +%global glibc_has_libnldbl 1 +%global glibc_has_libmvec 0 %endif %ifarch ppc64 %global glibc_ldso /lib64/ld64.so.1 +%global glibc_has_libnldbl 1 +%global glibc_has_libmvec 0 %endif %ifarch ppc64le %global glibc_ldso /lib64/ld64.so.2 +%global glibc_has_libnldbl 1 +%global glibc_has_libmvec 0 %define glibc_rtld_early_cflags -mcpu=power8 %endif %ifarch riscv64 %global glibc_ldso /lib/ld-linux-riscv64-lp64d.so.1 +%global glibc_has_libnldbl 0 +%global glibc_has_libmvec 0 %endif %ifarch s390 %global glibc_ldso /lib/ld.so.1 +%global glibc_has_libnldbl 1 +%global glibc_has_libmvec 0 %define glibc_rtld_early_cflags -march=z13 %endif %ifarch s390x %global glibc_ldso /lib/ld64.so.1 +%global glibc_has_libnldbl 1 +%global glibc_has_libmvec 0 %define glibc_rtld_early_cflags -march=z13 %endif %ifarch x86_64 x86_64_v2 x86_64_v3 x86_64_v4 %global glibc_ldso /lib64/ld-linux-x86-64.so.2 +%global glibc_has_libnldbl 0 +%global glibc_has_libmvec 1 %define glibc_rtld_early_cflags -march=x86-64 %endif +# This is necessary to enable source RPM building under noarch, as +# used by some build environments. +%ifarch noarch +%global glibc_ldso /lib/ld.so +%global glibc_has_libnldbl 0 +%global glibc_has_libmvec 0 +%endif + ###################################################################### # Activate the wrapper script for debuginfo generation, by rewriting # the definition of __debug_install_post. @@ -287,7 +292,7 @@ local original = rpm.expand("%{macrobody:__debug_install_post}") -- Avoid embedded newlines that confuse the macro definition. original = original:match("^%s*(.-)%s*$"):gsub("\\\n", "") rpm.define("__debug_install_post bash " .. wrapper - .. " " .. sysroot .. " %{glibc_ldso} " .. original) + .. " " .. sysroot .. " %{_prefix}%{glibc_ldso} " .. original) } # sysroot package support. These contain arch-specific packages, so @@ -431,6 +436,54 @@ Patch118: glibc-upstream-2.39-93.patch Patch119: glibc-upstream-2.39-94.patch Patch120: RHEL-18039-1.patch Patch121: RHEL-18039-2.patch +Patch122: glibc-build-xtests-1.patch +Patch123: glibc-build-xtests-2.patch +Patch124: glibc-RHEL-12867.patch +Patch125: glibc-upstream-2.39-95.patch +Patch126: glibc-upstream-2.39-96.patch +Patch127: glibc-upstream-2.39-97.patch +Patch128: glibc-upstream-2.39-98.patch +Patch129: glibc-upstream-2.39-99.patch +Patch130: glibc-upstream-2.39-100.patch +Patch131: glibc-upstream-2.39-101.patch +Patch132: glibc-upstream-2.39-102.patch +Patch133: glibc-upstream-2.39-103.patch +Patch134: glibc-upstream-2.39-104.patch +Patch135: glibc-upstream-2.39-105.patch +Patch136: glibc-upstream-2.39-106.patch +Patch137: glibc-upstream-2.39-107.patch +Patch138: glibc-upstream-2.39-108.patch +Patch139: glibc-upstream-2.39-109.patch +Patch140: glibc-upstream-2.39-110.patch +Patch141: glibc-upstream-2.39-111.patch +Patch142: glibc-upstream-2.39-112.patch +Patch143: glibc-upstream-2.39-113.patch +Patch144: glibc-upstream-2.39-114.patch +Patch145: glibc-upstream-2.39-115.patch +Patch146: glibc-upstream-2.39-116.patch +Patch147: glibc-upstream-2.39-117.patch +Patch148: glibc-upstream-2.39-118.patch +Patch149: glibc-upstream-2.39-119.patch +Patch150: glibc-upstream-2.39-120.patch +Patch151: glibc-upstream-2.39-121.patch +Patch152: glibc-upstream-2.39-122.patch +Patch153: glibc-upstream-2.39-123.patch +Patch154: glibc-upstream-2.39-124.patch +Patch155: glibc-upstream-2.39-125.patch +Patch156: glibc-upstream-2.39-126.patch +Patch157: glibc-upstream-2.39-127.patch +Patch158: glibc-upstream-2.39-128.patch +Patch159: glibc-upstream-2.39-129.patch +Patch160: glibc-upstream-2.39-130.patch +Patch161: glibc-upstream-2.39-131.patch +Patch162: glibc-upstream-2.39-132.patch +Patch163: glibc-upstream-2.39-133.patch +Patch164: glibc-upstream-2.39-134.patch +Patch165: glibc-upstream-2.39-135.patch +Patch166: glibc-upstream-2.39-136.patch +Patch167: glibc-upstream-2.39-137.patch +Patch168: glibc-RHEL-12867-2.patch +Patch169: glibc-RHEL-12867-3.patch ############################################################################## # Continued list of core "glibc" package information: @@ -440,6 +493,8 @@ Obsoletes: nscd < 2.35 Provides: ldconfig Provides: /sbin/ldconfig Provides: /usr/sbin/ldconfig +# Historic file paths provided for backwards compatibility. +Provides: %{glibc_ldso} # The dynamic linker supports DT_GNU_HASH Provides: rtld(GNU_HASH) @@ -598,14 +653,21 @@ Requires: %{name} = %{version}-%{release} Requires: libxcrypt-devel%{_isa} >= 4.0.0 Requires: kernel-headers >= 3.2 BuildRequires: kernel-headers >= 3.2 -%if %{need_headers_package} -Requires: %{headers_package_name} = %{version}-%{release} -%endif -%if !(0%{?rhel} > 0 && %{need_headers_package}) # For backwards compatibility, when the glibc-headers package existed. Provides: glibc-headers = %{version}-%{release} Provides: glibc-headers(%{_target_cpu}) Obsoletes: glibc-headers < %{version}-%{release} +# For backwards compatibility with alternative Fedora approach to +# work around multilib issue in composes. +%if 0%{?fedora} +%ifarch x86_64 +Provides: glibc-headers-x86 = %{version}-%{release} +Obsoletes: glibc-headers-x86 < %{version}-%{release} +%endif +%ifarch s390x +Provides: glibc-headers-s390 = %{version}-%{release} +Obsoletes: glibc-headers-s390 < %{version}-%{release} +%endif %endif %description devel @@ -652,32 +714,6 @@ The glibc-static package contains the C library static libraries for -static linking. You don't need these, unless you link statically, which is highly discouraged. -############################################################################## -# glibc "headers" sub-package -# - The headers package includes all common headers that are shared amongst -# the multilib builds. It avoids file conflicts between the architecture- -# specific glibc-devel variants. -# Files like gnu/stubs.h which have gnu/stubs-32.h (i686) and gnu/stubs-64.h -# are included in glibc-headers, but the -32 and -64 files are in their -# respective i686 and x86_64 devel packages. -############################################################################## -%if %{need_headers_package} -%package -n %{headers_package_name} -Summary: Additional internal header files for glibc-devel. -Requires: %{name} = %{version}-%{release} -%if 0%{?rhel} > 0 -Provides: %{name}-headers(%{_target_cpu}) -Obsoletes: glibc-headers-x86 < %{version}-%{release} -Obsoletes: glibc-headers-s390 < %{version}-%{release} -%else -BuildArch: noarch -%endif - -%description -n %{headers_package_name} -The %{headers_package_name} package contains the architecture-specific -header files which cannot be included in glibc-devel package. -%endif - ############################################################################## # glibc "common" sub-package ############################################################################## @@ -1515,14 +1551,20 @@ build build-%{target}-power10 \ # distribution that supports multiple installed glibc versions. %global glibc_sysroot $RPM_BUILD_ROOT -# Remove existing file lists. -find . -type f -name '*.filelist' -exec rm -rf {} \; +# Create symbolic links for Features/UsrMove (aka UsrMerge, MoveToUsr). +# See below: Remove UsrMove symbolic links. +usrmove_file_names="bin lib lib64 sbin" +for d in $usrmove_file_names ; do + mkdir -p "%{glibc_sysroot}/usr/$d" + ln -s "usr/$d" "%{glibc_sysroot}/$d" +done %ifarch riscv64 -# RISC-V ABI wants to install everything in /lib64/lp64d or /usr/lib64/lp64d. +# RISC-V ABI wants to install everything in /usr/lib64/lp64d. +# Make these be symlinks to /usr/lib64. See: # Make these be symlinks to /lib64 or /usr/lib64 respectively. See: # https://lists.fedoraproject.org/archives/list/devel@lists.fedoraproject.org/thread/DRHT5YTPK4WWVGL3GIN5BF2IKX2ODHZ3/ -for d in %{glibc_sysroot}%{_libdir} %{glibc_sysroot}/%{_lib}; do +for d in %{glibc_sysroot}%{_libdir}; do mkdir -p $d (cd $d && ln -sf . lp64d) done @@ -1534,12 +1576,13 @@ pushd build-%{target}-32 %make_build install_root=%{glibc_sysroot} install popd pushd %{glibc_sysroot} -rm -rf etc sbin var usr/bin usr/lib/gconv usr/libexec usr/sbin usr/share +rm -rf etc var usr/bin usr/lib/gconv usr/libexec usr/sbin usr/share rm -f lib/libnss_db* lib/libnss_hesiod* lib/libnsl* usr/lib/libnsl* usr/lib/libnss* rm usr/lib/libc_malloc_debug.so strip -g usr/lib/*.o -mv lib/{libmemusage,libpcprofile}.so usr/lib/ popd +mkdir glibc32-headers +cp -a %{glibc_sysroot}%{_includedir} glibc32-headers %endif # Build and install: @@ -1552,6 +1595,33 @@ popd # via hardlinks, so we must group them ourselves. hardlink -c %{glibc_sysroot}/usr/lib/locale +%ifarch x86_64 +# Verify that there are no unexpected differences in the header files common +# between i386 and x86_64. +diff -ur %{glibc_sysroot}%{_includedir} glibc32-headers/include \ + > glibc-32-64.diff || true +if test -s glibc-32-64.diff ; then + if test $(grep -v '^Only in ' glibc-32-64.diff | wc -l) -ne 0; then + : Unexpected header file differences + exit 1 + fi +else + : Missing additional stubs header files. +fi +rm glibc-32-64.diff +rm -rf glibc32-headers +%endif + +%if %{glibc_autorequires} +mkdir -p %{glibc_sysroot}/%{_rpmconfigdir} %{glibc_sysroot}/%{_fileattrsdir} +sed < %{SOURCE3} \ + -e s/@VERSION@/%{version}/ \ + -e s/@RELEASE@/%{baserelease}/ \ + -e s/@SYMVER@/%{glibc_autorequires_symver}/ \ + > %{glibc_sysroot}/%{_rpmconfigdir}/glibc.req +cp %{SOURCE4} %{glibc_sysroot}/%{_fileattrsdir}/glibc.attr +%endif + # install_different: # Install all core libraries into DESTDIR/SUBDIR. Either the file is # installed as a copy or a symlink to the default install (if it is the @@ -1587,7 +1657,7 @@ install_different() libbase=${lib#*/} # Take care that `libbaseso' has a * that needs expanding so # take care with quoting. - libbaseso=$(basename %{glibc_sysroot}/%{_lib}/${libbase}.so.*) + libbaseso=$(basename %{glibc_sysroot}/%{_libdir}/${libbase}.so.*) # Only install if different from default build library. if cmp -s ${lib}.so ../build-%{target}/${lib}.so; then ln -sf "$subdir_up"/$libbaseso $libdestdir/$libbaseso @@ -1612,11 +1682,10 @@ popd # XXX: This looks like a bug in glibc that accidentally installed these # wrong files. We probably don't need this today. rm -f %{glibc_sysroot}/%{_libdir}/libNoVersion* -rm -f %{glibc_sysroot}/%{_lib}/libNoVersion* # Remove the old nss modules. -rm -f %{glibc_sysroot}/%{_lib}/libnss1-* -rm -f %{glibc_sysroot}/%{_lib}/libnss-*.so.1 +rm -f %{glibc_sysroot}%{_libdir}/libnss1-* +rm -f %{glibc_sysroot}%{_libdir}/libnss-*.so.1 # This statically linked binary is no longer necessary in a world where # the default Fedora install uses an initramfs, and further we have rpm-ostree @@ -1775,13 +1844,6 @@ popd rm -f %{glibc_sysroot}%{_infodir}/dir %endif -# Move libpcprofile.so and libmemusage.so into the proper library directory. -# They can be moved without any real consequences because users would not use -# them directly. -mkdir -p %{glibc_sysroot}%{_libdir} -mv -f %{glibc_sysroot}/%{_lib}/lib{pcprofile,memusage}.so \ - %{glibc_sysroot}%{_libdir} - # Disallow linking against libc_malloc_debug. rm %{glibc_sysroot}%{_libdir}/libc_malloc_debug.so @@ -1807,7 +1869,14 @@ done # that have old linker scripts that reference this file. We ship this only # in compat-libpthread-nonshared sub-package. ############################################################################## -ar cr %{glibc_sysroot}%{_prefix}/%{_lib}/libpthread_nonshared.a +ar cr %{glibc_sysroot}%{_libdir}/libpthread_nonshared.a + +# Remove UsrMove symbolic links. +# These should not end in the packaged contents. +# They are part of the filesystem package. +for d in $usrmove_file_names ; do + rm "%{glibc_sysroot}/$d" +done ############################################################################### # Sysroot package creation. @@ -1883,419 +1952,65 @@ popd # installed files. ############################################################################## -############################################################################## -# Build the file lists used for describing the package and subpackages. -############################################################################## -# There are several main file lists (and many more for -# the langpack sub-packages (langpack-${lang}.filelist)): -# * master.filelist -# - Master file list from which all other lists are built. -# * glibc.filelist -# - Files for the glibc packages. -# * common.filelist -# - Flies for the common subpackage. -# * utils.filelist -# - Files for the utils subpackage. -# * devel.filelist -# - Files for the devel subpackage. -# * doc.filelist -# - Files for the documentation subpackage. -# * headers.filelist -# - Files for the headers subpackage. -# * static.filelist -# - Files for the static subpackage. -# * libnsl.filelist -# - Files for the libnsl subpackage -# * nss_db.filelist -# * nss_hesiod.filelist -# - File lists for nss_* NSS module subpackages. -# * nss-devel.filelist -# - File list with the .so symbolic links for NSS packages. -# * compat-libpthread-nonshared.filelist. -# - File list for compat-libpthread-nonshared subpackage. -# * glibc32.filelist -# - Files for the glibc32 packages. - -# Create the main file lists. This way we can append to any one of them later -# wihtout having to create it. Note these are removed at the start of the -# install phase. -touch master.filelist -touch glibc.filelist -touch common.filelist -touch utils.filelist -touch gconv.filelist -touch devel.filelist -touch doc.filelist -touch headers.filelist -touch static.filelist -touch libnsl.filelist -touch nss_db.filelist -touch nss_hesiod.filelist -touch nss-devel.filelist -touch compat-libpthread-nonshared.filelist -%ifarch x86_64 -touch glibc32.filelist -%endif - -############################################################################### -# Master file list, excluding a few things. -############################################################################### -{ - # List all files or links that we have created during install. - # Files with 'etc' are configuration files, likewise 'gconv-modules' - # and 'gconv-modules.cache' are caches, and we exclude them. - find %{glibc_sysroot} \( -type f -o -type l \) \ - \( \ - -name etc -printf "%%%%config " -o \ - -name gconv-modules.cache \ - -printf "%%%%verify(not md5 size mtime) " -o \ - -name gconv-modules* \ - -printf "%%%%verify(not md5 size mtime) %%%%config(noreplace) " \ - , \ - ! -path "*/lib/debug/*" -printf "/%%P\n" \) - # List all directories with a %%dir prefix. We omit the info directory and - # all directories in (and including) /usr/share/locale. - find %{glibc_sysroot} -type d \ - \( -path '*%{_prefix}/share/locale' -prune -o \ - \( -path '*%{_prefix}/share/*' \ -%if %{with docs} - ! -path '*%{_infodir}' -o \ -%endif - -path "*%{_prefix}/include/*" \ - \) -printf "%%%%dir /%%P\n" \) -} | { - # Also remove the *.mo entries. We will add them to the - # language specific sub-packages. - # libnss_ files go into subpackages related to NSS modules. - # and .*/share/i18n/charmaps/.*), they go into the sub-package - # "locale-source". /sys-root/ files are put into the sysroot package. - sed -e '\,.*/share/locale/\([^/_]\+\).*/LC_MESSAGES/.*\.mo,d' \ - -e '\,.*/share/i18n/locales/.*,d' \ - -e '\,.*/share/i18n/charmaps/.*,d' \ - -e '\,.*/etc/\(localtime\|nsswitch.conf\|ld\.so\.conf\|ld\.so\.cache\|default\|rpc\|gai\.conf\),d' \ - -e '\,.*/%{_libdir}/lib\(pcprofile\|memusage\)\.so,d' \ - -e '\,.*/bin/\(memusage\|mtrace\|xtrace\|pcprofiledump\),d' \ - -e '\,.*/sys-root,d' -} | sort > master.filelist - -# The master file list is now used by each subpackage to list their own -# files. We go through each package and subpackage now and create their lists. -# Each subpackage picks the files from the master list that they need. -# The order of the subpackage list generation does not matter. - -# Make the master file list read-only after this point to avoid accidental -# modification. -chmod 0444 master.filelist - -############################################################################### -# glibc -############################################################################### - -# Add all files with the following exceptions: -# - The info files '%{_infodir}/dir' -# - The partial (lib*_p.a) static libraries, include files. -# - The static files, objects, and unversioned DSOs. -# - The bin, locale, some sbin, and share. -# - We want iconvconfig in the main package and we do this by using -# a double negation of -v and [^i] so it removes all files in -# sbin *but* iconvconfig. -# - All the libnss files (we add back the ones we want later). -# - libc_malloc_debug.so, since it is a debugging library. -# - All bench test binaries. -# - The aux-cache, since it's handled specially in the files section. -# - Extra gconv modules. We add the required modules later. -cat master.filelist \ - | grep -v \ - -e '%{_infodir}' \ - -e '%{_libdir}/lib.*_p.a' \ - -e '%{_prefix}/include' \ - -e '%{_libdir}/lib.*\.a' \ - -e '%{_libdir}/.*\.o' \ - -e '%{_libdir}/lib.*\.so' \ - -e '%{_libdir}/gconv/.*\.so$' \ - -e '%{_libdir}/gconv/gconv-modules.d/gconv-modules-extra\.conf$' \ - -e '%{_prefix}/bin' \ - -e '%{_prefix}/lib/locale' \ - -e '%{_prefix}/sbin/[^i]' \ - -e '%{_prefix}/share' \ - -e '/var/db/Makefile' \ - -e '/libnss_.*\.so[0-9.]*$' \ - -e '/libnsl' \ -%if %{glibc_ship_tracelibs_in_utils} - -e 'libc_malloc_debug\.so' \ -%endif - -e 'glibc-benchtests' \ - -e 'aux-cache' \ -%ifarch x86_64 -%dnl Exclude 32-bit libraries built for glibc32. - -e '/lib/.*\.o' \ - -e '/lib/.*\.a' \ - -e '/lib/.*\.so.*' \ -%endif - > glibc.filelist - -# Add specific files: -# - The nss_files, nss_compat, and nss_db files. -# - The libmemusage.so and libpcprofile.so used by utils. -for module in compat files dns; do - cat master.filelist \ - | grep -E \ - -e "/libnss_$module(\.so\.[0-9.]+|-[0-9.]+\.so)$" \ -%ifarch x86_64 -%dnl Exclude 32-bit libraries built for glibc32. - | grep -v -e /lib/lib \ -%endif - >> glibc.filelist -done -grep \ -%if ! %{glibc_ship_tracelibs_in_utils} - -e "libmemusage.so" \ -%endif - -e "libpcprofile.so" \ - master.filelist \ -%ifarch x86_64 -%dnl Exclude 32-bit libraries built for glibc32. - | grep -v -e /lib/lib \ -%endif - >> glibc.filelist - -############################################################################### -# glibc-gconv-extra -############################################################################### - -grep -e "gconv-modules-extra.conf" master.filelist > gconv.filelist - -# Put the essential gconv modules into the main package. -GconvBaseModules="ISO8859-15 ISO8859-1 CP1252" -GconvBaseModules="$GconvBaseModules UNICODE UTF-16 UTF-32 UTF-7" -%ifarch s390 s390x -GconvBaseModules="$GconvBaseModules ISO-8859-1_CP037_Z900 UTF8_UTF16_Z9" -GconvBaseModules="$GconvBaseModules UTF16_UTF32_Z9 UTF8_UTF32_Z9" -%endif -GconvAllModules=$(cat master.filelist | - sed -n 's|%{_libdir}/gconv/\(.*\)\.so|\1|p') - -# Put the base modules into glibc and the rest into glibc-gconv-extra -for conv in $GconvAllModules; do - if echo $GconvBaseModules | grep -q $conv; then - grep -E -e "%{_libdir}/gconv/$conv.so$" \ - master.filelist >> glibc.filelist - else - grep -E -e "%{_libdir}/gconv/$conv.so$" \ - master.filelist >> gconv.filelist - fi -done - -############################################################################### -# glibc-devel -############################################################################### - -# Static libraries that land in glibc-devel, not glibc-static. -devel_static_library_pattern='/lib\(\(c\|nldbl\|mvec\)_nonshared\|g\|ieee\|mcheck\|pthread\|dl\|rt\|util\|anl\)\.a$' -# Static libraries neither in glibc-devel nor in glibc-static. -other_static_library_pattern='/libpthread_nonshared\.a' - -grep '%{_libdir}/lib.*\.a' master.filelist \ - | grep "$devel_static_library_pattern" \ - | grep -v "$other_static_library_pattern" \ -%ifarch x86_64 -%dnl Exclude 32-bit libraries built for glibc32. - | grep -v '/lib/.*\.a' \ -%endif - > devel.filelist - -# Put all of the object files and *.so (not the versioned ones) into the -# devel package. -grep '%{_libdir}/.*\.o' < master.filelist >> devel.filelist -grep '%{_libdir}/lib.*\.so' < master.filelist >> devel.filelist - -# The exceptions are: -# - libmemusage.so and libpcprofile.so in glibc used by utils. -# - libnss_*.so which are in nss-devel. -sed -i -e '\,libmemusage.so,d' \ - -e '\,libpcprofile.so,d' \ - -e '\,/libnss_[a-z]*\.so$,d' \ -%ifarch x86_64 -%dnl Exclude 32-bit libraries built for glibc32. - -e '\,/lib/.*\.so$,d' \ -%endif - devel.filelist - -%if %{glibc_autorequires} -mkdir -p %{glibc_sysroot}/%{_rpmconfigdir} %{glibc_sysroot}/%{_fileattrsdir} -sed < %{SOURCE3} \ - -e s/@VERSION@/%{version}/ \ - -e s/@RELEASE@/%{baserelease}/ \ - -e s/@SYMVER@/%{glibc_autorequires_symver}/ \ - > %{glibc_sysroot}/%{_rpmconfigdir}/glibc.req -cp %{SOURCE4} %{glibc_sysroot}/%{_fileattrsdir}/glibc.attr -%endif - -############################################################################### -# glibc-doc -############################################################################### - -%if %{with docs} -# Put the info files into the doc file list, but exclude the generated dir. -grep '%{_infodir}' master.filelist | grep -v '%{_infodir}/dir' > doc.filelist -grep '%{_docdir}' master.filelist >> doc.filelist -%endif - -############################################################################### -# glibc-headers -############################################################################### - -%if %{need_headers_package} -# The glibc-headers package includes only common files which are identical -# across all multilib packages. We must keep gnu/stubs.h and gnu/lib-names.h -# in the glibc-headers package, but the -32, -64, -64-v1, and -64-v2 versions -# go into glibc-devel. -%ifarch x86_64 -# Hardcode 32-bit and 64-bit header names here, so that 32-bit headers end up -# in glibc32. -grep '%{_prefix}/include/gnu/stubs-64\.h$' < master.filelist >> devel.filelist || : -grep '%{_prefix}/include/gnu/lib-names-64\.h$' < master.filelist >> devel.filelist || : -grep '%{_prefix}/include/gnu/stubs-32\.h$' < master.filelist >> glibc32.filelist || : -grep '%{_prefix}/include/gnu/lib-names-32\.h$' < master.filelist >> glibc32.filelist || : -%else -grep '%{_prefix}/include/gnu/stubs-.*\.h$' < master.filelist >> devel.filelist || : -grep '%{_prefix}/include/gnu/lib-names-.*\.h$' < master.filelist >> devel.filelist || : -%endif -# Put the include files into headers file list. -grep '%{_prefix}/include' < master.filelist \ - | grep -E -v '%{_prefix}/include/gnu/stubs-.*\.h$' \ - | grep -E -v '%{_prefix}/include/gnu/lib-names-.*\.h$' \ - > headers.filelist -%else -# If there is no glibc-headers package, all header files go into the -# glibc-devel package. -grep '%{_prefix}/include' < master.filelist >> devel.filelist -%endif - -############################################################################### -# glibc-static -############################################################################### - -# Put the rest of the static files into the static package. -grep '%{_libdir}/lib.*\.a' < master.filelist \ - | grep -v "$devel_static_library_pattern" \ - | grep -v "$other_static_library_pattern" \ -%ifarch x86_64 -%dnl Exclude 32-bit libraries built for glibc32. - | grep -v '/lib/.*\.a' \ -%endif - > static.filelist - -############################################################################### -# glibc-common -############################################################################### - -# All of the bin and certain sbin files go into the common package except -# iconvconfig which needs to go in glibc. The iconvconfig binary is kept in -# the main glibc package because we use it in the post-install scriptlet to -# rebuild the gconv-modules.cache. The makedb binary is in nss_db. -grep '%{_prefix}/bin' master.filelist \ - | grep -v '%{_prefix}/bin/makedb' \ - >> common.filelist -grep '%{_prefix}/sbin' master.filelist \ - | grep -v '%{_prefix}/sbin/iconvconfig' >> common.filelist -# All of the files under share go into the common package since they should be -# multilib-independent. -# Exceptions: -# - The actual share directory, not owned by us. -# - The info files which go into doc, and the info directory. -# - All documentation files, which go into doc. -grep '%{_prefix}/share' master.filelist \ - | grep -v \ - -e '%{_prefix}/share/info/libc.info.*' \ - -e '%%dir %{prefix}/share/info' \ - -e '%%dir %{prefix}/share' \ - -e '%{_docdir}' \ - >> common.filelist - -############################################################################### -# glibc-utils -############################################################################### - -# Add the utils scripts and programs to the utils subpackage. -cat > utils.filelist <> utils.filelist -%endif - -############################################################################### -# nss_db, nss_hesiod -############################################################################### - -# Move the NSS-related files to the NSS subpackages. Be careful not -# to pick up .debug files, and the -devel symbolic links. -for module in db hesiod; do - grep -E "/libnss_$module\\.so\\.[0-9.]+\$" \ - master.filelist > nss_$module.filelist -done -grep -E "%{_prefix}/bin/makedb$" master.filelist >> nss_db.filelist - -############################################################################### -# nss-devel -############################################################################### - -# Symlinks go into the nss-devel package (instead of the main devel -# package). -grep '/libnss_[a-z]*\.so$' master.filelist > nss-devel.filelist - -############################################################################### -# libnsl -############################################################################### - -# Prepare the libnsl-related file lists. -grep -E '/libnsl\.so\.[0-9]+$' master.filelist > libnsl.filelist -test $(wc -l < libnsl.filelist) -eq 1 - -%if %{with benchtests} -############################################################################### -# glibc-benchtests -############################################################################### +# Placement of files in subpackages is mostly controlled by the +# %%files section below. There are some exceptions where a subset of +# files are put in one package and need to be elided from another +# package, and it's not possible to do this easily using explicit file +# lists or directory matching. For these exceptions. .filelist file +# are created. + +# Make the sorting below more consistent. +export LC_ALL=C + +# `make_sysroot_filelist PATH FIND-ARGS LIST` writes %%files section +# lines for files and directories in the sysroot under PATH to the +# file LIST, with FIND-ARGS passed to the find command. The output is +# passed through sort. +make_sysroot_filelist () { + ( + find "%{glibc_sysroot}$1" \( -type f -o -type l \) $2 \ + -printf "$1/%%P\n" || true + find "%{glibc_sysroot}$1" -type d $2 -printf "%%%%dir $1/%%P\n" || true + ) | sort > "$3" +} -# List of benchmarks. -find build-%{target}/benchtests -type f -executable | while read b; do - echo "%{_prefix}/libexec/glibc-benchtests/$(basename $b)" -done >> benchtests.filelist -# ... and the makefile. -for b in %{SOURCE1} %{SOURCE2}; do - echo "%{_prefix}/libexec/glibc-benchtests/$(basename $b)" >> benchtests.filelist -done -# ... and finally, the comparison scripts. -echo "%{_prefix}/libexec/glibc-benchtests/benchout.schema.json" >> benchtests.filelist -echo "%{_prefix}/libexec/glibc-benchtests/compare_bench.py*" >> benchtests.filelist -echo "%{_prefix}/libexec/glibc-benchtests/import_bench.py*" >> benchtests.filelist -echo "%{_prefix}/libexec/glibc-benchtests/validate_benchout.py*" >> benchtests.filelist -%endif +# `remove_from_filelist FILE1 FILE2` removes the lines from FILE1 +# which are also in FILE2. The lines must not contain tabs, and the +# file is sorted as a side effect. The input files must be sorted +# according to the sort command. +remove_from_filelist () { + comm -23 "$1" "$2" > "$1.tmp" + mv "$1.tmp" "$1" +} -############################################################################### -# compat-libpthread-nonshared -############################################################################### -echo "%{_libdir}/libpthread_nonshared.a" >> compat-libpthread-nonshared.filelist +# `split_sysroot_file_list DIR FIND-ARGS REGEXP MAIN-LIST EXCEPTIONS-LIST` +# creates a list of files in the sysroot subdirectory # DIR. +# Files and directories are enumerated with the find command, +# passing FIND-ARGS as an extra argument. Those output paths that +# match REGEXP (an POSIX extended regular expression; all whitespace +# in it is removed before matching) are put into EXCEPTIONS-LIST. The +# remaining files are put into MAIN-LIST. +split_sysroot_file_list () { + make_sysroot_filelist "$1" "$2" "$4" + grep -E -e "$(printf %%s "$3" | tr -d '[:space:]')" < "$4" > "$5" + remove_from_filelist "$4" "$5" +} -############################################################################### -# glibc32 -############################################################################### -%ifarch x86_64 -grep '/lib/.*\.o$' master.filelist >> glibc32.filelist -grep '/lib/.*\.a$' master.filelist >> glibc32.filelist -grep '/lib/.*\.so' master.filelist >> glibc32.filelist -%endif +# The primary gconv converters are in the glibc package, the rest goes +# into glibc-gconv-extra. The Z9 and Z900 subpatterns are for +# s390x-specific converters. The -name clause skips over files +# that are not loadable gconv modules. +split_sysroot_file_list \ + %{_libdir}/gconv '-name *.so' \ + 'gconv/ + (CP1252 + |ISO8859-15? + |UNICODE + |UTF-[0-9]+ + |ISO-8859-1_CP037_Z900 + |UTF(8|16)_UTF(16|32)_Z9 + )\.so$' \ + gconv-extra.filelist glibc.filelist ############################################################################## # Run the glibc testsuite @@ -2337,7 +2052,7 @@ run_tests () { fi # Unconditonally dump differences in the system call list. - echo "* System call consistency checks:" >&2 + : "* System call consistency checks:" cat misc/tst-syscall-list.out >&2 set -x } @@ -2365,12 +2080,12 @@ fi echo ====================TESTING END===================== PLTCMD='/^Relocation section .*\(\.rela\?\.plt\|\.rela\.IA_64\.pltoff\)/,/^$/p' echo ====================PLT RELOCS LD.SO================ -readelf -Wr %{glibc_sysroot}/%{_lib}/ld-*.so | sed -n -e "$PLTCMD" +readelf -Wr %{glibc_sysroot}%{_libdir}/ld-*.so | sed -n -e "$PLTCMD" echo ====================PLT RELOCS LIBC.SO============== -readelf -Wr %{glibc_sysroot}/%{_lib}/libc-*.so | sed -n -e "$PLTCMD" +readelf -Wr %{glibc_sysroot}%{_libdir}/libc-*.so | sed -n -e "$PLTCMD" echo ====================PLT RELOCS END================== -run_ldso="%{glibc_sysroot}/%{glibc_ldso} --library-path %{glibc_sysroot}/%{_lib}" +run_ldso="%{glibc_sysroot}/%{_prefix}%{glibc_ldso} --library-path %{glibc_sysroot}/%{_libdir}" # Show the auxiliary vector as seen by the new library # (even if we do not perform the valgrind test). @@ -2582,16 +2297,46 @@ update_gconv_modules_cache () update_gconv_modules_cache () %files -f glibc.filelist -%dir %{_prefix}/%{_lib}/audit +%{_sbindir}/ldconfig +%{_sbindir}/iconvconfig +%{_libexecdir}/getconf +%{_prefix}%{glibc_ldso} +%{_libdir}/libBrokenLocale.so.1 +%{_libdir}/libanl.so.1 +%{_libdir}/libc.so.6 +%{_libdir}/libdl.so.2 +%{_libdir}/libm.so.6 +%{_libdir}/libnss_compat.so.2 +%{_libdir}/libnss_dns.so.2 +%{_libdir}/libnss_files.so.2 +%{_libdir}/libpthread.so.0 +%{_libdir}/libresolv.so.2 +%{_libdir}/librt.so.1 +%{_libdir}/libthread_db.so.1 +%{_libdir}/libutil.so.1 +%{_libdir}/libpcprofile.so +%{_libdir}/audit +%if %{glibc_has_libmvec} +%{_libdir}/libmvec.so.1 +%endif +%ifarch %{ix86} +# Needs to be in glibc.i686 so that glibc-utils.x86_64 can use it. +%{_libdir}/libmemusage.so +%{_libdir}/libc_malloc_debug.so.0 +%endif %if %{buildpower10} -%dir /%{_libdir}/glibc-hwcaps/power10 +%{_libdir}/glibc-hwcaps %endif %verify(not md5 size mtime) %config(noreplace) /etc/ld.so.conf %verify(not md5 size mtime) %config(noreplace) /etc/rpc %dir /etc/ld.so.conf.d -%dir %{_prefix}/libexec/getconf %dir %{_libdir}/gconv %dir %{_libdir}/gconv/gconv-modules.d +%verify(not md5 size mtime) %config(noreplace) %{_libdir}/gconv/gconv-modules +%verify(not md5 size mtime) %{_libdir}/gconv/gconv-modules.cache +%ifarch s390x +%verify(not md5 size mtime) %config(noreplace) %{_libdir}/gconv/gconv-modules.d/gconv-modules-s390.conf +%endif %dir %attr(0700,root,root) /var/cache/ldconfig %attr(0600,root,root) %verify(not md5 size mtime) %ghost %config(missingok,noreplace) /var/cache/ldconfig/aux-cache %attr(0644,root,root) %verify(not md5 size mtime) %ghost %config(missingok,noreplace) /etc/ld.so.cache @@ -2600,10 +2345,27 @@ update_gconv_modules_cache () %{!?_licensedir:%global license %%doc} %license COPYING COPYING.LIB LICENSES -%files -f common.filelist common +%files common +%{_bindir}/gencat +%{_bindir}/getconf +%{_bindir}/getent +%{_bindir}/iconv +%{_bindir}/ld.so +%{_bindir}/ldd +%{_bindir}/locale +%{_bindir}/localedef +%{_bindir}/pldd +%{_bindir}/sotruss +%{_bindir}/sprof +%{_bindir}/tzselect +%{_bindir}/zdump +%{_sbindir}/zic +%dir %{_datarootdir}/i18n +%dir %{_datarootdir}/i18n/locales +%dir %{_datarootdir}/i18n/charmaps %dir %{_prefix}/lib/locale -%dir %{_prefix}/lib/locale/C.utf8 -%{_prefix}/lib/locale/C.utf8/* +%{_datarootdir}/locale/locale.alias +%{_prefix}/lib/locale/C.utf8 %files all-langpacks %{_prefix}/lib/locale/locale-archive @@ -2611,45 +2373,95 @@ update_gconv_modules_cache () %{_prefix}/share/locale/*/LC_MESSAGES/libc.mo %files locale-source -%dir %{_prefix}/share/i18n/locales -%{_prefix}/share/i18n/locales/* -%dir %{_prefix}/share/i18n/charmaps -%{_prefix}/share/i18n/charmaps/* +%{_datarootdir}/i18n/locales +%{_datarootdir}/i18n/charmaps -%files -f devel.filelist devel +%files devel +%{_includedir}/* %if %{glibc_autorequires} %attr(0755,root,root) %{_rpmconfigdir}/glibc.req %{_fileattrsdir}/glibc.attr %endif +%{_libdir}/*.o +%{_libdir}/libBrokenLocale.so +%{_libdir}/libanl.a +%{_libdir}/libanl.so +%{_libdir}/libc.so +%{_libdir}/libc_nonshared.a +%{_libdir}/libdl.a +%{_libdir}/libg.a +%{_libdir}/libm.so +%{_libdir}/libmcheck.a +%{_libdir}/libpthread.a +%{_libdir}/libresolv.so +%{_libdir}/librt.a +%{_libdir}/libthread_db.so +%{_libdir}/libutil.a +%if %{glibc_has_libnldbl} +%{_libdir}/libnldbl_nonshared.a +%endif +%if %{glibc_has_libmvec} +%{_libdir}/libmvec.so +%endif +%ifarch x86_64 +# This files are included in the buildroot for glibc32 below. +%exclude %{_includedir}/gnu/lib-names-32.h +%exclude %{_includedir}/gnu/stubs-32.h +%endif %if %{with docs} -%files -f doc.filelist doc +%files doc +%{_datarootdir}/doc +%{_infodir}/*.info* %endif -%files -f static.filelist static - -%if %{need_headers_package} -%files -f headers.filelist -n %{headers_package_name} +%files static +%{_libdir}/libBrokenLocale.a +%{_libdir}/libc.a +%{_libdir}/libm.a +%{_libdir}/libresolv.a +%if %{glibc_has_libmvec} +%{_libdir}/libm-%{version}.a +%{_libdir}/libmvec.a %endif -%files -f utils.filelist utils +%files utils +%{_bindir}/memusage +%{_bindir}/memusagestat +%{_bindir}/mtrace +%{_bindir}/pcprofiledump +%{_bindir}/xtrace +%ifnarch %{ix86} +# Needs to be in glibc.i686 so that glibc-utils.x86_64 can use it. +%{_libdir}/libmemusage.so +%{_libdir}/libc_malloc_debug.so.0 +%endif -%files -f gconv.filelist gconv-extra +%files -f gconv-extra.filelist gconv-extra +%verify(not md5 size mtime) %config(noreplace) %{_libdir}/gconv/gconv-modules.d/gconv-modules-extra.conf -%files -f nss_db.filelist -n nss_db +%files -n nss_db +%{_bindir}/makedb +%{_libdir}/libnss_db.so.2 /var/db/Makefile -%files -f nss_hesiod.filelist -n nss_hesiod +%files -n nss_hesiod +%{_libdir}/libnss_hesiod.so.2 %doc hesiod/README.hesiod -%files -f nss-devel.filelist nss-devel +%files nss-devel +%{_libdir}/libnss_compat.so +%{_libdir}/libnss_db.so +%{_libdir}/libnss_hesiod.so -%files -f libnsl.filelist -n libnsl -/%{_lib}/libnsl.so.1 +%files -n libnsl +%{_libdir}/libnsl.so.1 %if %{with benchtests} -%files benchtests -f benchtests.filelist +%files benchtests +%{_libexecdir}/glibc-benchtests %endif -%files -f compat-libpthread-nonshared.filelist -n compat-libpthread-nonshared +%files -n compat-libpthread-nonshared +%{_libdir}/libpthread_nonshared.a %if %{without bootstrap} %files -n sysroot-%{_arch}-%{sysroot_dist}-glibc @@ -2657,17 +2469,94 @@ update_gconv_modules_cache () %endif %ifarch x86_64 -%files -f glibc32.filelist -n glibc32 +%files -n glibc32 +%{_includedir}/gnu/lib-names-32.h +%{_includedir}/gnu/stubs-32.h +%{_prefix}/lib/*.a +%{_prefix}/lib/*.o +%{_prefix}/lib/*.so* +%{_prefix}/lib/audit/* %endif %changelog +* Sun Dec 15 2024 Florian Weimer - 2.39-31 +- Minor update to getrandom vDSO handshake + +* Wed Dec 11 2024 Florian Weimer - 2.39-30 +- CVE-2024-12455: Incorrect getrandom return value on ppc64le + +* Wed Nov 20 2024 Arjun Shankar - 2.39-29 +- Sync with upstream branch release/2.39/master, + commit dcaf51b41e259387602774829c45222d0507f90a: +- elf: Change ldconfig auxcache magic number (bug 32231) +- Make tst-strtod-underflow type-generic +- Add crt1-2.0.o for glibc 2.0 compatibility tests +- Add tests of more strtod special cases +- Add more tests of strtod end pointer +- Make tst-strtod2 and tst-strtod5 type-generic +- powerpc64le: Build new strtod tests with long double ABI flags (bug 32145) +- Do not set errno for overflowing NaN payload in strtod/nan (bug 32045) +- Improve NaN payload testing +- Make __strtod_internal tests type-generic +- Fix strtod subnormal rounding (bug 30220) +- More thoroughly test underflow / errno in tst-strtod-round +- Test errno setting on strtod overflow in tst-strtod-round +- Add tests of fread +- stdio-common: Add new test for fdopen +- libio: Attempt wide backup free only for non-legacy code +- debug: Fix read error handling in pcprofiledump +- elf: Fix tst-dlopen-tlsreinit1.out test dependency +- elf: Avoid re-initializing already allocated TLS in dlopen (bug 31717) +- elf: Clarify and invert second argument of _dl_allocate_tls_init +- elf: Support recursive use of dynamic TLS in interposed malloc +- nptl: Use facilities in tst-setuid3 +- posix: Use facilities in tst-truncate and tst-truncate64 +- ungetc: Fix backup buffer leak on program exit [BZ #27821] +- ungetc: Fix uninitialized read when putting into unused streams [BZ #27821] +- Make tst-ungetc use libsupport +- stdio-common: Add test for vfscanf with matches longer than INT_MAX [BZ #27650] +- support: Add FAIL test failure helper +- string: strerror, strsignal cannot use buffer after dlmopen (bug 32026) +- Define __libc_initial for the static libc +- x86: Fix bug in strchrnul-evex512 [BZ #32078] +- Adjust check-local-headers test for libaudit 4.0 +- x32/cet: Support shadow stack during startup for Linux 6.10 +- x86-64: Remove sysdeps/x86_64/x32/dl-machine.h +- support: Add options list terminator to the test driver +- manual/stdio: Further clarify putc, putwc, getc, and getwc +- Fix name space violation in fortify wrappers (bug 32052) +- resolv: Fix tst-resolv-short-response for older GCC (bug 32042) +- Add mremap tests +- mremap: Update manual entry +- linux: Update the mremap C implementation [BZ #31968] +- Enhanced test coverage for strncmp, wcsncmp +- Enhance test coverage for strnlen, wcsnlen + +* Fri Nov 15 2024 Arjun Shankar - 2.39-28 +- Add support for getrandom vDSO (RHEL-12867) + +* Wed Nov 6 2024 Florian Weimer - 2.39-27 +- Eliminate glibc-headers and related packages + +* Tue Nov 5 2024 Florian Weimer - 2.39-26 +- Complete Features/UsrMove (aka UsrMerge, MoveToUsr) transition (#1063607) + +* Mon Nov 4 2024 Florian Weimer - 2.39-25 +- Rework filelist construction + +* Mon Nov 4 2024 Florian Weimer - 2.39-24 +- Switch to the upstream way of building xtests + * Tue Oct 29 2024 Troy Dawson - 2.39-23 - Bump release for October 2024 mass rebuild: Resolves: RHEL-64018 -* Fri Oct 25 2024 MSVSphere Packaging Team - 2.39-22 +* Fri Oct 25 2024 MSVSphere Packaging Team - 2.39-23 - Rebuilt for MSVSphere 10 +* Thu Sep 19 2024 Florian Weimer - 2.39-23 +- Ensure that xtests can be built (RHEL-59494) + * Wed Jul 31 2024 Florian Weimer - 2.39-22 - Support clearing options in /etc/resolv.conf, RES_OPTIONS with a - prefix - Introduce the strict-error/RES_STRICTERR stub resolver option (RHEL-18039)