mirror of
https://sourceware.org/git/glibc.git
synced 2024-12-26 12:41:05 +00:00
ace614b8a5
IEEE 754-2008 defines two ways in which tiny results can be detected, "before rounding" (based on the infinite-precision result) and "after rounding" (based on the result when rounded to normal precision as if the exponent range were unbounded). All binary operations on an architecture must use the same choice of how tininess is detected. soft-fp has so far implemented only before-rounding tininess detection. This patch adds support for after-rounding tininess detection. A new macro _FP_TININESS_AFTER_ROUNDING is added that sfp-machine.h must define (soft-fp is meant to be self-contained so the existing tininess.h files aren't used here, though the information going in sfp-machine.h has been taken from them). The soft-fp macros dealing with raising underflow exceptions then handle the cases where the choice matters specially, rounding a copy of the input to the appropriate precision to see if a value that's tiny before rounding isn't tiny after rounding. Tested for mips64 using GCC trunk (which now uses soft-fp on MIPS, so supporting exceptions and rounding modes for long double where not previously supported - this is the immediate motivation for doing this patch now) together with (a) a patch to sysdeps/mips/math-tests.h to enable exceptions / rounding modes tests for long double for GCC 4.9 and later, and (b) corresponding changes applied to libgcc's soft-fp and sfp-machine.h files. In the libgcc context this is also tested on x86_64 (also an after-rounding architecture) with testcases for __float128 that I intend to add to the GCC testsuite when updating soft-fp there. (To be clear: this patch does not fix any glibc bugs that were user-visible in past releases, since after-rounding architectures didn't use soft-fp in any affected case with support for floating-point exceptions - so there is no corresponding Bugzilla bug. Rather, it works together with the GCC changes to use soft-fp on MIPS to allow previously absent long double functionality to work properly, and allows soft-fp to be used in glibc on after-rounding architectures in cases where it couldn't previously be used.) * soft-fp/op-common.h (_FP_DECL): Mark exponent as possibly unused. (_FP_PACK_SEMIRAW): Determine tininess based on rounding shifted value if _FP_TININESS_AFTER_ROUNDING and unrounded value is in subnormal range. (_FP_PACK_CANONICAL): Determine tininess based on rounding to normal precision if _FP_TININESS_AFTER_ROUNDING and unrounded value has largest subnormal exponent. * soft-fp/soft-fp.h [FP_NO_EXCEPTIONS] (_FP_TININESS_AFTER_ROUNDING): Undefine and redefine to 0. * sysdeps/aarch64/soft-fp/sfp-machine.h (_FP_TININESS_AFTER_ROUNDING): New macro. * sysdeps/alpha/soft-fp/sfp-machine.h (_FP_TININESS_AFTER_ROUNDING): Likewise. * sysdeps/arm/soft-fp/sfp-machine.h (_FP_TININESS_AFTER_ROUNDING): Likewise. * sysdeps/mips/mips64/soft-fp/sfp-machine.h (_FP_TININESS_AFTER_ROUNDING): Likewise. * sysdeps/mips/soft-fp/sfp-machine.h (_FP_TININESS_AFTER_ROUNDING): Likewise. * sysdeps/powerpc/soft-fp/sfp-machine.h (_FP_TININESS_AFTER_ROUNDING): Likewise. * sysdeps/sh/soft-fp/sfp-machine.h (_FP_TININESS_AFTER_ROUNDING): Likewise. * sysdeps/sparc/sparc32/soft-fp/sfp-machine.h (_FP_TININESS_AFTER_ROUNDING): Likewise. * sysdeps/sparc/sparc64/soft-fp/sfp-machine.h (_FP_TININESS_AFTER_ROUNDING): Likewise. * sysdeps/tile/sfp-machine.h (_FP_TININESS_AFTER_ROUNDING): Likewise.
121 lines
3.6 KiB
C
121 lines
3.6 KiB
C
#include <fenv.h>
|
|
#include <fpu_control.h>
|
|
|
|
#define _FP_W_TYPE_SIZE 64
|
|
#define _FP_W_TYPE unsigned long long
|
|
#define _FP_WS_TYPE signed long long
|
|
#define _FP_I_TYPE long long
|
|
|
|
#define _FP_MUL_MEAT_S(R,X,Y) \
|
|
_FP_MUL_MEAT_1_imm(_FP_WFRACBITS_S,R,X,Y)
|
|
#define _FP_MUL_MEAT_D(R,X,Y) \
|
|
_FP_MUL_MEAT_1_wide(_FP_WFRACBITS_D,R,X,Y,umul_ppmm)
|
|
#define _FP_MUL_MEAT_Q(R,X,Y) \
|
|
_FP_MUL_MEAT_2_wide_3mul(_FP_WFRACBITS_Q,R,X,Y,umul_ppmm)
|
|
|
|
#define _FP_DIV_MEAT_S(R,X,Y) _FP_DIV_MEAT_1_imm(S,R,X,Y,_FP_DIV_HELP_imm)
|
|
#define _FP_DIV_MEAT_D(R,X,Y) _FP_DIV_MEAT_1_udiv_norm(D,R,X,Y)
|
|
#define _FP_DIV_MEAT_Q(R,X,Y) _FP_DIV_MEAT_2_udiv(Q,R,X,Y)
|
|
|
|
#define _FP_NANFRAC_S ((_FP_QNANBIT_S << 1) - 1)
|
|
#define _FP_NANFRAC_D ((_FP_QNANBIT_D << 1) - 1)
|
|
#define _FP_NANFRAC_Q ((_FP_QNANBIT_Q << 1) - 1), -1
|
|
#define _FP_NANSIGN_S 0
|
|
#define _FP_NANSIGN_D 0
|
|
#define _FP_NANSIGN_Q 0
|
|
|
|
#define _FP_KEEPNANFRACP 1
|
|
#define _FP_QNANNEGATEDP 0
|
|
|
|
/* From my experiments it seems X is chosen unless one of the
|
|
NaNs is sNaN, in which case the result is NANSIGN/NANFRAC. */
|
|
#define _FP_CHOOSENAN(fs, wc, R, X, Y, OP) \
|
|
do { \
|
|
if ((_FP_FRAC_HIGH_RAW_##fs(X) | \
|
|
_FP_FRAC_HIGH_RAW_##fs(Y)) & _FP_QNANBIT_##fs) \
|
|
{ \
|
|
R##_s = _FP_NANSIGN_##fs; \
|
|
_FP_FRAC_SET_##wc(R,_FP_NANFRAC_##fs); \
|
|
} \
|
|
else \
|
|
{ \
|
|
R##_s = X##_s; \
|
|
_FP_FRAC_COPY_##wc(R,X); \
|
|
} \
|
|
R##_c = FP_CLS_NAN; \
|
|
} while (0)
|
|
|
|
#define _FP_DECL_EX fpu_control_t _fcw
|
|
|
|
#define FP_ROUNDMODE (_fcw & _FPU_FPCR_RM_MASK)
|
|
|
|
#define FP_RND_NEAREST FE_TONEAREST
|
|
#define FP_RND_ZERO FE_TOWARDZERO
|
|
#define FP_RND_PINF FE_UPWARD
|
|
#define FP_RND_MINF FE_DOWNWARD
|
|
|
|
#define FP_EX_INVALID FE_INVALID
|
|
#define FP_EX_OVERFLOW FE_OVERFLOW
|
|
#define FP_EX_UNDERFLOW FE_UNDERFLOW
|
|
#define FP_EX_DIVZERO FE_DIVBYZERO
|
|
#define FP_EX_INEXACT FE_INEXACT
|
|
|
|
#define _FP_TININESS_AFTER_ROUNDING 0
|
|
|
|
#define FP_INIT_ROUNDMODE \
|
|
do { \
|
|
_FPU_GETCW (_fcw); \
|
|
} while (0)
|
|
|
|
#define FP_HANDLE_EXCEPTIONS \
|
|
do { \
|
|
const float fp_max = __FLT_MAX__; \
|
|
const float fp_min = __FLT_MIN__; \
|
|
const float fp_1e32 = 1.0e32f; \
|
|
const float fp_zero = 0.0; \
|
|
const float fp_one = 1.0; \
|
|
unsigned fpsr; \
|
|
if (_fex & FP_EX_INVALID) \
|
|
{ \
|
|
__asm__ __volatile__ ("fdiv\ts0, %s0, %s0" \
|
|
: \
|
|
: "w" (fp_zero) \
|
|
: "s0"); \
|
|
__asm__ __volatile__ ("mrs\t%0, fpsr" : "=r" (fpsr)); \
|
|
} \
|
|
if (_fex & FP_EX_DIVZERO) \
|
|
{ \
|
|
__asm__ __volatile__ ("fdiv\ts0, %s0, %s1" \
|
|
: \
|
|
: "w" (fp_one), "w" (fp_zero) \
|
|
: "s0"); \
|
|
__asm__ __volatile__ ("mrs\t%0, fpsr" : "=r" (fpsr)); \
|
|
} \
|
|
if (_fex & FP_EX_OVERFLOW) \
|
|
{ \
|
|
__asm__ __volatile__ ("fadd\ts0, %s0, %s1" \
|
|
: \
|
|
: "w" (fp_max), "w" (fp_1e32) \
|
|
: "s0"); \
|
|
__asm__ __volatile__ ("mrs\t%0, fpsr" : "=r" (fpsr)); \
|
|
} \
|
|
if (_fex & FP_EX_UNDERFLOW) \
|
|
{ \
|
|
__asm__ __volatile__ ("fmul\ts0, %s0, %s0" \
|
|
: \
|
|
: "w" (fp_min) \
|
|
: "s0"); \
|
|
__asm__ __volatile__ ("mrs\t%0, fpsr" : "=r" (fpsr)); \
|
|
} \
|
|
if (_fex & FP_EX_INEXACT) \
|
|
{ \
|
|
__asm__ __volatile__ ("fsub\ts0, %s0, %s1" \
|
|
: \
|
|
: "w" (fp_max), "w" (fp_one) \
|
|
: "s0"); \
|
|
__asm__ __volatile__ ("mrs\t%0, fpsr" : "=r" (fpsr)); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define FP_TRAPPING_EXCEPTIONS ((_fcw >> FE_EXCEPT_SHIFT) & FE_ALL_EXCEPT)
|