mirror of
https://sourceware.org/git/glibc.git
synced 2024-11-25 22:40:05 +00:00
462e83a4a0
This patch fixes more places where a space should have been present
before '(' in accordance with the GNU Coding Standards (as with the
previous patch, mainly for calls to sizeof).
Tested with build-many-glibcs.py.
* sysdeps/powerpc/powerpc32/dl-machine.c
(__elf_machine_fixup_plt): Use space before '('.
(__process_machine_rela): Likewise.
* sysdeps/powerpc/powerpc32/register-dump.h (register_dump):
Likewise.
* sysdeps/powerpc/powerpc64/le/fpu/sfp-machine.h (TI_BITS):
Likewise.
* sysdeps/powerpc/powerpc64/register-dump.h (register_dump):
Likewise.
* sysdeps/powerpc/test-arith.c (union_t): Likewise.
(pattern): Likewise.
(delta): Likewise.
(check_result): Likewise.
(check_excepts): Likewise.
(check_op): Likewise.
(fail_xr): Likewise.
* sysdeps/unix/alpha/sysdep.h (syscall_promote): Likewise.
* sysdeps/unix/sysv/linux/alpha/a.out.h (AOUTHSZ): Likewise.
(SCNHSZ): Likewise.
* sysdeps/unix/sysv/linux/hppa/makecontext.c (FRAME_SIZE_BYTES):
Likewise.
(ARGS): Likewise.
(__makecontext): Likewise.
* sysdeps/unix/sysv/linux/powerpc/sys/ucontext.h (ucontext_t):
Likewise.
605 lines
17 KiB
C
605 lines
17 KiB
C
/* Test floating-point arithmetic operations.
|
|
Copyright (C) 1997-2019 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
The GNU C Library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with the GNU C Library; if not, see
|
|
<http://www.gnu.org/licenses/>. */
|
|
#ifndef _GNU_SOURCE
|
|
#define _GNU_SOURCE
|
|
#endif
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <fenv.h>
|
|
#include <assert.h>
|
|
|
|
#ifndef ESIZE
|
|
typedef double tocheck_t;
|
|
#define ESIZE 11
|
|
#define MSIZE 52
|
|
#define FUNC(x) x
|
|
#endif
|
|
|
|
#define R_NEAREST 1
|
|
#define R_ZERO 2
|
|
#define R_UP 4
|
|
#define R_DOWN 8
|
|
#define R_ALL (R_NEAREST|R_ZERO|R_UP|R_DOWN)
|
|
static fenv_t rmodes[4];
|
|
static const char * const rmnames[4] =
|
|
{ "nearest","zero","+Inf","-Inf" };
|
|
|
|
typedef union {
|
|
tocheck_t tc;
|
|
unsigned char c[sizeof (tocheck_t)];
|
|
} union_t;
|
|
|
|
/* Don't try reading these in a font that doesn't distinguish
|
|
O and zero. */
|
|
typedef enum {
|
|
P_Z = 0x0, /* 00000...0 */
|
|
P_000O = 0x1, /* 00011...1 */
|
|
P_001Z = 0x2, /* 00100...0 */
|
|
P_00O = 0x3, /* 00111...1 */
|
|
P_01Z = 0x4, /* 01000...0 */
|
|
P_010O = 0x5, /* 01011...1 */
|
|
P_011Z = 0x6, /* 01100...0 */
|
|
P_0O = 0x7, /* 01111...1 */
|
|
P_1Z = 0x8, /* 10000...0 */
|
|
P_100O = 0x9, /* 10011...1 */
|
|
P_101Z = 0xa, /* 10100...0 */
|
|
P_10O = 0xb, /* 10111...1 */
|
|
P_11Z = 0xc, /* 11000...0 */
|
|
P_110O = 0xd, /* 11011...1 */
|
|
P_111Z = 0xe, /* 11100...0 */
|
|
P_O = 0xf, /* 11111...1 */
|
|
P_Z1 = 0x11, /* 000...001 */
|
|
P_Z10 = 0x12, /* 000...010 */
|
|
P_Z11 = 0x13, /* 000...011 */
|
|
P_0O00 = 0x14, /* 011...100 */
|
|
P_0O01 = 0x15, /* 011...101 */
|
|
P_0O0 = 0x16, /* 011...110 */
|
|
P_1Z1 = 0x19, /* 100...001 */
|
|
P_1Z10 = 0x1a, /* 100...010 */
|
|
P_1Z11 = 0x1b, /* 100...011 */
|
|
P_O00 = 0x1c, /* 111...100 */
|
|
P_O01 = 0x1d, /* 111...101 */
|
|
P_O0 = 0x1e, /* 111...110 */
|
|
P_R = 0x20, /* rrr...rrr */ /* ('r' means random. ) */
|
|
P_Ro = 0x21, /* rrr...rrr, with odd parity. */
|
|
P_0R = 0x22, /* 0rr...rrr */
|
|
P_1R = 0x23, /* 1rr...rrr */
|
|
P_Rno = 0x24, /* rrr...rrr, but not all ones. */
|
|
} pattern_t;
|
|
|
|
static void
|
|
pattern_fill(pattern_t ptn, unsigned char *start, int bitoffset, int count)
|
|
{
|
|
#define bitset(count, value) \
|
|
start[(count)/8] = (start[(count)/8] & ~(1 << 7-(count)%8) \
|
|
| (value) << 7-(count)%8)
|
|
int i;
|
|
|
|
if (ptn >= 0 && ptn <= 0xf)
|
|
{
|
|
/* Patterns between 0 and 0xF have the following format:
|
|
The LSBit is used to fill the last n-3 bits of the pattern;
|
|
The next 3 bits are the first 3 bits of the pattern. */
|
|
for (i = 0; i < count; i++)
|
|
if (i < 3)
|
|
bitset((bitoffset+i), ptn >> (3-i) & 1);
|
|
else
|
|
bitset((bitoffset+i), ptn >> 0 & 1);
|
|
}
|
|
else if (ptn <= 0x1f)
|
|
{
|
|
/* Patterns between 0x10 and 0x1F have the following format:
|
|
The two LSBits are the last two bits of the pattern;
|
|
The 0x8 bit is the first bit of the pattern;
|
|
The 0x4 bit is used to fill the remainder. */
|
|
for (i = 0; i < count; i++)
|
|
if (i == 0)
|
|
bitset((bitoffset+i), ptn >> 3 & 1);
|
|
else if (i >= count-2)
|
|
bitset((bitoffset+i), ptn >> (count-1-i) & 1);
|
|
else
|
|
bitset((bitoffset+i), ptn >> 2 & 1);
|
|
}
|
|
else switch (ptn)
|
|
{
|
|
case P_0R: case P_1R:
|
|
assert(count > 0);
|
|
bitset(bitoffset, ptn & 1);
|
|
count--;
|
|
bitoffset++;
|
|
case P_R:
|
|
for (; count > 0; count--, bitoffset++)
|
|
bitset(bitoffset, rand() & 1);
|
|
break;
|
|
case P_Ro:
|
|
{
|
|
int op = 1;
|
|
assert(count > 0);
|
|
for (; count > 1; count--, bitoffset++)
|
|
bitset(bitoffset, op ^= (rand() & 1));
|
|
bitset(bitoffset, op);
|
|
break;
|
|
}
|
|
case P_Rno:
|
|
{
|
|
int op = 1;
|
|
assert(count > 0);
|
|
for (; count > 1; count--, bitoffset++)
|
|
{
|
|
int r = rand() & 1;
|
|
op &= r;
|
|
bitset(bitoffset, r);
|
|
}
|
|
bitset(bitoffset, rand() & (op ^ 1));
|
|
break;
|
|
}
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
#undef bitset
|
|
}
|
|
|
|
static tocheck_t
|
|
pattern(int negative, pattern_t exp, pattern_t mant)
|
|
{
|
|
union_t result;
|
|
#if 0
|
|
int i;
|
|
#endif
|
|
|
|
pattern_fill(negative ? P_O : P_Z, result.c, 0, 1);
|
|
pattern_fill(exp, result.c, 1, ESIZE);
|
|
pattern_fill(mant, result.c, ESIZE+1, MSIZE);
|
|
#if 0
|
|
printf("neg=%d exp=%02x mant=%02x: ", negative, exp, mant);
|
|
for (i = 0; i < sizeof (tocheck_t); i++)
|
|
printf("%02x", result.c[i]);
|
|
printf("\n");
|
|
#endif
|
|
return result.tc;
|
|
}
|
|
|
|
/* Return the closest different tocheck_t to 'x' in the direction of
|
|
'direction', or 'x' if there is no such value. Assumes 'x' is not
|
|
a NaN. */
|
|
static tocheck_t
|
|
delta(tocheck_t x, int direction)
|
|
{
|
|
union_t xx;
|
|
int i;
|
|
|
|
xx.tc = x;
|
|
if (xx.c[0] & 0x80)
|
|
direction = -direction;
|
|
if (direction == +1)
|
|
{
|
|
union_t tx;
|
|
tx.tc = pattern(xx.c[0] >> 7, P_O, P_Z);
|
|
if (memcmp (tx.c, xx.c, sizeof (tocheck_t)) == 0)
|
|
return x;
|
|
}
|
|
for (i = sizeof (tocheck_t)-1; i > 0; i--)
|
|
{
|
|
xx.c[i] += direction;
|
|
if (xx.c[i] != (direction > 0 ? 0 : 0xff))
|
|
return xx.tc;
|
|
}
|
|
if (direction < 0 && (xx.c[0] & 0x7f) == 0)
|
|
return pattern(~(xx.c[0] >> 7) & 1, P_Z, P_Z1);
|
|
else
|
|
{
|
|
xx.c[0] += direction;
|
|
return xx.tc;
|
|
}
|
|
}
|
|
|
|
static int nerrors = 0;
|
|
|
|
#ifdef FE_ALL_INVALID
|
|
static const int all_exceptions = FE_ALL_INVALID | FE_ALL_EXCEPT;
|
|
#else
|
|
static const int all_exceptions = FE_ALL_EXCEPT;
|
|
#endif
|
|
|
|
static void
|
|
check_result(int line, const char *rm, tocheck_t expected, tocheck_t actual)
|
|
{
|
|
if (memcmp (&expected, &actual, sizeof (tocheck_t)) != 0)
|
|
{
|
|
unsigned char *ex, *ac;
|
|
size_t i;
|
|
|
|
printf("%s:%d:round %s:result failed\n"
|
|
" expected result 0x", __FILE__, line, rm);
|
|
ex = (unsigned char *)&expected;
|
|
ac = (unsigned char *)&actual;
|
|
for (i = 0; i < sizeof (tocheck_t); i++)
|
|
printf("%02x", ex[i]);
|
|
printf(" got 0x");
|
|
for (i = 0; i < sizeof (tocheck_t); i++)
|
|
printf("%02x", ac[i]);
|
|
printf("\n");
|
|
nerrors++;
|
|
}
|
|
}
|
|
|
|
static const struct {
|
|
int except;
|
|
const char *name;
|
|
} excepts[] = {
|
|
#define except_entry(ex) { ex, #ex } ,
|
|
#ifdef FE_INEXACT
|
|
except_entry(FE_INEXACT)
|
|
#else
|
|
# define FE_INEXACT 0
|
|
#endif
|
|
#ifdef FE_DIVBYZERO
|
|
except_entry(FE_DIVBYZERO)
|
|
#else
|
|
# define FE_DIVBYZERO 0
|
|
#endif
|
|
#ifdef FE_UNDERFLOW
|
|
except_entry(FE_UNDERFLOW)
|
|
#else
|
|
# define FE_UNDERFLOW 0
|
|
#endif
|
|
#ifdef FE_OVERFLOW
|
|
except_entry(FE_OVERFLOW)
|
|
#else
|
|
# define FE_OVERFLOW 0
|
|
#endif
|
|
#ifdef FE_INVALID
|
|
except_entry(FE_INVALID)
|
|
#else
|
|
# define FE_INVALID 0
|
|
#endif
|
|
#ifdef FE_INVALID_SNAN
|
|
except_entry(FE_INVALID_SNAN)
|
|
#else
|
|
# define FE_INVALID_SNAN FE_INVALID
|
|
#endif
|
|
#ifdef FE_INVALID_ISI
|
|
except_entry(FE_INVALID_ISI)
|
|
#else
|
|
# define FE_INVALID_ISI FE_INVALID
|
|
#endif
|
|
#ifdef FE_INVALID_IDI
|
|
except_entry(FE_INVALID_IDI)
|
|
#else
|
|
# define FE_INVALID_IDI FE_INVALID
|
|
#endif
|
|
#ifdef FE_INVALID_ZDZ
|
|
except_entry(FE_INVALID_ZDZ)
|
|
#else
|
|
# define FE_INVALID_ZDZ FE_INVALID
|
|
#endif
|
|
#ifdef FE_INVALID_COMPARE
|
|
except_entry(FE_INVALID_COMPARE)
|
|
#else
|
|
# define FE_INVALID_COMPARE FE_INVALID
|
|
#endif
|
|
#ifdef FE_INVALID_SOFTWARE
|
|
except_entry(FE_INVALID_SOFTWARE)
|
|
#else
|
|
# define FE_INVALID_SOFTWARE FE_INVALID
|
|
#endif
|
|
#ifdef FE_INVALID_SQRT
|
|
except_entry(FE_INVALID_SQRT)
|
|
#else
|
|
# define FE_INVALID_SQRT FE_INVALID
|
|
#endif
|
|
#ifdef FE_INVALID_INTEGER_CONVERSION
|
|
except_entry(FE_INVALID_INTEGER_CONVERSION)
|
|
#else
|
|
# define FE_INVALID_INTEGER_CONVERSION FE_INVALID
|
|
#endif
|
|
};
|
|
|
|
static int excepts_missing = 0;
|
|
|
|
static void
|
|
check_excepts(int line, const char *rm, int expected, int actual)
|
|
{
|
|
if (expected & excepts_missing)
|
|
expected = expected & ~excepts_missing | FE_INVALID_SNAN;
|
|
if ((expected & all_exceptions) != actual)
|
|
{
|
|
size_t i;
|
|
printf("%s:%d:round %s:exceptions failed\n"
|
|
" expected exceptions ", __FILE__, line,rm);
|
|
for (i = 0; i < sizeof (excepts) / sizeof (excepts[0]); i++)
|
|
if (expected & excepts[i].except)
|
|
printf("%s ",excepts[i].name);
|
|
if ((expected & all_exceptions) == 0)
|
|
printf("- ");
|
|
printf("got");
|
|
for (i = 0; i < sizeof (excepts) / sizeof (excepts[0]); i++)
|
|
if (actual & excepts[i].except)
|
|
printf(" %s",excepts[i].name);
|
|
if ((actual & all_exceptions) == 0)
|
|
printf("- ");
|
|
printf(".\n");
|
|
nerrors++;
|
|
}
|
|
}
|
|
|
|
typedef enum {
|
|
B_ADD, B_SUB, B_MUL, B_DIV, B_NEG, B_ABS, B_SQRT
|
|
} op_t;
|
|
typedef struct {
|
|
int line;
|
|
op_t op;
|
|
int a_sgn;
|
|
pattern_t a_exp, a_mant;
|
|
int b_sgn;
|
|
pattern_t b_exp, b_mant;
|
|
int rmode;
|
|
int excepts;
|
|
int x_sgn;
|
|
pattern_t x_exp, x_mant;
|
|
} optest_t;
|
|
static const optest_t optests[] = {
|
|
/* Additions of zero. */
|
|
{__LINE__,B_ADD, 0,P_Z,P_Z, 0,P_Z,P_Z, R_ALL,0, 0,P_Z,P_Z },
|
|
{__LINE__,B_ADD, 1,P_Z,P_Z, 0,P_Z,P_Z, R_ALL & ~R_DOWN,0, 0,P_Z,P_Z },
|
|
{__LINE__,B_ADD, 1,P_Z,P_Z, 0,P_Z,P_Z, R_DOWN,0, 1,P_Z,P_Z },
|
|
{__LINE__,B_ADD, 1,P_Z,P_Z, 1,P_Z,P_Z, R_ALL,0, 1,P_Z,P_Z },
|
|
|
|
/* Additions with NaN. */
|
|
{__LINE__,B_ADD, 0,P_O,P_101Z, 0,P_Z,P_Z, R_ALL,0, 0,P_O,P_101Z },
|
|
{__LINE__,B_ADD, 0,P_O,P_01Z, 0,P_Z,P_Z, R_ALL,
|
|
FE_INVALID | FE_INVALID_SNAN, 0,P_O,P_11Z },
|
|
{__LINE__,B_ADD, 0,P_O,P_Z, 0,P_O,P_0O, R_ALL,
|
|
FE_INVALID | FE_INVALID_SNAN, 0,P_O,P_O },
|
|
{__LINE__,B_ADD, 0,P_Z,P_Z, 0,P_O,P_11Z, R_ALL,0, 0,P_O,P_11Z },
|
|
{__LINE__,B_ADD, 0,P_O,P_001Z, 0,P_O,P_001Z, R_ALL,
|
|
FE_INVALID | FE_INVALID_SNAN, 0,P_O,P_101Z },
|
|
{__LINE__,B_ADD, 0,P_O,P_1Z, 0,P_Z,P_Z, R_ALL,0, 0,P_O,P_1Z },
|
|
{__LINE__,B_ADD, 0,P_0O,P_Z, 0,P_O,P_10O, R_ALL,0, 0,P_O,P_10O },
|
|
|
|
/* Additions with infinity. */
|
|
{__LINE__,B_ADD, 0,P_O,P_Z, 0,P_Z,P_Z, R_ALL,0, 0,P_O,P_Z },
|
|
{__LINE__,B_ADD, 0,P_O,P_Z, 1,P_Z,P_Z, R_ALL,0, 0,P_O,P_Z },
|
|
{__LINE__,B_ADD, 1,P_O,P_Z, 0,P_Z,P_Z, R_ALL,0, 1,P_O,P_Z },
|
|
{__LINE__,B_ADD, 1,P_O,P_Z, 1,P_Z,P_Z, R_ALL,0, 1,P_O,P_Z },
|
|
{__LINE__,B_ADD, 0,P_O,P_Z, 0,P_O,P_Z, R_ALL,0, 0,P_O,P_Z },
|
|
{__LINE__,B_ADD, 1,P_O,P_Z, 1,P_O,P_Z, R_ALL,0, 1,P_O,P_Z },
|
|
{__LINE__,B_ADD, 0,P_O,P_Z, 1,P_O,P_Z, R_ALL,
|
|
FE_INVALID | FE_INVALID_ISI, 0,P_O,P_1Z },
|
|
{__LINE__,B_ADD, 1,P_O,P_Z, 0,P_O,P_Z, R_ALL,
|
|
FE_INVALID | FE_INVALID_ISI, 0,P_O,P_1Z },
|
|
{__LINE__,B_ADD, 0,P_O,P_Z, 0,P_0O,P_Z, R_ALL,0, 0,P_O,P_Z },
|
|
{__LINE__,B_ADD, 1,P_O,P_Z, 0,P_0O,P_Z, R_ALL,0, 1,P_O,P_Z },
|
|
{__LINE__,B_ADD, 0,P_O,P_Z, 1,P_0O,P_Z, R_ALL,0, 0,P_O,P_Z },
|
|
{__LINE__,B_ADD, 1,P_O,P_Z, 1,P_0O,P_Z, R_ALL,0, 1,P_O,P_Z },
|
|
|
|
/* Overflow (and zero). */
|
|
{__LINE__,B_ADD, 0,P_O0,P_Z, 0,P_O0,P_Z, R_NEAREST | R_UP,
|
|
FE_INEXACT | FE_OVERFLOW, 0,P_O,P_Z },
|
|
{__LINE__,B_ADD, 0,P_O0,P_Z, 0,P_O0,P_Z, R_ZERO | R_DOWN,
|
|
FE_INEXACT | FE_OVERFLOW, 0,P_O0,P_O },
|
|
{__LINE__,B_ADD, 1,P_O0,P_Z, 1,P_O0,P_Z, R_NEAREST | R_DOWN,
|
|
FE_INEXACT | FE_OVERFLOW, 1,P_O,P_Z },
|
|
{__LINE__,B_ADD, 1,P_O0,P_Z, 1,P_O0,P_Z, R_ZERO | R_UP,
|
|
FE_INEXACT | FE_OVERFLOW, 1,P_O0,P_O },
|
|
{__LINE__,B_ADD, 0,P_O0,P_Z, 1,P_O0,P_Z, R_ALL & ~R_DOWN,
|
|
0, 0,P_Z,P_Z },
|
|
{__LINE__,B_ADD, 0,P_O0,P_Z, 1,P_O0,P_Z, R_DOWN,
|
|
0, 1,P_Z,P_Z },
|
|
|
|
/* Negation. */
|
|
{__LINE__,B_NEG, 0,P_Z,P_Z, 0,0,0, R_ALL, 0, 1,P_Z,P_Z },
|
|
{__LINE__,B_NEG, 1,P_Z,P_Z, 0,0,0, R_ALL, 0, 0,P_Z,P_Z },
|
|
{__LINE__,B_NEG, 0,P_O,P_Z, 0,0,0, R_ALL, 0, 1,P_O,P_Z },
|
|
{__LINE__,B_NEG, 1,P_O,P_Z, 0,0,0, R_ALL, 0, 0,P_O,P_Z },
|
|
{__LINE__,B_NEG, 0,P_O,P_1Z, 0,0,0, R_ALL, 0, 1,P_O,P_1Z },
|
|
{__LINE__,B_NEG, 1,P_O,P_1Z, 0,0,0, R_ALL, 0, 0,P_O,P_1Z },
|
|
{__LINE__,B_NEG, 0,P_O,P_01Z, 0,0,0, R_ALL, 0, 1,P_O,P_01Z },
|
|
{__LINE__,B_NEG, 1,P_O,P_01Z, 0,0,0, R_ALL, 0, 0,P_O,P_01Z },
|
|
{__LINE__,B_NEG, 0,P_1Z,P_1Z1, 0,0,0, R_ALL, 0, 1,P_1Z,P_1Z1 },
|
|
{__LINE__,B_NEG, 1,P_1Z,P_1Z1, 0,0,0, R_ALL, 0, 0,P_1Z,P_1Z1 },
|
|
{__LINE__,B_NEG, 0,P_Z,P_Z1, 0,0,0, R_ALL, 0, 1,P_Z,P_Z1 },
|
|
{__LINE__,B_NEG, 1,P_Z,P_Z1, 0,0,0, R_ALL, 0, 0,P_Z,P_Z1 },
|
|
|
|
/* Absolute value. */
|
|
{__LINE__,B_ABS, 0,P_Z,P_Z, 0,0,0, R_ALL, 0, 0,P_Z,P_Z },
|
|
{__LINE__,B_ABS, 1,P_Z,P_Z, 0,0,0, R_ALL, 0, 0,P_Z,P_Z },
|
|
{__LINE__,B_ABS, 0,P_O,P_Z, 0,0,0, R_ALL, 0, 0,P_O,P_Z },
|
|
{__LINE__,B_ABS, 1,P_O,P_Z, 0,0,0, R_ALL, 0, 0,P_O,P_Z },
|
|
{__LINE__,B_ABS, 0,P_O,P_1Z, 0,0,0, R_ALL, 0, 0,P_O,P_1Z },
|
|
{__LINE__,B_ABS, 1,P_O,P_1Z, 0,0,0, R_ALL, 0, 0,P_O,P_1Z },
|
|
{__LINE__,B_ABS, 0,P_O,P_01Z, 0,0,0, R_ALL, 0, 0,P_O,P_01Z },
|
|
{__LINE__,B_ABS, 1,P_O,P_01Z, 0,0,0, R_ALL, 0, 0,P_O,P_01Z },
|
|
{__LINE__,B_ABS, 0,P_1Z,P_1Z1, 0,0,0, R_ALL, 0, 0,P_1Z,P_1Z1 },
|
|
{__LINE__,B_ABS, 1,P_1Z,P_1Z1, 0,0,0, R_ALL, 0, 0,P_1Z,P_1Z1 },
|
|
{__LINE__,B_ABS, 0,P_Z,P_Z1, 0,0,0, R_ALL, 0, 0,P_Z,P_Z1 },
|
|
{__LINE__,B_ABS, 1,P_Z,P_Z1, 0,0,0, R_ALL, 0, 0,P_Z,P_Z1 },
|
|
|
|
/* Square root. */
|
|
{__LINE__,B_SQRT, 0,P_Z,P_Z, 0,0,0, R_ALL, 0, 0,P_Z,P_Z },
|
|
{__LINE__,B_SQRT, 1,P_Z,P_Z, 0,0,0, R_ALL, 0, 1,P_Z,P_Z },
|
|
{__LINE__,B_SQRT, 0,P_O,P_1Z, 0,0,0, R_ALL, 0, 0,P_O,P_1Z },
|
|
{__LINE__,B_SQRT, 1,P_O,P_1Z, 0,0,0, R_ALL, 0, 1,P_O,P_1Z },
|
|
{__LINE__,B_SQRT, 0,P_O,P_01Z, 0,0,0, R_ALL,
|
|
FE_INVALID | FE_INVALID_SNAN, 0,P_O,P_11Z },
|
|
{__LINE__,B_SQRT, 1,P_O,P_01Z, 0,0,0, R_ALL,
|
|
FE_INVALID | FE_INVALID_SNAN, 1,P_O,P_11Z },
|
|
|
|
{__LINE__,B_SQRT, 0,P_O,P_Z, 0,0,0, R_ALL, 0, 0,P_O,P_Z },
|
|
{__LINE__,B_SQRT, 0,P_0O,P_Z, 0,0,0, R_ALL, 0, 0,P_0O,P_Z },
|
|
|
|
{__LINE__,B_SQRT, 1,P_O,P_Z, 0,0,0, R_ALL,
|
|
FE_INVALID | FE_INVALID_SQRT, 0,P_O,P_1Z },
|
|
{__LINE__,B_SQRT, 1,P_1Z,P_1Z1, 0,0,0, R_ALL,
|
|
FE_INVALID | FE_INVALID_SQRT, 0,P_O,P_1Z },
|
|
{__LINE__,B_SQRT, 1,P_Z,P_Z1, 0,0,0, R_ALL,
|
|
FE_INVALID | FE_INVALID_SQRT, 0,P_O,P_1Z },
|
|
|
|
};
|
|
|
|
static void
|
|
check_op(void)
|
|
{
|
|
size_t i;
|
|
int j;
|
|
tocheck_t r, a, b, x;
|
|
int raised;
|
|
|
|
for (i = 0; i < sizeof (optests) / sizeof (optests[0]); i++)
|
|
{
|
|
a = pattern(optests[i].a_sgn, optests[i].a_exp,
|
|
optests[i].a_mant);
|
|
b = pattern(optests[i].b_sgn, optests[i].b_exp,
|
|
optests[i].b_mant);
|
|
x = pattern(optests[i].x_sgn, optests[i].x_exp,
|
|
optests[i].x_mant);
|
|
for (j = 0; j < 4; j++)
|
|
if (optests[i].rmode & 1<<j)
|
|
{
|
|
fesetenv(rmodes+j);
|
|
switch (optests[i].op)
|
|
{
|
|
case B_ADD: r = a + b; break;
|
|
case B_SUB: r = a - b; break;
|
|
case B_MUL: r = a * b; break;
|
|
case B_DIV: r = a / b; break;
|
|
case B_NEG: r = -a; break;
|
|
case B_ABS: r = FUNC(fabs)(a); break;
|
|
case B_SQRT: r = FUNC(sqrt)(a); break;
|
|
}
|
|
raised = fetestexcept(all_exceptions);
|
|
check_result(optests[i].line,rmnames[j],x,r);
|
|
check_excepts(optests[i].line,rmnames[j],
|
|
optests[i].excepts,raised);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
fail_xr(int line, const char *rm, tocheck_t x, tocheck_t r, tocheck_t xx,
|
|
int xflag)
|
|
{
|
|
size_t i;
|
|
unsigned char *cx, *cr, *cxx;
|
|
|
|
printf("%s:%d:round %s:fail\n with x=0x", __FILE__, line,rm);
|
|
cx = (unsigned char *)&x;
|
|
cr = (unsigned char *)&r;
|
|
cxx = (unsigned char *)&xx;
|
|
for (i = 0; i < sizeof (tocheck_t); i++)
|
|
printf("%02x", cx[i]);
|
|
printf(" r=0x");
|
|
for (i = 0; i < sizeof (tocheck_t); i++)
|
|
printf("%02x", cr[i]);
|
|
printf(" xx=0x");
|
|
for (i = 0; i < sizeof (tocheck_t); i++)
|
|
printf("%02x", cxx[i]);
|
|
printf(" inexact=%d\n", xflag != 0);
|
|
nerrors++;
|
|
}
|
|
|
|
static void
|
|
check_sqrt(tocheck_t a)
|
|
{
|
|
int j;
|
|
tocheck_t r0, r1, r2, x0, x1, x2;
|
|
int raised = 0;
|
|
int ok;
|
|
|
|
for (j = 0; j < 4; j++)
|
|
{
|
|
int excepts;
|
|
|
|
fesetenv(rmodes+j);
|
|
r1 = FUNC(sqrt)(a);
|
|
excepts = fetestexcept(all_exceptions);
|
|
fesetenv(FE_DFL_ENV);
|
|
raised |= excepts & ~FE_INEXACT;
|
|
x1 = r1 * r1 - a;
|
|
if (excepts & FE_INEXACT)
|
|
{
|
|
r0 = delta(r1,-1); r2 = delta(r1,1);
|
|
switch (1 << j)
|
|
{
|
|
case R_NEAREST:
|
|
x0 = r0 * r0 - a; x2 = r2 * r2 - a;
|
|
ok = fabs(x0) >= fabs(x1) && fabs(x1) <= fabs(x2);
|
|
break;
|
|
case R_ZERO: case R_DOWN:
|
|
x2 = r2 * r2 - a;
|
|
ok = x1 <= 0 && x2 >= 0;
|
|
break;
|
|
case R_UP:
|
|
x0 = r0 * r0 - a;
|
|
ok = x1 >= 0 && x0 <= 0;
|
|
break;
|
|
default:
|
|
assert(0);
|
|
}
|
|
}
|
|
else
|
|
ok = x1 == 0;
|
|
if (!ok)
|
|
fail_xr(__LINE__,rmnames[j],a,r1,x1,excepts&FE_INEXACT);
|
|
}
|
|
check_excepts(__LINE__,"all",0,raised);
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int i;
|
|
|
|
_LIB_VERSION = _IEEE_;
|
|
|
|
/* Set up environments for rounding modes. */
|
|
fesetenv(FE_DFL_ENV);
|
|
fesetround(FE_TONEAREST);
|
|
fegetenv(rmodes+0);
|
|
fesetround(FE_TOWARDZERO);
|
|
fegetenv(rmodes+1);
|
|
fesetround(FE_UPWARD);
|
|
fegetenv(rmodes+2);
|
|
fesetround(FE_DOWNWARD);
|
|
fegetenv(rmodes+3);
|
|
|
|
#if defined(FE_INVALID_SOFTWARE) || defined(FE_INVALID_SQRT)
|
|
/* There's this really stupid feature of the 601... */
|
|
fesetenv(FE_DFL_ENV);
|
|
feraiseexcept(FE_INVALID_SOFTWARE);
|
|
if (!fetestexcept(FE_INVALID_SOFTWARE))
|
|
excepts_missing |= FE_INVALID_SOFTWARE;
|
|
fesetenv(FE_DFL_ENV);
|
|
feraiseexcept(FE_INVALID_SQRT);
|
|
if (!fetestexcept(FE_INVALID_SQRT))
|
|
excepts_missing |= FE_INVALID_SQRT;
|
|
#endif
|
|
|
|
check_op();
|
|
for (i = 0; i < 100000; i++)
|
|
check_sqrt(pattern(0, P_Rno, P_R));
|
|
for (i = 0; i < 100; i++)
|
|
check_sqrt(pattern(0, P_Z, P_R));
|
|
check_sqrt(pattern(0,P_Z,P_Z1));
|
|
|
|
printf("%d errors.\n", nerrors);
|
|
return nerrors == 0 ? 0 : 1;
|
|
}
|