mirror of
https://sourceware.org/git/glibc.git
synced 2024-12-24 19:51:11 +00:00
5e4e10636c
These are a grab bag of changes where the testsuite was using internal symbols of some variety, but this was straightforward to fix, and the fixed code should work with or without the change to compile the testsuite under _ISOMAC. Four of these are just more #include adjustments, but I want to highlight sysdeps/powerpc/fpu/tst-setcontext-fpscr.c, which appears to have been written before the advent of sys/auxv.h. I think a big chunk of this file could be replaced by a simple call to getauxval, but I'll let someone who actually has a powerpc machine to test on do that. dlfcn/tst-dladdr.c was including ldsodefs.h just so it could use DL_LOOKUP_ADDRESS to print an additional diagnostic; as requested by Carlos, I have removed this. math/test-misc.c was using #ifndef NO_LONG_DOUBLE, which is an internal configuration macro, to decide whether to do certain tests involving 'long double'. I changed the test to #if LDBL_MANT_DIG > DBL_MANT_DIG instead, which uses only public float.h macros and is equivalent on all supported platforms. (Note that NO_LONG_DOUBLE doesn't mean 'the compiler doesn't support long double', it means 'long double is the same as double'.) tst-writev.c has a configuration macro 'ARTIFICIAL_LIMIT' that the Makefiles are expected to define, and sysdeps/unix/sysv/linux/Makefile was using the internal __getpagesize in the definition; changed to sysconf(_SC_PAGESIZE) which is the POSIX equivalent. ia64-linux doesn't supply 'clone', only '__clone2', which is not defined in the public headers(!) All the other clone tests have local extern declarations of __clone2, but tst-clone.c doesn't; it was getting away with this because include/sched.h does declare __clone2. * nss/tst-cancel-getpwuid_r.c: Include nss.h. * string/strcasestr.c: No need to include config.h. * sysdeps/powerpc/fpu/tst-setcontext-fpscr.c: Include sys/auxv.h. Don't include sysdep.h. * sysdeps/powerpc/tst-set_ppr.c: Don't include dl-procinfo.h. * dlfcn/tst-dladdr.c: Don't include ldsodefs.h. Don't use DL_LOOKUP_ADDRESS. * math/test-misc.c: Instead of testing NO_LONG_DOUBLE, test whether LDBL_MANT_DIG is greater than DBL_MANT_DIG. * sysdeps/unix/sysv/linux/Makefile (CFLAGS-tst-writev.c): Use sysconf (_SC_PAGESIZE) instead of __getpagesize in definition of ARTIFICIAL_LIMIT. * sysdeps/unix/sysv/linux/tst-clone.c [__ia64__]: Add extern declaration of __clone2.
1206 lines
29 KiB
C
1206 lines
29 KiB
C
/* Miscellaneous tests which don't fit anywhere else.
|
|
Copyright (C) 2000-2017 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
The GNU C Library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with the GNU C Library; if not, see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#include <fenv.h>
|
|
#include <float.h>
|
|
#include <ieee754.h>
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <math-tests.h>
|
|
|
|
|
|
static int
|
|
do_test (void)
|
|
{
|
|
int result = 0;
|
|
|
|
#if LDBL_MANT_DIG > DBL_MANT_DIG
|
|
{
|
|
long double x = 0x100000001ll + (long double) 0.5;
|
|
long double q;
|
|
long double r;
|
|
|
|
r = modfl (x, &q);
|
|
if (q != (long double) 0x100000001ll || r != 0.5)
|
|
{
|
|
printf ("modfl (%Lg, ...) failed\n", x);
|
|
result = 1;
|
|
}
|
|
}
|
|
|
|
{
|
|
long double x;
|
|
long double m;
|
|
long double r;
|
|
int e;
|
|
int i;
|
|
|
|
# if LDBL_MANT_DIG == 64
|
|
m = 0xf.fffffffffffffffp-4L;
|
|
# elif LDBL_MANT_DIG == 106
|
|
/* This has to match the mantissa of LDBL_MAX which actually does have a
|
|
missing bit in the middle. */
|
|
m = 0x1.fffffffffffff7ffffffffffff8p-1L;
|
|
# elif LDBL_MANT_DIG == 113
|
|
m = 0x1.ffffffffffffffffffffffffffffp-1L;
|
|
# else
|
|
# error "Unsupported LDBL_MANT_DIG, please adjust"
|
|
# endif
|
|
|
|
for (i = LDBL_MAX_EXP, x = LDBL_MAX; i >= LDBL_MIN_EXP; --i, x /= 2.0L)
|
|
{
|
|
printf ("2^%d: ", i);
|
|
|
|
r = frexpl (x, &e);
|
|
if (r != m)
|
|
{
|
|
printf ("mantissa incorrect: %.20La\n", r);
|
|
result = 1;
|
|
continue;
|
|
}
|
|
if (e != i)
|
|
{
|
|
printf ("exponent wrong %d (%.20Lg)\n", e, x);
|
|
result = 1;
|
|
continue;
|
|
}
|
|
puts ("ok");
|
|
}
|
|
|
|
for (i = LDBL_MIN_EXP, x = LDBL_MIN; i >= LDBL_MIN_EXP - LDBL_MANT_DIG + 1;
|
|
--i, x /= 2.0L)
|
|
{
|
|
printf ("2^%d: ", i);
|
|
|
|
r = frexpl (x, &e);
|
|
if (r != 0.5L)
|
|
{
|
|
printf ("mantissa incorrect: %.20La\n", r);
|
|
result = 1;
|
|
continue;
|
|
}
|
|
if (e != i)
|
|
{
|
|
printf ("exponent wrong %d (%.20Lg)\n", e, x);
|
|
result = 1;
|
|
continue;
|
|
}
|
|
puts ("ok");
|
|
}
|
|
|
|
}
|
|
|
|
# if 0
|
|
{
|
|
int e;
|
|
long double r = frexpl (LDBL_MIN * LDBL_EPSILON, &e);
|
|
|
|
if (r != 0.5)
|
|
{
|
|
printf ("frexpl (LDBL_MIN * LDBL_EPSILON, ...): mantissa wrong: %Lg\n",
|
|
r);
|
|
result = 1;
|
|
}
|
|
else if (e != -16444)
|
|
{
|
|
printf ("frexpl (LDBL_MIN * LDBL_EPSILON, ...): exponent wrong: %d\n",
|
|
e);
|
|
result = 1;
|
|
}
|
|
}
|
|
# endif
|
|
#endif
|
|
|
|
{
|
|
double x = 0x100000001ll + (double) 0.5;
|
|
double q;
|
|
double r;
|
|
|
|
r = modf (x, &q);
|
|
if (q != (double) 0x100000001ll || r != 0.5)
|
|
{
|
|
printf ("modf (%g, ...) failed\n", x);
|
|
result = 1;
|
|
}
|
|
}
|
|
|
|
{
|
|
union ieee754_float v1;
|
|
union ieee754_float v2;
|
|
float f;
|
|
|
|
v1.f = f = FLT_MIN;
|
|
if (fpclassify (f) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (FLT_MIN) failed: %d\n", fpclassify (f));
|
|
result = 1;
|
|
}
|
|
f = nextafterf (f, FLT_MIN / 2.0f);
|
|
if (fpclassify (f) != FP_SUBNORMAL)
|
|
{
|
|
printf ("fpclassify (FLT_MIN-epsilon) failed: %d\n", fpclassify (f));
|
|
result = 1;
|
|
}
|
|
v2.f = f = nextafterf (f, FLT_MIN);
|
|
if (fpclassify (f) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (FLT_MIN-epsilon+epsilon) failed: %d\n",
|
|
fpclassify (f));
|
|
result = 1;
|
|
}
|
|
|
|
if (v1.ieee.mantissa != v2.ieee.mantissa)
|
|
{
|
|
printf ("FLT_MIN: mantissa differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa, v2.ieee.mantissa);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("FLT_MIN: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.negative != v2.ieee.negative)
|
|
{
|
|
printf ("FLT_MIN: negative differs: %d vs %d\n",
|
|
v1.ieee.negative, v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
v1.f = f = -FLT_MIN;
|
|
if (fpclassify (f) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (-FLT_MIN) failed: %d\n", fpclassify (f));
|
|
result = 1;
|
|
}
|
|
f = nextafterf (f, -FLT_MIN / 2.0f);
|
|
if (fpclassify (f) != FP_SUBNORMAL)
|
|
{
|
|
printf ("fpclassify (-FLT_MIN-epsilon) failed: %d\n", fpclassify (f));
|
|
result = 1;
|
|
}
|
|
v2.f = f = nextafterf (f, -FLT_MIN);
|
|
if (fpclassify (f) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (-FLT_MIN-epsilon+epsilon) failed: %d\n",
|
|
fpclassify (f));
|
|
result = 1;
|
|
}
|
|
|
|
if (v1.ieee.mantissa != v2.ieee.mantissa)
|
|
{
|
|
printf ("-FLT_MIN: mantissa differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa, v2.ieee.mantissa);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("-FLT_MIN: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.negative != v2.ieee.negative)
|
|
{
|
|
printf ("-FLT_MIN: negative differs: %d vs %d\n",
|
|
v1.ieee.negative, v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
f = FLT_MAX;
|
|
if (fpclassify (f) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (FLT_MAX) failed: %d\n", fpclassify (f));
|
|
result = 1;
|
|
}
|
|
f = nextafterf (f, INFINITY);
|
|
if (fpclassify (f) != FP_INFINITE)
|
|
{
|
|
printf ("fpclassify (FLT_MAX+epsilon) failed: %d\n", fpclassify (f));
|
|
result = 1;
|
|
}
|
|
|
|
f = -FLT_MAX;
|
|
if (fpclassify (f) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (-FLT_MAX) failed: %d\n", fpclassify (f));
|
|
result = 1;
|
|
}
|
|
f = nextafterf (f, -INFINITY);
|
|
if (fpclassify (f) != FP_INFINITE)
|
|
{
|
|
printf ("fpclassify (-FLT_MAX-epsilon) failed: %d\n", fpclassify (f));
|
|
result = 1;
|
|
}
|
|
|
|
v1.f = f = 0.0625;
|
|
f = nextafterf (f, 0.0);
|
|
v2.f = f = nextafterf (f, 1.0);
|
|
|
|
if (v1.ieee.mantissa != v2.ieee.mantissa)
|
|
{
|
|
printf ("0.0625f down: mantissa differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa, v2.ieee.mantissa);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("0.0625f down: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.negative != v2.ieee.negative)
|
|
{
|
|
printf ("0.0625f down: negative differs: %d vs %d\n",
|
|
v1.ieee.negative, v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
v1.f = f = 0.0625;
|
|
f = nextafterf (f, 1.0);
|
|
v2.f = f = nextafterf (f, 0.0);
|
|
|
|
if (v1.ieee.mantissa != v2.ieee.mantissa)
|
|
{
|
|
printf ("0.0625f up: mantissa differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa, v2.ieee.mantissa);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("0.0625f up: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.negative != v2.ieee.negative)
|
|
{
|
|
printf ("0.0625f up: negative differs: %d vs %d\n",
|
|
v1.ieee.negative, v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
v1.f = f = -0.0625;
|
|
f = nextafterf (f, 0.0);
|
|
v2.f = f = nextafterf (f, -1.0);
|
|
|
|
if (v1.ieee.mantissa != v2.ieee.mantissa)
|
|
{
|
|
printf ("-0.0625f up: mantissa differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa, v2.ieee.mantissa);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("-0.0625f up: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.negative != v2.ieee.negative)
|
|
{
|
|
printf ("-0.0625f up: negative differs: %d vs %d\n",
|
|
v1.ieee.negative, v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
v1.f = f = -0.0625;
|
|
f = nextafterf (f, -1.0);
|
|
v2.f = f = nextafterf (f, 0.0);
|
|
|
|
if (v1.ieee.mantissa != v2.ieee.mantissa)
|
|
{
|
|
printf ("-0.0625f down: mantissa differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa, v2.ieee.mantissa);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("-0.0625f down: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.negative != v2.ieee.negative)
|
|
{
|
|
printf ("-0.0625f down: negative differs: %d vs %d\n",
|
|
v1.ieee.negative, v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
v1.f = f = 0.0f;
|
|
f = nextafterf (f, 1.0);
|
|
v2.f = nextafterf (f, -1.0);
|
|
|
|
if (v1.ieee.mantissa != v2.ieee.mantissa)
|
|
{
|
|
printf ("0.0f up: mantissa differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa, v2.ieee.mantissa);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("0.0f up: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (0 != v2.ieee.negative)
|
|
{
|
|
printf ("0.0f up: negative differs: 0 vs %d\n",
|
|
v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
v1.f = f = 0.0f;
|
|
f = nextafterf (f, -1.0);
|
|
v2.f = nextafterf (f, 1.0);
|
|
|
|
if (v1.ieee.mantissa != v2.ieee.mantissa)
|
|
{
|
|
printf ("0.0f down: mantissa differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa, v2.ieee.mantissa);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("0.0f down: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (1 != v2.ieee.negative)
|
|
{
|
|
printf ("0.0f down: negative differs: 1 vs %d\n",
|
|
v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
if (nextafterf (0.0f, INFINITY) != nextafterf (0.0f, 1.0f)
|
|
|| nextafterf (-0.0f, INFINITY) != nextafterf (-0.0f, 1.0f)
|
|
|| nextafterf (0.0f, -INFINITY) != nextafterf (0.0f, -1.0f)
|
|
|| nextafterf (-0.0f, -INFINITY) != nextafterf (-0.0f, -1.0f))
|
|
{
|
|
printf ("nextafterf (+-0, +-Inf) != nextafterf (+-0, +-1)\n");
|
|
result = 1;
|
|
}
|
|
|
|
if (nexttowardf (0.0f, INFINITY) != nexttowardf (0.0f, 1.0f)
|
|
|| nexttowardf (-0.0f, INFINITY) != nexttowardf (-0.0f, 1.0f)
|
|
|| nexttowardf (0.0f, -INFINITY) != nexttowardf (0.0f, -1.0f)
|
|
|| nexttowardf (-0.0f, -INFINITY) != nexttowardf (-0.0f, -1.0f))
|
|
{
|
|
printf ("nexttowardf (+-0, +-Inf) != nexttowardf (+-0, +-1)\n");
|
|
result = 1;
|
|
}
|
|
}
|
|
|
|
{
|
|
union ieee754_double v1;
|
|
union ieee754_double v2;
|
|
double d;
|
|
|
|
v1.d = d = DBL_MIN;
|
|
if (fpclassify (d) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (DBL_MIN) failed: %d\n", fpclassify (d));
|
|
result = 1;
|
|
}
|
|
d = nextafter (d, DBL_MIN / 2.0);
|
|
if (fpclassify (d) != FP_SUBNORMAL)
|
|
{
|
|
printf ("fpclassify (DBL_MIN-epsilon) failed: %d\n", fpclassify (d));
|
|
result = 1;
|
|
}
|
|
v2.d = d = nextafter (d, DBL_MIN);
|
|
if (fpclassify (d) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (DBL_MIN-epsilon+epsilon) failed: %d\n",
|
|
fpclassify (d));
|
|
result = 1;
|
|
}
|
|
|
|
if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
|
|
{
|
|
printf ("DBL_MIN: mantissa0 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa0, v2.ieee.mantissa0);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
|
|
{
|
|
printf ("DBL_MIN: mantissa1 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa1, v2.ieee.mantissa1);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("DBL_MIN: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.negative != v2.ieee.negative)
|
|
{
|
|
printf ("DBL_MIN: negative differs: %d vs %d\n",
|
|
v1.ieee.negative, v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
v1.d = d = -DBL_MIN;
|
|
if (fpclassify (d) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (-DBL_MIN) failed: %d\n", fpclassify (d));
|
|
result = 1;
|
|
}
|
|
d = nextafter (d, -DBL_MIN / 2.0);
|
|
if (fpclassify (d) != FP_SUBNORMAL)
|
|
{
|
|
printf ("fpclassify (-DBL_MIN-epsilon) failed: %d\n", fpclassify (d));
|
|
result = 1;
|
|
}
|
|
v2.d = d = nextafter (d, -DBL_MIN);
|
|
if (fpclassify (d) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (-DBL_MIN-epsilon+epsilon) failed: %d\n",
|
|
fpclassify (d));
|
|
result = 1;
|
|
}
|
|
|
|
if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
|
|
{
|
|
printf ("-DBL_MIN: mantissa0 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa0, v2.ieee.mantissa0);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
|
|
{
|
|
printf ("-DBL_MIN: mantissa1 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa1, v2.ieee.mantissa1);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("-DBL_MIN: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.negative != v2.ieee.negative)
|
|
{
|
|
printf ("-DBL_MIN: negative differs: %d vs %d\n",
|
|
v1.ieee.negative, v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
d = DBL_MAX;
|
|
if (fpclassify (d) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (DBL_MAX) failed: %d\n", fpclassify (d));
|
|
result = 1;
|
|
}
|
|
d = nextafter (d, INFINITY);
|
|
if (fpclassify (d) != FP_INFINITE)
|
|
{
|
|
printf ("fpclassify (DBL_MAX+epsilon) failed: %d\n", fpclassify (d));
|
|
result = 1;
|
|
}
|
|
|
|
d = -DBL_MAX;
|
|
if (fpclassify (d) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (-DBL_MAX) failed: %d\n", fpclassify (d));
|
|
result = 1;
|
|
}
|
|
d = nextafter (d, -INFINITY);
|
|
if (fpclassify (d) != FP_INFINITE)
|
|
{
|
|
printf ("fpclassify (-DBL_MAX-epsilon) failed: %d\n", fpclassify (d));
|
|
result = 1;
|
|
}
|
|
|
|
v1.d = d = 0.0625;
|
|
d = nextafter (d, 0.0);
|
|
v2.d = d = nextafter (d, 1.0);
|
|
|
|
if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
|
|
{
|
|
printf ("0.0625 down: mantissa0 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa0, v2.ieee.mantissa0);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
|
|
{
|
|
printf ("0.0625 down: mantissa1 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa1, v2.ieee.mantissa1);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("0.0625 down: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.negative != v2.ieee.negative)
|
|
{
|
|
printf ("0.0625 down: negative differs: %d vs %d\n",
|
|
v1.ieee.negative, v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
v1.d = d = 0.0625;
|
|
d = nextafter (d, 1.0);
|
|
v2.d = d = nextafter (d, 0.0);
|
|
|
|
if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
|
|
{
|
|
printf ("0.0625 up: mantissa0 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa0, v2.ieee.mantissa0);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
|
|
{
|
|
printf ("0.0625 up: mantissa1 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa1, v2.ieee.mantissa1);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("0.0625 up: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.negative != v2.ieee.negative)
|
|
{
|
|
printf ("0.0625 up: negative differs: %d vs %d\n",
|
|
v1.ieee.negative, v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
v1.d = d = -0.0625;
|
|
d = nextafter (d, 0.0);
|
|
v2.d = d = nextafter (d, -1.0);
|
|
|
|
if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
|
|
{
|
|
printf ("-0.0625 up: mantissa0 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa0, v2.ieee.mantissa0);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
|
|
{
|
|
printf ("-0.0625 up: mantissa1 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa1, v2.ieee.mantissa1);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("-0.0625 up: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.negative != v2.ieee.negative)
|
|
{
|
|
printf ("-0.0625 up: negative differs: %d vs %d\n",
|
|
v1.ieee.negative, v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
v1.d = d = -0.0625;
|
|
d = nextafter (d, -1.0);
|
|
v2.d = d = nextafter (d, 0.0);
|
|
|
|
if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
|
|
{
|
|
printf ("-0.0625 down: mantissa0 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa0, v2.ieee.mantissa0);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
|
|
{
|
|
printf ("-0.0625 down: mantissa1 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa1, v2.ieee.mantissa1);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("-0.0625 down: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.negative != v2.ieee.negative)
|
|
{
|
|
printf ("-0.0625 down: negative differs: %d vs %d\n",
|
|
v1.ieee.negative, v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
v1.d = d = 0.0;
|
|
d = nextafter (d, 1.0);
|
|
v2.d = nextafter (d, -1.0);
|
|
|
|
if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
|
|
{
|
|
printf ("0.0 up: mantissa0 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa0, v2.ieee.mantissa0);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
|
|
{
|
|
printf ("0.0 up: mantissa1 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa1, v2.ieee.mantissa1);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("0.0 up: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (0 != v2.ieee.negative)
|
|
{
|
|
printf ("0.0 up: negative differs: 0 vs %d\n",
|
|
v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
v1.d = d = 0.0;
|
|
d = nextafter (d, -1.0);
|
|
v2.d = nextafter (d, 1.0);
|
|
|
|
if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
|
|
{
|
|
printf ("0.0 down: mantissa0 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa0, v2.ieee.mantissa0);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
|
|
{
|
|
printf ("0.0 down: mantissa1 differs: %8x vs %8x\n",
|
|
v1.ieee.mantissa1, v2.ieee.mantissa1);
|
|
result = 1;
|
|
}
|
|
if (v1.ieee.exponent != v2.ieee.exponent)
|
|
{
|
|
printf ("0.0 down: exponent differs: %4x vs %4x\n",
|
|
v1.ieee.exponent, v2.ieee.exponent);
|
|
result = 1;
|
|
}
|
|
if (1 != v2.ieee.negative)
|
|
{
|
|
printf ("0.0 down: negative differs: 1 vs %d\n",
|
|
v2.ieee.negative);
|
|
result = 1;
|
|
}
|
|
|
|
if (nextafter (0.0, INFINITY) != nextafter (0.0, 1.0)
|
|
|| nextafter (-0.0, INFINITY) != nextafter (-0.0, 1.0)
|
|
|| nextafter (0.0, -INFINITY) != nextafter (0.0, -1.0)
|
|
|| nextafter (-0.0, -INFINITY) != nextafter (-0.0, -1.0))
|
|
{
|
|
printf ("nextafter (+-0, +-Inf) != nextafter (+-0, +-1)\n");
|
|
result = 1;
|
|
}
|
|
|
|
if (nexttoward (0.0, INFINITY) != nexttoward (0.0, 1.0)
|
|
|| nexttoward (-0.0, INFINITY) != nexttoward (-0.0, 1.0)
|
|
|| nexttoward (0.0, -INFINITY) != nexttoward (0.0, -1.0)
|
|
|| nexttoward (-0.0, -INFINITY) != nexttoward (-0.0, -1.0))
|
|
{
|
|
printf ("nexttoward (+-0, +-Inf) != nexttoward (+-0, +-1)\n");
|
|
result = 1;
|
|
}
|
|
}
|
|
|
|
#if LDBL_MANT_DIG > DBL_MANT_DIG
|
|
{
|
|
long double v1, v2;
|
|
|
|
v1 = LDBL_MIN;
|
|
if (fpclassify (v1) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (LDBL_MIN) failed: %d (%La)\n",
|
|
fpclassify (v1), v1);
|
|
result = 1;
|
|
}
|
|
v2 = nextafterl (v1, LDBL_MIN / 2.0);
|
|
if (fpclassify (v2) != FP_SUBNORMAL)
|
|
{
|
|
printf ("fpclassify (LDBL_MIN-epsilon) failed: %d (%La)\n",
|
|
fpclassify (v2), v2);
|
|
result = 1;
|
|
}
|
|
v2 = nextafterl (v2, LDBL_MIN);
|
|
if (fpclassify (v2) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (LDBL_MIN-epsilon+epsilon) failed: %d (%La)\n",
|
|
fpclassify (v2), v2);
|
|
result = 1;
|
|
}
|
|
|
|
if (v1 != v2)
|
|
{
|
|
printf ("LDBL_MIN-epsilon+epsilon != LDBL_MIN: %La vs %La\n", v2, v1);
|
|
result = 1;
|
|
}
|
|
|
|
v1 = -LDBL_MIN;
|
|
if (fpclassify (v1) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (-LDBL_MIN) failed: %d (%La)\n",
|
|
fpclassify (v1), v1);
|
|
result = 1;
|
|
}
|
|
v2 = nextafterl (v1, -LDBL_MIN / 2.0);
|
|
if (fpclassify (v2) != FP_SUBNORMAL)
|
|
{
|
|
printf ("fpclassify (-LDBL_MIN-epsilon) failed: %d (%La)\n",
|
|
fpclassify (v2), v2);
|
|
result = 1;
|
|
}
|
|
v2 = nextafterl (v2, -LDBL_MIN);
|
|
if (fpclassify (v2) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (-LDBL_MIN-epsilon+epsilon) failed: %d (%La)\n",
|
|
fpclassify (v2), v2);
|
|
result = 1;
|
|
}
|
|
|
|
if (v1 != v2)
|
|
{
|
|
printf ("-LDBL_MIN-epsilon+epsilon != -LDBL_MIN: %La vs %La\n", v2, v1);
|
|
result = 1;
|
|
}
|
|
|
|
v1 = LDBL_MAX;
|
|
if (fpclassify (v1) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (LDBL_MAX) failed: %d (%La)\n",
|
|
fpclassify (v1), v1);
|
|
result = 1;
|
|
}
|
|
v2 = nextafterl (v1, INFINITY);
|
|
if (fpclassify (v2) != FP_INFINITE)
|
|
{
|
|
printf ("fpclassify (LDBL_MAX+epsilon) failed: %d (%La)\n",
|
|
fpclassify (v2), v2);
|
|
result = 1;
|
|
}
|
|
|
|
v1 = -LDBL_MAX;
|
|
if (fpclassify (v1) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (-LDBL_MAX) failed: %d (%La)\n",
|
|
fpclassify (v1), v1);
|
|
result = 1;
|
|
}
|
|
v2 = nextafterl (v1, -INFINITY);
|
|
if (fpclassify (v2) != FP_INFINITE)
|
|
{
|
|
printf ("fpclassify (-LDBL_MAX-epsilon) failed: %d (%La)\n",
|
|
fpclassify (v2), v2);
|
|
result = 1;
|
|
}
|
|
|
|
v1 = 0.0625;
|
|
v2 = nextafterl (v1, 0.0);
|
|
v2 = nextafterl (v2, 1.0);
|
|
|
|
if (v1 != v2)
|
|
{
|
|
printf ("0.0625L-epsilon+epsilon != 0.0625L: %La vs %La\n", v2, v1);
|
|
result = 1;
|
|
}
|
|
|
|
v1 = 0.0625;
|
|
v2 = nextafterl (v1, 1.0);
|
|
v2 = nextafterl (v2, 0.0);
|
|
|
|
if (v1 != v2)
|
|
{
|
|
printf ("0.0625L+epsilon-epsilon != 0.0625L: %La vs %La\n", v2, v1);
|
|
result = 1;
|
|
}
|
|
|
|
v1 = -0.0625;
|
|
v2 = nextafterl (v1, 0.0);
|
|
v2 = nextafterl (v2, -1.0);
|
|
|
|
if (v1 != v2)
|
|
{
|
|
printf ("-0.0625L+epsilon-epsilon != -0.0625L: %La vs %La\n", v2, v1);
|
|
result = 1;
|
|
}
|
|
|
|
v1 = -0.0625;
|
|
v2 = nextafterl (v1, -1.0);
|
|
v2 = nextafterl (v2, 0.0);
|
|
|
|
if (v1 != v2)
|
|
{
|
|
printf ("-0.0625L-epsilon+epsilon != -0.0625L: %La vs %La\n", v2, v1);
|
|
result = 1;
|
|
}
|
|
|
|
v1 = 0.0;
|
|
v2 = nextafterl (v1, 1.0);
|
|
v2 = nextafterl (v2, -1.0);
|
|
|
|
if (v1 != v2)
|
|
{
|
|
printf ("0.0+epsilon-epsilon != 0.0L: %La vs %La\n", v2, v1);
|
|
result = 1;
|
|
}
|
|
if (signbit (v2))
|
|
{
|
|
printf ("0.0+epsilon-epsilon is negative\n");
|
|
result = 1;
|
|
}
|
|
|
|
v1 = 0.0;
|
|
v2 = nextafterl (v1, -1.0);
|
|
v2 = nextafterl (v2, 1.0);
|
|
|
|
if (v1 != v2)
|
|
{
|
|
printf ("0.0-epsilon+epsilon != 0.0L: %La vs %La\n", v2, v1);
|
|
result = 1;
|
|
}
|
|
if (!signbit (v2))
|
|
{
|
|
printf ("0.0-epsilon+epsilon is positive\n");
|
|
result = 1;
|
|
}
|
|
|
|
if (nextafterl (0.0, INFINITY) != nextafterl (0.0, 1.0)
|
|
|| nextafterl (-0.0, INFINITY) != nextafterl (-0.0, 1.0)
|
|
|| nextafterl (0.0, -INFINITY) != nextafterl (0.0, -1.0)
|
|
|| nextafterl (-0.0, -INFINITY) != nextafterl (-0.0, -1.0))
|
|
{
|
|
printf ("nextafterl (+-0, +-Inf) != nextafterl (+-0, +-1)\n");
|
|
result = 1;
|
|
}
|
|
|
|
if (nexttowardl (0.0L, INFINITY) != nexttowardl (0.0L, 1.0L)
|
|
|| nexttowardl (-0.0L, INFINITY) != nexttowardl (-0.0L, 1.0L)
|
|
|| nexttowardl (0.0L, -INFINITY) != nexttowardl (0.0L, -1.0L)
|
|
|| nexttowardl (-0.0L, -INFINITY) != nexttowardl (-0.0L, -1.0L))
|
|
{
|
|
printf ("nexttowardl (+-0, +-Inf) != nexttowardl (+-0, +-1)\n");
|
|
result = 1;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (! isnormal (FLT_MIN))
|
|
{
|
|
puts ("isnormal (FLT_MIN) failed");
|
|
result = 1;
|
|
}
|
|
if (! isnormal (DBL_MIN))
|
|
{
|
|
puts ("isnormal (DBL_MIN) failed");
|
|
result = 1;
|
|
}
|
|
#if LDBL_MANT_DIG > DBL_MANT_DIG
|
|
if (! isnormal (LDBL_MIN))
|
|
{
|
|
puts ("isnormal (LDBL_MIN) failed");
|
|
result = 1;
|
|
}
|
|
#endif
|
|
|
|
#if defined (__i386__) || defined (__x86_64__)
|
|
/* This is a test for the strange long doubles in x86 FPUs. */
|
|
{
|
|
union
|
|
{
|
|
char b[10];
|
|
long double d;
|
|
} u =
|
|
{ .b = { 0, 0, 0, 0, 0, 0, 0, 0x80, 0, 0 } };
|
|
|
|
if (fpclassify (u.d) != FP_NORMAL)
|
|
{
|
|
printf ("fpclassify (0x00008000000000000000) failed: %d (%Lg)\n",
|
|
fpclassify (u.d), u.d);
|
|
result = 1;
|
|
}
|
|
}
|
|
|
|
/* Special qNaNs in x86 long double. Test for scalbl. */
|
|
{
|
|
union
|
|
{
|
|
char b[10];
|
|
long double d;
|
|
} u =
|
|
{ .b = { 0, 1, 0, 0, 0, 0, 0, 0xc0, 0xff, 0x7f } };
|
|
long double r;
|
|
|
|
r = scalbl (u.d, 0.0);
|
|
if (!isnan (r))
|
|
{
|
|
puts ("scalbl (qNaN, 0) does not return NaN");
|
|
result = 1;
|
|
}
|
|
else if (memcmp (&r, &u.d, sizeof (double)) != 0)
|
|
{
|
|
puts ("scalbl (qNaN, 0) does not return the same NaN");
|
|
result = 1;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if LDBL_MANT_DIG > DBL_MANT_DIG
|
|
{
|
|
long double r;
|
|
|
|
feclearexcept (FE_ALL_EXCEPT);
|
|
r = scalbl (LDBL_MIN, 2147483647);
|
|
if (! isinf (r))
|
|
{
|
|
puts ("scalbl (LDBL_MIN, 2147483647) does not return Inf");
|
|
result = 1;
|
|
}
|
|
else if (signbit (r) != 0)
|
|
{
|
|
puts ("scalbl (LDBL_MIN, 2147483647) returns -Inf");
|
|
result = 1;
|
|
}
|
|
else if (fetestexcept (FE_UNDERFLOW))
|
|
{
|
|
puts ("scalbl (LDBL_MIN, 2147483647) raises underflow exception");
|
|
result = 1;
|
|
}
|
|
|
|
feclearexcept (FE_ALL_EXCEPT);
|
|
r = scalbl (LDBL_MAX, -2147483647);
|
|
if (r != 0.0)
|
|
{
|
|
puts ("scalbl (LDBL_MAX, -2147483647) does not return 0");
|
|
result = 1;
|
|
}
|
|
else if (signbit (r) != 0)
|
|
{
|
|
puts ("scalbl (LDBL_MAX, -2147483647) returns -Inf");
|
|
result = 1;
|
|
}
|
|
else if (fetestexcept (FE_OVERFLOW))
|
|
{
|
|
puts ("scalbl (LDBL_MAX, -2147483647) raises overflow exception");
|
|
result = 1;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* The tests here are very similar to tests earlier in this file,
|
|
the important difference is just that there are no intervening
|
|
union variables that cause some GCC versions to hide possible
|
|
bugs in nextafter* implementation. */
|
|
if (nextafterf (nextafterf (FLT_MIN, FLT_MIN / 2.0), FLT_MIN) != FLT_MIN)
|
|
{
|
|
puts ("nextafterf FLT_MIN test failed");
|
|
result = 1;
|
|
}
|
|
if (nextafterf (nextafterf (-FLT_MIN, -FLT_MIN / 2.0), -FLT_MIN)
|
|
!= -FLT_MIN)
|
|
{
|
|
puts ("nextafterf -FLT_MIN test failed");
|
|
result = 1;
|
|
}
|
|
if (nextafter (nextafter (DBL_MIN, DBL_MIN / 2.0), DBL_MIN) != DBL_MIN)
|
|
{
|
|
puts ("nextafter DBL_MIN test failed");
|
|
result = 1;
|
|
}
|
|
if (nextafter (nextafter (-DBL_MIN, -DBL_MIN / 2.0), -DBL_MIN) != -DBL_MIN)
|
|
{
|
|
puts ("nextafter -DBL_MIN test failed");
|
|
result = 1;
|
|
}
|
|
#if LDBL_MANT_DIG > DBL_MANT_DIG
|
|
if (nextafterl (nextafterl (LDBL_MIN, LDBL_MIN / 2.0), LDBL_MIN)
|
|
!= LDBL_MIN)
|
|
{
|
|
puts ("nextafterl LDBL_MIN test failed");
|
|
result = 1;
|
|
}
|
|
if (nextafterl (nextafterl (-LDBL_MIN, -LDBL_MIN / 2.0), -LDBL_MIN)
|
|
!= -LDBL_MIN)
|
|
{
|
|
puts ("nextafterl -LDBL_MIN test failed");
|
|
result = 1;
|
|
}
|
|
#endif
|
|
|
|
volatile float f1 = FLT_MAX;
|
|
volatile float f2 = FLT_MAX / 2;
|
|
(void) &f1;
|
|
(void) &f2;
|
|
feclearexcept (FE_ALL_EXCEPT);
|
|
f2 += f1;
|
|
#if defined(FE_OVERFLOW) && defined(FE_INEXACT)
|
|
int fe = fetestexcept (FE_ALL_EXCEPT);
|
|
if (EXCEPTION_TESTS (float) && fe != (FE_OVERFLOW | FE_INEXACT))
|
|
{
|
|
printf ("float overflow test failed: %x\n", fe);
|
|
result = 1;
|
|
}
|
|
#endif
|
|
|
|
volatile double d1 = DBL_MAX;
|
|
volatile double d2 = DBL_MAX / 2;
|
|
(void) &d1;
|
|
(void) &d2;
|
|
feclearexcept (FE_ALL_EXCEPT);
|
|
d2 += d1;
|
|
#if defined(FE_OVERFLOW) && defined(FE_INEXACT)
|
|
fe = fetestexcept (FE_ALL_EXCEPT);
|
|
if (EXCEPTION_TESTS (double) && fe != (FE_OVERFLOW | FE_INEXACT))
|
|
{
|
|
printf ("double overflow test failed: %x\n", fe);
|
|
result = 1;
|
|
}
|
|
#endif
|
|
|
|
#if LDBL_MANT_DIG > DBL_MANT_DIG
|
|
volatile long double ld1 = LDBL_MAX;
|
|
volatile long double ld2 = LDBL_MAX / 2;
|
|
(void) &ld1;
|
|
(void) &ld2;
|
|
feclearexcept (FE_ALL_EXCEPT);
|
|
ld2 += ld1;
|
|
# if defined(FE_OVERFLOW) && defined(FE_INEXACT)
|
|
fe = fetestexcept (FE_ALL_EXCEPT);
|
|
if (EXCEPTION_TESTS (long double) && fe != (FE_OVERFLOW | FE_INEXACT))
|
|
{
|
|
printf ("long double overflow test failed: %x\n", fe);
|
|
result = 1;
|
|
}
|
|
# endif
|
|
|
|
# if LDBL_MANT_DIG == 113
|
|
volatile long double ld3 = 0x1.0000000000010000000100000001p+1;
|
|
volatile long double ld4 = 0x1.0000000000000000000000000001p+1;
|
|
(void) &ld3;
|
|
(void) &ld4;
|
|
ld3 -= ld4;
|
|
if (ld3 != 0x1.0p-47)
|
|
{
|
|
printf ("long double subtraction test failed %.28La\n", ld3);
|
|
result = 1;
|
|
}
|
|
# endif
|
|
|
|
/* Skip testing IBM long double format, for 2 reasons:
|
|
1) it only supports FE_TONEAREST
|
|
2) nextafter (0.0, 1.0) == nextafterl (0.0L, 1.0L), so
|
|
nextafter (0.0, 1.0) / 16.0L will be 0.0L. */
|
|
# if LDBL_MANT_DIG >= DBL_MANT_DIG + 4 && LDBL_MANT_DIG != 106
|
|
int oldmode = fegetround ();
|
|
int j;
|
|
for (j = 0; j < 4; j++)
|
|
{
|
|
int mode;
|
|
int i;
|
|
int k = 0;
|
|
const char *mstr;
|
|
switch (j)
|
|
{
|
|
#ifdef FE_TONEAREST
|
|
case 0:
|
|
mode = FE_TONEAREST;
|
|
mstr = "nearest";
|
|
k = 8;
|
|
break;
|
|
#endif
|
|
#ifdef FE_DOWNWARD
|
|
case 1:
|
|
mode = FE_DOWNWARD;
|
|
mstr = "-inf";
|
|
break;
|
|
#endif
|
|
#ifdef FE_UPWARD
|
|
case 2:
|
|
mode = FE_UPWARD;
|
|
mstr = "+inf";
|
|
k = 15;
|
|
break;
|
|
#endif
|
|
#ifdef FE_TOWARDZERO
|
|
case 3:
|
|
mode = FE_TOWARDZERO;
|
|
mstr = "0";
|
|
break;
|
|
#endif
|
|
default:
|
|
continue;
|
|
}
|
|
|
|
volatile long double ld5 = nextafter (0.0, 1.0) / 16.0L;
|
|
volatile double d5;
|
|
(void) &ld5;
|
|
for (i = 0; i <= 32; i++)
|
|
{
|
|
if (fesetround (mode))
|
|
{
|
|
printf ("failed to set rounding mode to %s\n", mstr);
|
|
if (ROUNDING_TESTS (long double, mode)
|
|
&& ROUNDING_TESTS (double, mode))
|
|
result = 1;
|
|
else
|
|
puts ("ignoring this failure");
|
|
break;
|
|
}
|
|
d5 = ld5 * i;
|
|
(void) &d5;
|
|
fesetround (oldmode);
|
|
if (d5 != ((j == 0 && i == 8) ? 0 : (i + k) / 16)
|
|
* nextafter (0.0, 1.0))
|
|
{
|
|
printf ("%La incorrectly rounded to %s as %a\n",
|
|
ld5 * i, mstr, d5);
|
|
if (ROUNDING_TESTS (long double, mode)
|
|
&& ROUNDING_TESTS (double, mode))
|
|
result = 1;
|
|
else
|
|
puts ("ignoring this failure");
|
|
}
|
|
}
|
|
}
|
|
|
|
volatile long double ld7 = nextafterl (0.0L, 1.0L);
|
|
volatile double d7;
|
|
(void) &ld7;
|
|
fesetround (FE_UPWARD);
|
|
d7 = ld7;
|
|
(void) &d7;
|
|
fesetround (oldmode);
|
|
|
|
if (d7 != nextafter (0.0, 1.0))
|
|
{
|
|
printf ("%La incorrectly rounded upward to %a\n", ld7, d7);
|
|
if (ROUNDING_TESTS (long double, FE_UPWARD)
|
|
&& ROUNDING_TESTS (double, FE_UPWARD))
|
|
result = 1;
|
|
else
|
|
puts ("ignoring this failure");
|
|
}
|
|
# endif
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
#define TEST_FUNCTION do_test ()
|
|
#include "../test-skeleton.c"
|