diff options
Diffstat (limited to 'soft-fp')
88 files changed, 2255 insertions, 1453 deletions
diff --git a/soft-fp/Makefile b/soft-fp/Makefile index 8a7efa3dfd..28f9f0c374 100644 --- a/soft-fp/Makefile +++ b/soft-fp/Makefile @@ -1,4 +1,4 @@ -# Copyright (C) 1997-2014 Free Software Foundation, Inc. +# Copyright (C) 1997-2015 Free Software Foundation, Inc. # This file is part of the GNU C Library. # @@ -21,6 +21,8 @@ # subdir := soft-fp +include ../Makeconfig + gcc-single-routines := negsf2 addsf3 subsf3 mulsf3 divsf3 eqsf2 \ lesf2 gesf2 unordsf2 fixsfsi fixunssfsi floatsisf fixsfdi \ fixunssfdi floatdisf sqrtsf2 floatunsisf floatundisf diff --git a/soft-fp/adddf3.c b/soft-fp/adddf3.c index 95bc8e56b0..4d09525d3e 100644 --- a/soft-fp/adddf3.c +++ b/soft-fp/adddf3.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a + b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/addsf3.c b/soft-fp/addsf3.c index b332589d08..5006af40e9 100644 --- a/soft-fp/addsf3.c +++ b/soft-fp/addsf3.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a + b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/addtf3.c b/soft-fp/addtf3.c index ac0d9481fe..5894fec954 100644 --- a/soft-fp/addtf3.c +++ b/soft-fp/addtf3.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a + b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/divdf3.c b/soft-fp/divdf3.c index f59da8216b..878d932976 100644 --- a/soft-fp/divdf3.c +++ b/soft-fp/divdf3.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a / b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/divsf3.c b/soft-fp/divsf3.c index 794192825b..50de502057 100644 --- a/soft-fp/divsf3.c +++ b/soft-fp/divsf3.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a / b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/divtf3.c b/soft-fp/divtf3.c index 621f70d99f..e74591964d 100644 --- a/soft-fp/divtf3.c +++ b/soft-fp/divtf3.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a / b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/double.h b/soft-fp/double.h index 7782994044..a05713f683 100644 --- a/soft-fp/double.h +++ b/soft-fp/double.h @@ -1,6 +1,6 @@ /* Software floating-point emulation. Definitions for IEEE Double Precision - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com), Jakub Jelinek (jj@ultra.linux.cz), @@ -30,6 +30,9 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ +#ifndef SOFT_FP_DOUBLE_H +#define SOFT_FP_DOUBLE_H 1 + #if _FP_W_TYPE_SIZE < 32 # error "Here's a nickel kid. Go buy yourself a real computer." #endif @@ -90,21 +93,21 @@ union _FP_UNION_D }; # define FP_DECL_D(X) _FP_DECL (2, X) -# define FP_UNPACK_RAW_D(X, val) _FP_UNPACK_RAW_2 (D, X, val) -# define FP_UNPACK_RAW_DP(X, val) _FP_UNPACK_RAW_2_P (D, X, val) -# define FP_PACK_RAW_D(val, X) _FP_PACK_RAW_2 (D, val, X) +# define FP_UNPACK_RAW_D(X, val) _FP_UNPACK_RAW_2 (D, X, (val)) +# define FP_UNPACK_RAW_DP(X, val) _FP_UNPACK_RAW_2_P (D, X, (val)) +# define FP_PACK_RAW_D(val, X) _FP_PACK_RAW_2 (D, (val), X) # define FP_PACK_RAW_DP(val, X) \ do \ { \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_2_P (D, val, X); \ + _FP_PACK_RAW_2_P (D, (val), X); \ } \ while (0) # define FP_UNPACK_D(X, val) \ do \ { \ - _FP_UNPACK_RAW_2 (D, X, val); \ + _FP_UNPACK_RAW_2 (D, X, (val)); \ _FP_UNPACK_CANONICAL (D, 2, X); \ } \ while (0) @@ -112,7 +115,7 @@ union _FP_UNION_D # define FP_UNPACK_DP(X, val) \ do \ { \ - _FP_UNPACK_RAW_2_P (D, X, val); \ + _FP_UNPACK_RAW_2_P (D, X, (val)); \ _FP_UNPACK_CANONICAL (D, 2, X); \ } \ while (0) @@ -120,7 +123,7 @@ union _FP_UNION_D # define FP_UNPACK_SEMIRAW_D(X, val) \ do \ { \ - _FP_UNPACK_RAW_2 (D, X, val); \ + _FP_UNPACK_RAW_2 (D, X, (val)); \ _FP_UNPACK_SEMIRAW (D, 2, X); \ } \ while (0) @@ -128,7 +131,7 @@ union _FP_UNION_D # define FP_UNPACK_SEMIRAW_DP(X, val) \ do \ { \ - _FP_UNPACK_RAW_2_P (D, X, val); \ + _FP_UNPACK_RAW_2_P (D, X, (val)); \ _FP_UNPACK_SEMIRAW (D, 2, X); \ } \ while (0) @@ -137,7 +140,7 @@ union _FP_UNION_D do \ { \ _FP_PACK_CANONICAL (D, 2, X); \ - _FP_PACK_RAW_2 (D, val, X); \ + _FP_PACK_RAW_2 (D, (val), X); \ } \ while (0) @@ -146,7 +149,7 @@ union _FP_UNION_D { \ _FP_PACK_CANONICAL (D, 2, X); \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_2_P (D, val, X); \ + _FP_PACK_RAW_2_P (D, (val), X); \ } \ while (0) @@ -154,7 +157,7 @@ union _FP_UNION_D do \ { \ _FP_PACK_SEMIRAW (D, 2, X); \ - _FP_PACK_RAW_2 (D, val, X); \ + _FP_PACK_RAW_2 (D, (val), X); \ } \ while (0) @@ -163,7 +166,7 @@ union _FP_UNION_D { \ _FP_PACK_SEMIRAW (D, 2, X); \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_2_P (D, val, X); \ + _FP_PACK_RAW_2_P (D, (val), X); \ } \ while (0) @@ -174,15 +177,17 @@ union _FP_UNION_D # define FP_MUL_D(R, X, Y) _FP_MUL (D, 2, R, X, Y) # define FP_DIV_D(R, X, Y) _FP_DIV (D, 2, R, X, Y) # define FP_SQRT_D(R, X) _FP_SQRT (D, 2, R, X) -# define _FP_SQRT_MEAT_D(R, S, T, X, Q) _FP_SQRT_MEAT_2 (R, S, T, X, Q) +# define _FP_SQRT_MEAT_D(R, S, T, X, Q) _FP_SQRT_MEAT_2 (R, S, T, X, (Q)) # define FP_FMA_D(R, X, Y, Z) _FP_FMA (D, 2, 4, R, X, Y, Z) -# define FP_CMP_D(r, X, Y, un) _FP_CMP (D, 2, r, X, Y, un) -# define FP_CMP_EQ_D(r, X, Y) _FP_CMP_EQ (D, 2, r, X, Y) -# define FP_CMP_UNORD_D(r, X, Y) _FP_CMP_UNORD (D, 2, r, X, Y) +# define FP_CMP_D(r, X, Y, un, ex) _FP_CMP (D, 2, (r), X, Y, (un), (ex)) +# define FP_CMP_EQ_D(r, X, Y, ex) _FP_CMP_EQ (D, 2, (r), X, Y, (ex)) +# define FP_CMP_UNORD_D(r, X, Y, ex) _FP_CMP_UNORD (D, 2, (r), X, Y, (ex)) -# define FP_TO_INT_D(r, X, rsz, rsg) _FP_TO_INT (D, 2, r, X, rsz, rsg) -# define FP_FROM_INT_D(X, r, rs, rt) _FP_FROM_INT (D, 2, X, r, rs, rt) +# define FP_TO_INT_D(r, X, rsz, rsg) _FP_TO_INT (D, 2, (r), X, (rsz), (rsg)) +# define FP_TO_INT_ROUND_D(r, X, rsz, rsg) \ + _FP_TO_INT_ROUND (D, 2, (r), X, (rsz), (rsg)) +# define FP_FROM_INT_D(X, r, rs, rt) _FP_FROM_INT (D, 2, X, (r), (rs), rt) # define _FP_FRAC_HIGH_D(X) _FP_FRAC_HIGH_2 (X) # define _FP_FRAC_HIGH_RAW_D(X) _FP_FRAC_HIGH_2 (X) @@ -209,21 +214,21 @@ union _FP_UNION_D }; # define FP_DECL_D(X) _FP_DECL (1, X) -# define FP_UNPACK_RAW_D(X, val) _FP_UNPACK_RAW_1 (D, X, val) -# define FP_UNPACK_RAW_DP(X, val) _FP_UNPACK_RAW_1_P (D, X, val) -# define FP_PACK_RAW_D(val, X) _FP_PACK_RAW_1 (D, val, X) +# define FP_UNPACK_RAW_D(X, val) _FP_UNPACK_RAW_1 (D, X, (val)) +# define FP_UNPACK_RAW_DP(X, val) _FP_UNPACK_RAW_1_P (D, X, (val)) +# define FP_PACK_RAW_D(val, X) _FP_PACK_RAW_1 (D, (val), X) # define FP_PACK_RAW_DP(val, X) \ do \ { \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_1_P (D, val, X); \ + _FP_PACK_RAW_1_P (D, (val), X); \ } \ while (0) # define FP_UNPACK_D(X, val) \ do \ { \ - _FP_UNPACK_RAW_1 (D, X, val); \ + _FP_UNPACK_RAW_1 (D, X, (val)); \ _FP_UNPACK_CANONICAL (D, 1, X); \ } \ while (0) @@ -231,7 +236,7 @@ union _FP_UNION_D # define FP_UNPACK_DP(X, val) \ do \ { \ - _FP_UNPACK_RAW_1_P (D, X, val); \ + _FP_UNPACK_RAW_1_P (D, X, (val)); \ _FP_UNPACK_CANONICAL (D, 1, X); \ } \ while (0) @@ -239,7 +244,7 @@ union _FP_UNION_D # define FP_UNPACK_SEMIRAW_D(X, val) \ do \ { \ - _FP_UNPACK_RAW_1 (D, X, val); \ + _FP_UNPACK_RAW_1 (D, X, (val)); \ _FP_UNPACK_SEMIRAW (D, 1, X); \ } \ while (0) @@ -247,7 +252,7 @@ union _FP_UNION_D # define FP_UNPACK_SEMIRAW_DP(X, val) \ do \ { \ - _FP_UNPACK_RAW_1_P (D, X, val); \ + _FP_UNPACK_RAW_1_P (D, X, (val)); \ _FP_UNPACK_SEMIRAW (D, 1, X); \ } \ while (0) @@ -256,7 +261,7 @@ union _FP_UNION_D do \ { \ _FP_PACK_CANONICAL (D, 1, X); \ - _FP_PACK_RAW_1 (D, val, X); \ + _FP_PACK_RAW_1 (D, (val), X); \ } \ while (0) @@ -265,7 +270,7 @@ union _FP_UNION_D { \ _FP_PACK_CANONICAL (D, 1, X); \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_1_P (D, val, X); \ + _FP_PACK_RAW_1_P (D, (val), X); \ } \ while (0) @@ -273,7 +278,7 @@ union _FP_UNION_D do \ { \ _FP_PACK_SEMIRAW (D, 1, X); \ - _FP_PACK_RAW_1 (D, val, X); \ + _FP_PACK_RAW_1 (D, (val), X); \ } \ while (0) @@ -282,7 +287,7 @@ union _FP_UNION_D { \ _FP_PACK_SEMIRAW (D, 1, X); \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_1_P (D, val, X); \ + _FP_PACK_RAW_1_P (D, (val), X); \ } \ while (0) @@ -293,18 +298,20 @@ union _FP_UNION_D # define FP_MUL_D(R, X, Y) _FP_MUL (D, 1, R, X, Y) # define FP_DIV_D(R, X, Y) _FP_DIV (D, 1, R, X, Y) # define FP_SQRT_D(R, X) _FP_SQRT (D, 1, R, X) -# define _FP_SQRT_MEAT_D(R, S, T, X, Q) _FP_SQRT_MEAT_1 (R, S, T, X, Q) +# define _FP_SQRT_MEAT_D(R, S, T, X, Q) _FP_SQRT_MEAT_1 (R, S, T, X, (Q)) # define FP_FMA_D(R, X, Y, Z) _FP_FMA (D, 1, 2, R, X, Y, Z) /* The implementation of _FP_MUL_D and _FP_DIV_D should be chosen by the target machine. */ -# define FP_CMP_D(r, X, Y, un) _FP_CMP (D, 1, r, X, Y, un) -# define FP_CMP_EQ_D(r, X, Y) _FP_CMP_EQ (D, 1, r, X, Y) -# define FP_CMP_UNORD_D(r, X, Y) _FP_CMP_UNORD (D, 1, r, X, Y) +# define FP_CMP_D(r, X, Y, un, ex) _FP_CMP (D, 1, (r), X, Y, (un), (ex)) +# define FP_CMP_EQ_D(r, X, Y, ex) _FP_CMP_EQ (D, 1, (r), X, Y, (ex)) +# define FP_CMP_UNORD_D(r, X, Y, ex) _FP_CMP_UNORD (D, 1, (r), X, Y, (ex)) -# define FP_TO_INT_D(r, X, rsz, rsg) _FP_TO_INT (D, 1, r, X, rsz, rsg) -# define FP_FROM_INT_D(X, r, rs, rt) _FP_FROM_INT (D, 1, X, r, rs, rt) +# define FP_TO_INT_D(r, X, rsz, rsg) _FP_TO_INT (D, 1, (r), X, (rsz), (rsg)) +# define FP_TO_INT_ROUND_D(r, X, rsz, rsg) \ + _FP_TO_INT_ROUND (D, 1, (r), X, (rsz), (rsg)) +# define FP_FROM_INT_D(X, r, rs, rt) _FP_FROM_INT (D, 1, X, (r), (rs), rt) # define _FP_FRAC_HIGH_D(X) _FP_FRAC_HIGH_1 (X) # define _FP_FRAC_HIGH_RAW_D(X) _FP_FRAC_HIGH_1 (X) @@ -312,3 +319,5 @@ union _FP_UNION_D # define _FP_FRAC_HIGH_DW_D(X) _FP_FRAC_HIGH_2 (X) #endif /* W_TYPE_SIZE < 64 */ + +#endif /* !SOFT_FP_DOUBLE_H */ diff --git a/soft-fp/eqdf2.c b/soft-fp/eqdf2.c index 006b1ef83a..37d2684448 100644 --- a/soft-fp/eqdf2.c +++ b/soft-fp/eqdf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return 0 iff a == b, 1 otherwise - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). @@ -42,9 +42,7 @@ __eqdf2 (DFtype a, DFtype b) FP_INIT_EXCEPTIONS; FP_UNPACK_RAW_D (A, a); FP_UNPACK_RAW_D (B, b); - FP_CMP_EQ_D (r, A, B); - if (r && (FP_ISSIGNAN_D (A) || FP_ISSIGNAN_D (B))) - FP_SET_EXCEPTION (FP_EX_INVALID); + FP_CMP_EQ_D (r, A, B, 1); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/eqsf2.c b/soft-fp/eqsf2.c index 437ef99a2f..f6f83b7297 100644 --- a/soft-fp/eqsf2.c +++ b/soft-fp/eqsf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return 0 iff a == b, 1 otherwise - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). @@ -42,9 +42,7 @@ __eqsf2 (SFtype a, SFtype b) FP_INIT_EXCEPTIONS; FP_UNPACK_RAW_S (A, a); FP_UNPACK_RAW_S (B, b); - FP_CMP_EQ_S (r, A, B); - if (r && (FP_ISSIGNAN_S (A) || FP_ISSIGNAN_S (B))) - FP_SET_EXCEPTION (FP_EX_INVALID); + FP_CMP_EQ_S (r, A, B, 1); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/eqtf2.c b/soft-fp/eqtf2.c index ffc558ced2..23ac78854b 100644 --- a/soft-fp/eqtf2.c +++ b/soft-fp/eqtf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return 0 iff a == b, 1 otherwise - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). @@ -42,9 +42,7 @@ __eqtf2 (TFtype a, TFtype b) FP_INIT_EXCEPTIONS; FP_UNPACK_RAW_Q (A, a); FP_UNPACK_RAW_Q (B, b); - FP_CMP_EQ_Q (r, A, B); - if (r && (FP_ISSIGNAN_Q (A) || FP_ISSIGNAN_Q (B))) - FP_SET_EXCEPTION (FP_EX_INVALID); + FP_CMP_EQ_Q (r, A, B, 1); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/extenddftf2.c b/soft-fp/extenddftf2.c index 6984b41a80..c89af56f01 100644 --- a/soft-fp/extenddftf2.c +++ b/soft-fp/extenddftf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a converted to IEEE quad - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). @@ -28,6 +28,7 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ +#define FP_NO_EXACT_UNDERFLOW #include "soft-fp.h" #include "double.h" #include "quad.h" diff --git a/soft-fp/extended.h b/soft-fp/extended.h index 69a5a06260..428f9178a6 100644 --- a/soft-fp/extended.h +++ b/soft-fp/extended.h @@ -1,6 +1,6 @@ /* Software floating-point emulation. Definitions for IEEE Extended Precision. - Copyright (C) 1999-2014 Free Software Foundation, Inc. + Copyright (C) 1999-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Jakub Jelinek (jj@ultra.linux.cz). @@ -27,6 +27,9 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ +#ifndef SOFT_FP_EXTENDED_H +#define SOFT_FP_EXTENDED_H 1 + #if _FP_W_TYPE_SIZE < 32 # error "Here's a nickel, kid. Go buy yourself a real computer." #endif @@ -91,76 +94,78 @@ union _FP_UNION_E # define FP_DECL_E(X) _FP_DECL (4, X) -# define FP_UNPACK_RAW_E(X, val) \ - do \ - { \ - union _FP_UNION_E _flo; \ - _flo.flt = (val); \ - \ - X##_f[2] = 0; \ - X##_f[3] = 0; \ - X##_f[0] = _flo.bits.frac0; \ - X##_f[1] = _flo.bits.frac1; \ - X##_e = _flo.bits.exp; \ - X##_s = _flo.bits.sign; \ - } \ +# define FP_UNPACK_RAW_E(X, val) \ + do \ + { \ + union _FP_UNION_E FP_UNPACK_RAW_E_flo; \ + FP_UNPACK_RAW_E_flo.flt = (val); \ + \ + X##_f[2] = 0; \ + X##_f[3] = 0; \ + X##_f[0] = FP_UNPACK_RAW_E_flo.bits.frac0; \ + X##_f[1] = FP_UNPACK_RAW_E_flo.bits.frac1; \ + X##_e = FP_UNPACK_RAW_E_flo.bits.exp; \ + X##_s = FP_UNPACK_RAW_E_flo.bits.sign; \ + } \ while (0) -# define FP_UNPACK_RAW_EP(X, val) \ - do \ - { \ - union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val); \ - \ - X##_f[2] = 0; \ - X##_f[3] = 0; \ - X##_f[0] = _flo->bits.frac0; \ - X##_f[1] = _flo->bits.frac1; \ - X##_e = _flo->bits.exp; \ - X##_s = _flo->bits.sign; \ - } \ +# define FP_UNPACK_RAW_EP(X, val) \ + do \ + { \ + union _FP_UNION_E *FP_UNPACK_RAW_EP_flo \ + = (union _FP_UNION_E *) (val); \ + \ + X##_f[2] = 0; \ + X##_f[3] = 0; \ + X##_f[0] = FP_UNPACK_RAW_EP_flo->bits.frac0; \ + X##_f[1] = FP_UNPACK_RAW_EP_flo->bits.frac1; \ + X##_e = FP_UNPACK_RAW_EP_flo->bits.exp; \ + X##_s = FP_UNPACK_RAW_EP_flo->bits.sign; \ + } \ while (0) # define FP_PACK_RAW_E(val, X) \ do \ { \ - union _FP_UNION_E _flo; \ + union _FP_UNION_E FP_PACK_RAW_E_flo; \ \ if (X##_e) \ X##_f[1] |= _FP_IMPLBIT_E; \ else \ X##_f[1] &= ~(_FP_IMPLBIT_E); \ - _flo.bits.frac0 = X##_f[0]; \ - _flo.bits.frac1 = X##_f[1]; \ - _flo.bits.exp = X##_e; \ - _flo.bits.sign = X##_s; \ + FP_PACK_RAW_E_flo.bits.frac0 = X##_f[0]; \ + FP_PACK_RAW_E_flo.bits.frac1 = X##_f[1]; \ + FP_PACK_RAW_E_flo.bits.exp = X##_e; \ + FP_PACK_RAW_E_flo.bits.sign = X##_s; \ \ - (val) = _flo.flt; \ + (val) = FP_PACK_RAW_E_flo.flt; \ } \ while (0) -# define FP_PACK_RAW_EP(val, X) \ - do \ - { \ - if (!FP_INHIBIT_RESULTS) \ - { \ - union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val); \ - \ - if (X##_e) \ - X##_f[1] |= _FP_IMPLBIT_E; \ - else \ - X##_f[1] &= ~(_FP_IMPLBIT_E); \ - _flo->bits.frac0 = X##_f[0]; \ - _flo->bits.frac1 = X##_f[1]; \ - _flo->bits.exp = X##_e; \ - _flo->bits.sign = X##_s; \ - } \ - } \ +# define FP_PACK_RAW_EP(val, X) \ + do \ + { \ + if (!FP_INHIBIT_RESULTS) \ + { \ + union _FP_UNION_E *FP_PACK_RAW_EP_flo \ + = (union _FP_UNION_E *) (val); \ + \ + if (X##_e) \ + X##_f[1] |= _FP_IMPLBIT_E; \ + else \ + X##_f[1] &= ~(_FP_IMPLBIT_E); \ + FP_PACK_RAW_EP_flo->bits.frac0 = X##_f[0]; \ + FP_PACK_RAW_EP_flo->bits.frac1 = X##_f[1]; \ + FP_PACK_RAW_EP_flo->bits.exp = X##_e; \ + FP_PACK_RAW_EP_flo->bits.sign = X##_s; \ + } \ + } \ while (0) # define FP_UNPACK_E(X, val) \ do \ { \ - FP_UNPACK_RAW_E (X, val); \ + FP_UNPACK_RAW_E (X, (val)); \ _FP_UNPACK_CANONICAL (E, 4, X); \ } \ while (0) @@ -168,7 +173,7 @@ union _FP_UNION_E # define FP_UNPACK_EP(X, val) \ do \ { \ - FP_UNPACK_RAW_EP (X, val); \ + FP_UNPACK_RAW_EP (X, (val)); \ _FP_UNPACK_CANONICAL (E, 4, X); \ } \ while (0) @@ -176,7 +181,7 @@ union _FP_UNION_E # define FP_UNPACK_SEMIRAW_E(X, val) \ do \ { \ - FP_UNPACK_RAW_E (X, val); \ + FP_UNPACK_RAW_E (X, (val)); \ _FP_UNPACK_SEMIRAW (E, 4, X); \ } \ while (0) @@ -184,7 +189,7 @@ union _FP_UNION_E # define FP_UNPACK_SEMIRAW_EP(X, val) \ do \ { \ - FP_UNPACK_RAW_EP (X, val); \ + FP_UNPACK_RAW_EP (X, (val)); \ _FP_UNPACK_SEMIRAW (E, 4, X); \ } \ while (0) @@ -193,7 +198,7 @@ union _FP_UNION_E do \ { \ _FP_PACK_CANONICAL (E, 4, X); \ - FP_PACK_RAW_E (val, X); \ + FP_PACK_RAW_E ((val), X); \ } \ while (0) @@ -201,7 +206,7 @@ union _FP_UNION_E do \ { \ _FP_PACK_CANONICAL (E, 4, X); \ - FP_PACK_RAW_EP (val, X); \ + FP_PACK_RAW_EP ((val), X); \ } \ while (0) @@ -209,7 +214,7 @@ union _FP_UNION_E do \ { \ _FP_PACK_SEMIRAW (E, 4, X); \ - FP_PACK_RAW_E (val, X); \ + FP_PACK_RAW_E ((val), X); \ } \ while (0) @@ -217,7 +222,7 @@ union _FP_UNION_E do \ { \ _FP_PACK_SEMIRAW (E, 4, X); \ - FP_PACK_RAW_EP (val, X); \ + FP_PACK_RAW_EP ((val), X); \ } \ while (0) @@ -230,50 +235,48 @@ union _FP_UNION_E # define FP_SQRT_E(R, X) _FP_SQRT (E, 4, R, X) # define FP_FMA_E(R, X, Y, Z) _FP_FMA (E, 4, 8, R, X, Y, Z) -/* - * Square root algorithms: - * We have just one right now, maybe Newton approximation - * should be added for those machines where division is fast. - * This has special _E version because standard _4 square - * root would not work (it has to start normally with the - * second word and not the first), but as we have to do it - * anyway, we optimize it by doing most of the calculations - * in two UWtype registers instead of four. - */ +/* Square root algorithms: + We have just one right now, maybe Newton approximation + should be added for those machines where division is fast. + This has special _E version because standard _4 square + root would not work (it has to start normally with the + second word and not the first), but as we have to do it + anyway, we optimize it by doing most of the calculations + in two UWtype registers instead of four. */ # define _FP_SQRT_MEAT_E(R, S, T, X, q) \ do \ { \ - q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ + (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ _FP_FRAC_SRL_4 (X, (_FP_WORKBITS)); \ while (q) \ { \ - T##_f[1] = S##_f[1] + q; \ + T##_f[1] = S##_f[1] + (q); \ if (T##_f[1] <= X##_f[1]) \ { \ - S##_f[1] = T##_f[1] + q; \ + S##_f[1] = T##_f[1] + (q); \ X##_f[1] -= T##_f[1]; \ - R##_f[1] += q; \ + R##_f[1] += (q); \ } \ _FP_FRAC_SLL_2 (X, 1); \ - q >>= 1; \ + (q) >>= 1; \ } \ - q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ + (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ while (q) \ { \ - T##_f[0] = S##_f[0] + q; \ + T##_f[0] = S##_f[0] + (q); \ T##_f[1] = S##_f[1]; \ if (T##_f[1] < X##_f[1] \ || (T##_f[1] == X##_f[1] \ && T##_f[0] <= X##_f[0])) \ { \ - S##_f[0] = T##_f[0] + q; \ + S##_f[0] = T##_f[0] + (q); \ S##_f[1] += (T##_f[0] > S##_f[0]); \ _FP_FRAC_DEC_2 (X, T); \ - R##_f[0] += q; \ + R##_f[0] += (q); \ } \ _FP_FRAC_SLL_2 (X, 1); \ - q >>= 1; \ + (q) >>= 1; \ } \ _FP_FRAC_SLL_4 (R, (_FP_WORKBITS)); \ if (X##_f[0] | X##_f[1]) \ @@ -287,12 +290,14 @@ union _FP_UNION_E } \ while (0) -# define FP_CMP_E(r, X, Y, un) _FP_CMP (E, 4, r, X, Y, un) -# define FP_CMP_EQ_E(r, X, Y) _FP_CMP_EQ (E, 4, r, X, Y) -# define FP_CMP_UNORD_E(r, X, Y) _FP_CMP_UNORD (E, 4, r, X, Y) +# define FP_CMP_E(r, X, Y, un, ex) _FP_CMP (E, 4, (r), X, Y, (un), (ex)) +# define FP_CMP_EQ_E(r, X, Y, ex) _FP_CMP_EQ (E, 4, (r), X, Y, (ex)) +# define FP_CMP_UNORD_E(r, X, Y, ex) _FP_CMP_UNORD (E, 4, (r), X, Y, (ex)) -# define FP_TO_INT_E(r, X, rsz, rsg) _FP_TO_INT (E, 4, r, X, rsz, rsg) -# define FP_FROM_INT_E(X, r, rs, rt) _FP_FROM_INT (E, 4, X, r, rs, rt) +# define FP_TO_INT_E(r, X, rsz, rsg) _FP_TO_INT (E, 4, (r), X, (rsz), (rsg)) +# define FP_TO_INT_ROUND_E(r, X, rsz, rsg) \ + _FP_TO_INT_ROUND (E, 4, (r), X, (rsz), (rsg)) +# define FP_FROM_INT_E(X, r, rs, rt) _FP_FROM_INT (E, 4, X, (r), (rs), rt) # define _FP_FRAC_HIGH_E(X) (X##_f[2]) # define _FP_FRAC_HIGH_RAW_E(X) (X##_f[1]) @@ -323,68 +328,70 @@ union _FP_UNION_E # define FP_UNPACK_RAW_E(X, val) \ do \ { \ - union _FP_UNION_E _flo; \ - _flo.flt = (val); \ + union _FP_UNION_E FP_UNPACK_RAW_E_flo; \ + FP_UNPACK_RAW_E_flo.flt = (val); \ \ - X##_f0 = _flo.bits.frac; \ + X##_f0 = FP_UNPACK_RAW_E_flo.bits.frac; \ X##_f1 = 0; \ - X##_e = _flo.bits.exp; \ - X##_s = _flo.bits.sign; \ + X##_e = FP_UNPACK_RAW_E_flo.bits.exp; \ + X##_s = FP_UNPACK_RAW_E_flo.bits.sign; \ } \ while (0) -# define FP_UNPACK_RAW_EP(X, val) \ - do \ - { \ - union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val); \ - \ - X##_f0 = _flo->bits.frac; \ - X##_f1 = 0; \ - X##_e = _flo->bits.exp; \ - X##_s = _flo->bits.sign; \ - } \ +# define FP_UNPACK_RAW_EP(X, val) \ + do \ + { \ + union _FP_UNION_E *FP_UNPACK_RAW_EP_flo \ + = (union _FP_UNION_E *) (val); \ + \ + X##_f0 = FP_UNPACK_RAW_EP_flo->bits.frac; \ + X##_f1 = 0; \ + X##_e = FP_UNPACK_RAW_EP_flo->bits.exp; \ + X##_s = FP_UNPACK_RAW_EP_flo->bits.sign; \ + } \ while (0) # define FP_PACK_RAW_E(val, X) \ do \ { \ - union _FP_UNION_E _flo; \ + union _FP_UNION_E FP_PACK_RAW_E_flo; \ \ if (X##_e) \ X##_f0 |= _FP_IMPLBIT_E; \ else \ X##_f0 &= ~(_FP_IMPLBIT_E); \ - _flo.bits.frac = X##_f0; \ - _flo.bits.exp = X##_e; \ - _flo.bits.sign = X##_s; \ + FP_PACK_RAW_E_flo.bits.frac = X##_f0; \ + FP_PACK_RAW_E_flo.bits.exp = X##_e; \ + FP_PACK_RAW_E_flo.bits.sign = X##_s; \ \ - (val) = _flo.flt; \ + (val) = FP_PACK_RAW_E_flo.flt; \ } \ while (0) -# define FP_PACK_RAW_EP(fs, val, X) \ - do \ - { \ - if (!FP_INHIBIT_RESULTS) \ - { \ - union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val); \ - \ - if (X##_e) \ - X##_f0 |= _FP_IMPLBIT_E; \ - else \ - X##_f0 &= ~(_FP_IMPLBIT_E); \ - _flo->bits.frac = X##_f0; \ - _flo->bits.exp = X##_e; \ - _flo->bits.sign = X##_s; \ - } \ - } \ +# define FP_PACK_RAW_EP(fs, val, X) \ + do \ + { \ + if (!FP_INHIBIT_RESULTS) \ + { \ + union _FP_UNION_E *FP_PACK_RAW_EP_flo \ + = (union _FP_UNION_E *) (val); \ + \ + if (X##_e) \ + X##_f0 |= _FP_IMPLBIT_E; \ + else \ + X##_f0 &= ~(_FP_IMPLBIT_E); \ + FP_PACK_RAW_EP_flo->bits.frac = X##_f0; \ + FP_PACK_RAW_EP_flo->bits.exp = X##_e; \ + FP_PACK_RAW_EP_flo->bits.sign = X##_s; \ + } \ + } \ while (0) # define FP_UNPACK_E(X, val) \ do \ { \ - FP_UNPACK_RAW_E (X, val); \ + FP_UNPACK_RAW_E (X, (val)); \ _FP_UNPACK_CANONICAL (E, 2, X); \ } \ while (0) @@ -392,7 +399,7 @@ union _FP_UNION_E # define FP_UNPACK_EP(X, val) \ do \ { \ - FP_UNPACK_RAW_EP (X, val); \ + FP_UNPACK_RAW_EP (X, (val)); \ _FP_UNPACK_CANONICAL (E, 2, X); \ } \ while (0) @@ -400,7 +407,7 @@ union _FP_UNION_E # define FP_UNPACK_SEMIRAW_E(X, val) \ do \ { \ - FP_UNPACK_RAW_E (X, val); \ + FP_UNPACK_RAW_E (X, (val)); \ _FP_UNPACK_SEMIRAW (E, 2, X); \ } \ while (0) @@ -408,7 +415,7 @@ union _FP_UNION_E # define FP_UNPACK_SEMIRAW_EP(X, val) \ do \ { \ - FP_UNPACK_RAW_EP (X, val); \ + FP_UNPACK_RAW_EP (X, (val)); \ _FP_UNPACK_SEMIRAW (E, 2, X); \ } \ while (0) @@ -417,7 +424,7 @@ union _FP_UNION_E do \ { \ _FP_PACK_CANONICAL (E, 2, X); \ - FP_PACK_RAW_E (val, X); \ + FP_PACK_RAW_E ((val), X); \ } \ while (0) @@ -425,7 +432,7 @@ union _FP_UNION_E do \ { \ _FP_PACK_CANONICAL (E, 2, X); \ - FP_PACK_RAW_EP (val, X); \ + FP_PACK_RAW_EP ((val), X); \ } \ while (0) @@ -433,7 +440,7 @@ union _FP_UNION_E do \ { \ _FP_PACK_SEMIRAW (E, 2, X); \ - FP_PACK_RAW_E (val, X); \ + FP_PACK_RAW_E ((val), X); \ } \ while (0) @@ -441,7 +448,7 @@ union _FP_UNION_E do \ { \ _FP_PACK_SEMIRAW (E, 2, X); \ - FP_PACK_RAW_EP (val, X); \ + FP_PACK_RAW_EP ((val), X); \ } \ while (0) @@ -454,30 +461,28 @@ union _FP_UNION_E # define FP_SQRT_E(R, X) _FP_SQRT (E, 2, R, X) # define FP_FMA_E(R, X, Y, Z) _FP_FMA (E, 2, 4, R, X, Y, Z) -/* - * Square root algorithms: - * We have just one right now, maybe Newton approximation - * should be added for those machines where division is fast. - * We optimize it by doing most of the calculations - * in one UWtype registers instead of two, although we don't - * have to. - */ +/* Square root algorithms: + We have just one right now, maybe Newton approximation + should be added for those machines where division is fast. + We optimize it by doing most of the calculations + in one UWtype registers instead of two, although we don't + have to. */ # define _FP_SQRT_MEAT_E(R, S, T, X, q) \ do \ { \ - q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ + (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ _FP_FRAC_SRL_2 (X, (_FP_WORKBITS)); \ while (q) \ { \ - T##_f0 = S##_f0 + q; \ + T##_f0 = S##_f0 + (q); \ if (T##_f0 <= X##_f0) \ { \ - S##_f0 = T##_f0 + q; \ + S##_f0 = T##_f0 + (q); \ X##_f0 -= T##_f0; \ - R##_f0 += q; \ + R##_f0 += (q); \ } \ _FP_FRAC_SLL_1 (X, 1); \ - q >>= 1; \ + (q) >>= 1; \ } \ _FP_FRAC_SLL_2 (R, (_FP_WORKBITS)); \ if (X##_f0) \ @@ -489,12 +494,14 @@ union _FP_UNION_E } \ while (0) -# define FP_CMP_E(r, X, Y, un) _FP_CMP (E, 2, r, X, Y, un) -# define FP_CMP_EQ_E(r, X, Y) _FP_CMP_EQ (E, 2, r, X, Y) -# define FP_CMP_UNORD_E(r, X, Y) _FP_CMP_UNORD (E, 2, r, X, Y) +# define FP_CMP_E(r, X, Y, un, ex) _FP_CMP (E, 2, (r), X, Y, (un), (ex)) +# define FP_CMP_EQ_E(r, X, Y, ex) _FP_CMP_EQ (E, 2, (r), X, Y, (ex)) +# define FP_CMP_UNORD_E(r, X, Y, ex) _FP_CMP_UNORD (E, 2, (r), X, Y, (ex)) -# define FP_TO_INT_E(r, X, rsz, rsg) _FP_TO_INT (E, 2, r, X, rsz, rsg) -# define FP_FROM_INT_E(X, r, rs, rt) _FP_FROM_INT (E, 2, X, r, rs, rt) +# define FP_TO_INT_E(r, X, rsz, rsg) _FP_TO_INT (E, 2, (r), X, (rsz), (rsg)) +# define FP_TO_INT_ROUND_E(r, X, rsz, rsg) \ + _FP_TO_INT_ROUND (E, 2, (r), X, (rsz), (rsg)) +# define FP_FROM_INT_E(X, r, rs, rt) _FP_FROM_INT (E, 2, X, (r), (rs), rt) # define _FP_FRAC_HIGH_E(X) (X##_f1) # define _FP_FRAC_HIGH_RAW_E(X) (X##_f0) @@ -502,3 +509,5 @@ union _FP_UNION_E # define _FP_FRAC_HIGH_DW_E(X) (X##_f[2]) #endif /* not _FP_W_TYPE_SIZE < 64 */ + +#endif /* !SOFT_FP_EXTENDED_H */ diff --git a/soft-fp/extendsfdf2.c b/soft-fp/extendsfdf2.c index a9b6bfbee7..21bf18fa43 100644 --- a/soft-fp/extendsfdf2.c +++ b/soft-fp/extendsfdf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a converted to IEEE double - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). @@ -28,6 +28,7 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ +#define FP_NO_EXACT_UNDERFLOW #include "soft-fp.h" #include "single.h" #include "double.h" diff --git a/soft-fp/extendsftf2.c b/soft-fp/extendsftf2.c index 07fc3679ac..e5bfbbe1e4 100644 --- a/soft-fp/extendsftf2.c +++ b/soft-fp/extendsftf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a converted to IEEE quad - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). @@ -28,6 +28,7 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ +#define FP_NO_EXACT_UNDERFLOW #include "soft-fp.h" #include "single.h" #include "quad.h" diff --git a/soft-fp/extendxftf2.c b/soft-fp/extendxftf2.c index 67b909563f..87e4c7a0a5 100644 --- a/soft-fp/extendxftf2.c +++ b/soft-fp/extendxftf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a converted to IEEE quad - Copyright (C) 2007-2014 Free Software Foundation, Inc. + Copyright (C) 2007-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Uros Bizjak (ubizjak@gmail.com). @@ -39,7 +39,7 @@ __extendxftf2 (XFtype a) FP_DECL_Q (R); TFtype r; - FP_INIT_ROUNDMODE; + FP_INIT_TRAPPING_EXCEPTIONS; FP_UNPACK_RAW_E (A, a); #if (2 * _FP_W_TYPE_SIZE) < _FP_FRACBITS_Q FP_EXTEND (Q, E, 4, 4, R, A); diff --git a/soft-fp/fixdfdi.c b/soft-fp/fixdfdi.c index 4b7659a467..9a6894d5c5 100644 --- a/soft-fp/fixdfdi.c +++ b/soft-fp/fixdfdi.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a to 64bit signed integer - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/fixdfsi.c b/soft-fp/fixdfsi.c index 1545454a0b..bebee75bbd 100644 --- a/soft-fp/fixdfsi.c +++ b/soft-fp/fixdfsi.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a to 32bit signed integer - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/fixdfti.c b/soft-fp/fixdfti.c index b47b7c22cb..549166892c 100644 --- a/soft-fp/fixdfti.c +++ b/soft-fp/fixdfti.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert IEEE double to 128bit signed integer - Copyright (C) 2007-2014 Free Software Foundation, Inc. + Copyright (C) 2007-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Uros Bizjak (ubizjak@gmail.com). diff --git a/soft-fp/fixsfdi.c b/soft-fp/fixsfdi.c index 5353839b93..42a15b98c7 100644 --- a/soft-fp/fixsfdi.c +++ b/soft-fp/fixsfdi.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a to 64bit signed integer - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/fixsfsi.c b/soft-fp/fixsfsi.c index 8fbebaac61..1bf3dd8fb9 100644 --- a/soft-fp/fixsfsi.c +++ b/soft-fp/fixsfsi.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a to 32bit signed integer - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/fixsfti.c b/soft-fp/fixsfti.c index cf7d284a07..fea7d86f5f 100644 --- a/soft-fp/fixsfti.c +++ b/soft-fp/fixsfti.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert IEEE single to 128bit signed integer - Copyright (C) 2007-2014 Free Software Foundation, Inc. + Copyright (C) 2007-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Uros Bizjak (ubizjak@gmail.com). diff --git a/soft-fp/fixtfdi.c b/soft-fp/fixtfdi.c index 3697d0f070..84be9b12d3 100644 --- a/soft-fp/fixtfdi.c +++ b/soft-fp/fixtfdi.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a to 64bit signed integer - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/fixtfsi.c b/soft-fp/fixtfsi.c index 220a11ac66..7f694ca697 100644 --- a/soft-fp/fixtfsi.c +++ b/soft-fp/fixtfsi.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a to 32bit signed integer - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/fixtfti.c b/soft-fp/fixtfti.c index 47b062d15c..e36a6b6ea4 100644 --- a/soft-fp/fixtfti.c +++ b/soft-fp/fixtfti.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert IEEE quad to 128bit signed integer - Copyright (C) 2007-2014 Free Software Foundation, Inc. + Copyright (C) 2007-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Uros Bizjak (ubizjak@gmail.com). diff --git a/soft-fp/fixunsdfdi.c b/soft-fp/fixunsdfdi.c index a0a8be94f6..16eeded22a 100644 --- a/soft-fp/fixunsdfdi.c +++ b/soft-fp/fixunsdfdi.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a to 64bit unsigned integer - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/fixunsdfsi.c b/soft-fp/fixunsdfsi.c index 8905d825ef..dba8ccdd73 100644 --- a/soft-fp/fixunsdfsi.c +++ b/soft-fp/fixunsdfsi.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a to 32bit unsigned integer - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/fixunsdfti.c b/soft-fp/fixunsdfti.c index de8189e1a1..a803ee7f65 100644 --- a/soft-fp/fixunsdfti.c +++ b/soft-fp/fixunsdfti.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert IEEE double to 128bit unsigned integer - Copyright (C) 2007-2014 Free Software Foundation, Inc. + Copyright (C) 2007-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Uros Bizjak (ubizjak@gmail.com). diff --git a/soft-fp/fixunssfdi.c b/soft-fp/fixunssfdi.c index 68e413d870..00244567da 100644 --- a/soft-fp/fixunssfdi.c +++ b/soft-fp/fixunssfdi.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a to 64bit unsigned integer - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/fixunssfsi.c b/soft-fp/fixunssfsi.c index 7e0bc6bbb8..360344397a 100644 --- a/soft-fp/fixunssfsi.c +++ b/soft-fp/fixunssfsi.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a to 32bit unsigned integer - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/fixunssfti.c b/soft-fp/fixunssfti.c index 264ba13a6d..65d836d006 100644 --- a/soft-fp/fixunssfti.c +++ b/soft-fp/fixunssfti.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert IEEE single to 128bit unsigned integer - Copyright (C) 2007-2014 Free Software Foundation, Inc. + Copyright (C) 2007-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Uros Bizjak (ubizjak@gmail.com). diff --git a/soft-fp/fixunstfdi.c b/soft-fp/fixunstfdi.c index 7e866e4218..390030fc6f 100644 --- a/soft-fp/fixunstfdi.c +++ b/soft-fp/fixunstfdi.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a to 64bit unsigned integer - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/fixunstfsi.c b/soft-fp/fixunstfsi.c index 9665721f3b..ce9a07aa97 100644 --- a/soft-fp/fixunstfsi.c +++ b/soft-fp/fixunstfsi.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a to 32bit unsigned integer - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/fixunstfti.c b/soft-fp/fixunstfti.c index fcdf122d24..351e535b4f 100644 --- a/soft-fp/fixunstfti.c +++ b/soft-fp/fixunstfti.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert IEEE quad to 128bit unsigned integer - Copyright (C) 2007-2014 Free Software Foundation, Inc. + Copyright (C) 2007-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Uros Bizjak (ubizjak@gmail.com). diff --git a/soft-fp/floatdidf.c b/soft-fp/floatdidf.c index f290e248f8..ff1a12efb0 100644 --- a/soft-fp/floatdidf.c +++ b/soft-fp/floatdidf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 64bit signed integer to IEEE double - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/floatdisf.c b/soft-fp/floatdisf.c index b54cef8ae0..3397d3ff0f 100644 --- a/soft-fp/floatdisf.c +++ b/soft-fp/floatdisf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 64bit signed integer to IEEE single - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/floatditf.c b/soft-fp/floatditf.c index 33c3b197db..e2b5ea11d2 100644 --- a/soft-fp/floatditf.c +++ b/soft-fp/floatditf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 64bit signed integer to IEEE quad - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/floatsidf.c b/soft-fp/floatsidf.c index fdd9d752f0..4e10c2e065 100644 --- a/soft-fp/floatsidf.c +++ b/soft-fp/floatsidf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 32bit signed integer to IEEE double - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/floatsisf.c b/soft-fp/floatsisf.c index 3b2f8047bd..71fd463af2 100644 --- a/soft-fp/floatsisf.c +++ b/soft-fp/floatsisf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 32bit signed integer to IEEE single - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/floatsitf.c b/soft-fp/floatsitf.c index d92e4bdd25..f07a883db7 100644 --- a/soft-fp/floatsitf.c +++ b/soft-fp/floatsitf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 32bit signed integer to IEEE quad - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/floattidf.c b/soft-fp/floattidf.c index 74c3599f04..8fbe2775f2 100644 --- a/soft-fp/floattidf.c +++ b/soft-fp/floattidf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 128bit signed integer to IEEE double - Copyright (C) 2007-2014 Free Software Foundation, Inc. + Copyright (C) 2007-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Uros Bizjak (ubizjak@gmail.com). diff --git a/soft-fp/floattisf.c b/soft-fp/floattisf.c index 1dc76438a0..4f6f4a7e3b 100644 --- a/soft-fp/floattisf.c +++ b/soft-fp/floattisf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 128bit signed integer to IEEE single - Copyright (C) 2007-2014 Free Software Foundation, Inc. + Copyright (C) 2007-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Uros Bizjak (ubizjak@gmail.com). diff --git a/soft-fp/floattitf.c b/soft-fp/floattitf.c index 8c439260b7..b2ed57dd3e 100644 --- a/soft-fp/floattitf.c +++ b/soft-fp/floattitf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 128bit signed integer to IEEE quad - Copyright (C) 2007-2014 Free Software Foundation, Inc. + Copyright (C) 2007-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Uros Bizjak (ubizjak@gmail.com). diff --git a/soft-fp/floatundidf.c b/soft-fp/floatundidf.c index 43d59c19b2..70d8cc3751 100644 --- a/soft-fp/floatundidf.c +++ b/soft-fp/floatundidf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 64bit unsigned integer to IEEE double - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/floatundisf.c b/soft-fp/floatundisf.c index bf32a214fd..09f6e395a3 100644 --- a/soft-fp/floatundisf.c +++ b/soft-fp/floatundisf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 64bit unsigned integer to IEEE single - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/floatunditf.c b/soft-fp/floatunditf.c index 4eff13671a..7aa081b903 100644 --- a/soft-fp/floatunditf.c +++ b/soft-fp/floatunditf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 64bit unsigned integer to IEEE quad - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/floatunsidf.c b/soft-fp/floatunsidf.c index e995bf4e6a..a9da8e1ae0 100644 --- a/soft-fp/floatunsidf.c +++ b/soft-fp/floatunsidf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 32bit unsigned integer to IEEE double - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/floatunsisf.c b/soft-fp/floatunsisf.c index 803e0db77f..5a560efd8d 100644 --- a/soft-fp/floatunsisf.c +++ b/soft-fp/floatunsisf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 32bit unsigned integer to IEEE single - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/floatunsitf.c b/soft-fp/floatunsitf.c index 956cb62ef2..2022d53e45 100644 --- a/soft-fp/floatunsitf.c +++ b/soft-fp/floatunsitf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 32bit unsigned integer to IEEE quad - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/floatuntidf.c b/soft-fp/floatuntidf.c index 1b543d4a96..6f678c416d 100644 --- a/soft-fp/floatuntidf.c +++ b/soft-fp/floatuntidf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 128bit unsigned integer to IEEE double - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Uros Bizjak (ubizjak@gmail.com). diff --git a/soft-fp/floatuntisf.c b/soft-fp/floatuntisf.c index 09a610d309..bb389d3d87 100644 --- a/soft-fp/floatuntisf.c +++ b/soft-fp/floatuntisf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 128bit unsigned integer to IEEE single - Copyright (C) 2007-2014 Free Software Foundation, Inc. + Copyright (C) 2007-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Uros Bizjak (ubizjak@gmail.com). diff --git a/soft-fp/floatuntitf.c b/soft-fp/floatuntitf.c index d6e57fdae8..0d3878f7df 100644 --- a/soft-fp/floatuntitf.c +++ b/soft-fp/floatuntitf.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Convert a 128bit unsigned integer to IEEE quad - Copyright (C) 2007-2014 Free Software Foundation, Inc. + Copyright (C) 2007-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Uros Bizjak (ubizjak@gmail.com). diff --git a/soft-fp/fmadf4.c b/soft-fp/fmadf4.c index c4826ca20c..da6749d0ec 100644 --- a/soft-fp/fmadf4.c +++ b/soft-fp/fmadf4.c @@ -1,5 +1,5 @@ /* Implement fma using soft-fp. - Copyright (C) 2013-2014 Free Software Foundation, Inc. + Copyright (C) 2013-2015 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 @@ -25,6 +25,7 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ +#include <libc-internal.h> #include <math.h> #include "soft-fp.h" #include "double.h" @@ -44,7 +45,18 @@ __fma (double a, double b, double c) FP_UNPACK_D (B, b); FP_UNPACK_D (C, c); FP_FMA_D (R, A, B, C); + /* R_e is not set in cases where it is not used in packing, but the + compiler does not see that it is set in all cases where it is + used, resulting in warnings that it may be used + uninitialized. */ + DIAG_PUSH_NEEDS_COMMENT; +#if __GNUC_PREREQ (4, 7) + DIAG_IGNORE_NEEDS_COMMENT (4.9, "-Wmaybe-uninitialized"); +#else + DIAG_IGNORE_NEEDS_COMMENT (4.9, "-Wuninitialized"); +#endif FP_PACK_D (r, R); + DIAG_POP_NEEDS_COMMENT; FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fmasf4.c b/soft-fp/fmasf4.c index a48e19d1f3..b770a0719f 100644 --- a/soft-fp/fmasf4.c +++ b/soft-fp/fmasf4.c @@ -1,5 +1,5 @@ /* Implement fmaf using soft-fp. - Copyright (C) 2013-2014 Free Software Foundation, Inc. + Copyright (C) 2013-2015 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 @@ -25,6 +25,7 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ +#include <libc-internal.h> #include <math.h> #include "soft-fp.h" #include "single.h" @@ -44,7 +45,18 @@ __fmaf (float a, float b, float c) FP_UNPACK_S (B, b); FP_UNPACK_S (C, c); FP_FMA_S (R, A, B, C); + /* R_e is not set in cases where it is not used in packing, but the + compiler does not see that it is set in all cases where it is + used, resulting in warnings that it may be used + uninitialized. */ + DIAG_PUSH_NEEDS_COMMENT; +#if __GNUC_PREREQ (4, 7) + DIAG_IGNORE_NEEDS_COMMENT (4.9, "-Wmaybe-uninitialized"); +#else + DIAG_IGNORE_NEEDS_COMMENT (4.9, "-Wuninitialized"); +#endif FP_PACK_S (r, R); + DIAG_POP_NEEDS_COMMENT; FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fmatf4.c b/soft-fp/fmatf4.c index 1fe4b46e05..880961cfd1 100644 --- a/soft-fp/fmatf4.c +++ b/soft-fp/fmatf4.c @@ -1,5 +1,5 @@ /* Implement fmal using soft-fp. - Copyright (C) 2013-2014 Free Software Foundation, Inc. + Copyright (C) 2013-2015 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 @@ -25,6 +25,7 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ +#include <libc-internal.h> #include <math.h> #include "soft-fp.h" #include "quad.h" @@ -44,7 +45,18 @@ __fmal (long double a, long double b, long double c) FP_UNPACK_Q (B, b); FP_UNPACK_Q (C, c); FP_FMA_Q (R, A, B, C); + /* R_e is not set in cases where it is not used in packing, but the + compiler does not see that it is set in all cases where it is + used, resulting in warnings that it may be used + uninitialized. */ + DIAG_PUSH_NEEDS_COMMENT; +#if __GNUC_PREREQ (4, 7) + DIAG_IGNORE_NEEDS_COMMENT (4.9, "-Wmaybe-uninitialized"); +#else + DIAG_IGNORE_NEEDS_COMMENT (4.9, "-Wuninitialized"); +#endif FP_PACK_Q (r, R); + DIAG_POP_NEEDS_COMMENT; FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/gedf2.c b/soft-fp/gedf2.c index 4ff97561ba..eea3647f82 100644 --- a/soft-fp/gedf2.c +++ b/soft-fp/gedf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return 0 iff a == b, 1 iff a > b, -2 iff a ? b, -1 iff a < b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). @@ -42,9 +42,7 @@ __gedf2 (DFtype a, DFtype b) FP_INIT_EXCEPTIONS; FP_UNPACK_RAW_D (A, a); FP_UNPACK_RAW_D (B, b); - FP_CMP_D (r, A, B, -2); - if (r == -2) - FP_SET_EXCEPTION (FP_EX_INVALID); + FP_CMP_D (r, A, B, -2, 2); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/gesf2.c b/soft-fp/gesf2.c index f3c5d2d710..b554207bf4 100644 --- a/soft-fp/gesf2.c +++ b/soft-fp/gesf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return 0 iff a == b, 1 iff a > b, -2 iff a ? b, -1 iff a < b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). @@ -42,9 +42,7 @@ __gesf2 (SFtype a, SFtype b) FP_INIT_EXCEPTIONS; FP_UNPACK_RAW_S (A, a); FP_UNPACK_RAW_S (B, b); - FP_CMP_S (r, A, B, -2); - if (r == -2) - FP_SET_EXCEPTION (FP_EX_INVALID); + FP_CMP_S (r, A, B, -2, 2); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/getf2.c b/soft-fp/getf2.c index fb82b795ca..3c30431793 100644 --- a/soft-fp/getf2.c +++ b/soft-fp/getf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return 0 iff a == b, 1 iff a > b, -2 iff a ? b, -1 iff a < b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). @@ -42,9 +42,7 @@ __getf2 (TFtype a, TFtype b) FP_INIT_EXCEPTIONS; FP_UNPACK_RAW_Q (A, a); FP_UNPACK_RAW_Q (B, b); - FP_CMP_Q (r, A, B, -2); - if (r == -2) - FP_SET_EXCEPTION (FP_EX_INVALID); + FP_CMP_Q (r, A, B, -2, 2); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/ledf2.c b/soft-fp/ledf2.c index 8b15d32b74..ea059cc3f9 100644 --- a/soft-fp/ledf2.c +++ b/soft-fp/ledf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return 0 iff a == b, 1 iff a > b, 2 iff a ? b, -1 iff a < b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). @@ -42,9 +42,7 @@ __ledf2 (DFtype a, DFtype b) FP_INIT_EXCEPTIONS; FP_UNPACK_RAW_D (A, a); FP_UNPACK_RAW_D (B, b); - FP_CMP_D (r, A, B, 2); - if (r == 2) - FP_SET_EXCEPTION (FP_EX_INVALID); + FP_CMP_D (r, A, B, 2, 2); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/lesf2.c b/soft-fp/lesf2.c index e86ac3f08e..b47bca9b18 100644 --- a/soft-fp/lesf2.c +++ b/soft-fp/lesf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return 0 iff a == b, 1 iff a > b, 2 iff a ? b, -1 iff a < b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). @@ -42,9 +42,7 @@ __lesf2 (SFtype a, SFtype b) FP_INIT_EXCEPTIONS; FP_UNPACK_RAW_S (A, a); FP_UNPACK_RAW_S (B, b); - FP_CMP_S (r, A, B, 2); - if (r == 2) - FP_SET_EXCEPTION (FP_EX_INVALID); + FP_CMP_S (r, A, B, 2, 2); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/letf2.c b/soft-fp/letf2.c index 94b7d786d6..113a2308cd 100644 --- a/soft-fp/letf2.c +++ b/soft-fp/letf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return 0 iff a == b, 1 iff a > b, 2 iff a ? b, -1 iff a < b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). @@ -42,9 +42,7 @@ __letf2 (TFtype a, TFtype b) FP_INIT_EXCEPTIONS; FP_UNPACK_RAW_Q (A, a); FP_UNPACK_RAW_Q (B, b); - FP_CMP_Q (r, A, B, 2); - if (r == 2) - FP_SET_EXCEPTION (FP_EX_INVALID); + FP_CMP_Q (r, A, B, 2, 2); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/muldf3.c b/soft-fp/muldf3.c index 96bf65f554..acea9a76a4 100644 --- a/soft-fp/muldf3.c +++ b/soft-fp/muldf3.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a * b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/mulsf3.c b/soft-fp/mulsf3.c index d8160a1a1b..fd9c6ff8d8 100644 --- a/soft-fp/mulsf3.c +++ b/soft-fp/mulsf3.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a * b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/multf3.c b/soft-fp/multf3.c index d67a12b7bb..c8f352fd7f 100644 --- a/soft-fp/multf3.c +++ b/soft-fp/multf3.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a * b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/negdf2.c b/soft-fp/negdf2.c index 5d3c6114e5..f95e13bd64 100644 --- a/soft-fp/negdf2.c +++ b/soft-fp/negdf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return -a - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/negsf2.c b/soft-fp/negsf2.c index c4a06089ee..5bfc486ad8 100644 --- a/soft-fp/negsf2.c +++ b/soft-fp/negsf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return -a - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/negtf2.c b/soft-fp/negtf2.c index 5306005b8b..cb0a998529 100644 --- a/soft-fp/negtf2.c +++ b/soft-fp/negtf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return -a - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/op-1.h b/soft-fp/op-1.h index 33682cf51e..e3a91bfc7b 100644 --- a/soft-fp/op-1.h +++ b/soft-fp/op-1.h @@ -1,6 +1,6 @@ /* Software floating-point emulation. Basic one-word fraction declaration and manipulation. - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com), Jakub Jelinek (jj@ultra.linux.cz), @@ -30,7 +30,10 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ -#define _FP_FRAC_DECL_1(X) _FP_W_TYPE X##_f +#ifndef SOFT_FP_OP_1_H +#define SOFT_FP_OP_1_H 1 + +#define _FP_FRAC_DECL_1(X) _FP_W_TYPE X##_f _FP_ZERO_INIT #define _FP_FRAC_COPY_1(D, S) (D##_f = S##_f) #define _FP_FRAC_SET_1(X, I) (X##_f = I) #define _FP_FRAC_HIGH_1(X) (X##_f) @@ -50,8 +53,8 @@ #define _FP_FRAC_SRL_1(X, N) (X##_f >>= N) /* Right shift with sticky-lsb. */ -#define _FP_FRAC_SRST_1(X, S, N, sz) __FP_FRAC_SRST_1 (X##_f, S, N, sz) -#define _FP_FRAC_SRS_1(X, N, sz) __FP_FRAC_SRS_1 (X##_f, N, sz) +#define _FP_FRAC_SRST_1(X, S, N, sz) __FP_FRAC_SRST_1 (X##_f, S, (N), (sz)) +#define _FP_FRAC_SRS_1(X, N, sz) __FP_FRAC_SRS_1 (X##_f, (N), (sz)) #define __FP_FRAC_SRST_1(X, S, N, sz) \ do \ @@ -71,9 +74,9 @@ #define _FP_FRAC_ADD_1(R, X, Y) (R##_f = X##_f + Y##_f) #define _FP_FRAC_SUB_1(R, X, Y) (R##_f = X##_f - Y##_f) #define _FP_FRAC_DEC_1(X, Y) (X##_f -= Y##_f) -#define _FP_FRAC_CLZ_1(z, X) __FP_CLZ (z, X##_f) +#define _FP_FRAC_CLZ_1(z, X) __FP_CLZ ((z), X##_f) -/* Predicates */ +/* Predicates. */ #define _FP_FRAC_NEGP_1(X) ((_FP_WS_TYPE) X##_f < 0) #define _FP_FRAC_ZEROP_1(X) (X##_f == 0) #define _FP_FRAC_OVERP_1(fs, X) (X##_f & _FP_OVERFLOW_##fs) @@ -87,66 +90,62 @@ #define _FP_MINFRAC_1 1 #define _FP_MAXFRAC_1 (~(_FP_WS_TYPE) 0) -/* - * Unpack the raw bits of a native fp value. Do not classify or - * normalize the data. - */ +/* Unpack the raw bits of a native fp value. Do not classify or + normalize the data. */ -#define _FP_UNPACK_RAW_1(fs, X, val) \ - do \ - { \ - union _FP_UNION_##fs _flo; \ - _flo.flt = (val); \ - \ - X##_f = _flo.bits.frac; \ - X##_e = _flo.bits.exp; \ - X##_s = _flo.bits.sign; \ - } \ +#define _FP_UNPACK_RAW_1(fs, X, val) \ + do \ + { \ + union _FP_UNION_##fs _FP_UNPACK_RAW_1_flo; \ + _FP_UNPACK_RAW_1_flo.flt = (val); \ + \ + X##_f = _FP_UNPACK_RAW_1_flo.bits.frac; \ + X##_e = _FP_UNPACK_RAW_1_flo.bits.exp; \ + X##_s = _FP_UNPACK_RAW_1_flo.bits.sign; \ + } \ while (0) -#define _FP_UNPACK_RAW_1_P(fs, X, val) \ - do \ - { \ - union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val); \ - \ - X##_f = _flo->bits.frac; \ - X##_e = _flo->bits.exp; \ - X##_s = _flo->bits.sign; \ - } \ +#define _FP_UNPACK_RAW_1_P(fs, X, val) \ + do \ + { \ + union _FP_UNION_##fs *_FP_UNPACK_RAW_1_P_flo \ + = (union _FP_UNION_##fs *) (val); \ + \ + X##_f = _FP_UNPACK_RAW_1_P_flo->bits.frac; \ + X##_e = _FP_UNPACK_RAW_1_P_flo->bits.exp; \ + X##_s = _FP_UNPACK_RAW_1_P_flo->bits.sign; \ + } \ while (0) -/* - * Repack the raw bits of a native fp value. - */ +/* Repack the raw bits of a native fp value. */ #define _FP_PACK_RAW_1(fs, val, X) \ do \ { \ - union _FP_UNION_##fs _flo; \ + union _FP_UNION_##fs _FP_PACK_RAW_1_flo; \ \ - _flo.bits.frac = X##_f; \ - _flo.bits.exp = X##_e; \ - _flo.bits.sign = X##_s; \ + _FP_PACK_RAW_1_flo.bits.frac = X##_f; \ + _FP_PACK_RAW_1_flo.bits.exp = X##_e; \ + _FP_PACK_RAW_1_flo.bits.sign = X##_s; \ \ - (val) = _flo.flt; \ + (val) = _FP_PACK_RAW_1_flo.flt; \ } \ while (0) -#define _FP_PACK_RAW_1_P(fs, val, X) \ - do \ - { \ - union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val); \ - \ - _flo->bits.frac = X##_f; \ - _flo->bits.exp = X##_e; \ - _flo->bits.sign = X##_s; \ - } \ +#define _FP_PACK_RAW_1_P(fs, val, X) \ + do \ + { \ + union _FP_UNION_##fs *_FP_PACK_RAW_1_P_flo \ + = (union _FP_UNION_##fs *) (val); \ + \ + _FP_PACK_RAW_1_P_flo->bits.frac = X##_f; \ + _FP_PACK_RAW_1_P_flo->bits.exp = X##_e; \ + _FP_PACK_RAW_1_P_flo->bits.sign = X##_s; \ + } \ while (0) -/* - * Multiplication algorithms: - */ +/* Multiplication algorithms: */ /* Basic. Assuming the host word size is >= 2*FRACBITS, we can do the multiplication immediately. */ @@ -161,11 +160,11 @@ #define _FP_MUL_MEAT_1_imm(wfracbits, R, X, Y) \ do \ { \ - _FP_MUL_MEAT_DW_1_imm (wfracbits, R, X, Y); \ + _FP_MUL_MEAT_DW_1_imm ((wfracbits), R, X, Y); \ /* Normalize since we know where the msb of the multiplicands \ were (bit B), we know that the msb of the of the product is \ at either 2B or 2B-1. */ \ - _FP_FRAC_SRS_1 (R, wfracbits-1, 2*wfracbits); \ + _FP_FRAC_SRS_1 (R, (wfracbits)-1, 2*(wfracbits)); \ } \ while (0) @@ -181,13 +180,15 @@ #define _FP_MUL_MEAT_1_wide(wfracbits, R, X, Y, doit) \ do \ { \ - _FP_FRAC_DECL_2 (_Z); \ - _FP_MUL_MEAT_DW_1_wide (wfracbits, _Z, X, Y, doit); \ + _FP_FRAC_DECL_2 (_FP_MUL_MEAT_1_wide_Z); \ + _FP_MUL_MEAT_DW_1_wide ((wfracbits), _FP_MUL_MEAT_1_wide_Z, \ + X, Y, doit); \ /* Normalize since we know where the msb of the multiplicands \ were (bit B), we know that the msb of the of the product is \ at either 2B or 2B-1. */ \ - _FP_FRAC_SRS_2 (_Z, wfracbits-1, 2*wfracbits); \ - R##_f = _Z_f0; \ + _FP_FRAC_SRS_2 (_FP_MUL_MEAT_1_wide_Z, (wfracbits)-1, \ + 2*(wfracbits)); \ + R##_f = _FP_MUL_MEAT_1_wide_Z_f0; \ } \ while (0) @@ -196,62 +197,70 @@ #define _FP_MUL_MEAT_DW_1_hard(wfracbits, R, X, Y) \ do \ { \ - _FP_W_TYPE _xh, _xl, _yh, _yl; \ - _FP_FRAC_DECL_2 (_a); \ + _FP_W_TYPE _FP_MUL_MEAT_DW_1_hard_xh, _FP_MUL_MEAT_DW_1_hard_xl; \ + _FP_W_TYPE _FP_MUL_MEAT_DW_1_hard_yh, _FP_MUL_MEAT_DW_1_hard_yl; \ + _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_1_hard_a); \ \ - /* split the words in half */ \ - _xh = X##_f >> (_FP_W_TYPE_SIZE/2); \ - _xl = X##_f & (((_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2)) - 1); \ - _yh = Y##_f >> (_FP_W_TYPE_SIZE/2); \ - _yl = Y##_f & (((_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2)) - 1); \ + /* Split the words in half. */ \ + _FP_MUL_MEAT_DW_1_hard_xh = X##_f >> (_FP_W_TYPE_SIZE/2); \ + _FP_MUL_MEAT_DW_1_hard_xl \ + = X##_f & (((_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2)) - 1); \ + _FP_MUL_MEAT_DW_1_hard_yh = Y##_f >> (_FP_W_TYPE_SIZE/2); \ + _FP_MUL_MEAT_DW_1_hard_yl \ + = Y##_f & (((_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2)) - 1); \ \ - /* multiply the pieces */ \ - R##_f0 = _xl * _yl; \ - _a_f0 = _xh * _yl; \ - _a_f1 = _xl * _yh; \ - R##_f1 = _xh * _yh; \ + /* Multiply the pieces. */ \ + R##_f0 = _FP_MUL_MEAT_DW_1_hard_xl * _FP_MUL_MEAT_DW_1_hard_yl; \ + _FP_MUL_MEAT_DW_1_hard_a_f0 \ + = _FP_MUL_MEAT_DW_1_hard_xh * _FP_MUL_MEAT_DW_1_hard_yl; \ + _FP_MUL_MEAT_DW_1_hard_a_f1 \ + = _FP_MUL_MEAT_DW_1_hard_xl * _FP_MUL_MEAT_DW_1_hard_yh; \ + R##_f1 = _FP_MUL_MEAT_DW_1_hard_xh * _FP_MUL_MEAT_DW_1_hard_yh; \ \ - /* reassemble into two full words */ \ - if ((_a_f0 += _a_f1) < _a_f1) \ + /* Reassemble into two full words. */ \ + if ((_FP_MUL_MEAT_DW_1_hard_a_f0 += _FP_MUL_MEAT_DW_1_hard_a_f1) \ + < _FP_MUL_MEAT_DW_1_hard_a_f1) \ R##_f1 += (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2); \ - _a_f1 = _a_f0 >> (_FP_W_TYPE_SIZE/2); \ - _a_f0 = _a_f0 << (_FP_W_TYPE_SIZE/2); \ - _FP_FRAC_ADD_2 (R, R, _a); \ + _FP_MUL_MEAT_DW_1_hard_a_f1 \ + = _FP_MUL_MEAT_DW_1_hard_a_f0 >> (_FP_W_TYPE_SIZE/2); \ + _FP_MUL_MEAT_DW_1_hard_a_f0 \ + = _FP_MUL_MEAT_DW_1_hard_a_f0 << (_FP_W_TYPE_SIZE/2); \ + _FP_FRAC_ADD_2 (R, R, _FP_MUL_MEAT_DW_1_hard_a); \ } \ while (0) -#define _FP_MUL_MEAT_1_hard(wfracbits, R, X, Y) \ - do \ - { \ - _FP_FRAC_DECL_2 (_z); \ - _FP_MUL_MEAT_DW_1_hard (wfracbits, _z, X, Y); \ - \ - /* normalize */ \ - _FP_FRAC_SRS_2 (_z, wfracbits - 1, 2*wfracbits); \ - R##_f = _z_f0; \ - } \ +#define _FP_MUL_MEAT_1_hard(wfracbits, R, X, Y) \ + do \ + { \ + _FP_FRAC_DECL_2 (_FP_MUL_MEAT_1_hard_z); \ + _FP_MUL_MEAT_DW_1_hard ((wfracbits), \ + _FP_MUL_MEAT_1_hard_z, X, Y); \ + \ + /* Normalize. */ \ + _FP_FRAC_SRS_2 (_FP_MUL_MEAT_1_hard_z, \ + (wfracbits) - 1, 2*(wfracbits)); \ + R##_f = _FP_MUL_MEAT_1_hard_z_f0; \ + } \ while (0) -/* - * Division algorithms: - */ +/* Division algorithms: */ /* Basic. Assuming the host word size is >= 2*FRACBITS, we can do the division immediately. Give this macro either _FP_DIV_HELP_imm for C primitives or _FP_DIV_HELP_ldiv for the ISO function. Which you choose will depend on what the compiler does with divrem4. */ -#define _FP_DIV_MEAT_1_imm(fs, R, X, Y, doit) \ - do \ - { \ - _FP_W_TYPE _q, _r; \ - X##_f <<= (X##_f < Y##_f \ - ? R##_e--, _FP_WFRACBITS_##fs \ - : _FP_WFRACBITS_##fs - 1); \ - doit (_q, _r, X##_f, Y##_f); \ - R##_f = _q | (_r != 0); \ - } \ +#define _FP_DIV_MEAT_1_imm(fs, R, X, Y, doit) \ + do \ + { \ + _FP_W_TYPE _FP_DIV_MEAT_1_imm_q, _FP_DIV_MEAT_1_imm_r; \ + X##_f <<= (X##_f < Y##_f \ + ? R##_e--, _FP_WFRACBITS_##fs \ + : _FP_WFRACBITS_##fs - 1); \ + doit (_FP_DIV_MEAT_1_imm_q, _FP_DIV_MEAT_1_imm_r, X##_f, Y##_f); \ + R##_f = _FP_DIV_MEAT_1_imm_q | (_FP_DIV_MEAT_1_imm_r != 0); \ + } \ while (0) /* GCC's longlong.h defines a 2W / 1W => (1W,1W) primitive udiv_qrnnd @@ -262,70 +271,80 @@ #define _FP_DIV_MEAT_1_udiv_norm(fs, R, X, Y) \ do \ { \ - _FP_W_TYPE _nh, _nl, _q, _r, _y; \ + _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_nh; \ + _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_nl; \ + _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_q; \ + _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_r; \ + _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_y; \ \ /* Normalize Y -- i.e. make the most significant bit set. */ \ - _y = Y##_f << _FP_WFRACXBITS_##fs; \ + _FP_DIV_MEAT_1_udiv_norm_y = Y##_f << _FP_WFRACXBITS_##fs; \ \ /* Shift X op correspondingly high, that is, up one full word. */ \ if (X##_f < Y##_f) \ { \ R##_e--; \ - _nl = 0; \ - _nh = X##_f; \ + _FP_DIV_MEAT_1_udiv_norm_nl = 0; \ + _FP_DIV_MEAT_1_udiv_norm_nh = X##_f; \ } \ else \ { \ - _nl = X##_f << (_FP_W_TYPE_SIZE - 1); \ - _nh = X##_f >> 1; \ + _FP_DIV_MEAT_1_udiv_norm_nl = X##_f << (_FP_W_TYPE_SIZE - 1); \ + _FP_DIV_MEAT_1_udiv_norm_nh = X##_f >> 1; \ } \ \ - udiv_qrnnd (_q, _r, _nh, _nl, _y); \ - R##_f = _q | (_r != 0); \ + udiv_qrnnd (_FP_DIV_MEAT_1_udiv_norm_q, \ + _FP_DIV_MEAT_1_udiv_norm_r, \ + _FP_DIV_MEAT_1_udiv_norm_nh, \ + _FP_DIV_MEAT_1_udiv_norm_nl, \ + _FP_DIV_MEAT_1_udiv_norm_y); \ + R##_f = (_FP_DIV_MEAT_1_udiv_norm_q \ + | (_FP_DIV_MEAT_1_udiv_norm_r != 0)); \ } \ while (0) -#define _FP_DIV_MEAT_1_udiv(fs, R, X, Y) \ - do \ - { \ - _FP_W_TYPE _nh, _nl, _q, _r; \ - if (X##_f < Y##_f) \ - { \ - R##_e--; \ - _nl = X##_f << _FP_WFRACBITS_##fs; \ - _nh = X##_f >> _FP_WFRACXBITS_##fs; \ - } \ - else \ - { \ - _nl = X##_f << (_FP_WFRACBITS_##fs - 1); \ - _nh = X##_f >> (_FP_WFRACXBITS_##fs + 1); \ - } \ - udiv_qrnnd (_q, _r, _nh, _nl, Y##_f); \ - R##_f = _q | (_r != 0); \ - } \ +#define _FP_DIV_MEAT_1_udiv(fs, R, X, Y) \ + do \ + { \ + _FP_W_TYPE _FP_DIV_MEAT_1_udiv_nh, _FP_DIV_MEAT_1_udiv_nl; \ + _FP_W_TYPE _FP_DIV_MEAT_1_udiv_q, _FP_DIV_MEAT_1_udiv_r; \ + if (X##_f < Y##_f) \ + { \ + R##_e--; \ + _FP_DIV_MEAT_1_udiv_nl = X##_f << _FP_WFRACBITS_##fs; \ + _FP_DIV_MEAT_1_udiv_nh = X##_f >> _FP_WFRACXBITS_##fs; \ + } \ + else \ + { \ + _FP_DIV_MEAT_1_udiv_nl = X##_f << (_FP_WFRACBITS_##fs - 1); \ + _FP_DIV_MEAT_1_udiv_nh = X##_f >> (_FP_WFRACXBITS_##fs + 1); \ + } \ + udiv_qrnnd (_FP_DIV_MEAT_1_udiv_q, _FP_DIV_MEAT_1_udiv_r, \ + _FP_DIV_MEAT_1_udiv_nh, _FP_DIV_MEAT_1_udiv_nl, \ + Y##_f); \ + R##_f = _FP_DIV_MEAT_1_udiv_q | (_FP_DIV_MEAT_1_udiv_r != 0); \ + } \ while (0) -/* - * Square root algorithms: - * We have just one right now, maybe Newton approximation - * should be added for those machines where division is fast. - */ +/* Square root algorithms: + We have just one right now, maybe Newton approximation + should be added for those machines where division is fast. */ #define _FP_SQRT_MEAT_1(R, S, T, X, q) \ do \ { \ - while (q != _FP_WORK_ROUND) \ + while ((q) != _FP_WORK_ROUND) \ { \ - T##_f = S##_f + q; \ + T##_f = S##_f + (q); \ if (T##_f <= X##_f) \ { \ - S##_f = T##_f + q; \ + S##_f = T##_f + (q); \ X##_f -= T##_f; \ - R##_f += q; \ + R##_f += (q); \ } \ _FP_FRAC_SLL_1 (X, 1); \ - q >>= 1; \ + (q) >>= 1; \ } \ if (X##_f) \ { \ @@ -336,17 +355,15 @@ } \ while (0) -/* - * Assembly/disassembly for converting to/from integral types. - * No shifting or overflow handled here. - */ +/* Assembly/disassembly for converting to/from integral types. + No shifting or overflow handled here. */ -#define _FP_FRAC_ASSEMBLE_1(r, X, rsize) (r = X##_f) -#define _FP_FRAC_DISASSEMBLE_1(X, r, rsize) (X##_f = r) +#define _FP_FRAC_ASSEMBLE_1(r, X, rsize) ((r) = X##_f) +#define _FP_FRAC_DISASSEMBLE_1(X, r, rsize) (X##_f = (r)) -/* - * Convert FP values between word sizes - */ +/* Convert FP values between word sizes. */ #define _FP_FRAC_COPY_1_1(D, S) (D##_f = S##_f) + +#endif /* !SOFT_FP_OP_1_H */ diff --git a/soft-fp/op-2.h b/soft-fp/op-2.h index 160990fe4e..a51eb6b35d 100644 --- a/soft-fp/op-2.h +++ b/soft-fp/op-2.h @@ -1,6 +1,6 @@ /* Software floating-point emulation. Basic two-word fraction declaration and manipulation. - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com), Jakub Jelinek (jj@ultra.linux.cz), @@ -30,7 +30,11 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ -#define _FP_FRAC_DECL_2(X) _FP_W_TYPE X##_f0, X##_f1 +#ifndef SOFT_FP_OP_2_H +#define SOFT_FP_OP_2_H 1 + +#define _FP_FRAC_DECL_2(X) \ + _FP_W_TYPE X##_f0 _FP_ZERO_INIT, X##_f1 _FP_ZERO_INIT #define _FP_FRAC_COPY_2(D, S) (D##_f0 = S##_f0, D##_f1 = S##_f1) #define _FP_FRAC_SET_2(X, I) __FP_FRAC_SET_2 (X, I) #define _FP_FRAC_HIGH_2(X) (X##_f1) @@ -122,16 +126,16 @@ do \ { \ if (X##_f1) \ - __FP_CLZ (R, X##_f1); \ + __FP_CLZ ((R), X##_f1); \ else \ { \ - __FP_CLZ (R, X##_f0); \ - R += _FP_W_TYPE_SIZE; \ + __FP_CLZ ((R), X##_f0); \ + (R) += _FP_W_TYPE_SIZE; \ } \ } \ while (0) -/* Predicates */ +/* Predicates. */ #define _FP_FRAC_NEGP_2(X) ((_FP_WS_TYPE) X##_f1 < 0) #define _FP_FRAC_ZEROP_2(X) ((X##_f1 | X##_f0) == 0) #define _FP_FRAC_OVERP_2(fs, X) (_FP_FRAC_HIGH_##fs (X) & _FP_OVERFLOW_##fs) @@ -148,9 +152,7 @@ #define _FP_MINFRAC_2 0, 1 #define _FP_MAXFRAC_2 (~(_FP_WS_TYPE) 0), (~(_FP_WS_TYPE) 0) -/* - * Internals - */ +/* Internals. */ #define __FP_FRAC_SET_2(X, I1, I0) (X##_f0 = I0, X##_f1 = I1) @@ -158,11 +160,11 @@ do \ { \ if (xh) \ - __FP_CLZ (R, xh); \ + __FP_CLZ ((R), xh); \ else \ { \ - __FP_CLZ (R, xl); \ - R += _FP_W_TYPE_SIZE; \ + __FP_CLZ ((R), xl); \ + (R) += _FP_W_TYPE_SIZE; \ } \ } \ while (0) @@ -182,12 +184,12 @@ (rh = xh - yh - ((rl = xl - yl) > xl)) # endif # ifndef __FP_FRAC_DEC_2 -# define __FP_FRAC_DEC_2(xh, xl, yh, yl) \ - do \ - { \ - UWtype _t = xl; \ - xh -= yh + ((xl -= yl) > _t); \ - } \ +# define __FP_FRAC_DEC_2(xh, xl, yh, yl) \ + do \ + { \ + UWtype __FP_FRAC_DEC_2_t = xl; \ + xh -= yh + ((xl -= yl) > __FP_FRAC_DEC_2_t); \ + } \ while (0) # endif @@ -205,91 +207,95 @@ #endif -/* - * Unpack the raw bits of a native fp value. Do not classify or - * normalize the data. - */ +/* Unpack the raw bits of a native fp value. Do not classify or + normalize the data. */ -#define _FP_UNPACK_RAW_2(fs, X, val) \ - do \ - { \ - union _FP_UNION_##fs _flo; \ - _flo.flt = (val); \ - \ - X##_f0 = _flo.bits.frac0; \ - X##_f1 = _flo.bits.frac1; \ - X##_e = _flo.bits.exp; \ - X##_s = _flo.bits.sign; \ - } \ +#define _FP_UNPACK_RAW_2(fs, X, val) \ + do \ + { \ + union _FP_UNION_##fs _FP_UNPACK_RAW_2_flo; \ + _FP_UNPACK_RAW_2_flo.flt = (val); \ + \ + X##_f0 = _FP_UNPACK_RAW_2_flo.bits.frac0; \ + X##_f1 = _FP_UNPACK_RAW_2_flo.bits.frac1; \ + X##_e = _FP_UNPACK_RAW_2_flo.bits.exp; \ + X##_s = _FP_UNPACK_RAW_2_flo.bits.sign; \ + } \ while (0) -#define _FP_UNPACK_RAW_2_P(fs, X, val) \ - do \ - { \ - union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val); \ - \ - X##_f0 = _flo->bits.frac0; \ - X##_f1 = _flo->bits.frac1; \ - X##_e = _flo->bits.exp; \ - X##_s = _flo->bits.sign; \ - } \ +#define _FP_UNPACK_RAW_2_P(fs, X, val) \ + do \ + { \ + union _FP_UNION_##fs *_FP_UNPACK_RAW_2_P_flo \ + = (union _FP_UNION_##fs *) (val); \ + \ + X##_f0 = _FP_UNPACK_RAW_2_P_flo->bits.frac0; \ + X##_f1 = _FP_UNPACK_RAW_2_P_flo->bits.frac1; \ + X##_e = _FP_UNPACK_RAW_2_P_flo->bits.exp; \ + X##_s = _FP_UNPACK_RAW_2_P_flo->bits.sign; \ + } \ while (0) -/* - * Repack the raw bits of a native fp value. - */ +/* Repack the raw bits of a native fp value. */ #define _FP_PACK_RAW_2(fs, val, X) \ do \ { \ - union _FP_UNION_##fs _flo; \ + union _FP_UNION_##fs _FP_PACK_RAW_2_flo; \ \ - _flo.bits.frac0 = X##_f0; \ - _flo.bits.frac1 = X##_f1; \ - _flo.bits.exp = X##_e; \ - _flo.bits.sign = X##_s; \ + _FP_PACK_RAW_2_flo.bits.frac0 = X##_f0; \ + _FP_PACK_RAW_2_flo.bits.frac1 = X##_f1; \ + _FP_PACK_RAW_2_flo.bits.exp = X##_e; \ + _FP_PACK_RAW_2_flo.bits.sign = X##_s; \ \ - (val) = _flo.flt; \ + (val) = _FP_PACK_RAW_2_flo.flt; \ } \ while (0) -#define _FP_PACK_RAW_2_P(fs, val, X) \ - do \ - { \ - union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val); \ - \ - _flo->bits.frac0 = X##_f0; \ - _flo->bits.frac1 = X##_f1; \ - _flo->bits.exp = X##_e; \ - _flo->bits.sign = X##_s; \ - } \ +#define _FP_PACK_RAW_2_P(fs, val, X) \ + do \ + { \ + union _FP_UNION_##fs *_FP_PACK_RAW_2_P_flo \ + = (union _FP_UNION_##fs *) (val); \ + \ + _FP_PACK_RAW_2_P_flo->bits.frac0 = X##_f0; \ + _FP_PACK_RAW_2_P_flo->bits.frac1 = X##_f1; \ + _FP_PACK_RAW_2_P_flo->bits.exp = X##_e; \ + _FP_PACK_RAW_2_P_flo->bits.sign = X##_s; \ + } \ while (0) -/* - * Multiplication algorithms: - */ +/* Multiplication algorithms: */ /* Given a 1W * 1W => 2W primitive, do the extended multiplication. */ #define _FP_MUL_MEAT_DW_2_wide(wfracbits, R, X, Y, doit) \ do \ { \ - _FP_FRAC_DECL_2 (_b); \ - _FP_FRAC_DECL_2 (_c); \ + _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_2_wide_b); \ + _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_2_wide_c); \ \ - doit (_FP_FRAC_WORD_4 (R, 1), _FP_FRAC_WORD_4 (R, 0), X##_f0, Y##_f0); \ - doit (_b_f1, _b_f0, X##_f0, Y##_f1); \ - doit (_c_f1, _c_f0, X##_f1, Y##_f0); \ - doit (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), X##_f1, Y##_f1); \ + doit (_FP_FRAC_WORD_4 (R, 1), _FP_FRAC_WORD_4 (R, 0), \ + X##_f0, Y##_f0); \ + doit (_FP_MUL_MEAT_DW_2_wide_b_f1, _FP_MUL_MEAT_DW_2_wide_b_f0, \ + X##_f0, Y##_f1); \ + doit (_FP_MUL_MEAT_DW_2_wide_c_f1, _FP_MUL_MEAT_DW_2_wide_c_f0, \ + X##_f1, Y##_f0); \ + doit (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \ + X##_f1, Y##_f1); \ \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \ - _FP_FRAC_WORD_4 (R, 1), 0, _b_f1, _b_f0, \ + _FP_FRAC_WORD_4 (R, 1), 0, \ + _FP_MUL_MEAT_DW_2_wide_b_f1, \ + _FP_MUL_MEAT_DW_2_wide_b_f0, \ _FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \ _FP_FRAC_WORD_4 (R, 1)); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \ - _FP_FRAC_WORD_4 (R, 1), 0, _c_f1, _c_f0, \ + _FP_FRAC_WORD_4 (R, 1), 0, \ + _FP_MUL_MEAT_DW_2_wide_c_f1, \ + _FP_MUL_MEAT_DW_2_wide_c_f0, \ _FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \ _FP_FRAC_WORD_4 (R, 1)); \ } \ @@ -298,16 +304,18 @@ #define _FP_MUL_MEAT_2_wide(wfracbits, R, X, Y, doit) \ do \ { \ - _FP_FRAC_DECL_4 (_z); \ + _FP_FRAC_DECL_4 (_FP_MUL_MEAT_2_wide_z); \ \ - _FP_MUL_MEAT_DW_2_wide (wfracbits, _z, X, Y, doit); \ + _FP_MUL_MEAT_DW_2_wide ((wfracbits), _FP_MUL_MEAT_2_wide_z, \ + X, Y, doit); \ \ /* Normalize since we know where the msb of the multiplicands \ were (bit B), we know that the msb of the of the product is \ at either 2B or 2B-1. */ \ - _FP_FRAC_SRS_4 (_z, wfracbits-1, 2*wfracbits); \ - R##_f0 = _FP_FRAC_WORD_4 (_z, 0); \ - R##_f1 = _FP_FRAC_WORD_4 (_z, 1); \ + _FP_FRAC_SRS_4 (_FP_MUL_MEAT_2_wide_z, (wfracbits)-1, \ + 2*(wfracbits)); \ + R##_f0 = _FP_FRAC_WORD_4 (_FP_MUL_MEAT_2_wide_z, 0); \ + R##_f1 = _FP_FRAC_WORD_4 (_FP_MUL_MEAT_2_wide_z, 1); \ } \ while (0) @@ -318,35 +326,51 @@ #define _FP_MUL_MEAT_DW_2_wide_3mul(wfracbits, R, X, Y, doit) \ do \ { \ - _FP_FRAC_DECL_2 (_b); \ - _FP_FRAC_DECL_2 (_c); \ - _FP_W_TYPE _d; \ - int _c1, _c2; \ + _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_2_wide_3mul_b); \ + _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_2_wide_3mul_c); \ + _FP_W_TYPE _FP_MUL_MEAT_DW_2_wide_3mul_d; \ + int _FP_MUL_MEAT_DW_2_wide_3mul_c1; \ + int _FP_MUL_MEAT_DW_2_wide_3mul_c2; \ \ - _b_f0 = X##_f0 + X##_f1; \ - _c1 = _b_f0 < X##_f0; \ - _b_f1 = Y##_f0 + Y##_f1; \ - _c2 = _b_f1 < Y##_f0; \ - doit (_d, _FP_FRAC_WORD_4 (R, 0), X##_f0, Y##_f0); \ - doit (_FP_FRAC_WORD_4 (R, 2), _FP_FRAC_WORD_4 (R, 1), _b_f0, _b_f1); \ - doit (_c_f1, _c_f0, X##_f1, Y##_f1); \ + _FP_MUL_MEAT_DW_2_wide_3mul_b_f0 = X##_f0 + X##_f1; \ + _FP_MUL_MEAT_DW_2_wide_3mul_c1 \ + = _FP_MUL_MEAT_DW_2_wide_3mul_b_f0 < X##_f0; \ + _FP_MUL_MEAT_DW_2_wide_3mul_b_f1 = Y##_f0 + Y##_f1; \ + _FP_MUL_MEAT_DW_2_wide_3mul_c2 \ + = _FP_MUL_MEAT_DW_2_wide_3mul_b_f1 < Y##_f0; \ + doit (_FP_MUL_MEAT_DW_2_wide_3mul_d, _FP_FRAC_WORD_4 (R, 0), \ + X##_f0, Y##_f0); \ + doit (_FP_FRAC_WORD_4 (R, 2), _FP_FRAC_WORD_4 (R, 1), \ + _FP_MUL_MEAT_DW_2_wide_3mul_b_f0, \ + _FP_MUL_MEAT_DW_2_wide_3mul_b_f1); \ + doit (_FP_MUL_MEAT_DW_2_wide_3mul_c_f1, \ + _FP_MUL_MEAT_DW_2_wide_3mul_c_f0, X##_f1, Y##_f1); \ \ - _b_f0 &= -_c2; \ - _b_f1 &= -_c1; \ + _FP_MUL_MEAT_DW_2_wide_3mul_b_f0 \ + &= -_FP_MUL_MEAT_DW_2_wide_3mul_c2; \ + _FP_MUL_MEAT_DW_2_wide_3mul_b_f1 \ + &= -_FP_MUL_MEAT_DW_2_wide_3mul_c1; \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \ - _FP_FRAC_WORD_4 (R, 1), (_c1 & _c2), 0, _d, \ + _FP_FRAC_WORD_4 (R, 1), \ + (_FP_MUL_MEAT_DW_2_wide_3mul_c1 \ + & _FP_MUL_MEAT_DW_2_wide_3mul_c2), 0, \ + _FP_MUL_MEAT_DW_2_wide_3mul_d, \ 0, _FP_FRAC_WORD_4 (R, 2), _FP_FRAC_WORD_4 (R, 1)); \ __FP_FRAC_ADDI_2 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \ - _b_f0); \ + _FP_MUL_MEAT_DW_2_wide_3mul_b_f0); \ __FP_FRAC_ADDI_2 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \ - _b_f1); \ + _FP_MUL_MEAT_DW_2_wide_3mul_b_f1); \ __FP_FRAC_DEC_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \ _FP_FRAC_WORD_4 (R, 1), \ - 0, _d, _FP_FRAC_WORD_4 (R, 0)); \ + 0, _FP_MUL_MEAT_DW_2_wide_3mul_d, \ + _FP_FRAC_WORD_4 (R, 0)); \ __FP_FRAC_DEC_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \ - _FP_FRAC_WORD_4 (R, 1), 0, _c_f1, _c_f0); \ + _FP_FRAC_WORD_4 (R, 1), 0, \ + _FP_MUL_MEAT_DW_2_wide_3mul_c_f1, \ + _FP_MUL_MEAT_DW_2_wide_3mul_c_f0); \ __FP_FRAC_ADD_2 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \ - _c_f1, _c_f0, \ + _FP_MUL_MEAT_DW_2_wide_3mul_c_f1, \ + _FP_MUL_MEAT_DW_2_wide_3mul_c_f0, \ _FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2)); \ } \ while (0) @@ -354,45 +378,51 @@ #define _FP_MUL_MEAT_2_wide_3mul(wfracbits, R, X, Y, doit) \ do \ { \ - _FP_FRAC_DECL_4 (_z); \ + _FP_FRAC_DECL_4 (_FP_MUL_MEAT_2_wide_3mul_z); \ \ - _FP_MUL_MEAT_DW_2_wide_3mul (wfracbits, _z, X, Y, doit); \ + _FP_MUL_MEAT_DW_2_wide_3mul ((wfracbits), \ + _FP_MUL_MEAT_2_wide_3mul_z, \ + X, Y, doit); \ \ /* Normalize since we know where the msb of the multiplicands \ were (bit B), we know that the msb of the of the product is \ at either 2B or 2B-1. */ \ - _FP_FRAC_SRS_4 (_z, wfracbits-1, 2*wfracbits); \ - R##_f0 = _FP_FRAC_WORD_4 (_z, 0); \ - R##_f1 = _FP_FRAC_WORD_4 (_z, 1); \ + _FP_FRAC_SRS_4 (_FP_MUL_MEAT_2_wide_3mul_z, \ + (wfracbits)-1, 2*(wfracbits)); \ + R##_f0 = _FP_FRAC_WORD_4 (_FP_MUL_MEAT_2_wide_3mul_z, 0); \ + R##_f1 = _FP_FRAC_WORD_4 (_FP_MUL_MEAT_2_wide_3mul_z, 1); \ } \ while (0) #define _FP_MUL_MEAT_DW_2_gmp(wfracbits, R, X, Y) \ do \ { \ - _FP_W_TYPE _x[2], _y[2]; \ - _x[0] = X##_f0; \ - _x[1] = X##_f1; \ - _y[0] = Y##_f0; \ - _y[1] = Y##_f1; \ + _FP_W_TYPE _FP_MUL_MEAT_DW_2_gmp_x[2]; \ + _FP_W_TYPE _FP_MUL_MEAT_DW_2_gmp_y[2]; \ + _FP_MUL_MEAT_DW_2_gmp_x[0] = X##_f0; \ + _FP_MUL_MEAT_DW_2_gmp_x[1] = X##_f1; \ + _FP_MUL_MEAT_DW_2_gmp_y[0] = Y##_f0; \ + _FP_MUL_MEAT_DW_2_gmp_y[1] = Y##_f1; \ \ - mpn_mul_n (R##_f, _x, _y, 2); \ + mpn_mul_n (R##_f, _FP_MUL_MEAT_DW_2_gmp_x, \ + _FP_MUL_MEAT_DW_2_gmp_y, 2); \ } \ while (0) #define _FP_MUL_MEAT_2_gmp(wfracbits, R, X, Y) \ do \ { \ - _FP_FRAC_DECL_4 (_z); \ + _FP_FRAC_DECL_4 (_FP_MUL_MEAT_2_gmp_z); \ \ - _FP_MUL_MEAT_DW_2_gmp (wfracbits, _z, X, Y); \ + _FP_MUL_MEAT_DW_2_gmp ((wfracbits), _FP_MUL_MEAT_2_gmp_z, X, Y); \ \ /* Normalize since we know where the msb of the multiplicands \ were (bit B), we know that the msb of the of the product is \ at either 2B or 2B-1. */ \ - _FP_FRAC_SRS_4 (_z, wfracbits-1, 2*wfracbits); \ - R##_f0 = _z_f[0]; \ - R##_f1 = _z_f[1]; \ + _FP_FRAC_SRS_4 (_FP_MUL_MEAT_2_gmp_z, (wfracbits)-1, \ + 2*(wfracbits)); \ + R##_f0 = _FP_MUL_MEAT_2_gmp_z_f[0]; \ + R##_f1 = _FP_MUL_MEAT_2_gmp_z_f[1]; \ } \ while (0) @@ -428,8 +458,8 @@ _p240, _q240, _r240, _s240; \ UDItype _t240, _u240, _v240, _w240, _x240, _y240 = 0; \ \ - if (wfracbits < 106 || wfracbits > 120) \ - abort (); \ + _FP_STATIC_ASSERT ((wfracbits) >= 106 && (wfracbits) <= 120, \ + "wfracbits out of range"); \ \ setfetz; \ \ @@ -500,116 +530,136 @@ } \ while (0) -/* - * Division algorithms: - */ +/* Division algorithms: */ #define _FP_DIV_MEAT_2_udiv(fs, R, X, Y) \ do \ { \ - _FP_W_TYPE _n_f2, _n_f1, _n_f0, _r_f1, _r_f0, _m_f1, _m_f0; \ + _FP_W_TYPE _FP_DIV_MEAT_2_udiv_n_f2; \ + _FP_W_TYPE _FP_DIV_MEAT_2_udiv_n_f1; \ + _FP_W_TYPE _FP_DIV_MEAT_2_udiv_n_f0; \ + _FP_W_TYPE _FP_DIV_MEAT_2_udiv_r_f1; \ + _FP_W_TYPE _FP_DIV_MEAT_2_udiv_r_f0; \ + _FP_W_TYPE _FP_DIV_MEAT_2_udiv_m_f1; \ + _FP_W_TYPE _FP_DIV_MEAT_2_udiv_m_f0; \ if (_FP_FRAC_GE_2 (X, Y)) \ { \ - _n_f2 = X##_f1 >> 1; \ - _n_f1 = X##_f1 << (_FP_W_TYPE_SIZE - 1) | X##_f0 >> 1; \ - _n_f0 = X##_f0 << (_FP_W_TYPE_SIZE - 1); \ + _FP_DIV_MEAT_2_udiv_n_f2 = X##_f1 >> 1; \ + _FP_DIV_MEAT_2_udiv_n_f1 \ + = X##_f1 << (_FP_W_TYPE_SIZE - 1) | X##_f0 >> 1; \ + _FP_DIV_MEAT_2_udiv_n_f0 \ + = X##_f0 << (_FP_W_TYPE_SIZE - 1); \ } \ else \ { \ R##_e--; \ - _n_f2 = X##_f1; \ - _n_f1 = X##_f0; \ - _n_f0 = 0; \ + _FP_DIV_MEAT_2_udiv_n_f2 = X##_f1; \ + _FP_DIV_MEAT_2_udiv_n_f1 = X##_f0; \ + _FP_DIV_MEAT_2_udiv_n_f0 = 0; \ } \ \ /* Normalize, i.e. make the most significant bit of the \ - denominator set. */ \ + denominator set. */ \ _FP_FRAC_SLL_2 (Y, _FP_WFRACXBITS_##fs); \ \ - udiv_qrnnd (R##_f1, _r_f1, _n_f2, _n_f1, Y##_f1); \ - umul_ppmm (_m_f1, _m_f0, R##_f1, Y##_f0); \ - _r_f0 = _n_f0; \ - if (_FP_FRAC_GT_2 (_m, _r)) \ + udiv_qrnnd (R##_f1, _FP_DIV_MEAT_2_udiv_r_f1, \ + _FP_DIV_MEAT_2_udiv_n_f2, _FP_DIV_MEAT_2_udiv_n_f1, \ + Y##_f1); \ + umul_ppmm (_FP_DIV_MEAT_2_udiv_m_f1, _FP_DIV_MEAT_2_udiv_m_f0, \ + R##_f1, Y##_f0); \ + _FP_DIV_MEAT_2_udiv_r_f0 = _FP_DIV_MEAT_2_udiv_n_f0; \ + if (_FP_FRAC_GT_2 (_FP_DIV_MEAT_2_udiv_m, _FP_DIV_MEAT_2_udiv_r)) \ { \ R##_f1--; \ - _FP_FRAC_ADD_2 (_r, Y, _r); \ - if (_FP_FRAC_GE_2 (_r, Y) && _FP_FRAC_GT_2 (_m, _r)) \ + _FP_FRAC_ADD_2 (_FP_DIV_MEAT_2_udiv_r, Y, \ + _FP_DIV_MEAT_2_udiv_r); \ + if (_FP_FRAC_GE_2 (_FP_DIV_MEAT_2_udiv_r, Y) \ + && _FP_FRAC_GT_2 (_FP_DIV_MEAT_2_udiv_m, \ + _FP_DIV_MEAT_2_udiv_r)) \ { \ R##_f1--; \ - _FP_FRAC_ADD_2 (_r, Y, _r); \ + _FP_FRAC_ADD_2 (_FP_DIV_MEAT_2_udiv_r, Y, \ + _FP_DIV_MEAT_2_udiv_r); \ } \ } \ - _FP_FRAC_DEC_2 (_r, _m); \ + _FP_FRAC_DEC_2 (_FP_DIV_MEAT_2_udiv_r, _FP_DIV_MEAT_2_udiv_m); \ \ - if (_r_f1 == Y##_f1) \ + if (_FP_DIV_MEAT_2_udiv_r_f1 == Y##_f1) \ { \ /* This is a special case, not an optimization \ - (_r/Y##_f1 would not fit into UWtype). \ - As _r is guaranteed to be < Y, R##_f0 can be either \ - (UWtype)-1 or (UWtype)-2. But as we know what kind \ - of bits it is (sticky, guard, round), we don't care. \ - We also don't care what the reminder is, because the \ - guard bit will be set anyway. -jj */ \ + (_FP_DIV_MEAT_2_udiv_r/Y##_f1 would not fit into UWtype). \ + As _FP_DIV_MEAT_2_udiv_r is guaranteed to be < Y, \ + R##_f0 can be either (UWtype)-1 or (UWtype)-2. But as we \ + know what kind of bits it is (sticky, guard, round), \ + we don't care. We also don't care what the reminder is, \ + because the guard bit will be set anyway. -jj */ \ R##_f0 = -1; \ } \ else \ { \ - udiv_qrnnd (R##_f0, _r_f1, _r_f1, _r_f0, Y##_f1); \ - umul_ppmm (_m_f1, _m_f0, R##_f0, Y##_f0); \ - _r_f0 = 0; \ - if (_FP_FRAC_GT_2 (_m, _r)) \ + udiv_qrnnd (R##_f0, _FP_DIV_MEAT_2_udiv_r_f1, \ + _FP_DIV_MEAT_2_udiv_r_f1, \ + _FP_DIV_MEAT_2_udiv_r_f0, Y##_f1); \ + umul_ppmm (_FP_DIV_MEAT_2_udiv_m_f1, \ + _FP_DIV_MEAT_2_udiv_m_f0, R##_f0, Y##_f0); \ + _FP_DIV_MEAT_2_udiv_r_f0 = 0; \ + if (_FP_FRAC_GT_2 (_FP_DIV_MEAT_2_udiv_m, \ + _FP_DIV_MEAT_2_udiv_r)) \ { \ R##_f0--; \ - _FP_FRAC_ADD_2 (_r, Y, _r); \ - if (_FP_FRAC_GE_2 (_r, Y) && _FP_FRAC_GT_2 (_m, _r)) \ + _FP_FRAC_ADD_2 (_FP_DIV_MEAT_2_udiv_r, Y, \ + _FP_DIV_MEAT_2_udiv_r); \ + if (_FP_FRAC_GE_2 (_FP_DIV_MEAT_2_udiv_r, Y) \ + && _FP_FRAC_GT_2 (_FP_DIV_MEAT_2_udiv_m, \ + _FP_DIV_MEAT_2_udiv_r)) \ { \ R##_f0--; \ - _FP_FRAC_ADD_2 (_r, Y, _r); \ + _FP_FRAC_ADD_2 (_FP_DIV_MEAT_2_udiv_r, Y, \ + _FP_DIV_MEAT_2_udiv_r); \ } \ } \ - if (!_FP_FRAC_EQ_2 (_r, _m)) \ + if (!_FP_FRAC_EQ_2 (_FP_DIV_MEAT_2_udiv_r, \ + _FP_DIV_MEAT_2_udiv_m)) \ R##_f0 |= _FP_WORK_STICKY; \ } \ } \ while (0) -/* - * Square root algorithms: - * We have just one right now, maybe Newton approximation - * should be added for those machines where division is fast. - */ +/* Square root algorithms: + We have just one right now, maybe Newton approximation + should be added for those machines where division is fast. */ #define _FP_SQRT_MEAT_2(R, S, T, X, q) \ do \ { \ while (q) \ { \ - T##_f1 = S##_f1 + q; \ + T##_f1 = S##_f1 + (q); \ if (T##_f1 <= X##_f1) \ { \ - S##_f1 = T##_f1 + q; \ + S##_f1 = T##_f1 + (q); \ X##_f1 -= T##_f1; \ - R##_f1 += q; \ + R##_f1 += (q); \ } \ _FP_FRAC_SLL_2 (X, 1); \ - q >>= 1; \ + (q) >>= 1; \ } \ - q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ - while (q != _FP_WORK_ROUND) \ + (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ + while ((q) != _FP_WORK_ROUND) \ { \ - T##_f0 = S##_f0 + q; \ + T##_f0 = S##_f0 + (q); \ T##_f1 = S##_f1; \ if (T##_f1 < X##_f1 \ || (T##_f1 == X##_f1 && T##_f0 <= X##_f0)) \ { \ - S##_f0 = T##_f0 + q; \ + S##_f0 = T##_f0 + (q); \ S##_f1 += (T##_f0 > S##_f0); \ _FP_FRAC_DEC_2 (X, T); \ - R##_f0 += q; \ + R##_f0 += (q); \ } \ _FP_FRAC_SLL_2 (X, 1); \ - q >>= 1; \ + (q) >>= 1; \ } \ if (X##_f0 | X##_f1) \ { \ @@ -622,34 +672,34 @@ while (0) -/* - * Assembly/disassembly for converting to/from integral types. - * No shifting or overflow handled here. - */ +/* Assembly/disassembly for converting to/from integral types. + No shifting or overflow handled here. */ #define _FP_FRAC_ASSEMBLE_2(r, X, rsize) \ - (void) ((rsize <= _FP_W_TYPE_SIZE) \ - ? ({ r = X##_f0; }) \ + (void) (((rsize) <= _FP_W_TYPE_SIZE) \ + ? ({ (r) = X##_f0; }) \ : ({ \ - r = X##_f1; \ - r <<= _FP_W_TYPE_SIZE; \ - r += X##_f0; \ + (r) = X##_f1; \ + (r) <<= _FP_W_TYPE_SIZE; \ + (r) += X##_f0; \ })) -#define _FP_FRAC_DISASSEMBLE_2(X, r, rsize) \ - do \ - { \ - X##_f0 = r; \ - X##_f1 = (rsize <= _FP_W_TYPE_SIZE ? 0 : r >> _FP_W_TYPE_SIZE); \ - } \ +#define _FP_FRAC_DISASSEMBLE_2(X, r, rsize) \ + do \ + { \ + X##_f0 = (r); \ + X##_f1 = ((rsize) <= _FP_W_TYPE_SIZE \ + ? 0 \ + : (r) >> _FP_W_TYPE_SIZE); \ + } \ while (0) -/* - * Convert FP values between word sizes - */ +/* Convert FP values between word sizes. */ #define _FP_FRAC_COPY_1_2(D, S) (D##_f = S##_f0) #define _FP_FRAC_COPY_2_1(D, S) ((D##_f0 = S##_f), (D##_f1 = 0)) #define _FP_FRAC_COPY_2_2(D, S) _FP_FRAC_COPY_2 (D, S) + +#endif /* !SOFT_FP_OP_2_H */ diff --git a/soft-fp/op-4.h b/soft-fp/op-4.h index a80bdb2f27..a5805170e4 100644 --- a/soft-fp/op-4.h +++ b/soft-fp/op-4.h @@ -1,6 +1,6 @@ /* Software floating-point emulation. Basic four-word fraction declaration and manipulation. - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com), Jakub Jelinek (jj@ultra.linux.cz), @@ -30,6 +30,9 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ +#ifndef SOFT_FP_OP_4_H +#define SOFT_FP_OP_4_H 1 + #define _FP_FRAC_DECL_4(X) _FP_W_TYPE X##_f[4] #define _FP_FRAC_COPY_4(D, S) \ (D##_f[0] = S##_f[0], D##_f[1] = S##_f[1], \ @@ -39,91 +42,121 @@ #define _FP_FRAC_LOW_4(X) (X##_f[0]) #define _FP_FRAC_WORD_4(X, w) (X##_f[w]) -#define _FP_FRAC_SLL_4(X, N) \ - do \ - { \ - _FP_I_TYPE _up, _down, _skip, _i; \ - _skip = (N) / _FP_W_TYPE_SIZE; \ - _up = (N) % _FP_W_TYPE_SIZE; \ - _down = _FP_W_TYPE_SIZE - _up; \ - if (!_up) \ - for (_i = 3; _i >= _skip; --_i) \ - X##_f[_i] = X##_f[_i-_skip]; \ - else \ - { \ - for (_i = 3; _i > _skip; --_i) \ - X##_f[_i] = (X##_f[_i-_skip] << _up \ - | X##_f[_i-_skip-1] >> _down); \ - X##_f[_i--] = X##_f[0] << _up; \ - } \ - for (; _i >= 0; --_i) \ - X##_f[_i] = 0; \ - } \ +#define _FP_FRAC_SLL_4(X, N) \ + do \ + { \ + _FP_I_TYPE _FP_FRAC_SLL_4_up, _FP_FRAC_SLL_4_down; \ + _FP_I_TYPE _FP_FRAC_SLL_4_skip, _FP_FRAC_SLL_4_i; \ + _FP_FRAC_SLL_4_skip = (N) / _FP_W_TYPE_SIZE; \ + _FP_FRAC_SLL_4_up = (N) % _FP_W_TYPE_SIZE; \ + _FP_FRAC_SLL_4_down = _FP_W_TYPE_SIZE - _FP_FRAC_SLL_4_up; \ + if (!_FP_FRAC_SLL_4_up) \ + for (_FP_FRAC_SLL_4_i = 3; \ + _FP_FRAC_SLL_4_i >= _FP_FRAC_SLL_4_skip; \ + --_FP_FRAC_SLL_4_i) \ + X##_f[_FP_FRAC_SLL_4_i] \ + = X##_f[_FP_FRAC_SLL_4_i-_FP_FRAC_SLL_4_skip]; \ + else \ + { \ + for (_FP_FRAC_SLL_4_i = 3; \ + _FP_FRAC_SLL_4_i > _FP_FRAC_SLL_4_skip; \ + --_FP_FRAC_SLL_4_i) \ + X##_f[_FP_FRAC_SLL_4_i] \ + = ((X##_f[_FP_FRAC_SLL_4_i-_FP_FRAC_SLL_4_skip] \ + << _FP_FRAC_SLL_4_up) \ + | (X##_f[_FP_FRAC_SLL_4_i-_FP_FRAC_SLL_4_skip-1] \ + >> _FP_FRAC_SLL_4_down)); \ + X##_f[_FP_FRAC_SLL_4_i--] = X##_f[0] << _FP_FRAC_SLL_4_up; \ + } \ + for (; _FP_FRAC_SLL_4_i >= 0; --_FP_FRAC_SLL_4_i) \ + X##_f[_FP_FRAC_SLL_4_i] = 0; \ + } \ while (0) -/* This one was broken too */ -#define _FP_FRAC_SRL_4(X, N) \ - do \ - { \ - _FP_I_TYPE _up, _down, _skip, _i; \ - _skip = (N) / _FP_W_TYPE_SIZE; \ - _down = (N) % _FP_W_TYPE_SIZE; \ - _up = _FP_W_TYPE_SIZE - _down; \ - if (!_down) \ - for (_i = 0; _i <= 3-_skip; ++_i) \ - X##_f[_i] = X##_f[_i+_skip]; \ - else \ - { \ - for (_i = 0; _i < 3-_skip; ++_i) \ - X##_f[_i] = (X##_f[_i+_skip] >> _down \ - | X##_f[_i+_skip+1] << _up); \ - X##_f[_i++] = X##_f[3] >> _down; \ - } \ - for (; _i < 4; ++_i) \ - X##_f[_i] = 0; \ - } \ +/* This one was broken too. */ +#define _FP_FRAC_SRL_4(X, N) \ + do \ + { \ + _FP_I_TYPE _FP_FRAC_SRL_4_up, _FP_FRAC_SRL_4_down; \ + _FP_I_TYPE _FP_FRAC_SRL_4_skip, _FP_FRAC_SRL_4_i; \ + _FP_FRAC_SRL_4_skip = (N) / _FP_W_TYPE_SIZE; \ + _FP_FRAC_SRL_4_down = (N) % _FP_W_TYPE_SIZE; \ + _FP_FRAC_SRL_4_up = _FP_W_TYPE_SIZE - _FP_FRAC_SRL_4_down; \ + if (!_FP_FRAC_SRL_4_down) \ + for (_FP_FRAC_SRL_4_i = 0; \ + _FP_FRAC_SRL_4_i <= 3-_FP_FRAC_SRL_4_skip; \ + ++_FP_FRAC_SRL_4_i) \ + X##_f[_FP_FRAC_SRL_4_i] \ + = X##_f[_FP_FRAC_SRL_4_i+_FP_FRAC_SRL_4_skip]; \ + else \ + { \ + for (_FP_FRAC_SRL_4_i = 0; \ + _FP_FRAC_SRL_4_i < 3-_FP_FRAC_SRL_4_skip; \ + ++_FP_FRAC_SRL_4_i) \ + X##_f[_FP_FRAC_SRL_4_i] \ + = ((X##_f[_FP_FRAC_SRL_4_i+_FP_FRAC_SRL_4_skip] \ + >> _FP_FRAC_SRL_4_down) \ + | (X##_f[_FP_FRAC_SRL_4_i+_FP_FRAC_SRL_4_skip+1] \ + << _FP_FRAC_SRL_4_up)); \ + X##_f[_FP_FRAC_SRL_4_i++] = X##_f[3] >> _FP_FRAC_SRL_4_down; \ + } \ + for (; _FP_FRAC_SRL_4_i < 4; ++_FP_FRAC_SRL_4_i) \ + X##_f[_FP_FRAC_SRL_4_i] = 0; \ + } \ while (0) /* Right shift with sticky-lsb. - * What this actually means is that we do a standard right-shift, - * but that if any of the bits that fall off the right hand side - * were one then we always set the LSbit. - */ -#define _FP_FRAC_SRST_4(X, S, N, size) \ - do \ - { \ - _FP_I_TYPE _up, _down, _skip, _i; \ - _FP_W_TYPE _s; \ - _skip = (N) / _FP_W_TYPE_SIZE; \ - _down = (N) % _FP_W_TYPE_SIZE; \ - _up = _FP_W_TYPE_SIZE - _down; \ - for (_s = _i = 0; _i < _skip; ++_i) \ - _s |= X##_f[_i]; \ - if (!_down) \ - for (_i = 0; _i <= 3-_skip; ++_i) \ - X##_f[_i] = X##_f[_i+_skip]; \ - else \ - { \ - _s |= X##_f[_i] << _up; \ - for (_i = 0; _i < 3-_skip; ++_i) \ - X##_f[_i] = (X##_f[_i+_skip] >> _down \ - | X##_f[_i+_skip+1] << _up); \ - X##_f[_i++] = X##_f[3] >> _down; \ - } \ - for (; _i < 4; ++_i) \ - X##_f[_i] = 0; \ - S = (_s != 0); \ - } \ + What this actually means is that we do a standard right-shift, + but that if any of the bits that fall off the right hand side + were one then we always set the LSbit. */ +#define _FP_FRAC_SRST_4(X, S, N, size) \ + do \ + { \ + _FP_I_TYPE _FP_FRAC_SRST_4_up, _FP_FRAC_SRST_4_down; \ + _FP_I_TYPE _FP_FRAC_SRST_4_skip, _FP_FRAC_SRST_4_i; \ + _FP_W_TYPE _FP_FRAC_SRST_4_s; \ + _FP_FRAC_SRST_4_skip = (N) / _FP_W_TYPE_SIZE; \ + _FP_FRAC_SRST_4_down = (N) % _FP_W_TYPE_SIZE; \ + _FP_FRAC_SRST_4_up = _FP_W_TYPE_SIZE - _FP_FRAC_SRST_4_down; \ + for (_FP_FRAC_SRST_4_s = _FP_FRAC_SRST_4_i = 0; \ + _FP_FRAC_SRST_4_i < _FP_FRAC_SRST_4_skip; \ + ++_FP_FRAC_SRST_4_i) \ + _FP_FRAC_SRST_4_s |= X##_f[_FP_FRAC_SRST_4_i]; \ + if (!_FP_FRAC_SRST_4_down) \ + for (_FP_FRAC_SRST_4_i = 0; \ + _FP_FRAC_SRST_4_i <= 3-_FP_FRAC_SRST_4_skip; \ + ++_FP_FRAC_SRST_4_i) \ + X##_f[_FP_FRAC_SRST_4_i] \ + = X##_f[_FP_FRAC_SRST_4_i+_FP_FRAC_SRST_4_skip]; \ + else \ + { \ + _FP_FRAC_SRST_4_s \ + |= X##_f[_FP_FRAC_SRST_4_i] << _FP_FRAC_SRST_4_up; \ + for (_FP_FRAC_SRST_4_i = 0; \ + _FP_FRAC_SRST_4_i < 3-_FP_FRAC_SRST_4_skip; \ + ++_FP_FRAC_SRST_4_i) \ + X##_f[_FP_FRAC_SRST_4_i] \ + = ((X##_f[_FP_FRAC_SRST_4_i+_FP_FRAC_SRST_4_skip] \ + >> _FP_FRAC_SRST_4_down) \ + | (X##_f[_FP_FRAC_SRST_4_i+_FP_FRAC_SRST_4_skip+1] \ + << _FP_FRAC_SRST_4_up)); \ + X##_f[_FP_FRAC_SRST_4_i++] \ + = X##_f[3] >> _FP_FRAC_SRST_4_down; \ + } \ + for (; _FP_FRAC_SRST_4_i < 4; ++_FP_FRAC_SRST_4_i) \ + X##_f[_FP_FRAC_SRST_4_i] = 0; \ + S = (_FP_FRAC_SRST_4_s != 0); \ + } \ while (0) -#define _FP_FRAC_SRS_4(X, N, size) \ - do \ - { \ - int _sticky; \ - _FP_FRAC_SRST_4 (X, _sticky, N, size); \ - X##_f[0] |= _sticky; \ - } \ +#define _FP_FRAC_SRS_4(X, N, size) \ + do \ + { \ + int _FP_FRAC_SRS_4_sticky; \ + _FP_FRAC_SRST_4 (X, _FP_FRAC_SRS_4_sticky, (N), (size)); \ + X##_f[0] |= _FP_FRAC_SRS_4_sticky; \ + } \ while (0) #define _FP_FRAC_ADD_4(R, X, Y) \ @@ -181,166 +214,211 @@ do \ { \ if (X##_f[3]) \ - __FP_CLZ (R, X##_f[3]); \ + __FP_CLZ ((R), X##_f[3]); \ else if (X##_f[2]) \ { \ - __FP_CLZ (R, X##_f[2]); \ - R += _FP_W_TYPE_SIZE; \ + __FP_CLZ ((R), X##_f[2]); \ + (R) += _FP_W_TYPE_SIZE; \ } \ else if (X##_f[1]) \ { \ - __FP_CLZ (R, X##_f[1]); \ - R += _FP_W_TYPE_SIZE*2; \ + __FP_CLZ ((R), X##_f[1]); \ + (R) += _FP_W_TYPE_SIZE*2; \ } \ else \ { \ - __FP_CLZ (R, X##_f[0]); \ - R += _FP_W_TYPE_SIZE*3; \ + __FP_CLZ ((R), X##_f[0]); \ + (R) += _FP_W_TYPE_SIZE*3; \ } \ } \ while (0) -#define _FP_UNPACK_RAW_4(fs, X, val) \ - do \ - { \ - union _FP_UNION_##fs _flo; \ - _flo.flt = (val); \ - X##_f[0] = _flo.bits.frac0; \ - X##_f[1] = _flo.bits.frac1; \ - X##_f[2] = _flo.bits.frac2; \ - X##_f[3] = _flo.bits.frac3; \ - X##_e = _flo.bits.exp; \ - X##_s = _flo.bits.sign; \ - } \ +#define _FP_UNPACK_RAW_4(fs, X, val) \ + do \ + { \ + union _FP_UNION_##fs _FP_UNPACK_RAW_4_flo; \ + _FP_UNPACK_RAW_4_flo.flt = (val); \ + X##_f[0] = _FP_UNPACK_RAW_4_flo.bits.frac0; \ + X##_f[1] = _FP_UNPACK_RAW_4_flo.bits.frac1; \ + X##_f[2] = _FP_UNPACK_RAW_4_flo.bits.frac2; \ + X##_f[3] = _FP_UNPACK_RAW_4_flo.bits.frac3; \ + X##_e = _FP_UNPACK_RAW_4_flo.bits.exp; \ + X##_s = _FP_UNPACK_RAW_4_flo.bits.sign; \ + } \ while (0) -#define _FP_UNPACK_RAW_4_P(fs, X, val) \ - do \ - { \ - union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val); \ - \ - X##_f[0] = _flo->bits.frac0; \ - X##_f[1] = _flo->bits.frac1; \ - X##_f[2] = _flo->bits.frac2; \ - X##_f[3] = _flo->bits.frac3; \ - X##_e = _flo->bits.exp; \ - X##_s = _flo->bits.sign; \ - } \ +#define _FP_UNPACK_RAW_4_P(fs, X, val) \ + do \ + { \ + union _FP_UNION_##fs *_FP_UNPACK_RAW_4_P_flo \ + = (union _FP_UNION_##fs *) (val); \ + \ + X##_f[0] = _FP_UNPACK_RAW_4_P_flo->bits.frac0; \ + X##_f[1] = _FP_UNPACK_RAW_4_P_flo->bits.frac1; \ + X##_f[2] = _FP_UNPACK_RAW_4_P_flo->bits.frac2; \ + X##_f[3] = _FP_UNPACK_RAW_4_P_flo->bits.frac3; \ + X##_e = _FP_UNPACK_RAW_4_P_flo->bits.exp; \ + X##_s = _FP_UNPACK_RAW_4_P_flo->bits.sign; \ + } \ while (0) #define _FP_PACK_RAW_4(fs, val, X) \ do \ { \ - union _FP_UNION_##fs _flo; \ - _flo.bits.frac0 = X##_f[0]; \ - _flo.bits.frac1 = X##_f[1]; \ - _flo.bits.frac2 = X##_f[2]; \ - _flo.bits.frac3 = X##_f[3]; \ - _flo.bits.exp = X##_e; \ - _flo.bits.sign = X##_s; \ - (val) = _flo.flt; \ + union _FP_UNION_##fs _FP_PACK_RAW_4_flo; \ + _FP_PACK_RAW_4_flo.bits.frac0 = X##_f[0]; \ + _FP_PACK_RAW_4_flo.bits.frac1 = X##_f[1]; \ + _FP_PACK_RAW_4_flo.bits.frac2 = X##_f[2]; \ + _FP_PACK_RAW_4_flo.bits.frac3 = X##_f[3]; \ + _FP_PACK_RAW_4_flo.bits.exp = X##_e; \ + _FP_PACK_RAW_4_flo.bits.sign = X##_s; \ + (val) = _FP_PACK_RAW_4_flo.flt; \ } \ while (0) -#define _FP_PACK_RAW_4_P(fs, val, X) \ - do \ - { \ - union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val); \ - \ - _flo->bits.frac0 = X##_f[0]; \ - _flo->bits.frac1 = X##_f[1]; \ - _flo->bits.frac2 = X##_f[2]; \ - _flo->bits.frac3 = X##_f[3]; \ - _flo->bits.exp = X##_e; \ - _flo->bits.sign = X##_s; \ - } \ +#define _FP_PACK_RAW_4_P(fs, val, X) \ + do \ + { \ + union _FP_UNION_##fs *_FP_PACK_RAW_4_P_flo \ + = (union _FP_UNION_##fs *) (val); \ + \ + _FP_PACK_RAW_4_P_flo->bits.frac0 = X##_f[0]; \ + _FP_PACK_RAW_4_P_flo->bits.frac1 = X##_f[1]; \ + _FP_PACK_RAW_4_P_flo->bits.frac2 = X##_f[2]; \ + _FP_PACK_RAW_4_P_flo->bits.frac3 = X##_f[3]; \ + _FP_PACK_RAW_4_P_flo->bits.exp = X##_e; \ + _FP_PACK_RAW_4_P_flo->bits.sign = X##_s; \ + } \ while (0) -/* - * Multiplication algorithms: - */ +/* Multiplication algorithms: */ /* Given a 1W * 1W => 2W primitive, do the extended multiplication. */ #define _FP_MUL_MEAT_DW_4_wide(wfracbits, R, X, Y, doit) \ do \ { \ - _FP_FRAC_DECL_2 (_b); \ - _FP_FRAC_DECL_2 (_c); \ - _FP_FRAC_DECL_2 (_d); \ - _FP_FRAC_DECL_2 (_e); \ - _FP_FRAC_DECL_2 (_f); \ + _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_4_wide_b); \ + _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_4_wide_c); \ + _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_4_wide_d); \ + _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_4_wide_e); \ + _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_4_wide_f); \ \ - doit (_FP_FRAC_WORD_8 (R, 1), _FP_FRAC_WORD_8 (R, 0), X##_f[0], Y##_f[0]); \ - doit (_b_f1, _b_f0, X##_f[0], Y##_f[1]); \ - doit (_c_f1, _c_f0, X##_f[1], Y##_f[0]); \ - doit (_d_f1, _d_f0, X##_f[1], Y##_f[1]); \ - doit (_e_f1, _e_f0, X##_f[0], Y##_f[2]); \ - doit (_f_f1, _f_f0, X##_f[2], Y##_f[0]); \ + doit (_FP_FRAC_WORD_8 (R, 1), _FP_FRAC_WORD_8 (R, 0), \ + X##_f[0], Y##_f[0]); \ + doit (_FP_MUL_MEAT_DW_4_wide_b_f1, _FP_MUL_MEAT_DW_4_wide_b_f0, \ + X##_f[0], Y##_f[1]); \ + doit (_FP_MUL_MEAT_DW_4_wide_c_f1, _FP_MUL_MEAT_DW_4_wide_c_f0, \ + X##_f[1], Y##_f[0]); \ + doit (_FP_MUL_MEAT_DW_4_wide_d_f1, _FP_MUL_MEAT_DW_4_wide_d_f0, \ + X##_f[1], Y##_f[1]); \ + doit (_FP_MUL_MEAT_DW_4_wide_e_f1, _FP_MUL_MEAT_DW_4_wide_e_f0, \ + X##_f[0], Y##_f[2]); \ + doit (_FP_MUL_MEAT_DW_4_wide_f_f1, _FP_MUL_MEAT_DW_4_wide_f_f0, \ + X##_f[2], Y##_f[0]); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 3), _FP_FRAC_WORD_8 (R, 2), \ - _FP_FRAC_WORD_8 (R, 1), 0, _b_f1, _b_f0, \ + _FP_FRAC_WORD_8 (R, 1), 0, \ + _FP_MUL_MEAT_DW_4_wide_b_f1, \ + _FP_MUL_MEAT_DW_4_wide_b_f0, \ 0, 0, _FP_FRAC_WORD_8 (R, 1)); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 3), _FP_FRAC_WORD_8 (R, 2), \ - _FP_FRAC_WORD_8 (R, 1), 0, _c_f1, _c_f0, \ + _FP_FRAC_WORD_8 (R, 1), 0, \ + _FP_MUL_MEAT_DW_4_wide_c_f1, \ + _FP_MUL_MEAT_DW_4_wide_c_f0, \ _FP_FRAC_WORD_8 (R, 3), _FP_FRAC_WORD_8 (R, 2), \ _FP_FRAC_WORD_8 (R, 1)); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3), \ - _FP_FRAC_WORD_8 (R, 2), 0, _d_f1, _d_f0, \ + _FP_FRAC_WORD_8 (R, 2), 0, \ + _FP_MUL_MEAT_DW_4_wide_d_f1, \ + _FP_MUL_MEAT_DW_4_wide_d_f0, \ 0, _FP_FRAC_WORD_8 (R, 3), _FP_FRAC_WORD_8 (R, 2)); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3), \ - _FP_FRAC_WORD_8 (R, 2), 0, _e_f1, _e_f0, \ + _FP_FRAC_WORD_8 (R, 2), 0, \ + _FP_MUL_MEAT_DW_4_wide_e_f1, \ + _FP_MUL_MEAT_DW_4_wide_e_f0, \ _FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3), \ _FP_FRAC_WORD_8 (R, 2)); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3), \ - _FP_FRAC_WORD_8 (R, 2), 0, _f_f1, _f_f0, \ + _FP_FRAC_WORD_8 (R, 2), 0, \ + _FP_MUL_MEAT_DW_4_wide_f_f1, \ + _FP_MUL_MEAT_DW_4_wide_f_f0, \ _FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3), \ _FP_FRAC_WORD_8 (R, 2)); \ - doit (_b_f1, _b_f0, X##_f[0], Y##_f[3]); \ - doit (_c_f1, _c_f0, X##_f[3], Y##_f[0]); \ - doit (_d_f1, _d_f0, X##_f[1], Y##_f[2]); \ - doit (_e_f1, _e_f0, X##_f[2], Y##_f[1]); \ + doit (_FP_MUL_MEAT_DW_4_wide_b_f1, \ + _FP_MUL_MEAT_DW_4_wide_b_f0, X##_f[0], Y##_f[3]); \ + doit (_FP_MUL_MEAT_DW_4_wide_c_f1, \ + _FP_MUL_MEAT_DW_4_wide_c_f0, X##_f[3], Y##_f[0]); \ + doit (_FP_MUL_MEAT_DW_4_wide_d_f1, _FP_MUL_MEAT_DW_4_wide_d_f0, \ + X##_f[1], Y##_f[2]); \ + doit (_FP_MUL_MEAT_DW_4_wide_e_f1, _FP_MUL_MEAT_DW_4_wide_e_f0, \ + X##_f[2], Y##_f[1]); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4), \ - _FP_FRAC_WORD_8 (R, 3), 0, _b_f1, _b_f0, \ + _FP_FRAC_WORD_8 (R, 3), 0, \ + _FP_MUL_MEAT_DW_4_wide_b_f1, \ + _FP_MUL_MEAT_DW_4_wide_b_f0, \ 0, _FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3)); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4), \ - _FP_FRAC_WORD_8 (R, 3), 0, _c_f1, _c_f0, \ + _FP_FRAC_WORD_8 (R, 3), 0, \ + _FP_MUL_MEAT_DW_4_wide_c_f1, \ + _FP_MUL_MEAT_DW_4_wide_c_f0, \ _FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4), \ _FP_FRAC_WORD_8 (R, 3)); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4), \ - _FP_FRAC_WORD_8 (R, 3), 0, _d_f1, _d_f0, \ + _FP_FRAC_WORD_8 (R, 3), 0, \ + _FP_MUL_MEAT_DW_4_wide_d_f1, \ + _FP_MUL_MEAT_DW_4_wide_d_f0, \ _FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4), \ _FP_FRAC_WORD_8 (R, 3)); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4), \ - _FP_FRAC_WORD_8 (R, 3), 0, _e_f1, _e_f0, \ + _FP_FRAC_WORD_8 (R, 3), 0, \ + _FP_MUL_MEAT_DW_4_wide_e_f1, \ + _FP_MUL_MEAT_DW_4_wide_e_f0, \ _FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4), \ _FP_FRAC_WORD_8 (R, 3)); \ - doit (_b_f1, _b_f0, X##_f[2], Y##_f[2]); \ - doit (_c_f1, _c_f0, X##_f[1], Y##_f[3]); \ - doit (_d_f1, _d_f0, X##_f[3], Y##_f[1]); \ - doit (_e_f1, _e_f0, X##_f[2], Y##_f[3]); \ - doit (_f_f1, _f_f0, X##_f[3], Y##_f[2]); \ + doit (_FP_MUL_MEAT_DW_4_wide_b_f1, _FP_MUL_MEAT_DW_4_wide_b_f0, \ + X##_f[2], Y##_f[2]); \ + doit (_FP_MUL_MEAT_DW_4_wide_c_f1, _FP_MUL_MEAT_DW_4_wide_c_f0, \ + X##_f[1], Y##_f[3]); \ + doit (_FP_MUL_MEAT_DW_4_wide_d_f1, _FP_MUL_MEAT_DW_4_wide_d_f0, \ + X##_f[3], Y##_f[1]); \ + doit (_FP_MUL_MEAT_DW_4_wide_e_f1, _FP_MUL_MEAT_DW_4_wide_e_f0, \ + X##_f[2], Y##_f[3]); \ + doit (_FP_MUL_MEAT_DW_4_wide_f_f1, _FP_MUL_MEAT_DW_4_wide_f_f0, \ + X##_f[3], Y##_f[2]); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5), \ - _FP_FRAC_WORD_8 (R, 4), 0, _b_f1, _b_f0, \ + _FP_FRAC_WORD_8 (R, 4), 0, \ + _FP_MUL_MEAT_DW_4_wide_b_f1, \ + _FP_MUL_MEAT_DW_4_wide_b_f0, \ 0, _FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4)); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5), \ - _FP_FRAC_WORD_8 (R, 4), 0, _c_f1, _c_f0, \ + _FP_FRAC_WORD_8 (R, 4), 0, \ + _FP_MUL_MEAT_DW_4_wide_c_f1, \ + _FP_MUL_MEAT_DW_4_wide_c_f0, \ _FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5), \ _FP_FRAC_WORD_8 (R, 4)); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5), \ - _FP_FRAC_WORD_8 (R, 4), 0, _d_f1, _d_f0, \ + _FP_FRAC_WORD_8 (R, 4), 0, \ + _FP_MUL_MEAT_DW_4_wide_d_f1, \ + _FP_MUL_MEAT_DW_4_wide_d_f0, \ _FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5), \ _FP_FRAC_WORD_8 (R, 4)); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6), \ - _FP_FRAC_WORD_8 (R, 5), 0, _e_f1, _e_f0, \ + _FP_FRAC_WORD_8 (R, 5), 0, \ + _FP_MUL_MEAT_DW_4_wide_e_f1, \ + _FP_MUL_MEAT_DW_4_wide_e_f0, \ 0, _FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5)); \ __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6), \ - _FP_FRAC_WORD_8 (R, 5), 0, _f_f1, _f_f0, \ + _FP_FRAC_WORD_8 (R, 5), 0, \ + _FP_MUL_MEAT_DW_4_wide_f_f1, \ + _FP_MUL_MEAT_DW_4_wide_f_f0, \ _FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6), \ _FP_FRAC_WORD_8 (R, 5)); \ - doit (_b_f1, _b_f0, X##_f[3], Y##_f[3]); \ + doit (_FP_MUL_MEAT_DW_4_wide_b_f1, _FP_MUL_MEAT_DW_4_wide_b_f0, \ + X##_f[3], Y##_f[3]); \ __FP_FRAC_ADD_2 (_FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6), \ - _b_f1, _b_f0, \ + _FP_MUL_MEAT_DW_4_wide_b_f1, \ + _FP_MUL_MEAT_DW_4_wide_b_f0, \ _FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6)); \ } \ while (0) @@ -348,16 +426,20 @@ #define _FP_MUL_MEAT_4_wide(wfracbits, R, X, Y, doit) \ do \ { \ - _FP_FRAC_DECL_8 (_z); \ + _FP_FRAC_DECL_8 (_FP_MUL_MEAT_4_wide_z); \ \ - _FP_MUL_MEAT_DW_4_wide (wfracbits, _z, X, Y, doit); \ + _FP_MUL_MEAT_DW_4_wide ((wfracbits), _FP_MUL_MEAT_4_wide_z, \ + X, Y, doit); \ \ /* Normalize since we know where the msb of the multiplicands \ were (bit B), we know that the msb of the of the product is \ at either 2B or 2B-1. */ \ - _FP_FRAC_SRS_8 (_z, wfracbits-1, 2*wfracbits); \ - __FP_FRAC_SET_4 (R, _FP_FRAC_WORD_8 (_z, 3), _FP_FRAC_WORD_8 (_z, 2), \ - _FP_FRAC_WORD_8 (_z, 1), _FP_FRAC_WORD_8 (_z, 0)); \ + _FP_FRAC_SRS_8 (_FP_MUL_MEAT_4_wide_z, (wfracbits)-1, \ + 2*(wfracbits)); \ + __FP_FRAC_SET_4 (R, _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_wide_z, 3), \ + _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_wide_z, 2), \ + _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_wide_z, 1), \ + _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_wide_z, 0)); \ } \ while (0) @@ -371,101 +453,110 @@ #define _FP_MUL_MEAT_4_gmp(wfracbits, R, X, Y) \ do \ { \ - _FP_FRAC_DECL_8 (_z); \ + _FP_FRAC_DECL_8 (_FP_MUL_MEAT_4_gmp_z); \ \ - _FP_MUL_MEAT_DW_4_gmp (wfracbits, _z, X, Y); \ + _FP_MUL_MEAT_DW_4_gmp ((wfracbits), _FP_MUL_MEAT_4_gmp_z, X, Y); \ \ /* Normalize since we know where the msb of the multiplicands \ were (bit B), we know that the msb of the of the product is \ at either 2B or 2B-1. */ \ - _FP_FRAC_SRS_8 (_z, wfracbits-1, 2*wfracbits); \ - __FP_FRAC_SET_4 (R, _FP_FRAC_WORD_8 (_z, 3), _FP_FRAC_WORD_8 (_z, 2), \ - _FP_FRAC_WORD_8 (_z, 1), _FP_FRAC_WORD_8 (_z, 0)); \ + _FP_FRAC_SRS_8 (_FP_MUL_MEAT_4_gmp_z, (wfracbits)-1, \ + 2*(wfracbits)); \ + __FP_FRAC_SET_4 (R, _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_gmp_z, 3), \ + _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_gmp_z, 2), \ + _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_gmp_z, 1), \ + _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_gmp_z, 0)); \ } \ while (0) -/* - * Helper utility for _FP_DIV_MEAT_4_udiv: - * pppp = m * nnn - */ +/* Helper utility for _FP_DIV_MEAT_4_udiv: + * pppp = m * nnn. */ #define umul_ppppmnnn(p3, p2, p1, p0, m, n2, n1, n0) \ do \ { \ - UWtype _t; \ + UWtype umul_ppppmnnn_t; \ umul_ppmm (p1, p0, m, n0); \ - umul_ppmm (p2, _t, m, n1); \ - __FP_FRAC_ADDI_2 (p2, p1, _t); \ - umul_ppmm (p3, _t, m, n2); \ - __FP_FRAC_ADDI_2 (p3, p2, _t); \ + umul_ppmm (p2, umul_ppppmnnn_t, m, n1); \ + __FP_FRAC_ADDI_2 (p2, p1, umul_ppppmnnn_t); \ + umul_ppmm (p3, umul_ppppmnnn_t, m, n2); \ + __FP_FRAC_ADDI_2 (p3, p2, umul_ppppmnnn_t); \ } \ while (0) -/* - * Division algorithms: - */ +/* Division algorithms: */ #define _FP_DIV_MEAT_4_udiv(fs, R, X, Y) \ do \ { \ - int _i; \ - _FP_FRAC_DECL_4 (_n); \ - _FP_FRAC_DECL_4 (_m); \ - _FP_FRAC_SET_4 (_n, _FP_ZEROFRAC_4); \ + int _FP_DIV_MEAT_4_udiv_i; \ + _FP_FRAC_DECL_4 (_FP_DIV_MEAT_4_udiv_n); \ + _FP_FRAC_DECL_4 (_FP_DIV_MEAT_4_udiv_m); \ + _FP_FRAC_SET_4 (_FP_DIV_MEAT_4_udiv_n, _FP_ZEROFRAC_4); \ if (_FP_FRAC_GE_4 (X, Y)) \ { \ - _n_f[3] = X##_f[0] << (_FP_W_TYPE_SIZE - 1); \ + _FP_DIV_MEAT_4_udiv_n_f[3] \ + = X##_f[0] << (_FP_W_TYPE_SIZE - 1); \ _FP_FRAC_SRL_4 (X, 1); \ } \ else \ R##_e--; \ \ /* Normalize, i.e. make the most significant bit of the \ - denominator set. */ \ + denominator set. */ \ _FP_FRAC_SLL_4 (Y, _FP_WFRACXBITS_##fs); \ \ - for (_i = 3; ; _i--) \ + for (_FP_DIV_MEAT_4_udiv_i = 3; ; _FP_DIV_MEAT_4_udiv_i--) \ { \ if (X##_f[3] == Y##_f[3]) \ { \ /* This is a special case, not an optimization \ (X##_f[3]/Y##_f[3] would not fit into UWtype). \ - As X## is guaranteed to be < Y, R##_f[_i] can be either \ + As X## is guaranteed to be < Y, \ + R##_f[_FP_DIV_MEAT_4_udiv_i] can be either \ (UWtype)-1 or (UWtype)-2. */ \ - R##_f[_i] = -1; \ - if (!_i) \ + R##_f[_FP_DIV_MEAT_4_udiv_i] = -1; \ + if (!_FP_DIV_MEAT_4_udiv_i) \ break; \ __FP_FRAC_SUB_4 (X##_f[3], X##_f[2], X##_f[1], X##_f[0], \ Y##_f[2], Y##_f[1], Y##_f[0], 0, \ - X##_f[2], X##_f[1], X##_f[0], _n_f[_i]); \ + X##_f[2], X##_f[1], X##_f[0], \ + _FP_DIV_MEAT_4_udiv_n_f[_FP_DIV_MEAT_4_udiv_i]); \ _FP_FRAC_SUB_4 (X, Y, X); \ if (X##_f[3] > Y##_f[3]) \ { \ - R##_f[_i] = -2; \ + R##_f[_FP_DIV_MEAT_4_udiv_i] = -2; \ _FP_FRAC_ADD_4 (X, Y, X); \ } \ } \ else \ { \ - udiv_qrnnd (R##_f[_i], X##_f[3], X##_f[3], X##_f[2], Y##_f[3]); \ - umul_ppppmnnn (_m_f[3], _m_f[2], _m_f[1], _m_f[0], \ - R##_f[_i], Y##_f[2], Y##_f[1], Y##_f[0]); \ + udiv_qrnnd (R##_f[_FP_DIV_MEAT_4_udiv_i], \ + X##_f[3], X##_f[3], X##_f[2], Y##_f[3]); \ + umul_ppppmnnn (_FP_DIV_MEAT_4_udiv_m_f[3], \ + _FP_DIV_MEAT_4_udiv_m_f[2], \ + _FP_DIV_MEAT_4_udiv_m_f[1], \ + _FP_DIV_MEAT_4_udiv_m_f[0], \ + R##_f[_FP_DIV_MEAT_4_udiv_i], \ + Y##_f[2], Y##_f[1], Y##_f[0]); \ X##_f[2] = X##_f[1]; \ X##_f[1] = X##_f[0]; \ - X##_f[0] = _n_f[_i]; \ - if (_FP_FRAC_GT_4 (_m, X)) \ + X##_f[0] \ + = _FP_DIV_MEAT_4_udiv_n_f[_FP_DIV_MEAT_4_udiv_i]; \ + if (_FP_FRAC_GT_4 (_FP_DIV_MEAT_4_udiv_m, X)) \ { \ - R##_f[_i]--; \ + R##_f[_FP_DIV_MEAT_4_udiv_i]--; \ _FP_FRAC_ADD_4 (X, Y, X); \ - if (_FP_FRAC_GE_4 (X, Y) && _FP_FRAC_GT_4 (_m, X)) \ + if (_FP_FRAC_GE_4 (X, Y) \ + && _FP_FRAC_GT_4 (_FP_DIV_MEAT_4_udiv_m, X)) \ { \ - R##_f[_i]--; \ + R##_f[_FP_DIV_MEAT_4_udiv_i]--; \ _FP_FRAC_ADD_4 (X, Y, X); \ } \ } \ - _FP_FRAC_DEC_4 (X, _m); \ - if (!_i) \ + _FP_FRAC_DEC_4 (X, _FP_DIV_MEAT_4_udiv_m); \ + if (!_FP_DIV_MEAT_4_udiv_i) \ { \ - if (!_FP_FRAC_EQ_4 (X, _m)) \ + if (!_FP_FRAC_EQ_4 (X, _FP_DIV_MEAT_4_udiv_m)) \ R##_f[0] |= _FP_WORK_STICKY; \ break; \ } \ @@ -475,48 +566,46 @@ while (0) -/* - * Square root algorithms: - * We have just one right now, maybe Newton approximation - * should be added for those machines where division is fast. - */ +/* Square root algorithms: + We have just one right now, maybe Newton approximation + should be added for those machines where division is fast. */ #define _FP_SQRT_MEAT_4(R, S, T, X, q) \ do \ { \ while (q) \ { \ - T##_f[3] = S##_f[3] + q; \ + T##_f[3] = S##_f[3] + (q); \ if (T##_f[3] <= X##_f[3]) \ { \ - S##_f[3] = T##_f[3] + q; \ + S##_f[3] = T##_f[3] + (q); \ X##_f[3] -= T##_f[3]; \ - R##_f[3] += q; \ + R##_f[3] += (q); \ } \ _FP_FRAC_SLL_4 (X, 1); \ - q >>= 1; \ + (q) >>= 1; \ } \ - q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ + (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ while (q) \ { \ - T##_f[2] = S##_f[2] + q; \ + T##_f[2] = S##_f[2] + (q); \ T##_f[3] = S##_f[3]; \ if (T##_f[3] < X##_f[3] \ || (T##_f[3] == X##_f[3] && T##_f[2] <= X##_f[2])) \ { \ - S##_f[2] = T##_f[2] + q; \ + S##_f[2] = T##_f[2] + (q); \ S##_f[3] += (T##_f[2] > S##_f[2]); \ __FP_FRAC_DEC_2 (X##_f[3], X##_f[2], \ T##_f[3], T##_f[2]); \ - R##_f[2] += q; \ + R##_f[2] += (q); \ } \ _FP_FRAC_SLL_4 (X, 1); \ - q >>= 1; \ + (q) >>= 1; \ } \ - q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ + (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ while (q) \ { \ - T##_f[1] = S##_f[1] + q; \ + T##_f[1] = S##_f[1] + (q); \ T##_f[2] = S##_f[2]; \ T##_f[3] = S##_f[3]; \ if (T##_f[3] < X##_f[3] \ @@ -525,34 +614,34 @@ || (T##_f[2] == X##_f[2] \ && T##_f[1] <= X##_f[1])))) \ { \ - S##_f[1] = T##_f[1] + q; \ + S##_f[1] = T##_f[1] + (q); \ S##_f[2] += (T##_f[1] > S##_f[1]); \ S##_f[3] += (T##_f[2] > S##_f[2]); \ __FP_FRAC_DEC_3 (X##_f[3], X##_f[2], X##_f[1], \ T##_f[3], T##_f[2], T##_f[1]); \ - R##_f[1] += q; \ + R##_f[1] += (q); \ } \ _FP_FRAC_SLL_4 (X, 1); \ - q >>= 1; \ + (q) >>= 1; \ } \ - q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ - while (q != _FP_WORK_ROUND) \ + (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ + while ((q) != _FP_WORK_ROUND) \ { \ - T##_f[0] = S##_f[0] + q; \ + T##_f[0] = S##_f[0] + (q); \ T##_f[1] = S##_f[1]; \ T##_f[2] = S##_f[2]; \ T##_f[3] = S##_f[3]; \ if (_FP_FRAC_GE_4 (X, T)) \ { \ - S##_f[0] = T##_f[0] + q; \ + S##_f[0] = T##_f[0] + (q); \ S##_f[1] += (T##_f[0] > S##_f[0]); \ S##_f[2] += (T##_f[1] > S##_f[1]); \ S##_f[3] += (T##_f[2] > S##_f[2]); \ _FP_FRAC_DEC_4 (X, T); \ - R##_f[0] += q; \ + R##_f[0] += (q); \ } \ _FP_FRAC_SLL_4 (X, 1); \ - q >>= 1; \ + (q) >>= 1; \ } \ if (!_FP_FRAC_ZEROP_4 (X)) \ { \ @@ -564,9 +653,7 @@ while (0) -/* - * Internals - */ +/* Internals. */ #define __FP_FRAC_SET_4(X, I3, I2, I1, I0) \ (X##_f[3] = I3, X##_f[2] = I2, X##_f[1] = I1, X##_f[0] = I0) @@ -591,18 +678,19 @@ # define __FP_FRAC_ADD_4(r3, r2, r1, r0, x3, x2, x1, x0, y3, y2, y1, y0) \ do \ { \ - _FP_W_TYPE _c1, _c2, _c3; \ + _FP_W_TYPE __FP_FRAC_ADD_4_c1, __FP_FRAC_ADD_4_c2; \ + _FP_W_TYPE __FP_FRAC_ADD_4_c3; \ r0 = x0 + y0; \ - _c1 = r0 < x0; \ + __FP_FRAC_ADD_4_c1 = r0 < x0; \ r1 = x1 + y1; \ - _c2 = r1 < x1; \ - r1 += _c1; \ - _c2 |= r1 < _c1; \ + __FP_FRAC_ADD_4_c2 = r1 < x1; \ + r1 += __FP_FRAC_ADD_4_c1; \ + __FP_FRAC_ADD_4_c2 |= r1 < __FP_FRAC_ADD_4_c1; \ r2 = x2 + y2; \ - _c3 = r2 < x2; \ - r2 += _c2; \ - _c3 |= r2 < _c2; \ - r3 = x3 + y3 + _c3; \ + __FP_FRAC_ADD_4_c3 = r2 < x2; \ + r2 += __FP_FRAC_ADD_4_c2; \ + __FP_FRAC_ADD_4_c3 |= r2 < __FP_FRAC_ADD_4_c2; \ + r3 = x3 + y3 + __FP_FRAC_ADD_4_c3; \ } \ while (0) #endif @@ -611,14 +699,14 @@ # define __FP_FRAC_SUB_3(r2, r1, r0, x2, x1, x0, y2, y1, y0) \ do \ { \ - _FP_W_TYPE _c1, _c2; \ + _FP_W_TYPE __FP_FRAC_SUB_3_c1, __FP_FRAC_SUB_3_c2; \ r0 = x0 - y0; \ - _c1 = r0 > x0; \ + __FP_FRAC_SUB_3_c1 = r0 > x0; \ r1 = x1 - y1; \ - _c2 = r1 > x1; \ - r1 -= _c1; \ - _c2 |= _c1 && (y1 == x1); \ - r2 = x2 - y2 - _c2; \ + __FP_FRAC_SUB_3_c2 = r1 > x1; \ + r1 -= __FP_FRAC_SUB_3_c1; \ + __FP_FRAC_SUB_3_c2 |= __FP_FRAC_SUB_3_c1 && (y1 == x1); \ + r2 = x2 - y2 - __FP_FRAC_SUB_3_c2; \ } \ while (0) #endif @@ -627,18 +715,19 @@ # define __FP_FRAC_SUB_4(r3, r2, r1, r0, x3, x2, x1, x0, y3, y2, y1, y0) \ do \ { \ - _FP_W_TYPE _c1, _c2, _c3; \ + _FP_W_TYPE __FP_FRAC_SUB_4_c1, __FP_FRAC_SUB_4_c2; \ + _FP_W_TYPE __FP_FRAC_SUB_4_c3; \ r0 = x0 - y0; \ - _c1 = r0 > x0; \ + __FP_FRAC_SUB_4_c1 = r0 > x0; \ r1 = x1 - y1; \ - _c2 = r1 > x1; \ - r1 -= _c1; \ - _c2 |= _c1 && (y1 == x1); \ + __FP_FRAC_SUB_4_c2 = r1 > x1; \ + r1 -= __FP_FRAC_SUB_4_c1; \ + __FP_FRAC_SUB_4_c2 |= __FP_FRAC_SUB_4_c1 && (y1 == x1); \ r2 = x2 - y2; \ - _c3 = r2 > x2; \ - r2 -= _c2; \ - _c3 |= _c2 && (y2 == x2); \ - r3 = x3 - y3 - _c3; \ + __FP_FRAC_SUB_4_c3 = r2 > x2; \ + r2 -= __FP_FRAC_SUB_4_c2; \ + __FP_FRAC_SUB_4_c3 |= __FP_FRAC_SUB_4_c2 && (y2 == x2); \ + r3 = x3 - y3 - __FP_FRAC_SUB_4_c3; \ } \ while (0) #endif @@ -647,46 +736,56 @@ # define __FP_FRAC_DEC_3(x2, x1, x0, y2, y1, y0) \ do \ { \ - UWtype _t0, _t1, _t2; \ - _t0 = x0, _t1 = x1, _t2 = x2; \ - __FP_FRAC_SUB_3 (x2, x1, x0, _t2, _t1, _t0, y2, y1, y0); \ + UWtype __FP_FRAC_DEC_3_t0, __FP_FRAC_DEC_3_t1; \ + UWtype __FP_FRAC_DEC_3_t2; \ + __FP_FRAC_DEC_3_t0 = x0; \ + __FP_FRAC_DEC_3_t1 = x1; \ + __FP_FRAC_DEC_3_t2 = x2; \ + __FP_FRAC_SUB_3 (x2, x1, x0, __FP_FRAC_DEC_3_t2, \ + __FP_FRAC_DEC_3_t1, __FP_FRAC_DEC_3_t0, \ + y2, y1, y0); \ } \ while (0) #endif #ifndef __FP_FRAC_DEC_4 -# define __FP_FRAC_DEC_4(x3, x2, x1, x0, y3, y2, y1, y0) \ - do \ - { \ - UWtype _t0, _t1, _t2, _t3; \ - _t0 = x0, _t1 = x1, _t2 = x2, _t3 = x3; \ - __FP_FRAC_SUB_4 (x3, x2, x1, x0, _t3, _t2, _t1, _t0, y3, y2, y1, y0); \ - } \ +# define __FP_FRAC_DEC_4(x3, x2, x1, x0, y3, y2, y1, y0) \ + do \ + { \ + UWtype __FP_FRAC_DEC_4_t0, __FP_FRAC_DEC_4_t1; \ + UWtype __FP_FRAC_DEC_4_t2, __FP_FRAC_DEC_4_t3; \ + __FP_FRAC_DEC_4_t0 = x0; \ + __FP_FRAC_DEC_4_t1 = x1; \ + __FP_FRAC_DEC_4_t2 = x2; \ + __FP_FRAC_DEC_4_t3 = x3; \ + __FP_FRAC_SUB_4 (x3, x2, x1, x0, __FP_FRAC_DEC_4_t3, \ + __FP_FRAC_DEC_4_t2, __FP_FRAC_DEC_4_t1, \ + __FP_FRAC_DEC_4_t0, y3, y2, y1, y0); \ + } \ while (0) #endif #ifndef __FP_FRAC_ADDI_4 -# define __FP_FRAC_ADDI_4(x3, x2, x1, x0, i) \ - do \ - { \ - UWtype _t; \ - _t = ((x0 += i) < i); \ - x1 += _t; \ - _t = (x1 < _t); \ - x2 += _t; \ - _t = (x2 < _t); \ - x3 += _t; \ - } \ +# define __FP_FRAC_ADDI_4(x3, x2, x1, x0, i) \ + do \ + { \ + UWtype __FP_FRAC_ADDI_4_t; \ + __FP_FRAC_ADDI_4_t = ((x0 += i) < i); \ + x1 += __FP_FRAC_ADDI_4_t; \ + __FP_FRAC_ADDI_4_t = (x1 < __FP_FRAC_ADDI_4_t); \ + x2 += __FP_FRAC_ADDI_4_t; \ + __FP_FRAC_ADDI_4_t = (x2 < __FP_FRAC_ADDI_4_t); \ + x3 += __FP_FRAC_ADDI_4_t; \ + } \ while (0) #endif /* Convert FP values between word sizes. This appears to be more - * complicated than I'd have expected it to be, so these might be - * wrong... These macros are in any case somewhat bogus because they - * use information about what various FRAC_n variables look like - * internally [eg, that 2 word vars are X_f0 and x_f1]. But so do - * the ones in op-2.h and op-1.h. - */ + complicated than I'd have expected it to be, so these might be + wrong... These macros are in any case somewhat bogus because they + use information about what various FRAC_n variables look like + internally [eg, that 2 word vars are X_f0 and x_f1]. But so do + the ones in op-2.h and op-1.h. */ #define _FP_FRAC_COPY_1_4(D, S) (D##_f = S##_f[0]) #define _FP_FRAC_COPY_2_4(D, S) \ @@ -698,48 +797,60 @@ while (0) /* Assembly/disassembly for converting to/from integral types. - * No shifting or overflow handled here. - */ -/* Put the FP value X into r, which is an integer of size rsize. */ + No shifting or overflow handled here. */ +/* Put the FP value X into r, which is an integer of size rsize. */ #define _FP_FRAC_ASSEMBLE_4(r, X, rsize) \ do \ { \ - if (rsize <= _FP_W_TYPE_SIZE) \ - r = X##_f[0]; \ - else if (rsize <= 2*_FP_W_TYPE_SIZE) \ + if ((rsize) <= _FP_W_TYPE_SIZE) \ + (r) = X##_f[0]; \ + else if ((rsize) <= 2*_FP_W_TYPE_SIZE) \ { \ - r = X##_f[1]; \ - r = (rsize <= _FP_W_TYPE_SIZE ? 0 : r << _FP_W_TYPE_SIZE); \ - r += X##_f[0]; \ + (r) = X##_f[1]; \ + (r) = ((rsize) <= _FP_W_TYPE_SIZE \ + ? 0 \ + : (r) << _FP_W_TYPE_SIZE); \ + (r) += X##_f[0]; \ } \ else \ { \ - /* I'm feeling lazy so we deal with int == 3words (implausible)*/ \ - /* and int == 4words as a single case. */ \ - r = X##_f[3]; \ - r = (rsize <= _FP_W_TYPE_SIZE ? 0 : r << _FP_W_TYPE_SIZE); \ - r += X##_f[2]; \ - r = (rsize <= _FP_W_TYPE_SIZE ? 0 : r << _FP_W_TYPE_SIZE); \ - r += X##_f[1]; \ - r = (rsize <= _FP_W_TYPE_SIZE ? 0 : r << _FP_W_TYPE_SIZE); \ - r += X##_f[0]; \ + /* I'm feeling lazy so we deal with int == 3words \ + (implausible) and int == 4words as a single case. */ \ + (r) = X##_f[3]; \ + (r) = ((rsize) <= _FP_W_TYPE_SIZE \ + ? 0 \ + : (r) << _FP_W_TYPE_SIZE); \ + (r) += X##_f[2]; \ + (r) = ((rsize) <= _FP_W_TYPE_SIZE \ + ? 0 \ + : (r) << _FP_W_TYPE_SIZE); \ + (r) += X##_f[1]; \ + (r) = ((rsize) <= _FP_W_TYPE_SIZE \ + ? 0 \ + : (r) << _FP_W_TYPE_SIZE); \ + (r) += X##_f[0]; \ } \ } \ while (0) /* "No disassemble Number Five!" */ -/* move an integer of size rsize into X's fractional part. We rely on - * the _f[] array consisting of words of size _FP_W_TYPE_SIZE to avoid - * having to mask the values we store into it. - */ -#define _FP_FRAC_DISASSEMBLE_4(X, r, rsize) \ - do \ - { \ - X##_f[0] = r; \ - X##_f[1] = (rsize <= _FP_W_TYPE_SIZE ? 0 : r >> _FP_W_TYPE_SIZE); \ - X##_f[2] = (rsize <= 2*_FP_W_TYPE_SIZE ? 0 : r >> 2*_FP_W_TYPE_SIZE); \ - X##_f[3] = (rsize <= 3*_FP_W_TYPE_SIZE ? 0 : r >> 3*_FP_W_TYPE_SIZE); \ - } \ +/* Move an integer of size rsize into X's fractional part. We rely on + the _f[] array consisting of words of size _FP_W_TYPE_SIZE to avoid + having to mask the values we store into it. */ +#define _FP_FRAC_DISASSEMBLE_4(X, r, rsize) \ + do \ + { \ + X##_f[0] = (r); \ + X##_f[1] = ((rsize) <= _FP_W_TYPE_SIZE \ + ? 0 \ + : (r) >> _FP_W_TYPE_SIZE); \ + X##_f[2] = ((rsize) <= 2*_FP_W_TYPE_SIZE \ + ? 0 \ + : (r) >> 2*_FP_W_TYPE_SIZE); \ + X##_f[3] = ((rsize) <= 3*_FP_W_TYPE_SIZE \ + ? 0 \ + : (r) >> 3*_FP_W_TYPE_SIZE); \ + } \ while (0) #define _FP_FRAC_COPY_4_1(D, S) \ @@ -760,3 +871,5 @@ while (0) #define _FP_FRAC_COPY_4_4(D, S) _FP_FRAC_COPY_4 (D, S) + +#endif /* !SOFT_FP_OP_4_H */ diff --git a/soft-fp/op-8.h b/soft-fp/op-8.h index a50cd7b582..5267ae34ec 100644 --- a/soft-fp/op-8.h +++ b/soft-fp/op-8.h @@ -1,6 +1,6 @@ /* Software floating-point emulation. Basic eight-word fraction declaration and manipulation. - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com), Jakub Jelinek (jj@ultra.linux.cz) and @@ -29,88 +29,122 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ +#ifndef SOFT_FP_OP_8_H +#define SOFT_FP_OP_8_H 1 + /* We need just a few things from here for op-4, if we ever need some - other macros, they can be added. */ + other macros, they can be added. */ #define _FP_FRAC_DECL_8(X) _FP_W_TYPE X##_f[8] #define _FP_FRAC_HIGH_8(X) (X##_f[7]) #define _FP_FRAC_LOW_8(X) (X##_f[0]) #define _FP_FRAC_WORD_8(X, w) (X##_f[w]) -#define _FP_FRAC_SLL_8(X, N) \ - do \ - { \ - _FP_I_TYPE _up, _down, _skip, _i; \ - _skip = (N) / _FP_W_TYPE_SIZE; \ - _up = (N) % _FP_W_TYPE_SIZE; \ - _down = _FP_W_TYPE_SIZE - _up; \ - if (!_up) \ - for (_i = 7; _i >= _skip; --_i) \ - X##_f[_i] = X##_f[_i-_skip]; \ - else \ - { \ - for (_i = 7; _i > _skip; --_i) \ - X##_f[_i] = (X##_f[_i-_skip] << _up \ - | X##_f[_i-_skip-1] >> _down); \ - X##_f[_i--] = X##_f[0] << _up; \ - } \ - for (; _i >= 0; --_i) \ - X##_f[_i] = 0; \ - } \ +#define _FP_FRAC_SLL_8(X, N) \ + do \ + { \ + _FP_I_TYPE _FP_FRAC_SLL_8_up, _FP_FRAC_SLL_8_down; \ + _FP_I_TYPE _FP_FRAC_SLL_8_skip, _FP_FRAC_SLL_8_i; \ + _FP_FRAC_SLL_8_skip = (N) / _FP_W_TYPE_SIZE; \ + _FP_FRAC_SLL_8_up = (N) % _FP_W_TYPE_SIZE; \ + _FP_FRAC_SLL_8_down = _FP_W_TYPE_SIZE - _FP_FRAC_SLL_8_up; \ + if (!_FP_FRAC_SLL_8_up) \ + for (_FP_FRAC_SLL_8_i = 7; \ + _FP_FRAC_SLL_8_i >= _FP_FRAC_SLL_8_skip; \ + --_FP_FRAC_SLL_8_i) \ + X##_f[_FP_FRAC_SLL_8_i] \ + = X##_f[_FP_FRAC_SLL_8_i-_FP_FRAC_SLL_8_skip]; \ + else \ + { \ + for (_FP_FRAC_SLL_8_i = 7; \ + _FP_FRAC_SLL_8_i > _FP_FRAC_SLL_8_skip; \ + --_FP_FRAC_SLL_8_i) \ + X##_f[_FP_FRAC_SLL_8_i] \ + = ((X##_f[_FP_FRAC_SLL_8_i-_FP_FRAC_SLL_8_skip] \ + << _FP_FRAC_SLL_8_up) \ + | (X##_f[_FP_FRAC_SLL_8_i-_FP_FRAC_SLL_8_skip-1] \ + >> _FP_FRAC_SLL_8_down)); \ + X##_f[_FP_FRAC_SLL_8_i--] = X##_f[0] << _FP_FRAC_SLL_8_up; \ + } \ + for (; _FP_FRAC_SLL_8_i >= 0; --_FP_FRAC_SLL_8_i) \ + X##_f[_FP_FRAC_SLL_8_i] = 0; \ + } \ while (0) -#define _FP_FRAC_SRL_8(X, N) \ - do \ - { \ - _FP_I_TYPE _up, _down, _skip, _i; \ - _skip = (N) / _FP_W_TYPE_SIZE; \ - _down = (N) % _FP_W_TYPE_SIZE; \ - _up = _FP_W_TYPE_SIZE - _down; \ - if (!_down) \ - for (_i = 0; _i <= 7-_skip; ++_i) \ - X##_f[_i] = X##_f[_i+_skip]; \ - else \ - { \ - for (_i = 0; _i < 7-_skip; ++_i) \ - X##_f[_i] = (X##_f[_i+_skip] >> _down \ - | X##_f[_i+_skip+1] << _up); \ - X##_f[_i++] = X##_f[7] >> _down; \ - } \ - for (; _i < 8; ++_i) \ - X##_f[_i] = 0; \ - } \ +#define _FP_FRAC_SRL_8(X, N) \ + do \ + { \ + _FP_I_TYPE _FP_FRAC_SRL_8_up, _FP_FRAC_SRL_8_down; \ + _FP_I_TYPE _FP_FRAC_SRL_8_skip, _FP_FRAC_SRL_8_i; \ + _FP_FRAC_SRL_8_skip = (N) / _FP_W_TYPE_SIZE; \ + _FP_FRAC_SRL_8_down = (N) % _FP_W_TYPE_SIZE; \ + _FP_FRAC_SRL_8_up = _FP_W_TYPE_SIZE - _FP_FRAC_SRL_8_down; \ + if (!_FP_FRAC_SRL_8_down) \ + for (_FP_FRAC_SRL_8_i = 0; \ + _FP_FRAC_SRL_8_i <= 7-_FP_FRAC_SRL_8_skip; \ + ++_FP_FRAC_SRL_8_i) \ + X##_f[_FP_FRAC_SRL_8_i] \ + = X##_f[_FP_FRAC_SRL_8_i+_FP_FRAC_SRL_8_skip]; \ + else \ + { \ + for (_FP_FRAC_SRL_8_i = 0; \ + _FP_FRAC_SRL_8_i < 7-_FP_FRAC_SRL_8_skip; \ + ++_FP_FRAC_SRL_8_i) \ + X##_f[_FP_FRAC_SRL_8_i] \ + = ((X##_f[_FP_FRAC_SRL_8_i+_FP_FRAC_SRL_8_skip] \ + >> _FP_FRAC_SRL_8_down) \ + | (X##_f[_FP_FRAC_SRL_8_i+_FP_FRAC_SRL_8_skip+1] \ + << _FP_FRAC_SRL_8_up)); \ + X##_f[_FP_FRAC_SRL_8_i++] = X##_f[7] >> _FP_FRAC_SRL_8_down; \ + } \ + for (; _FP_FRAC_SRL_8_i < 8; ++_FP_FRAC_SRL_8_i) \ + X##_f[_FP_FRAC_SRL_8_i] = 0; \ + } \ while (0) /* Right shift with sticky-lsb. - * What this actually means is that we do a standard right-shift, - * but that if any of the bits that fall off the right hand side - * were one then we always set the LSbit. - */ + What this actually means is that we do a standard right-shift, + but that if any of the bits that fall off the right hand side + were one then we always set the LSbit. */ #define _FP_FRAC_SRS_8(X, N, size) \ do \ { \ - _FP_I_TYPE _up, _down, _skip, _i; \ - _FP_W_TYPE _s; \ - _skip = (N) / _FP_W_TYPE_SIZE; \ - _down = (N) % _FP_W_TYPE_SIZE; \ - _up = _FP_W_TYPE_SIZE - _down; \ - for (_s = _i = 0; _i < _skip; ++_i) \ - _s |= X##_f[_i]; \ - if (!_down) \ - for (_i = 0; _i <= 7-_skip; ++_i) \ - X##_f[_i] = X##_f[_i+_skip]; \ + _FP_I_TYPE _FP_FRAC_SRS_8_up, _FP_FRAC_SRS_8_down; \ + _FP_I_TYPE _FP_FRAC_SRS_8_skip, _FP_FRAC_SRS_8_i; \ + _FP_W_TYPE _FP_FRAC_SRS_8_s; \ + _FP_FRAC_SRS_8_skip = (N) / _FP_W_TYPE_SIZE; \ + _FP_FRAC_SRS_8_down = (N) % _FP_W_TYPE_SIZE; \ + _FP_FRAC_SRS_8_up = _FP_W_TYPE_SIZE - _FP_FRAC_SRS_8_down; \ + for (_FP_FRAC_SRS_8_s = _FP_FRAC_SRS_8_i = 0; \ + _FP_FRAC_SRS_8_i < _FP_FRAC_SRS_8_skip; \ + ++_FP_FRAC_SRS_8_i) \ + _FP_FRAC_SRS_8_s |= X##_f[_FP_FRAC_SRS_8_i]; \ + if (!_FP_FRAC_SRS_8_down) \ + for (_FP_FRAC_SRS_8_i = 0; \ + _FP_FRAC_SRS_8_i <= 7-_FP_FRAC_SRS_8_skip; \ + ++_FP_FRAC_SRS_8_i) \ + X##_f[_FP_FRAC_SRS_8_i] \ + = X##_f[_FP_FRAC_SRS_8_i+_FP_FRAC_SRS_8_skip]; \ else \ { \ - _s |= X##_f[_i] << _up; \ - for (_i = 0; _i < 7-_skip; ++_i) \ - X##_f[_i] = (X##_f[_i+_skip] >> _down \ - | X##_f[_i+_skip+1] << _up); \ - X##_f[_i++] = X##_f[7] >> _down; \ + _FP_FRAC_SRS_8_s \ + |= X##_f[_FP_FRAC_SRS_8_i] << _FP_FRAC_SRS_8_up; \ + for (_FP_FRAC_SRS_8_i = 0; \ + _FP_FRAC_SRS_8_i < 7-_FP_FRAC_SRS_8_skip; \ + ++_FP_FRAC_SRS_8_i) \ + X##_f[_FP_FRAC_SRS_8_i] \ + = ((X##_f[_FP_FRAC_SRS_8_i+_FP_FRAC_SRS_8_skip] \ + >> _FP_FRAC_SRS_8_down) \ + | (X##_f[_FP_FRAC_SRS_8_i+_FP_FRAC_SRS_8_skip+1] \ + << _FP_FRAC_SRS_8_up)); \ + X##_f[_FP_FRAC_SRS_8_i++] = X##_f[7] >> _FP_FRAC_SRS_8_down; \ } \ - for (; _i < 8; ++_i) \ - X##_f[_i] = 0; \ - /* don't fix the LSB until the very end when we're sure f[0] is \ - stable */ \ - X##_f[0] |= (_s != 0); \ + for (; _FP_FRAC_SRS_8_i < 8; ++_FP_FRAC_SRS_8_i) \ + X##_f[_FP_FRAC_SRS_8_i] = 0; \ + /* Don't fix the LSB until the very end when we're sure f[0] is \ + stable. */ \ + X##_f[0] |= (_FP_FRAC_SRS_8_s != 0); \ } \ while (0) + +#endif /* !SOFT_FP_OP_8_H */ diff --git a/soft-fp/op-common.h b/soft-fp/op-common.h index e901981b95..080ef0e9b9 100644 --- a/soft-fp/op-common.h +++ b/soft-fp/op-common.h @@ -1,5 +1,5 @@ /* Software floating-point emulation. Common operations. - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com), Jakub Jelinek (jj@ultra.linux.cz), @@ -29,10 +29,13 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ -#define _FP_DECL(wc, X) \ - _FP_I_TYPE X##_c __attribute__ ((unused)); \ - _FP_I_TYPE X##_s __attribute__ ((unused)); \ - _FP_I_TYPE X##_e; \ +#ifndef SOFT_FP_OP_COMMON_H +#define SOFT_FP_OP_COMMON_H 1 + +#define _FP_DECL(wc, X) \ + _FP_I_TYPE X##_c __attribute__ ((unused)) _FP_ZERO_INIT; \ + _FP_I_TYPE X##_s __attribute__ ((unused)) _FP_ZERO_INIT; \ + _FP_I_TYPE X##_e __attribute__ ((unused)) _FP_ZERO_INIT; \ _FP_FRAC_DECL_##wc (X) /* Test whether the qNaN bit denotes a signaling NaN. */ @@ -45,10 +48,8 @@ ? (_FP_FRAC_HIGH_##fs (X) & _FP_QNANBIT_SH_##fs) \ : !(_FP_FRAC_HIGH_##fs (X) & _FP_QNANBIT_SH_##fs)) -/* - * Finish truly unpacking a native fp value by classifying the kind - * of fp value and normalizing both the exponent and the fraction. - */ +/* Finish truly unpacking a native fp value by classifying the kind + of fp value and normalizing both the exponent and the fraction. */ #define _FP_UNPACK_CANONICAL(fs, wc, X) \ do \ @@ -65,14 +66,23 @@ case 0: \ if (_FP_FRAC_ZEROP_##wc (X)) \ X##_c = FP_CLS_ZERO; \ + else if (FP_DENORM_ZERO) \ + { \ + X##_c = FP_CLS_ZERO; \ + _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ + } \ else \ { \ - /* a denormalized number */ \ - _FP_I_TYPE _shift; \ - _FP_FRAC_CLZ_##wc (_shift, X); \ - _shift -= _FP_FRACXBITS_##fs; \ - _FP_FRAC_SLL_##wc (X, (_shift+_FP_WORKBITS)); \ - X##_e -= _FP_EXPBIAS_##fs - 1 + _shift; \ + /* A denormalized number. */ \ + _FP_I_TYPE _FP_UNPACK_CANONICAL_shift; \ + _FP_FRAC_CLZ_##wc (_FP_UNPACK_CANONICAL_shift, \ + X); \ + _FP_UNPACK_CANONICAL_shift -= _FP_FRACXBITS_##fs; \ + _FP_FRAC_SLL_##wc (X, (_FP_UNPACK_CANONICAL_shift \ + + _FP_WORKBITS)); \ + X##_e -= (_FP_EXPBIAS_##fs - 1 \ + + _FP_UNPACK_CANONICAL_shift); \ X##_c = FP_CLS_NORMAL; \ FP_SET_EXCEPTION (FP_EX_DENORM); \ } \ @@ -84,9 +94,10 @@ else \ { \ X##_c = FP_CLS_NAN; \ - /* Check for signaling NaN */ \ + /* Check for signaling NaN. */ \ if (_FP_FRAC_SNANP (fs, X)) \ - FP_SET_EXCEPTION (FP_EX_INVALID); \ + FP_SET_EXCEPTION (FP_EX_INVALID \ + | FP_EX_INVALID_SNAN); \ } \ break; \ } \ @@ -98,6 +109,21 @@ other classification is not done. */ #define _FP_UNPACK_SEMIRAW(fs, wc, X) _FP_FRAC_SLL_##wc (X, _FP_WORKBITS) +/* Check whether a raw or semi-raw input value should be flushed to + zero, and flush it to zero if so. */ +#define _FP_CHECK_FLUSH_ZERO(fs, wc, X) \ + do \ + { \ + if (FP_DENORM_ZERO \ + && X##_e == 0 \ + && !_FP_FRAC_ZEROP_##wc (X)) \ + { \ + _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ + } \ + } \ + while (0) + /* A semi-raw value has overflowed to infinity. Adjust the mantissa and exponent appropriately. */ #define _FP_OVERFLOW_SEMIRAW(fs, wc, X) \ @@ -122,14 +148,14 @@ /* Check for a semi-raw value being a signaling NaN and raise the invalid exception if so. */ -#define _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X) \ - do \ - { \ - if (X##_e == _FP_EXPMAX_##fs \ - && !_FP_FRAC_ZEROP_##wc (X) \ - && _FP_FRAC_SNANP_SEMIRAW (fs, X)) \ - FP_SET_EXCEPTION (FP_EX_INVALID); \ - } \ +#define _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X) \ + do \ + { \ + if (X##_e == _FP_EXPMAX_##fs \ + && !_FP_FRAC_ZEROP_##wc (X) \ + && _FP_FRAC_SNANP_SEMIRAW (fs, X)) \ + FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_SNAN); \ + } \ while (0) /* Choose a NaN result from an operation on two semi-raw NaN @@ -191,8 +217,22 @@ #define _FP_PACK_SEMIRAW(fs, wc, X) \ do \ { \ + int _FP_PACK_SEMIRAW_is_tiny \ + = X##_e == 0 && !_FP_FRAC_ZEROP_##wc (X); \ + if (_FP_TININESS_AFTER_ROUNDING \ + && _FP_PACK_SEMIRAW_is_tiny) \ + { \ + FP_DECL_##fs (_FP_PACK_SEMIRAW_T); \ + _FP_FRAC_COPY_##wc (_FP_PACK_SEMIRAW_T, X); \ + _FP_PACK_SEMIRAW_T##_s = X##_s; \ + _FP_PACK_SEMIRAW_T##_e = X##_e; \ + _FP_FRAC_SLL_##wc (_FP_PACK_SEMIRAW_T, 1); \ + _FP_ROUND (wc, _FP_PACK_SEMIRAW_T); \ + if (_FP_FRAC_OVERP_##wc (fs, _FP_PACK_SEMIRAW_T)) \ + _FP_PACK_SEMIRAW_is_tiny = 0; \ + } \ _FP_ROUND (wc, X); \ - if (X##_e == 0 && !_FP_FRAC_ZEROP_##wc (X)) \ + if (_FP_PACK_SEMIRAW_is_tiny) \ { \ if ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT) \ || (FP_TRAPPING_EXCEPTIONS & FP_EX_UNDERFLOW)) \ @@ -220,12 +260,10 @@ } \ while (0) -/* - * Before packing the bits back into the native fp result, take care - * of such mundane things as rounding and overflow. Also, for some - * kinds of fp values, the original parts may not have been fully - * extracted -- but that is ok, we can regenerate them now. - */ +/* Before packing the bits back into the native fp result, take care + of such mundane things as rounding and overflow. Also, for some + kinds of fp values, the original parts may not have been fully + extracted -- but that is ok, we can regenerate them now. */ #define _FP_PACK_CANONICAL(fs, wc, X) \ do \ @@ -245,7 +283,7 @@ _FP_FRAC_SRL_##wc (X, _FP_WORKBITS); \ if (X##_e >= _FP_EXPMAX_##fs) \ { \ - /* overflow */ \ + /* Overflow. */ \ switch (FP_ROUNDMODE) \ { \ case FP_RND_NEAREST: \ @@ -262,13 +300,13 @@ } \ if (X##_c == FP_CLS_INF) \ { \ - /* Overflow to infinity */ \ + /* Overflow to infinity. */ \ X##_e = _FP_EXPMAX_##fs; \ _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \ } \ else \ { \ - /* Overflow to maximum normal */ \ + /* Overflow to maximum normal. */ \ X##_e = _FP_EXPMAX_##fs - 1; \ _FP_FRAC_SET_##wc (X, _FP_MAXFRAC_##wc); \ } \ @@ -278,7 +316,18 @@ } \ else \ { \ - /* we've got a denormalized number */ \ + /* We've got a denormalized number. */ \ + int _FP_PACK_CANONICAL_is_tiny = 1; \ + if (_FP_TININESS_AFTER_ROUNDING && X##_e == 0) \ + { \ + FP_DECL_##fs (_FP_PACK_CANONICAL_T); \ + _FP_FRAC_COPY_##wc (_FP_PACK_CANONICAL_T, X); \ + _FP_PACK_CANONICAL_T##_s = X##_s; \ + _FP_PACK_CANONICAL_T##_e = X##_e; \ + _FP_ROUND (wc, _FP_PACK_CANONICAL_T); \ + if (_FP_FRAC_OVERP_##wc (fs, _FP_PACK_CANONICAL_T)) \ + _FP_PACK_CANONICAL_is_tiny = 0; \ + } \ X##_e = -X##_e + 1; \ if (X##_e <= _FP_WFRACBITS_##fs) \ { \ @@ -296,13 +345,15 @@ X##_e = 0; \ _FP_FRAC_SRL_##wc (X, _FP_WORKBITS); \ } \ - if ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT) \ - || (FP_TRAPPING_EXCEPTIONS & FP_EX_UNDERFLOW)) \ + if (_FP_PACK_CANONICAL_is_tiny \ + && ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT) \ + || (FP_TRAPPING_EXCEPTIONS \ + & FP_EX_UNDERFLOW))) \ FP_SET_EXCEPTION (FP_EX_UNDERFLOW); \ } \ else \ { \ - /* underflow to zero */ \ + /* Underflow to zero. */ \ X##_e = 0; \ if (!_FP_FRAC_ZEROP_##wc (X)) \ { \ @@ -340,18 +391,17 @@ while (0) /* This one accepts raw argument and not cooked, returns - * 1 if X is a signaling NaN. - */ + 1 if X is a signaling NaN. */ #define _FP_ISSIGNAN(fs, wc, X) \ ({ \ - int __ret = 0; \ + int _FP_ISSIGNAN_ret = 0; \ if (X##_e == _FP_EXPMAX_##fs) \ { \ if (!_FP_FRAC_ZEROP_##wc (X) \ && _FP_FRAC_SNANP (fs, X)) \ - __ret = 1; \ + _FP_ISSIGNAN_ret = 1; \ } \ - __ret; \ + _FP_ISSIGNAN_ret; \ }) @@ -362,12 +412,15 @@ #define _FP_ADD_INTERNAL(fs, wc, R, X, Y, OP) \ do \ { \ + _FP_CHECK_FLUSH_ZERO (fs, wc, X); \ + _FP_CHECK_FLUSH_ZERO (fs, wc, Y); \ if (X##_s == Y##_s) \ { \ /* Addition. */ \ + __label__ add1, add2, add3, add_done; \ R##_s = X##_s; \ - int ediff = X##_e - Y##_e; \ - if (ediff > 0) \ + int _FP_ADD_INTERNAL_ediff = X##_e - Y##_e; \ + if (_FP_ADD_INTERNAL_ediff > 0) \ { \ R##_e = X##_e; \ if (Y##_e == 0) \ @@ -382,8 +435,8 @@ else \ { \ FP_SET_EXCEPTION (FP_EX_DENORM); \ - ediff--; \ - if (ediff == 0) \ + _FP_ADD_INTERNAL_ediff--; \ + if (_FP_ADD_INTERNAL_ediff == 0) \ { \ _FP_FRAC_ADD_##wc (R, X, Y); \ goto add3; \ @@ -409,17 +462,19 @@ _FP_FRAC_HIGH_##fs (Y) |= _FP_IMPLBIT_SH_##fs; \ \ add1: \ - /* Shift the mantissa of Y to the right EDIFF steps; \ - remember to account later for the implicit MSB of X. */ \ - if (ediff <= _FP_WFRACBITS_##fs) \ - _FP_FRAC_SRS_##wc (Y, ediff, _FP_WFRACBITS_##fs); \ + /* Shift the mantissa of Y to the right \ + _FP_ADD_INTERNAL_EDIFF steps; remember to account \ + later for the implicit MSB of X. */ \ + if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs) \ + _FP_FRAC_SRS_##wc (Y, _FP_ADD_INTERNAL_ediff, \ + _FP_WFRACBITS_##fs); \ else if (!_FP_FRAC_ZEROP_##wc (Y)) \ _FP_FRAC_SET_##wc (Y, _FP_MINFRAC_##wc); \ _FP_FRAC_ADD_##wc (R, X, Y); \ } \ - else if (ediff < 0) \ + else if (_FP_ADD_INTERNAL_ediff < 0) \ { \ - ediff = -ediff; \ + _FP_ADD_INTERNAL_ediff = -_FP_ADD_INTERNAL_ediff; \ R##_e = Y##_e; \ if (X##_e == 0) \ { \ @@ -433,8 +488,8 @@ else \ { \ FP_SET_EXCEPTION (FP_EX_DENORM); \ - ediff--; \ - if (ediff == 0) \ + _FP_ADD_INTERNAL_ediff--; \ + if (_FP_ADD_INTERNAL_ediff == 0) \ { \ _FP_FRAC_ADD_##wc (R, Y, X); \ goto add3; \ @@ -460,17 +515,19 @@ _FP_FRAC_HIGH_##fs (X) |= _FP_IMPLBIT_SH_##fs; \ \ add2: \ - /* Shift the mantissa of X to the right EDIFF steps; \ - remember to account later for the implicit MSB of Y. */ \ - if (ediff <= _FP_WFRACBITS_##fs) \ - _FP_FRAC_SRS_##wc (X, ediff, _FP_WFRACBITS_##fs); \ + /* Shift the mantissa of X to the right \ + _FP_ADD_INTERNAL_EDIFF steps; remember to account \ + later for the implicit MSB of Y. */ \ + if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs) \ + _FP_FRAC_SRS_##wc (X, _FP_ADD_INTERNAL_ediff, \ + _FP_WFRACBITS_##fs); \ else if (!_FP_FRAC_ZEROP_##wc (X)) \ _FP_FRAC_SET_##wc (X, _FP_MINFRAC_##wc); \ _FP_FRAC_ADD_##wc (R, Y, X); \ } \ else \ { \ - /* ediff == 0. */ \ + /* _FP_ADD_INTERNAL_ediff == 0. */ \ if (!_FP_EXP_NORMAL (fs, wc, X)) \ { \ if (X##_e == 0) \ @@ -546,8 +603,9 @@ else \ { \ /* Subtraction. */ \ - int ediff = X##_e - Y##_e; \ - if (ediff > 0) \ + __label__ sub1, sub2, sub3, norm, sub_done; \ + int _FP_ADD_INTERNAL_ediff = X##_e - Y##_e; \ + if (_FP_ADD_INTERNAL_ediff > 0) \ { \ R##_e = X##_e; \ R##_s = X##_s; \ @@ -563,8 +621,8 @@ else \ { \ FP_SET_EXCEPTION (FP_EX_DENORM); \ - ediff--; \ - if (ediff == 0) \ + _FP_ADD_INTERNAL_ediff--; \ + if (_FP_ADD_INTERNAL_ediff == 0) \ { \ _FP_FRAC_SUB_##wc (R, X, Y); \ goto sub3; \ @@ -590,17 +648,19 @@ _FP_FRAC_HIGH_##fs (Y) |= _FP_IMPLBIT_SH_##fs; \ \ sub1: \ - /* Shift the mantissa of Y to the right EDIFF steps; \ - remember to account later for the implicit MSB of X. */ \ - if (ediff <= _FP_WFRACBITS_##fs) \ - _FP_FRAC_SRS_##wc (Y, ediff, _FP_WFRACBITS_##fs); \ + /* Shift the mantissa of Y to the right \ + _FP_ADD_INTERNAL_EDIFF steps; remember to account \ + later for the implicit MSB of X. */ \ + if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs) \ + _FP_FRAC_SRS_##wc (Y, _FP_ADD_INTERNAL_ediff, \ + _FP_WFRACBITS_##fs); \ else if (!_FP_FRAC_ZEROP_##wc (Y)) \ _FP_FRAC_SET_##wc (Y, _FP_MINFRAC_##wc); \ _FP_FRAC_SUB_##wc (R, X, Y); \ } \ - else if (ediff < 0) \ + else if (_FP_ADD_INTERNAL_ediff < 0) \ { \ - ediff = -ediff; \ + _FP_ADD_INTERNAL_ediff = -_FP_ADD_INTERNAL_ediff; \ R##_e = Y##_e; \ R##_s = Y##_s; \ if (X##_e == 0) \ @@ -615,8 +675,8 @@ else \ { \ FP_SET_EXCEPTION (FP_EX_DENORM); \ - ediff--; \ - if (ediff == 0) \ + _FP_ADD_INTERNAL_ediff--; \ + if (_FP_ADD_INTERNAL_ediff == 0) \ { \ _FP_FRAC_SUB_##wc (R, Y, X); \ goto sub3; \ @@ -642,10 +702,12 @@ _FP_FRAC_HIGH_##fs (X) |= _FP_IMPLBIT_SH_##fs; \ \ sub2: \ - /* Shift the mantissa of X to the right EDIFF steps; \ - remember to account later for the implicit MSB of Y. */ \ - if (ediff <= _FP_WFRACBITS_##fs) \ - _FP_FRAC_SRS_##wc (X, ediff, _FP_WFRACBITS_##fs); \ + /* Shift the mantissa of X to the right \ + _FP_ADD_INTERNAL_EDIFF steps; remember to account \ + later for the implicit MSB of Y. */ \ + if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs) \ + _FP_FRAC_SRS_##wc (X, _FP_ADD_INTERNAL_ediff, \ + _FP_WFRACBITS_##fs); \ else if (!_FP_FRAC_ZEROP_##wc (X)) \ _FP_FRAC_SET_##wc (X, _FP_MINFRAC_##wc); \ _FP_FRAC_SUB_##wc (R, Y, X); \ @@ -708,7 +770,8 @@ R##_s = _FP_NANSIGN_##fs; \ _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \ _FP_FRAC_SLL_##wc (R, _FP_WORKBITS); \ - FP_SET_EXCEPTION (FP_EX_INVALID); \ + FP_SET_EXCEPTION (FP_EX_INVALID \ + | FP_EX_INVALID_ISI); \ } \ else \ { \ @@ -756,24 +819,26 @@ sub3: \ if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs) \ { \ - int diff; \ + int _FP_ADD_INTERNAL_diff; \ /* Carry into most significant bit of larger one of X and Y, \ canceling it; renormalize. */ \ _FP_FRAC_HIGH_##fs (R) &= _FP_IMPLBIT_SH_##fs - 1; \ norm: \ - _FP_FRAC_CLZ_##wc (diff, R); \ - diff -= _FP_WFRACXBITS_##fs; \ - _FP_FRAC_SLL_##wc (R, diff); \ - if (R##_e <= diff) \ + _FP_FRAC_CLZ_##wc (_FP_ADD_INTERNAL_diff, R); \ + _FP_ADD_INTERNAL_diff -= _FP_WFRACXBITS_##fs; \ + _FP_FRAC_SLL_##wc (R, _FP_ADD_INTERNAL_diff); \ + if (R##_e <= _FP_ADD_INTERNAL_diff) \ { \ /* R is denormalized. */ \ - diff = diff - R##_e + 1; \ - _FP_FRAC_SRS_##wc (R, diff, _FP_WFRACBITS_##fs); \ + _FP_ADD_INTERNAL_diff \ + = _FP_ADD_INTERNAL_diff - R##_e + 1; \ + _FP_FRAC_SRS_##wc (R, _FP_ADD_INTERNAL_diff, \ + _FP_WFRACBITS_##fs); \ R##_e = 0; \ } \ else \ { \ - R##_e -= diff; \ + R##_e -= _FP_ADD_INTERNAL_diff; \ _FP_FRAC_HIGH_##fs (R) &= ~(_FP_W_TYPE) _FP_IMPLBIT_SH_##fs; \ } \ } \ @@ -793,9 +858,7 @@ while (0) -/* - * Main negation routine. The input value is raw. - */ +/* Main negation routine. The input value is raw. */ #define _FP_NEG(fs, wc, R, X) \ do \ @@ -807,9 +870,7 @@ while (0) -/* - * Main multiplication routine. The input values should be cooked. - */ +/* Main multiplication routine. The input values should be cooked. */ #define _FP_MUL(fs, wc, R, X, Y) \ do \ @@ -862,11 +923,11 @@ R##_s = _FP_NANSIGN_##fs; \ R##_c = FP_CLS_NAN; \ _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \ - FP_SET_EXCEPTION (FP_EX_INVALID); \ + FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_IMZ); \ break; \ \ default: \ - abort (); \ + _FP_UNREACHABLE; \ } \ } \ while (0) @@ -877,9 +938,10 @@ #define _FP_FMA(fs, wc, dwc, R, X, Y, Z) \ do \ { \ - FP_DECL_##fs (T); \ - T##_s = X##_s ^ Y##_s; \ - T##_e = X##_e + Y##_e + 1; \ + __label__ done_fma; \ + FP_DECL_##fs (_FP_FMA_T); \ + _FP_FMA_T##_s = X##_s ^ Y##_s; \ + _FP_FMA_T##_e = X##_e + Y##_e + 1; \ switch (_FP_CLS_COMBINE (X##_c, Y##_c)) \ { \ case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_NORMAL): \ @@ -894,8 +956,8 @@ \ case FP_CLS_ZERO: \ R##_c = FP_CLS_NORMAL; \ - R##_s = T##_s; \ - R##_e = T##_e; \ + R##_s = _FP_FMA_T##_s; \ + R##_e = _FP_FMA_T##_e; \ \ _FP_MUL_MEAT_##fs (R, X, Y); \ \ @@ -906,38 +968,43 @@ break; \ \ case FP_CLS_NORMAL:; \ - _FP_FRAC_DECL_##dwc (TD); \ - _FP_FRAC_DECL_##dwc (ZD); \ - _FP_FRAC_DECL_##dwc (RD); \ - _FP_MUL_MEAT_DW_##fs (TD, X, Y); \ - R##_e = T##_e; \ - int tsh = _FP_FRAC_HIGHBIT_DW_##dwc (fs, TD) == 0; \ - T##_e -= tsh; \ - int ediff = T##_e - Z##_e; \ - if (ediff >= 0) \ + _FP_FRAC_DECL_##dwc (_FP_FMA_TD); \ + _FP_FRAC_DECL_##dwc (_FP_FMA_ZD); \ + _FP_FRAC_DECL_##dwc (_FP_FMA_RD); \ + _FP_MUL_MEAT_DW_##fs (_FP_FMA_TD, X, Y); \ + R##_e = _FP_FMA_T##_e; \ + int _FP_FMA_tsh \ + = _FP_FRAC_HIGHBIT_DW_##dwc (fs, _FP_FMA_TD) == 0; \ + _FP_FMA_T##_e -= _FP_FMA_tsh; \ + int _FP_FMA_ediff = _FP_FMA_T##_e - Z##_e; \ + if (_FP_FMA_ediff >= 0) \ { \ - int shift = _FP_WFRACBITS_##fs - tsh - ediff; \ - if (shift <= -_FP_WFRACBITS_##fs) \ - _FP_FRAC_SET_##dwc (ZD, _FP_MINFRAC_##dwc); \ + int _FP_FMA_shift \ + = _FP_WFRACBITS_##fs - _FP_FMA_tsh - _FP_FMA_ediff; \ + if (_FP_FMA_shift <= -_FP_WFRACBITS_##fs) \ + _FP_FRAC_SET_##dwc (_FP_FMA_ZD, _FP_MINFRAC_##dwc); \ else \ { \ - _FP_FRAC_COPY_##dwc##_##wc (ZD, Z); \ - if (shift < 0) \ - _FP_FRAC_SRS_##dwc (ZD, -shift, \ + _FP_FRAC_COPY_##dwc##_##wc (_FP_FMA_ZD, Z); \ + if (_FP_FMA_shift < 0) \ + _FP_FRAC_SRS_##dwc (_FP_FMA_ZD, -_FP_FMA_shift, \ _FP_WFRACBITS_DW_##fs); \ - else if (shift > 0) \ - _FP_FRAC_SLL_##dwc (ZD, shift); \ + else if (_FP_FMA_shift > 0) \ + _FP_FRAC_SLL_##dwc (_FP_FMA_ZD, _FP_FMA_shift); \ } \ - R##_s = T##_s; \ - if (T##_s == Z##_s) \ - _FP_FRAC_ADD_##dwc (RD, TD, ZD); \ + R##_s = _FP_FMA_T##_s; \ + if (_FP_FMA_T##_s == Z##_s) \ + _FP_FRAC_ADD_##dwc (_FP_FMA_RD, _FP_FMA_TD, \ + _FP_FMA_ZD); \ else \ { \ - _FP_FRAC_SUB_##dwc (RD, TD, ZD); \ - if (_FP_FRAC_NEGP_##dwc (RD)) \ + _FP_FRAC_SUB_##dwc (_FP_FMA_RD, _FP_FMA_TD, \ + _FP_FMA_ZD); \ + if (_FP_FRAC_NEGP_##dwc (_FP_FMA_RD)) \ { \ R##_s = Z##_s; \ - _FP_FRAC_SUB_##dwc (RD, ZD, TD); \ + _FP_FRAC_SUB_##dwc (_FP_FMA_RD, _FP_FMA_ZD, \ + _FP_FMA_TD); \ } \ } \ } \ @@ -945,22 +1012,24 @@ { \ R##_e = Z##_e; \ R##_s = Z##_s; \ - _FP_FRAC_COPY_##dwc##_##wc (ZD, Z); \ - _FP_FRAC_SLL_##dwc (ZD, _FP_WFRACBITS_##fs); \ - int shift = -ediff - tsh; \ - if (shift >= _FP_WFRACBITS_DW_##fs) \ - _FP_FRAC_SET_##dwc (TD, _FP_MINFRAC_##dwc); \ - else if (shift > 0) \ - _FP_FRAC_SRS_##dwc (TD, shift, \ + _FP_FRAC_COPY_##dwc##_##wc (_FP_FMA_ZD, Z); \ + _FP_FRAC_SLL_##dwc (_FP_FMA_ZD, _FP_WFRACBITS_##fs); \ + int _FP_FMA_shift = -_FP_FMA_ediff - _FP_FMA_tsh; \ + if (_FP_FMA_shift >= _FP_WFRACBITS_DW_##fs) \ + _FP_FRAC_SET_##dwc (_FP_FMA_TD, _FP_MINFRAC_##dwc); \ + else if (_FP_FMA_shift > 0) \ + _FP_FRAC_SRS_##dwc (_FP_FMA_TD, _FP_FMA_shift, \ _FP_WFRACBITS_DW_##fs); \ - if (Z##_s == T##_s) \ - _FP_FRAC_ADD_##dwc (RD, ZD, TD); \ + if (Z##_s == _FP_FMA_T##_s) \ + _FP_FRAC_ADD_##dwc (_FP_FMA_RD, _FP_FMA_ZD, \ + _FP_FMA_TD); \ else \ - _FP_FRAC_SUB_##dwc (RD, ZD, TD); \ + _FP_FRAC_SUB_##dwc (_FP_FMA_RD, _FP_FMA_ZD, \ + _FP_FMA_TD); \ } \ - if (_FP_FRAC_ZEROP_##dwc (RD)) \ + if (_FP_FRAC_ZEROP_##dwc (_FP_FMA_RD)) \ { \ - if (T##_s == Z##_s) \ + if (_FP_FMA_T##_s == Z##_s) \ R##_s = Z##_s; \ else \ R##_s = (FP_ROUNDMODE == FP_RND_MINF); \ @@ -969,17 +1038,17 @@ } \ else \ { \ - int rlz; \ - _FP_FRAC_CLZ_##dwc (rlz, RD); \ - rlz -= _FP_WFRACXBITS_DW_##fs; \ - R##_e -= rlz; \ - int shift = _FP_WFRACBITS_##fs - rlz; \ - if (shift > 0) \ - _FP_FRAC_SRS_##dwc (RD, shift, \ + int _FP_FMA_rlz; \ + _FP_FRAC_CLZ_##dwc (_FP_FMA_rlz, _FP_FMA_RD); \ + _FP_FMA_rlz -= _FP_WFRACXBITS_DW_##fs; \ + R##_e -= _FP_FMA_rlz; \ + int _FP_FMA_shift = _FP_WFRACBITS_##fs - _FP_FMA_rlz; \ + if (_FP_FMA_shift > 0) \ + _FP_FRAC_SRS_##dwc (_FP_FMA_RD, _FP_FMA_shift, \ _FP_WFRACBITS_DW_##fs); \ - else if (shift < 0) \ - _FP_FRAC_SLL_##dwc (RD, -shift); \ - _FP_FRAC_COPY_##wc##_##dwc (R, RD); \ + else if (_FP_FMA_shift < 0) \ + _FP_FRAC_SLL_##dwc (_FP_FMA_RD, -_FP_FMA_shift); \ + _FP_FRAC_COPY_##wc##_##dwc (R, _FP_FMA_RD); \ R##_c = FP_CLS_NORMAL; \ } \ break; \ @@ -987,50 +1056,50 @@ goto done_fma; \ \ case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NAN): \ - _FP_CHOOSENAN (fs, wc, T, X, Y, '*'); \ + _FP_CHOOSENAN (fs, wc, _FP_FMA_T, X, Y, '*'); \ break; \ \ case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NORMAL): \ case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_INF): \ case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_ZERO): \ - T##_s = X##_s; \ + _FP_FMA_T##_s = X##_s; \ \ case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_INF): \ case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NORMAL): \ case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NORMAL): \ case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_ZERO): \ - _FP_FRAC_COPY_##wc (T, X); \ - T##_c = X##_c; \ + _FP_FRAC_COPY_##wc (_FP_FMA_T, X); \ + _FP_FMA_T##_c = X##_c; \ break; \ \ case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_NAN): \ case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NAN): \ case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NAN): \ - T##_s = Y##_s; \ + _FP_FMA_T##_s = Y##_s; \ \ case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_INF): \ case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_ZERO): \ - _FP_FRAC_COPY_##wc (T, Y); \ - T##_c = Y##_c; \ + _FP_FRAC_COPY_##wc (_FP_FMA_T, Y); \ + _FP_FMA_T##_c = Y##_c; \ break; \ \ case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_ZERO): \ case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_INF): \ - T##_s = _FP_NANSIGN_##fs; \ - T##_c = FP_CLS_NAN; \ - _FP_FRAC_SET_##wc (T, _FP_NANFRAC_##fs); \ - FP_SET_EXCEPTION (FP_EX_INVALID); \ + _FP_FMA_T##_s = _FP_NANSIGN_##fs; \ + _FP_FMA_T##_c = FP_CLS_NAN; \ + _FP_FRAC_SET_##wc (_FP_FMA_T, _FP_NANFRAC_##fs); \ + FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_IMZ_FMA); \ break; \ \ default: \ - abort (); \ + _FP_UNREACHABLE; \ } \ \ /* T = X * Y is zero, infinity or NaN. */ \ - switch (_FP_CLS_COMBINE (T##_c, Z##_c)) \ + switch (_FP_CLS_COMBINE (_FP_FMA_T##_c, Z##_c)) \ { \ case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NAN): \ - _FP_CHOOSENAN (fs, wc, R, T, Z, '+'); \ + _FP_CHOOSENAN (fs, wc, R, _FP_FMA_T, Z, '+'); \ break; \ \ case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NORMAL): \ @@ -1038,9 +1107,9 @@ case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_ZERO): \ case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NORMAL): \ case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_ZERO): \ - R##_s = T##_s; \ - _FP_FRAC_COPY_##wc (R, T); \ - R##_c = T##_c; \ + R##_s = _FP_FMA_T##_s; \ + _FP_FRAC_COPY_##wc (R, _FP_FMA_T); \ + R##_c = _FP_FMA_T##_c; \ break; \ \ case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NAN): \ @@ -1050,10 +1119,11 @@ R##_s = Z##_s; \ _FP_FRAC_COPY_##wc (R, Z); \ R##_c = Z##_c; \ + R##_e = Z##_e; \ break; \ \ case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_INF): \ - if (T##_s == Z##_s) \ + if (_FP_FMA_T##_s == Z##_s) \ { \ R##_s = Z##_s; \ _FP_FRAC_COPY_##wc (R, Z); \ @@ -1064,12 +1134,12 @@ R##_s = _FP_NANSIGN_##fs; \ R##_c = FP_CLS_NAN; \ _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \ - FP_SET_EXCEPTION (FP_EX_INVALID); \ + FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_ISI); \ } \ break; \ \ case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_ZERO): \ - if (T##_s == Z##_s) \ + if (_FP_FMA_T##_s == Z##_s) \ R##_s = Z##_s; \ else \ R##_s = (FP_ROUNDMODE == FP_RND_MINF); \ @@ -1078,16 +1148,14 @@ break; \ \ default: \ - abort (); \ + _FP_UNREACHABLE; \ } \ done_fma: ; \ } \ while (0) -/* - * Main division routine. The input values should be cooked. - */ +/* Main division routine. The input values should be cooked. */ #define _FP_DIV(fs, wc, R, X, Y) \ do \ @@ -1140,56 +1208,138 @@ R##_s = _FP_NANSIGN_##fs; \ R##_c = FP_CLS_NAN; \ _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \ - FP_SET_EXCEPTION (FP_EX_INVALID); \ + FP_SET_EXCEPTION (FP_EX_INVALID \ + | (X##_c == FP_CLS_INF \ + ? FP_EX_INVALID_IDI \ + : FP_EX_INVALID_ZDZ)); \ break; \ \ default: \ - abort (); \ + _FP_UNREACHABLE; \ } \ } \ while (0) -/* - * Main differential comparison routine. The inputs should be raw not - * cooked. The return is -1,0,1 for normal values, 2 otherwise. - */ +/* Helper for comparisons. EX is 0 not to raise exceptions, 1 to + raise exceptions for signaling NaN operands, 2 to raise exceptions + for all NaN operands. Conditionals are organized to allow the + compiler to optimize away code based on the value of EX. */ + +#define _FP_CMP_CHECK_NAN(fs, wc, X, Y, ex) \ + do \ + { \ + /* The arguments are unordered, which may or may not result in \ + an exception. */ \ + if (ex) \ + { \ + /* At least some cases of unordered arguments result in \ + exceptions; check whether this is one. */ \ + if (FP_EX_INVALID_SNAN || FP_EX_INVALID_VC) \ + { \ + /* Check separately for each case of "invalid" \ + exceptions. */ \ + if ((ex) == 2) \ + FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_VC); \ + if (_FP_ISSIGNAN (fs, wc, X) \ + || _FP_ISSIGNAN (fs, wc, Y)) \ + FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_SNAN); \ + } \ + /* Otherwise, we only need to check whether to raise an \ + exception, not which case or cases it is. */ \ + else if ((ex) == 2 \ + || _FP_ISSIGNAN (fs, wc, X) \ + || _FP_ISSIGNAN (fs, wc, Y)) \ + FP_SET_EXCEPTION (FP_EX_INVALID); \ + } \ + } \ + while (0) + +/* Helper for comparisons. If denormal operands would raise an + exception, check for them, and flush to zero as appropriate + (otherwise, we need only check and flush to zero if it might affect + the result, which is done later with _FP_CMP_CHECK_FLUSH_ZERO). */ +#define _FP_CMP_CHECK_DENORM(fs, wc, X, Y) \ + do \ + { \ + if (FP_EX_DENORM != 0) \ + { \ + /* We must ensure the correct exceptions are raised for \ + denormal operands, even though this may not affect the \ + result of the comparison. */ \ + if (FP_DENORM_ZERO) \ + { \ + _FP_CHECK_FLUSH_ZERO (fs, wc, X); \ + _FP_CHECK_FLUSH_ZERO (fs, wc, Y); \ + } \ + else \ + { \ + if ((X##_e == 0 && !_FP_FRAC_ZEROP_##wc (X)) \ + || (Y##_e == 0 && !_FP_FRAC_ZEROP_##wc (Y))) \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ + } \ + } \ + } \ + while (0) + +/* Helper for comparisons. Check for flushing denormals for zero if + we didn't need to check earlier for any denormal operands. */ +#define _FP_CMP_CHECK_FLUSH_ZERO(fs, wc, X, Y) \ + do \ + { \ + if (FP_EX_DENORM == 0) \ + { \ + _FP_CHECK_FLUSH_ZERO (fs, wc, X); \ + _FP_CHECK_FLUSH_ZERO (fs, wc, Y); \ + } \ + } \ + while (0) + +/* Main differential comparison routine. The inputs should be raw not + cooked. The return is -1, 0, 1 for normal values, UN + otherwise. */ -#define _FP_CMP(fs, wc, ret, X, Y, un) \ +#define _FP_CMP(fs, wc, ret, X, Y, un, ex) \ do \ { \ - /* NANs are unordered */ \ + _FP_CMP_CHECK_DENORM (fs, wc, X, Y); \ + /* NANs are unordered. */ \ if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (X)) \ || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (Y))) \ { \ - ret = un; \ + (ret) = (un); \ + _FP_CMP_CHECK_NAN (fs, wc, X, Y, (ex)); \ } \ else \ { \ - int __is_zero_x; \ - int __is_zero_y; \ + int _FP_CMP_is_zero_x; \ + int _FP_CMP_is_zero_y; \ \ - __is_zero_x = (!X##_e && _FP_FRAC_ZEROP_##wc (X)) ? 1 : 0; \ - __is_zero_y = (!Y##_e && _FP_FRAC_ZEROP_##wc (Y)) ? 1 : 0; \ + _FP_CMP_CHECK_FLUSH_ZERO (fs, wc, X, Y); \ \ - if (__is_zero_x && __is_zero_y) \ - ret = 0; \ - else if (__is_zero_x) \ - ret = Y##_s ? 1 : -1; \ - else if (__is_zero_y) \ - ret = X##_s ? -1 : 1; \ + _FP_CMP_is_zero_x \ + = (!X##_e && _FP_FRAC_ZEROP_##wc (X)) ? 1 : 0; \ + _FP_CMP_is_zero_y \ + = (!Y##_e && _FP_FRAC_ZEROP_##wc (Y)) ? 1 : 0; \ + \ + if (_FP_CMP_is_zero_x && _FP_CMP_is_zero_y) \ + (ret) = 0; \ + else if (_FP_CMP_is_zero_x) \ + (ret) = Y##_s ? 1 : -1; \ + else if (_FP_CMP_is_zero_y) \ + (ret) = X##_s ? -1 : 1; \ else if (X##_s != Y##_s) \ - ret = X##_s ? -1 : 1; \ + (ret) = X##_s ? -1 : 1; \ else if (X##_e > Y##_e) \ - ret = X##_s ? -1 : 1; \ + (ret) = X##_s ? -1 : 1; \ else if (X##_e < Y##_e) \ - ret = X##_s ? 1 : -1; \ + (ret) = X##_s ? 1 : -1; \ else if (_FP_FRAC_GT_##wc (X, Y)) \ - ret = X##_s ? -1 : 1; \ + (ret) = X##_s ? -1 : 1; \ else if (_FP_FRAC_GT_##wc (Y, X)) \ - ret = X##_s ? 1 : -1; \ + (ret) = X##_s ? 1 : -1; \ else \ - ret = 0; \ + (ret) = 0; \ } \ } \ while (0) @@ -1197,215 +1347,479 @@ /* Simplification for strict equality. */ -#define _FP_CMP_EQ(fs, wc, ret, X, Y) \ +#define _FP_CMP_EQ(fs, wc, ret, X, Y, ex) \ do \ { \ - /* NANs are unordered */ \ + _FP_CMP_CHECK_DENORM (fs, wc, X, Y); \ + /* NANs are unordered. */ \ if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (X)) \ || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (Y))) \ { \ - ret = 1; \ + (ret) = 1; \ + _FP_CMP_CHECK_NAN (fs, wc, X, Y, (ex)); \ } \ else \ { \ - ret = !(X##_e == Y##_e \ - && _FP_FRAC_EQ_##wc (X, Y) \ - && (X##_s == Y##_s || (!X##_e && _FP_FRAC_ZEROP_##wc (X)))); \ + _FP_CMP_CHECK_FLUSH_ZERO (fs, wc, X, Y); \ + \ + (ret) = !(X##_e == Y##_e \ + && _FP_FRAC_EQ_##wc (X, Y) \ + && (X##_s == Y##_s \ + || (!X##_e && _FP_FRAC_ZEROP_##wc (X)))); \ } \ } \ while (0) /* Version to test unordered. */ -#define _FP_CMP_UNORD(fs, wc, ret, X, Y) \ +#define _FP_CMP_UNORD(fs, wc, ret, X, Y, ex) \ do \ { \ - ret = ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (X)) \ - || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (Y))); \ + _FP_CMP_CHECK_DENORM (fs, wc, X, Y); \ + (ret) = ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (X)) \ + || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (Y))); \ + if (ret) \ + _FP_CMP_CHECK_NAN (fs, wc, X, Y, (ex)); \ } \ while (0) -/* - * Main square root routine. The input value should be cooked. - */ +/* Main square root routine. The input value should be cooked. */ -#define _FP_SQRT(fs, wc, R, X) \ - do \ - { \ - _FP_FRAC_DECL_##wc (T); \ - _FP_FRAC_DECL_##wc (S); \ - _FP_W_TYPE q; \ - switch (X##_c) \ - { \ - case FP_CLS_NAN: \ - _FP_FRAC_COPY_##wc (R, X); \ - R##_s = X##_s; \ - R##_c = FP_CLS_NAN; \ - break; \ - case FP_CLS_INF: \ - if (X##_s) \ - { \ - R##_s = _FP_NANSIGN_##fs; \ - R##_c = FP_CLS_NAN; /* NAN */ \ - _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \ - FP_SET_EXCEPTION (FP_EX_INVALID); \ - } \ - else \ - { \ - R##_s = 0; \ - R##_c = FP_CLS_INF; /* sqrt(+inf) = +inf */ \ - } \ - break; \ - case FP_CLS_ZERO: \ - R##_s = X##_s; \ - R##_c = FP_CLS_ZERO; /* sqrt(+-0) = +-0 */ \ - break; \ - case FP_CLS_NORMAL: \ - R##_s = 0; \ - if (X##_s) \ - { \ - R##_c = FP_CLS_NAN; /* NAN */ \ - R##_s = _FP_NANSIGN_##fs; \ - _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \ - FP_SET_EXCEPTION (FP_EX_INVALID); \ - break; \ - } \ - R##_c = FP_CLS_NORMAL; \ - if (X##_e & 1) \ - _FP_FRAC_SLL_##wc (X, 1); \ - R##_e = X##_e >> 1; \ - _FP_FRAC_SET_##wc (S, _FP_ZEROFRAC_##wc); \ - _FP_FRAC_SET_##wc (R, _FP_ZEROFRAC_##wc); \ - q = _FP_OVERFLOW_##fs >> 1; \ - _FP_SQRT_MEAT_##wc (R, S, T, X, q); \ - } \ - } \ +#define _FP_SQRT(fs, wc, R, X) \ + do \ + { \ + _FP_FRAC_DECL_##wc (_FP_SQRT_T); \ + _FP_FRAC_DECL_##wc (_FP_SQRT_S); \ + _FP_W_TYPE _FP_SQRT_q; \ + switch (X##_c) \ + { \ + case FP_CLS_NAN: \ + _FP_FRAC_COPY_##wc (R, X); \ + R##_s = X##_s; \ + R##_c = FP_CLS_NAN; \ + break; \ + case FP_CLS_INF: \ + if (X##_s) \ + { \ + R##_s = _FP_NANSIGN_##fs; \ + R##_c = FP_CLS_NAN; /* NAN */ \ + _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \ + FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_SQRT); \ + } \ + else \ + { \ + R##_s = 0; \ + R##_c = FP_CLS_INF; /* sqrt(+inf) = +inf */ \ + } \ + break; \ + case FP_CLS_ZERO: \ + R##_s = X##_s; \ + R##_c = FP_CLS_ZERO; /* sqrt(+-0) = +-0 */ \ + break; \ + case FP_CLS_NORMAL: \ + R##_s = 0; \ + if (X##_s) \ + { \ + R##_c = FP_CLS_NAN; /* NAN */ \ + R##_s = _FP_NANSIGN_##fs; \ + _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \ + FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_SQRT); \ + break; \ + } \ + R##_c = FP_CLS_NORMAL; \ + if (X##_e & 1) \ + _FP_FRAC_SLL_##wc (X, 1); \ + R##_e = X##_e >> 1; \ + _FP_FRAC_SET_##wc (_FP_SQRT_S, _FP_ZEROFRAC_##wc); \ + _FP_FRAC_SET_##wc (R, _FP_ZEROFRAC_##wc); \ + _FP_SQRT_q = _FP_OVERFLOW_##fs >> 1; \ + _FP_SQRT_MEAT_##wc (R, _FP_SQRT_S, _FP_SQRT_T, X, \ + _FP_SQRT_q); \ + } \ + } \ while (0) -/* - * Convert from FP to integer. Input is raw. - */ +/* Convert from FP to integer. Input is raw. */ /* RSIGNED can have following values: - * 0: the number is required to be 0..(2^rsize)-1, if not, NV is set plus - * the result is either 0 or (2^rsize)-1 depending on the sign in such - * case. - * 1: the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not, - * NV is set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1 - * depending on the sign in such case. - * -1: the number is required to be -(2^(rsize-1))..(2^rsize)-1, if not, NV is - * set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1 - * depending on the sign in such case. - */ + 0: the number is required to be 0..(2^rsize)-1, if not, NV is set plus + the result is either 0 or (2^rsize)-1 depending on the sign in such + case. + 1: the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not, + NV is set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1 + depending on the sign in such case. + 2: the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not, + NV is set plus the result is reduced modulo 2^rsize. + -1: the number is required to be -(2^(rsize-1))..(2^rsize)-1, if not, NV is + set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1 + depending on the sign in such case. */ #define _FP_TO_INT(fs, wc, r, X, rsize, rsigned) \ do \ { \ if (X##_e < _FP_EXPBIAS_##fs) \ { \ - r = 0; \ + (r) = 0; \ if (X##_e == 0) \ { \ if (!_FP_FRAC_ZEROP_##wc (X)) \ { \ - FP_SET_EXCEPTION (FP_EX_INEXACT); \ + if (!FP_DENORM_ZERO) \ + FP_SET_EXCEPTION (FP_EX_INEXACT); \ FP_SET_EXCEPTION (FP_EX_DENORM); \ } \ } \ else \ FP_SET_EXCEPTION (FP_EX_INEXACT); \ } \ - else if (X##_e >= _FP_EXPBIAS_##fs + rsize - (rsigned > 0 || X##_s) \ - || (!rsigned && X##_s)) \ + else if ((rsigned) == 2 \ + && (X##_e \ + >= ((_FP_EXPMAX_##fs \ + < _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs + (rsize) - 1) \ + ? _FP_EXPMAX_##fs \ + : _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs + (rsize) - 1))) \ + { \ + /* Overflow resulting in 0. */ \ + (r) = 0; \ + FP_SET_EXCEPTION (FP_EX_INVALID \ + | FP_EX_INVALID_CVI \ + | ((FP_EX_INVALID_SNAN \ + && _FP_ISSIGNAN (fs, wc, X)) \ + ? FP_EX_INVALID_SNAN \ + : 0)); \ + } \ + else if ((rsigned) != 2 \ + && (X##_e >= (_FP_EXPMAX_##fs < _FP_EXPBIAS_##fs + (rsize) \ + ? _FP_EXPMAX_##fs \ + : (_FP_EXPBIAS_##fs + (rsize) \ + - ((rsigned) > 0 || X##_s))) \ + || (!(rsigned) && X##_s))) \ { \ /* Overflow or converting to the most negative integer. */ \ if (rsigned) \ { \ - r = 1; \ - r <<= rsize - 1; \ - r -= 1 - X##_s; \ - } else { \ - r = 0; \ - if (!X##_s) \ - r = ~r; \ - } \ + (r) = 1; \ + (r) <<= (rsize) - 1; \ + (r) -= 1 - X##_s; \ + } \ + else \ + { \ + (r) = 0; \ + if (!X##_s) \ + (r) = ~(r); \ + } \ \ - if (rsigned && X##_s && X##_e == _FP_EXPBIAS_##fs + rsize - 1) \ + if (_FP_EXPBIAS_##fs + (rsize) - 1 < _FP_EXPMAX_##fs \ + && (rsigned) \ + && X##_s \ + && X##_e == _FP_EXPBIAS_##fs + (rsize) - 1) \ { \ /* Possibly converting to most negative integer; check the \ mantissa. */ \ - int inexact = 0; \ - (void) ((_FP_FRACBITS_##fs > rsize) \ + int _FP_TO_INT_inexact = 0; \ + (void) ((_FP_FRACBITS_##fs > (rsize)) \ ? ({ \ - _FP_FRAC_SRST_##wc (X, inexact, \ - _FP_FRACBITS_##fs - rsize, \ + _FP_FRAC_SRST_##wc (X, _FP_TO_INT_inexact, \ + _FP_FRACBITS_##fs - (rsize), \ _FP_FRACBITS_##fs); \ 0; \ }) \ : 0); \ if (!_FP_FRAC_ZEROP_##wc (X)) \ - FP_SET_EXCEPTION (FP_EX_INVALID); \ - else if (inexact) \ + FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_CVI); \ + else if (_FP_TO_INT_inexact) \ FP_SET_EXCEPTION (FP_EX_INEXACT); \ } \ else \ - FP_SET_EXCEPTION (FP_EX_INVALID); \ + FP_SET_EXCEPTION (FP_EX_INVALID \ + | FP_EX_INVALID_CVI \ + | ((FP_EX_INVALID_SNAN \ + && _FP_ISSIGNAN (fs, wc, X)) \ + ? FP_EX_INVALID_SNAN \ + : 0)); \ } \ else \ { \ + int _FP_TO_INT_inexact = 0; \ _FP_FRAC_HIGH_RAW_##fs (X) |= _FP_IMPLBIT_##fs; \ if (X##_e >= _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs - 1) \ { \ - _FP_FRAC_ASSEMBLE_##wc (r, X, rsize); \ - r <<= X##_e - _FP_EXPBIAS_##fs - _FP_FRACBITS_##fs + 1; \ + _FP_FRAC_ASSEMBLE_##wc ((r), X, (rsize)); \ + (r) <<= X##_e - _FP_EXPBIAS_##fs - _FP_FRACBITS_##fs + 1; \ } \ else \ { \ - int inexact; \ - _FP_FRAC_SRST_##wc (X, inexact, \ + _FP_FRAC_SRST_##wc (X, _FP_TO_INT_inexact, \ (_FP_FRACBITS_##fs + _FP_EXPBIAS_##fs - 1 \ - X##_e), \ _FP_FRACBITS_##fs); \ - if (inexact) \ - FP_SET_EXCEPTION (FP_EX_INEXACT); \ - _FP_FRAC_ASSEMBLE_##wc (r, X, rsize); \ + _FP_FRAC_ASSEMBLE_##wc ((r), X, (rsize)); \ } \ - if (rsigned && X##_s) \ - r = -r; \ + if ((rsigned) && X##_s) \ + (r) = -(r); \ + if ((rsigned) == 2 && X##_e >= _FP_EXPBIAS_##fs + (rsize) - 1) \ + { \ + /* Overflow or converting to the most negative integer. */ \ + if (X##_e > _FP_EXPBIAS_##fs + (rsize) - 1 \ + || !X##_s \ + || (r) != (((typeof (r)) 1) << ((rsize) - 1))) \ + { \ + _FP_TO_INT_inexact = 0; \ + FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_CVI); \ + } \ + } \ + if (_FP_TO_INT_inexact) \ + FP_SET_EXCEPTION (FP_EX_INEXACT); \ } \ } \ while (0) +/* Convert from floating point to integer, rounding according to the + current rounding direction. Input is raw. RSIGNED is as for + _FP_TO_INT. */ +#define _FP_TO_INT_ROUND(fs, wc, r, X, rsize, rsigned) \ + do \ + { \ + __label__ _FP_TO_INT_ROUND_done; \ + if (X##_e < _FP_EXPBIAS_##fs) \ + { \ + int _FP_TO_INT_ROUND_rounds_away = 0; \ + if (X##_e == 0) \ + { \ + if (_FP_FRAC_ZEROP_##wc (X)) \ + { \ + (r) = 0; \ + goto _FP_TO_INT_ROUND_done; \ + } \ + else \ + { \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ + if (FP_DENORM_ZERO) \ + { \ + (r) = 0; \ + goto _FP_TO_INT_ROUND_done; \ + } \ + } \ + } \ + /* The result is 0, 1 or -1 depending on the rounding mode; \ + -1 may cause overflow in the unsigned case. */ \ + switch (FP_ROUNDMODE) \ + { \ + case FP_RND_NEAREST: \ + _FP_TO_INT_ROUND_rounds_away \ + = (X##_e == _FP_EXPBIAS_##fs - 1 \ + && !_FP_FRAC_ZEROP_##wc (X)); \ + break; \ + case FP_RND_ZERO: \ + /* _FP_TO_INT_ROUND_rounds_away is already 0. */ \ + break; \ + case FP_RND_PINF: \ + _FP_TO_INT_ROUND_rounds_away = !X##_s; \ + break; \ + case FP_RND_MINF: \ + _FP_TO_INT_ROUND_rounds_away = X##_s; \ + break; \ + } \ + if ((rsigned) == 0 && _FP_TO_INT_ROUND_rounds_away && X##_s) \ + { \ + /* Result of -1 for an unsigned conversion. */ \ + (r) = 0; \ + FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_CVI); \ + } \ + else if ((rsize) == 1 && (rsigned) > 0 \ + && _FP_TO_INT_ROUND_rounds_away && !X##_s) \ + { \ + /* Converting to a 1-bit signed bit-field, which cannot \ + represent +1. */ \ + (r) = ((rsigned) == 2 ? -1 : 0); \ + FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_CVI); \ + } \ + else \ + { \ + (r) = (_FP_TO_INT_ROUND_rounds_away \ + ? (X##_s ? -1 : 1) \ + : 0); \ + FP_SET_EXCEPTION (FP_EX_INEXACT); \ + } \ + } \ + else if ((rsigned) == 2 \ + && (X##_e \ + >= ((_FP_EXPMAX_##fs \ + < _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs + (rsize) - 1) \ + ? _FP_EXPMAX_##fs \ + : _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs + (rsize) - 1))) \ + { \ + /* Overflow resulting in 0. */ \ + (r) = 0; \ + FP_SET_EXCEPTION (FP_EX_INVALID \ + | FP_EX_INVALID_CVI \ + | ((FP_EX_INVALID_SNAN \ + && _FP_ISSIGNAN (fs, wc, X)) \ + ? FP_EX_INVALID_SNAN \ + : 0)); \ + } \ + else if ((rsigned) != 2 \ + && (X##_e >= (_FP_EXPMAX_##fs < _FP_EXPBIAS_##fs + (rsize) \ + ? _FP_EXPMAX_##fs \ + : (_FP_EXPBIAS_##fs + (rsize) \ + - ((rsigned) > 0 && !X##_s))) \ + || ((rsigned) == 0 && X##_s))) \ + { \ + /* Definite overflow (does not require rounding to tell). */ \ + if ((rsigned) != 0) \ + { \ + (r) = 1; \ + (r) <<= (rsize) - 1; \ + (r) -= 1 - X##_s; \ + } \ + else \ + { \ + (r) = 0; \ + if (!X##_s) \ + (r) = ~(r); \ + } \ + \ + FP_SET_EXCEPTION (FP_EX_INVALID \ + | FP_EX_INVALID_CVI \ + | ((FP_EX_INVALID_SNAN \ + && _FP_ISSIGNAN (fs, wc, X)) \ + ? FP_EX_INVALID_SNAN \ + : 0)); \ + } \ + else \ + { \ + /* The value is finite, with magnitude at least 1. If \ + the conversion is unsigned, the value is positive. \ + If RSIGNED is not 2, the value does not definitely \ + overflow by virtue of its exponent, but may still turn \ + out to overflow after rounding; if RSIGNED is 2, the \ + exponent may be such that the value definitely overflows, \ + but at least one mantissa bit will not be shifted out. */ \ + int _FP_TO_INT_ROUND_inexact = 0; \ + _FP_FRAC_HIGH_RAW_##fs (X) |= _FP_IMPLBIT_##fs; \ + if (X##_e >= _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs - 1) \ + { \ + /* The value is an integer, no rounding needed. */ \ + _FP_FRAC_ASSEMBLE_##wc ((r), X, (rsize)); \ + (r) <<= X##_e - _FP_EXPBIAS_##fs - _FP_FRACBITS_##fs + 1; \ + } \ + else \ + { \ + /* May need to shift in order to round (unless there \ + are exactly _FP_WORKBITS fractional bits already). */ \ + int _FP_TO_INT_ROUND_rshift \ + = (_FP_FRACBITS_##fs + _FP_EXPBIAS_##fs \ + - 1 - _FP_WORKBITS - X##_e); \ + if (_FP_TO_INT_ROUND_rshift > 0) \ + _FP_FRAC_SRS_##wc (X, _FP_TO_INT_ROUND_rshift, \ + _FP_WFRACBITS_##fs); \ + else if (_FP_TO_INT_ROUND_rshift < 0) \ + _FP_FRAC_SLL_##wc (X, -_FP_TO_INT_ROUND_rshift); \ + /* Round like _FP_ROUND, but setting \ + _FP_TO_INT_ROUND_inexact instead of directly setting \ + the "inexact" exception, since it may turn out we \ + should set "invalid" instead. */ \ + if (_FP_FRAC_LOW_##wc (X) & 7) \ + { \ + _FP_TO_INT_ROUND_inexact = 1; \ + switch (FP_ROUNDMODE) \ + { \ + case FP_RND_NEAREST: \ + _FP_ROUND_NEAREST (wc, X); \ + break; \ + case FP_RND_ZERO: \ + _FP_ROUND_ZERO (wc, X); \ + break; \ + case FP_RND_PINF: \ + _FP_ROUND_PINF (wc, X); \ + break; \ + case FP_RND_MINF: \ + _FP_ROUND_MINF (wc, X); \ + break; \ + } \ + } \ + _FP_FRAC_SRL_##wc (X, _FP_WORKBITS); \ + _FP_FRAC_ASSEMBLE_##wc ((r), X, (rsize)); \ + } \ + if ((rsigned) != 0 && X##_s) \ + (r) = -(r); \ + /* An exponent of RSIZE - 1 always needs testing for \ + overflow (either directly overflowing, or overflowing \ + when rounding up results in 2^RSIZE). An exponent of \ + RSIZE - 2 can overflow for positive values when rounding \ + up to 2^(RSIZE-1), but cannot overflow for negative \ + values. Smaller exponents cannot overflow. */ \ + if (X##_e >= (_FP_EXPBIAS_##fs + (rsize) - 1 \ + - ((rsigned) > 0 && !X##_s))) \ + { \ + if (X##_e > _FP_EXPBIAS_##fs + (rsize) - 1 \ + || (X##_e == _FP_EXPBIAS_##fs + (rsize) - 1 \ + && (X##_s \ + ? (r) != (((typeof (r)) 1) << ((rsize) - 1)) \ + : ((rsigned) > 0 || (r) == 0))) \ + || ((rsigned) > 0 \ + && !X##_s \ + && X##_e == _FP_EXPBIAS_##fs + (rsize) - 2 \ + && (r) == (((typeof (r)) 1) << ((rsize) - 1)))) \ + { \ + if ((rsigned) != 2) \ + { \ + if ((rsigned) != 0) \ + { \ + (r) = 1; \ + (r) <<= (rsize) - 1; \ + (r) -= 1 - X##_s; \ + } \ + else \ + { \ + (r) = 0; \ + (r) = ~(r); \ + } \ + } \ + _FP_TO_INT_ROUND_inexact = 0; \ + FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_CVI); \ + } \ + } \ + if (_FP_TO_INT_ROUND_inexact) \ + FP_SET_EXCEPTION (FP_EX_INEXACT); \ + } \ + _FP_TO_INT_ROUND_done: ; \ + } \ + while (0) + /* Convert integer to fp. Output is raw. RTYPE is unsigned even if input is signed. */ #define _FP_FROM_INT(fs, wc, X, r, rsize, rtype) \ do \ { \ + __label__ pack_semiraw; \ if (r) \ { \ - rtype ur_; \ + rtype _FP_FROM_INT_ur = (r); \ \ - if ((X##_s = (r < 0))) \ - r = -(rtype) r; \ + if ((X##_s = ((r) < 0))) \ + _FP_FROM_INT_ur = -_FP_FROM_INT_ur; \ \ - ur_ = (rtype) r; \ - (void) ((rsize <= _FP_W_TYPE_SIZE) \ + _FP_STATIC_ASSERT ((rsize) <= 2 * _FP_W_TYPE_SIZE, \ + "rsize too large"); \ + (void) (((rsize) <= _FP_W_TYPE_SIZE) \ ? ({ \ - int lz_; \ - __FP_CLZ (lz_, (_FP_W_TYPE) ur_); \ - X##_e = _FP_EXPBIAS_##fs + _FP_W_TYPE_SIZE - 1 - lz_; \ + int _FP_FROM_INT_lz; \ + __FP_CLZ (_FP_FROM_INT_lz, \ + (_FP_W_TYPE) _FP_FROM_INT_ur); \ + X##_e = (_FP_EXPBIAS_##fs + _FP_W_TYPE_SIZE - 1 \ + - _FP_FROM_INT_lz); \ }) \ - : ((rsize <= 2 * _FP_W_TYPE_SIZE) \ - ? ({ \ - int lz_; \ - __FP_CLZ_2 (lz_, \ - (_FP_W_TYPE) (ur_ >> _FP_W_TYPE_SIZE), \ - (_FP_W_TYPE) ur_); \ - X##_e = (_FP_EXPBIAS_##fs + 2 * _FP_W_TYPE_SIZE - 1 \ - - lz_); \ - }) \ - : (abort (), 0))); \ + : ({ \ + int _FP_FROM_INT_lz; \ + __FP_CLZ_2 (_FP_FROM_INT_lz, \ + (_FP_W_TYPE) (_FP_FROM_INT_ur \ + >> _FP_W_TYPE_SIZE), \ + (_FP_W_TYPE) _FP_FROM_INT_ur); \ + X##_e = (_FP_EXPBIAS_##fs + 2 * _FP_W_TYPE_SIZE - 1 \ + - _FP_FROM_INT_lz); \ + })); \ \ - if (rsize - 1 + _FP_EXPBIAS_##fs >= _FP_EXPMAX_##fs \ + if ((rsize) - 1 + _FP_EXPBIAS_##fs >= _FP_EXPMAX_##fs \ && X##_e >= _FP_EXPMAX_##fs) \ { \ /* Exponent too big; overflow to infinity. (May also \ @@ -1414,11 +1828,11 @@ goto pack_semiraw; \ } \ \ - if (rsize <= _FP_FRACBITS_##fs \ + if ((rsize) <= _FP_FRACBITS_##fs \ || X##_e < _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs) \ { \ /* Exactly representable; shift left. */ \ - _FP_FRAC_DISASSEMBLE_##wc (X, ur_, rsize); \ + _FP_FRAC_DISASSEMBLE_##wc (X, _FP_FROM_INT_ur, (rsize)); \ if (_FP_EXPBIAS_##fs + _FP_FRACBITS_##fs - 1 - X##_e > 0) \ _FP_FRAC_SLL_##wc (X, (_FP_EXPBIAS_##fs \ + _FP_FRACBITS_##fs - 1 - X##_e)); \ @@ -1428,12 +1842,14 @@ /* More bits in integer than in floating type; need to \ round. */ \ if (_FP_EXPBIAS_##fs + _FP_WFRACBITS_##fs - 1 < X##_e) \ - ur_ = ((ur_ >> (X##_e - _FP_EXPBIAS_##fs \ - - _FP_WFRACBITS_##fs + 1)) \ - | ((ur_ << (rsize - (X##_e - _FP_EXPBIAS_##fs \ - - _FP_WFRACBITS_##fs + 1))) \ - != 0)); \ - _FP_FRAC_DISASSEMBLE_##wc (X, ur_, rsize); \ + _FP_FROM_INT_ur \ + = ((_FP_FROM_INT_ur >> (X##_e - _FP_EXPBIAS_##fs \ + - _FP_WFRACBITS_##fs + 1)) \ + | ((_FP_FROM_INT_ur \ + << ((rsize) - (X##_e - _FP_EXPBIAS_##fs \ + - _FP_WFRACBITS_##fs + 1))) \ + != 0)); \ + _FP_FRAC_DISASSEMBLE_##wc (X, _FP_FROM_INT_ur, (rsize)); \ if ((_FP_EXPBIAS_##fs + _FP_WFRACBITS_##fs - 1 - X##_e) > 0) \ _FP_FRAC_SLL_##wc (X, (_FP_EXPBIAS_##fs \ + _FP_WFRACBITS_##fs - 1 - X##_e)); \ @@ -1453,16 +1869,24 @@ /* Extend from a narrower floating-point format to a wider one. Input - and output are raw. */ -#define FP_EXTEND(dfs, sfs, dwc, swc, D, S) \ + and output are raw. If CHECK_NAN, then signaling NaNs are + converted to quiet with the "invalid" exception raised; otherwise + signaling NaNs remain signaling with no exception. */ +#define _FP_EXTEND_CNAN(dfs, sfs, dwc, swc, D, S, check_nan) \ do \ { \ - if (_FP_FRACBITS_##dfs < _FP_FRACBITS_##sfs \ - || (_FP_EXPMAX_##dfs - _FP_EXPBIAS_##dfs \ - < _FP_EXPMAX_##sfs - _FP_EXPBIAS_##sfs) \ - || (_FP_EXPBIAS_##dfs < _FP_EXPBIAS_##sfs + _FP_FRACBITS_##sfs - 1 \ - && _FP_EXPBIAS_##dfs != _FP_EXPBIAS_##sfs)) \ - abort (); \ + _FP_STATIC_ASSERT (_FP_FRACBITS_##dfs >= _FP_FRACBITS_##sfs, \ + "destination mantissa narrower than source"); \ + _FP_STATIC_ASSERT ((_FP_EXPMAX_##dfs - _FP_EXPBIAS_##dfs \ + >= _FP_EXPMAX_##sfs - _FP_EXPBIAS_##sfs), \ + "destination max exponent smaller" \ + " than source"); \ + _FP_STATIC_ASSERT (((_FP_EXPBIAS_##dfs \ + >= (_FP_EXPBIAS_##sfs \ + + _FP_FRACBITS_##sfs - 1)) \ + || (_FP_EXPBIAS_##dfs == _FP_EXPBIAS_##sfs)), \ + "source subnormals do not all become normal," \ + " but bias not the same"); \ D##_s = S##_s; \ _FP_FRAC_COPY_##dwc##_##swc (D, S); \ if (_FP_EXP_NORMAL (sfs, swc, S)) \ @@ -1474,6 +1898,7 @@ { \ if (S##_e == 0) \ { \ + _FP_CHECK_FLUSH_ZERO (sfs, swc, S); \ if (_FP_FRAC_ZEROP_##swc (S)) \ D##_e = 0; \ else if (_FP_EXPBIAS_##dfs \ @@ -1483,17 +1908,19 @@ _FP_FRAC_SLL_##dwc (D, (_FP_FRACBITS_##dfs \ - _FP_FRACBITS_##sfs)); \ D##_e = 0; \ + if (FP_TRAPPING_EXCEPTIONS & FP_EX_UNDERFLOW) \ + FP_SET_EXCEPTION (FP_EX_UNDERFLOW); \ } \ else \ { \ - int _lz; \ + int FP_EXTEND_lz; \ FP_SET_EXCEPTION (FP_EX_DENORM); \ - _FP_FRAC_CLZ_##swc (_lz, S); \ + _FP_FRAC_CLZ_##swc (FP_EXTEND_lz, S); \ _FP_FRAC_SLL_##dwc (D, \ - _lz + _FP_FRACBITS_##dfs \ + FP_EXTEND_lz + _FP_FRACBITS_##dfs \ - _FP_FRACTBITS_##sfs); \ D##_e = (_FP_EXPBIAS_##dfs - _FP_EXPBIAS_##sfs + 1 \ - + _FP_FRACXBITS_##sfs - _lz); \ + + _FP_FRACXBITS_##sfs - FP_EXTEND_lz); \ } \ } \ else \ @@ -1501,26 +1928,35 @@ D##_e = _FP_EXPMAX_##dfs; \ if (!_FP_FRAC_ZEROP_##swc (S)) \ { \ - if (_FP_FRAC_SNANP (sfs, S)) \ - FP_SET_EXCEPTION (FP_EX_INVALID); \ + if (check_nan && _FP_FRAC_SNANP (sfs, S)) \ + FP_SET_EXCEPTION (FP_EX_INVALID \ + | FP_EX_INVALID_SNAN); \ _FP_FRAC_SLL_##dwc (D, (_FP_FRACBITS_##dfs \ - _FP_FRACBITS_##sfs)); \ - _FP_SETQNAN (dfs, dwc, D); \ + if (check_nan) \ + _FP_SETQNAN (dfs, dwc, D); \ } \ } \ } \ } \ while (0) +#define FP_EXTEND(dfs, sfs, dwc, swc, D, S) \ + _FP_EXTEND_CNAN (dfs, sfs, dwc, swc, D, S, 1) + /* Truncate from a wider floating-point format to a narrower one. Input and output are semi-raw. */ #define FP_TRUNC(dfs, sfs, dwc, swc, D, S) \ do \ { \ - if (_FP_FRACBITS_##sfs < _FP_FRACBITS_##dfs \ - || (_FP_EXPBIAS_##sfs < _FP_EXPBIAS_##dfs + _FP_FRACBITS_##dfs - 1 \ - && _FP_EXPBIAS_##sfs != _FP_EXPBIAS_##dfs)) \ - abort (); \ + _FP_STATIC_ASSERT (_FP_FRACBITS_##sfs >= _FP_FRACBITS_##dfs, \ + "destination mantissa wider than source"); \ + _FP_STATIC_ASSERT (((_FP_EXPBIAS_##sfs \ + >= (_FP_EXPBIAS_##dfs \ + + _FP_FRACBITS_##dfs - 1)) \ + || _FP_EXPBIAS_##sfs == _FP_EXPBIAS_##dfs), \ + "source subnormals do not all become same," \ + " but bias not the same"); \ D##_s = S##_s; \ if (_FP_EXP_NORMAL (sfs, swc, S)) \ { \ @@ -1557,6 +1993,7 @@ { \ if (S##_e == 0) \ { \ + _FP_CHECK_FLUSH_ZERO (sfs, swc, S); \ D##_e = 0; \ if (_FP_FRAC_ZEROP_##swc (S)) \ _FP_FRAC_SET_##dwc (D, _FP_ZEROFRAC_##dwc); \ @@ -1599,9 +2036,7 @@ } \ while (0) -/* - * Helper primitives. - */ +/* Helper primitives. */ /* Count leading zeros in a word. */ @@ -1610,14 +2045,18 @@ # define __FP_CLZ(r, x) \ do \ { \ + _FP_STATIC_ASSERT ((sizeof (_FP_W_TYPE) == sizeof (unsigned int) \ + || (sizeof (_FP_W_TYPE) \ + == sizeof (unsigned long)) \ + || (sizeof (_FP_W_TYPE) \ + == sizeof (unsigned long long))), \ + "_FP_W_TYPE size unsupported for clz"); \ if (sizeof (_FP_W_TYPE) == sizeof (unsigned int)) \ - r = __builtin_clz (x); \ + (r) = __builtin_clz (x); \ else if (sizeof (_FP_W_TYPE) == sizeof (unsigned long)) \ - r = __builtin_clzl (x); \ - else if (sizeof (_FP_W_TYPE) == sizeof (unsigned long long)) \ - r = __builtin_clzll (x); \ - else \ - abort (); \ + (r) = __builtin_clzl (x); \ + else /* sizeof (_FP_W_TYPE) == sizeof (unsigned long long). */ \ + (r) = __builtin_clzll (x); \ } \ while (0) #endif /* ndef __FP_CLZ */ @@ -1625,7 +2064,7 @@ #define _FP_DIV_HELP_imm(q, r, n, d) \ do \ { \ - q = n / d, r = n % d; \ + (q) = (n) / (d), (r) = (n) % (d); \ } \ while (0) @@ -1635,45 +2074,56 @@ #define _FP_DIV_MEAT_N_loop(fs, wc, R, X, Y) \ do \ { \ - int count = _FP_WFRACBITS_##fs; \ - _FP_FRAC_DECL_##wc (u); \ - _FP_FRAC_DECL_##wc (v); \ - _FP_FRAC_COPY_##wc (u, X); \ - _FP_FRAC_COPY_##wc (v, Y); \ + int _FP_DIV_MEAT_N_loop_count = _FP_WFRACBITS_##fs; \ + _FP_FRAC_DECL_##wc (_FP_DIV_MEAT_N_loop_u); \ + _FP_FRAC_DECL_##wc (_FP_DIV_MEAT_N_loop_v); \ + _FP_FRAC_COPY_##wc (_FP_DIV_MEAT_N_loop_u, X); \ + _FP_FRAC_COPY_##wc (_FP_DIV_MEAT_N_loop_v, Y); \ _FP_FRAC_SET_##wc (R, _FP_ZEROFRAC_##wc); \ - /* Normalize U and V. */ \ - _FP_FRAC_SLL_##wc (u, _FP_WFRACXBITS_##fs); \ - _FP_FRAC_SLL_##wc (v, _FP_WFRACXBITS_##fs); \ + /* Normalize _FP_DIV_MEAT_N_LOOP_U and _FP_DIV_MEAT_N_LOOP_V. */ \ + _FP_FRAC_SLL_##wc (_FP_DIV_MEAT_N_loop_u, _FP_WFRACXBITS_##fs); \ + _FP_FRAC_SLL_##wc (_FP_DIV_MEAT_N_loop_v, _FP_WFRACXBITS_##fs); \ /* First round. Since the operands are normalized, either the \ first or second bit will be set in the fraction. Produce a \ normalized result by checking which and adjusting the loop \ count and exponent accordingly. */ \ - if (_FP_FRAC_GE_1 (u, v)) \ + if (_FP_FRAC_GE_1 (_FP_DIV_MEAT_N_loop_u, _FP_DIV_MEAT_N_loop_v)) \ { \ - _FP_FRAC_SUB_##wc (u, u, v); \ + _FP_FRAC_SUB_##wc (_FP_DIV_MEAT_N_loop_u, \ + _FP_DIV_MEAT_N_loop_u, \ + _FP_DIV_MEAT_N_loop_v); \ _FP_FRAC_LOW_##wc (R) |= 1; \ - count--; \ + _FP_DIV_MEAT_N_loop_count--; \ } \ else \ R##_e--; \ /* Subsequent rounds. */ \ do \ { \ - int msb = (_FP_WS_TYPE) _FP_FRAC_HIGH_##wc (u) < 0; \ - _FP_FRAC_SLL_##wc (u, 1); \ + int _FP_DIV_MEAT_N_loop_msb \ + = (_FP_WS_TYPE) _FP_FRAC_HIGH_##wc (_FP_DIV_MEAT_N_loop_u) < 0; \ + _FP_FRAC_SLL_##wc (_FP_DIV_MEAT_N_loop_u, 1); \ _FP_FRAC_SLL_##wc (R, 1); \ - if (msb || _FP_FRAC_GE_1 (u, v)) \ + if (_FP_DIV_MEAT_N_loop_msb \ + || _FP_FRAC_GE_1 (_FP_DIV_MEAT_N_loop_u, \ + _FP_DIV_MEAT_N_loop_v)) \ { \ - _FP_FRAC_SUB_##wc (u, u, v); \ + _FP_FRAC_SUB_##wc (_FP_DIV_MEAT_N_loop_u, \ + _FP_DIV_MEAT_N_loop_u, \ + _FP_DIV_MEAT_N_loop_v); \ _FP_FRAC_LOW_##wc (R) |= 1; \ } \ } \ - while (--count > 0); \ - /* If there's anything left in U, the result is inexact. */ \ - _FP_FRAC_LOW_##wc (R) |= !_FP_FRAC_ZEROP_##wc (u); \ + while (--_FP_DIV_MEAT_N_loop_count > 0); \ + /* If there's anything left in _FP_DIV_MEAT_N_LOOP_U, the result \ + is inexact. */ \ + _FP_FRAC_LOW_##wc (R) \ + |= !_FP_FRAC_ZEROP_##wc (_FP_DIV_MEAT_N_loop_u); \ } \ while (0) #define _FP_DIV_MEAT_1_loop(fs, R, X, Y) _FP_DIV_MEAT_N_loop (fs, 1, R, X, Y) #define _FP_DIV_MEAT_2_loop(fs, R, X, Y) _FP_DIV_MEAT_N_loop (fs, 2, R, X, Y) #define _FP_DIV_MEAT_4_loop(fs, R, X, Y) _FP_DIV_MEAT_N_loop (fs, 4, R, X, Y) + +#endif /* !SOFT_FP_OP_COMMON_H */ diff --git a/soft-fp/quad.h b/soft-fp/quad.h index 16e362f1c6..9b5191cf5d 100644 --- a/soft-fp/quad.h +++ b/soft-fp/quad.h @@ -1,6 +1,6 @@ /* Software floating-point emulation. Definitions for IEEE Quad Precision. - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com), Jakub Jelinek (jj@ultra.linux.cz), @@ -30,6 +30,9 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ +#ifndef SOFT_FP_QUAD_H +#define SOFT_FP_QUAD_H 1 + #if _FP_W_TYPE_SIZE < 32 # error "Here's a nickel, kid. Go buy yourself a real computer." #endif @@ -95,21 +98,21 @@ union _FP_UNION_Q # define FP_DECL_Q(X) _FP_DECL (4, X) -# define FP_UNPACK_RAW_Q(X, val) _FP_UNPACK_RAW_4 (Q, X, val) -# define FP_UNPACK_RAW_QP(X, val) _FP_UNPACK_RAW_4_P (Q, X, val) -# define FP_PACK_RAW_Q(val, X) _FP_PACK_RAW_4 (Q, val, X) +# define FP_UNPACK_RAW_Q(X, val) _FP_UNPACK_RAW_4 (Q, X, (val)) +# define FP_UNPACK_RAW_QP(X, val) _FP_UNPACK_RAW_4_P (Q, X, (val)) +# define FP_PACK_RAW_Q(val, X) _FP_PACK_RAW_4 (Q, (val), X) # define FP_PACK_RAW_QP(val, X) \ do \ { \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_4_P (Q, val, X); \ + _FP_PACK_RAW_4_P (Q, (val), X); \ } \ while (0) # define FP_UNPACK_Q(X, val) \ do \ { \ - _FP_UNPACK_RAW_4 (Q, X, val); \ + _FP_UNPACK_RAW_4 (Q, X, (val)); \ _FP_UNPACK_CANONICAL (Q, 4, X); \ } \ while (0) @@ -117,7 +120,7 @@ union _FP_UNION_Q # define FP_UNPACK_QP(X, val) \ do \ { \ - _FP_UNPACK_RAW_4_P (Q, X, val); \ + _FP_UNPACK_RAW_4_P (Q, X, (val)); \ _FP_UNPACK_CANONICAL (Q, 4, X); \ } \ while (0) @@ -125,7 +128,7 @@ union _FP_UNION_Q # define FP_UNPACK_SEMIRAW_Q(X, val) \ do \ { \ - _FP_UNPACK_RAW_4 (Q, X, val); \ + _FP_UNPACK_RAW_4 (Q, X, (val)); \ _FP_UNPACK_SEMIRAW (Q, 4, X); \ } \ while (0) @@ -133,7 +136,7 @@ union _FP_UNION_Q # define FP_UNPACK_SEMIRAW_QP(X, val) \ do \ { \ - _FP_UNPACK_RAW_4_P (Q, X, val); \ + _FP_UNPACK_RAW_4_P (Q, X, (val)); \ _FP_UNPACK_SEMIRAW (Q, 4, X); \ } \ while (0) @@ -142,7 +145,7 @@ union _FP_UNION_Q do \ { \ _FP_PACK_CANONICAL (Q, 4, X); \ - _FP_PACK_RAW_4 (Q, val, X); \ + _FP_PACK_RAW_4 (Q, (val), X); \ } \ while (0) @@ -151,7 +154,7 @@ union _FP_UNION_Q { \ _FP_PACK_CANONICAL (Q, 4, X); \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_4_P (Q, val, X); \ + _FP_PACK_RAW_4_P (Q, (val), X); \ } \ while (0) @@ -159,7 +162,7 @@ union _FP_UNION_Q do \ { \ _FP_PACK_SEMIRAW (Q, 4, X); \ - _FP_PACK_RAW_4 (Q, val, X); \ + _FP_PACK_RAW_4 (Q, (val), X); \ } \ while (0) @@ -168,7 +171,7 @@ union _FP_UNION_Q { \ _FP_PACK_SEMIRAW (Q, 4, X); \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_4_P (Q, val, X); \ + _FP_PACK_RAW_4_P (Q, (val), X); \ } \ while (0) @@ -179,15 +182,17 @@ union _FP_UNION_Q # define FP_MUL_Q(R, X, Y) _FP_MUL (Q, 4, R, X, Y) # define FP_DIV_Q(R, X, Y) _FP_DIV (Q, 4, R, X, Y) # define FP_SQRT_Q(R, X) _FP_SQRT (Q, 4, R, X) -# define _FP_SQRT_MEAT_Q(R, S, T, X, Q) _FP_SQRT_MEAT_4 (R, S, T, X, Q) +# define _FP_SQRT_MEAT_Q(R, S, T, X, Q) _FP_SQRT_MEAT_4 (R, S, T, X, (Q)) # define FP_FMA_Q(R, X, Y, Z) _FP_FMA (Q, 4, 8, R, X, Y, Z) -# define FP_CMP_Q(r, X, Y, un) _FP_CMP (Q, 4, r, X, Y, un) -# define FP_CMP_EQ_Q(r, X, Y) _FP_CMP_EQ (Q, 4, r, X, Y) -# define FP_CMP_UNORD_Q(r, X, Y) _FP_CMP_UNORD (Q, 4, r, X, Y) +# define FP_CMP_Q(r, X, Y, un, ex) _FP_CMP (Q, 4, (r), X, Y, (un), (ex)) +# define FP_CMP_EQ_Q(r, X, Y, ex) _FP_CMP_EQ (Q, 4, (r), X, Y, (ex)) +# define FP_CMP_UNORD_Q(r, X, Y, ex) _FP_CMP_UNORD (Q, 4, (r), X, Y, (ex)) -# define FP_TO_INT_Q(r, X, rsz, rsg) _FP_TO_INT (Q, 4, r, X, rsz, rsg) -# define FP_FROM_INT_Q(X, r, rs, rt) _FP_FROM_INT (Q, 4, X, r, rs, rt) +# define FP_TO_INT_Q(r, X, rsz, rsg) _FP_TO_INT (Q, 4, (r), X, (rsz), (rsg)) +# define FP_TO_INT_ROUND_Q(r, X, rsz, rsg) \ + _FP_TO_INT_ROUND (Q, 4, (r), X, (rsz), (rsg)) +# define FP_FROM_INT_Q(X, r, rs, rt) _FP_FROM_INT (Q, 4, X, (r), (rs), rt) # define _FP_FRAC_HIGH_Q(X) _FP_FRAC_HIGH_4 (X) # define _FP_FRAC_HIGH_RAW_Q(X) _FP_FRAC_HIGH_4 (X) @@ -219,21 +224,21 @@ union _FP_UNION_Q }; # define FP_DECL_Q(X) _FP_DECL (2, X) -# define FP_UNPACK_RAW_Q(X, val) _FP_UNPACK_RAW_2 (Q, X, val) -# define FP_UNPACK_RAW_QP(X, val) _FP_UNPACK_RAW_2_P (Q, X, val) -# define FP_PACK_RAW_Q(val, X) _FP_PACK_RAW_2 (Q, val, X) +# define FP_UNPACK_RAW_Q(X, val) _FP_UNPACK_RAW_2 (Q, X, (val)) +# define FP_UNPACK_RAW_QP(X, val) _FP_UNPACK_RAW_2_P (Q, X, (val)) +# define FP_PACK_RAW_Q(val, X) _FP_PACK_RAW_2 (Q, (val), X) # define FP_PACK_RAW_QP(val, X) \ do \ { \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_2_P (Q, val, X); \ + _FP_PACK_RAW_2_P (Q, (val), X); \ } \ while (0) # define FP_UNPACK_Q(X, val) \ do \ { \ - _FP_UNPACK_RAW_2 (Q, X, val); \ + _FP_UNPACK_RAW_2 (Q, X, (val)); \ _FP_UNPACK_CANONICAL (Q, 2, X); \ } \ while (0) @@ -241,7 +246,7 @@ union _FP_UNION_Q # define FP_UNPACK_QP(X, val) \ do \ { \ - _FP_UNPACK_RAW_2_P (Q, X, val); \ + _FP_UNPACK_RAW_2_P (Q, X, (val)); \ _FP_UNPACK_CANONICAL (Q, 2, X); \ } \ while (0) @@ -249,7 +254,7 @@ union _FP_UNION_Q # define FP_UNPACK_SEMIRAW_Q(X, val) \ do \ { \ - _FP_UNPACK_RAW_2 (Q, X, val); \ + _FP_UNPACK_RAW_2 (Q, X, (val)); \ _FP_UNPACK_SEMIRAW (Q, 2, X); \ } \ while (0) @@ -257,7 +262,7 @@ union _FP_UNION_Q # define FP_UNPACK_SEMIRAW_QP(X, val) \ do \ { \ - _FP_UNPACK_RAW_2_P (Q, X, val); \ + _FP_UNPACK_RAW_2_P (Q, X, (val)); \ _FP_UNPACK_SEMIRAW (Q, 2, X); \ } \ while (0) @@ -266,7 +271,7 @@ union _FP_UNION_Q do \ { \ _FP_PACK_CANONICAL (Q, 2, X); \ - _FP_PACK_RAW_2 (Q, val, X); \ + _FP_PACK_RAW_2 (Q, (val), X); \ } \ while (0) @@ -275,7 +280,7 @@ union _FP_UNION_Q { \ _FP_PACK_CANONICAL (Q, 2, X); \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_2_P (Q, val, X); \ + _FP_PACK_RAW_2_P (Q, (val), X); \ } \ while (0) @@ -283,7 +288,7 @@ union _FP_UNION_Q do \ { \ _FP_PACK_SEMIRAW (Q, 2, X); \ - _FP_PACK_RAW_2 (Q, val, X); \ + _FP_PACK_RAW_2 (Q, (val), X); \ } \ while (0) @@ -292,7 +297,7 @@ union _FP_UNION_Q { \ _FP_PACK_SEMIRAW (Q, 2, X); \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_2_P (Q, val, X); \ + _FP_PACK_RAW_2_P (Q, (val), X); \ } \ while (0) @@ -303,15 +308,17 @@ union _FP_UNION_Q # define FP_MUL_Q(R, X, Y) _FP_MUL (Q, 2, R, X, Y) # define FP_DIV_Q(R, X, Y) _FP_DIV (Q, 2, R, X, Y) # define FP_SQRT_Q(R, X) _FP_SQRT (Q, 2, R, X) -# define _FP_SQRT_MEAT_Q(R, S, T, X, Q) _FP_SQRT_MEAT_2 (R, S, T, X, Q) +# define _FP_SQRT_MEAT_Q(R, S, T, X, Q) _FP_SQRT_MEAT_2 (R, S, T, X, (Q)) # define FP_FMA_Q(R, X, Y, Z) _FP_FMA (Q, 2, 4, R, X, Y, Z) -# define FP_CMP_Q(r, X, Y, un) _FP_CMP (Q, 2, r, X, Y, un) -# define FP_CMP_EQ_Q(r, X, Y) _FP_CMP_EQ (Q, 2, r, X, Y) -# define FP_CMP_UNORD_Q(r, X, Y) _FP_CMP_UNORD (Q, 2, r, X, Y) +# define FP_CMP_Q(r, X, Y, un, ex) _FP_CMP (Q, 2, (r), X, Y, (un), (ex)) +# define FP_CMP_EQ_Q(r, X, Y, ex) _FP_CMP_EQ (Q, 2, (r), X, Y, (ex)) +# define FP_CMP_UNORD_Q(r, X, Y, ex) _FP_CMP_UNORD (Q, 2, (r), X, Y, (ex)) -# define FP_TO_INT_Q(r, X, rsz, rsg) _FP_TO_INT (Q, 2, r, X, rsz, rsg) -# define FP_FROM_INT_Q(X, r, rs, rt) _FP_FROM_INT (Q, 2, X, r, rs, rt) +# define FP_TO_INT_Q(r, X, rsz, rsg) _FP_TO_INT (Q, 2, (r), X, (rsz), (rsg)) +# define FP_TO_INT_ROUND_Q(r, X, rsz, rsg) \ + _FP_TO_INT_ROUND (Q, 2, (r), X, (rsz), (rsg)) +# define FP_FROM_INT_Q(X, r, rs, rt) _FP_FROM_INT (Q, 2, X, (r), (rs), rt) # define _FP_FRAC_HIGH_Q(X) _FP_FRAC_HIGH_2 (X) # define _FP_FRAC_HIGH_RAW_Q(X) _FP_FRAC_HIGH_2 (X) @@ -319,3 +326,5 @@ union _FP_UNION_Q # define _FP_FRAC_HIGH_DW_Q(X) _FP_FRAC_HIGH_4 (X) #endif /* not _FP_W_TYPE_SIZE < 64 */ + +#endif /* !SOFT_FP_QUAD_H */ diff --git a/soft-fp/single.h b/soft-fp/single.h index 19fd6476ee..b03514006f 100644 --- a/soft-fp/single.h +++ b/soft-fp/single.h @@ -1,6 +1,6 @@ /* Software floating-point emulation. Definitions for IEEE Single Precision. - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com), Jakub Jelinek (jj@ultra.linux.cz), @@ -30,6 +30,9 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ +#ifndef SOFT_FP_SINGLE_H +#define SOFT_FP_SINGLE_H 1 + #if _FP_W_TYPE_SIZE < 32 # error "Here's a nickel kid. Go buy yourself a real computer." #endif @@ -83,21 +86,21 @@ union _FP_UNION_S }; #define FP_DECL_S(X) _FP_DECL (1, X) -#define FP_UNPACK_RAW_S(X, val) _FP_UNPACK_RAW_1 (S, X, val) -#define FP_UNPACK_RAW_SP(X, val) _FP_UNPACK_RAW_1_P (S, X, val) -#define FP_PACK_RAW_S(val, X) _FP_PACK_RAW_1 (S, val, X) +#define FP_UNPACK_RAW_S(X, val) _FP_UNPACK_RAW_1 (S, X, (val)) +#define FP_UNPACK_RAW_SP(X, val) _FP_UNPACK_RAW_1_P (S, X, (val)) +#define FP_PACK_RAW_S(val, X) _FP_PACK_RAW_1 (S, (val), X) #define FP_PACK_RAW_SP(val, X) \ do \ { \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_1_P (S, val, X); \ + _FP_PACK_RAW_1_P (S, (val), X); \ } \ while (0) #define FP_UNPACK_S(X, val) \ do \ { \ - _FP_UNPACK_RAW_1 (S, X, val); \ + _FP_UNPACK_RAW_1 (S, X, (val)); \ _FP_UNPACK_CANONICAL (S, 1, X); \ } \ while (0) @@ -105,7 +108,7 @@ union _FP_UNION_S #define FP_UNPACK_SP(X, val) \ do \ { \ - _FP_UNPACK_RAW_1_P (S, X, val); \ + _FP_UNPACK_RAW_1_P (S, X, (val)); \ _FP_UNPACK_CANONICAL (S, 1, X); \ } \ while (0) @@ -113,7 +116,7 @@ union _FP_UNION_S #define FP_UNPACK_SEMIRAW_S(X, val) \ do \ { \ - _FP_UNPACK_RAW_1 (S, X, val); \ + _FP_UNPACK_RAW_1 (S, X, (val)); \ _FP_UNPACK_SEMIRAW (S, 1, X); \ } \ while (0) @@ -121,7 +124,7 @@ union _FP_UNION_S #define FP_UNPACK_SEMIRAW_SP(X, val) \ do \ { \ - _FP_UNPACK_RAW_1_P (S, X, val); \ + _FP_UNPACK_RAW_1_P (S, X, (val)); \ _FP_UNPACK_SEMIRAW (S, 1, X); \ } \ while (0) @@ -130,7 +133,7 @@ union _FP_UNION_S do \ { \ _FP_PACK_CANONICAL (S, 1, X); \ - _FP_PACK_RAW_1 (S, val, X); \ + _FP_PACK_RAW_1 (S, (val), X); \ } \ while (0) @@ -139,7 +142,7 @@ union _FP_UNION_S { \ _FP_PACK_CANONICAL (S, 1, X); \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_1_P (S, val, X); \ + _FP_PACK_RAW_1_P (S, (val), X); \ } \ while (0) @@ -147,7 +150,7 @@ union _FP_UNION_S do \ { \ _FP_PACK_SEMIRAW (S, 1, X); \ - _FP_PACK_RAW_1 (S, val, X); \ + _FP_PACK_RAW_1 (S, (val), X); \ } \ while (0) @@ -156,7 +159,7 @@ union _FP_UNION_S { \ _FP_PACK_SEMIRAW (S, 1, X); \ if (!FP_INHIBIT_RESULTS) \ - _FP_PACK_RAW_1_P (S, val, X); \ + _FP_PACK_RAW_1_P (S, (val), X); \ } \ while (0) @@ -167,7 +170,7 @@ union _FP_UNION_S #define FP_MUL_S(R, X, Y) _FP_MUL (S, 1, R, X, Y) #define FP_DIV_S(R, X, Y) _FP_DIV (S, 1, R, X, Y) #define FP_SQRT_S(R, X) _FP_SQRT (S, 1, R, X) -#define _FP_SQRT_MEAT_S(R, S, T, X, Q) _FP_SQRT_MEAT_1 (R, S, T, X, Q) +#define _FP_SQRT_MEAT_S(R, S, T, X, Q) _FP_SQRT_MEAT_1 (R, S, T, X, (Q)) #if _FP_W_TYPE_SIZE < 64 # define FP_FMA_S(R, X, Y, Z) _FP_FMA (S, 1, 2, R, X, Y, Z) @@ -175,12 +178,14 @@ union _FP_UNION_S # define FP_FMA_S(R, X, Y, Z) _FP_FMA (S, 1, 1, R, X, Y, Z) #endif -#define FP_CMP_S(r, X, Y, un) _FP_CMP (S, 1, r, X, Y, un) -#define FP_CMP_EQ_S(r, X, Y) _FP_CMP_EQ (S, 1, r, X, Y) -#define FP_CMP_UNORD_S(r, X, Y) _FP_CMP_UNORD (S, 1, r, X, Y) +#define FP_CMP_S(r, X, Y, un, ex) _FP_CMP (S, 1, (r), X, Y, (un), (ex)) +#define FP_CMP_EQ_S(r, X, Y, ex) _FP_CMP_EQ (S, 1, (r), X, Y, (ex)) +#define FP_CMP_UNORD_S(r, X, Y, ex) _FP_CMP_UNORD (S, 1, (r), X, Y, (ex)) -#define FP_TO_INT_S(r, X, rsz, rsg) _FP_TO_INT (S, 1, r, X, rsz, rsg) -#define FP_FROM_INT_S(X, r, rs, rt) _FP_FROM_INT (S, 1, X, r, rs, rt) +#define FP_TO_INT_S(r, X, rsz, rsg) _FP_TO_INT (S, 1, (r), X, (rsz), (rsg)) +#define FP_TO_INT_ROUND_S(r, X, rsz, rsg) \ + _FP_TO_INT_ROUND (S, 1, (r), X, (rsz), (rsg)) +#define FP_FROM_INT_S(X, r, rs, rt) _FP_FROM_INT (S, 1, X, (r), (rs), rt) #define _FP_FRAC_HIGH_S(X) _FP_FRAC_HIGH_1 (X) #define _FP_FRAC_HIGH_RAW_S(X) _FP_FRAC_HIGH_1 (X) @@ -190,3 +195,5 @@ union _FP_UNION_S #else # define _FP_FRAC_HIGH_DW_S(X) _FP_FRAC_HIGH_1 (X) #endif + +#endif /* !SOFT_FP_SINGLE_H */ diff --git a/soft-fp/soft-fp.h b/soft-fp/soft-fp.h index c8a98948f8..3b39336b38 100644 --- a/soft-fp/soft-fp.h +++ b/soft-fp/soft-fp.h @@ -1,5 +1,5 @@ /* Software floating-point emulation. - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com), Jakub Jelinek (jj@ultra.linux.cz), @@ -30,15 +30,19 @@ <http://www.gnu.org/licenses/>. */ #ifndef SOFT_FP_H -#define SOFT_FP_H +#define SOFT_FP_H 1 #ifdef _LIBC # include <sfp-machine.h> +#elif defined __KERNEL__ +/* The Linux kernel uses asm/ names for architecture-specific + files. */ +# include <asm/sfp-machine.h> #else # include "sfp-machine.h" #endif -/* Allow sfp-machine to have its own byte order definitions. */ +/* Allow sfp-machine to have its own byte order definitions. */ #ifndef __BYTE_ORDER # ifdef _LIBC # include <endian.h> @@ -47,6 +51,37 @@ # endif #endif +/* For unreachable default cases in switch statements over bitwise OR + of FP_CLS_* values. */ +#if (defined __GNUC__ \ + && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))) +# define _FP_UNREACHABLE __builtin_unreachable () +#else +# define _FP_UNREACHABLE abort () +#endif + +#if ((defined __GNUC__ \ + && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))) \ + || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 201112L)) +# define _FP_STATIC_ASSERT(expr, msg) \ + _Static_assert ((expr), msg) +#else +# define _FP_STATIC_ASSERT(expr, msg) \ + extern int (*__Static_assert_function (void)) \ + [!!sizeof (struct { int __error_if_negative: (expr) ? 2 : -1; })] +#endif + +/* In the Linux kernel, some architectures have a single function that + uses different kinds of unpacking and packing depending on the + instruction being emulated, meaning it is not readily visible to + the compiler that variables from _FP_DECL and _FP_FRAC_DECL_* + macros are only used in cases where they were initialized. */ +#ifdef __KERNEL__ +# define _FP_ZERO_INIT = 0 +#else +# define _FP_ZERO_INIT +#endif + #define _FP_WORKBITS 3 #define _FP_WORK_LSB ((_FP_W_TYPE) 1 << 3) #define _FP_WORK_ROUND ((_FP_W_TYPE) 1 << 2) @@ -63,7 +98,7 @@ # define FP_ROUNDMODE FP_RND_NEAREST #endif -/* By default don't care about exceptions. */ +/* By default don't care about exceptions. */ #ifndef FP_EX_INVALID # define FP_EX_INVALID 0 #endif @@ -83,6 +118,44 @@ # define FP_EX_DENORM 0 #endif +/* Sub-exceptions of "invalid". */ +/* Signaling NaN operand. */ +#ifndef FP_EX_INVALID_SNAN +# define FP_EX_INVALID_SNAN 0 +#endif +/* Inf * 0. */ +#ifndef FP_EX_INVALID_IMZ +# define FP_EX_INVALID_IMZ 0 +#endif +/* fma (Inf, 0, c). */ +#ifndef FP_EX_INVALID_IMZ_FMA +# define FP_EX_INVALID_IMZ_FMA 0 +#endif +/* Inf - Inf. */ +#ifndef FP_EX_INVALID_ISI +# define FP_EX_INVALID_ISI 0 +#endif +/* 0 / 0. */ +#ifndef FP_EX_INVALID_ZDZ +# define FP_EX_INVALID_ZDZ 0 +#endif +/* Inf / Inf. */ +#ifndef FP_EX_INVALID_IDI +# define FP_EX_INVALID_IDI 0 +#endif +/* sqrt (negative). */ +#ifndef FP_EX_INVALID_SQRT +# define FP_EX_INVALID_SQRT 0 +#endif +/* Invalid conversion to integer. */ +#ifndef FP_EX_INVALID_CVI +# define FP_EX_INVALID_CVI 0 +#endif +/* Invalid comparison. */ +#ifndef FP_EX_INVALID_VC +# define FP_EX_INVALID_VC 0 +#endif + /* _FP_STRUCT_LAYOUT may be defined as an attribute to determine the struct layout variant used for structures where bit-fields are used to access specific parts of binary floating-point numbers. This is @@ -108,30 +181,37 @@ #endif /* Initialize any machine-specific state used in + FP_TRAPPING_EXCEPTIONS or FP_HANDLE_EXCEPTIONS. */ +#ifndef FP_INIT_TRAPPING_EXCEPTIONS +# define FP_INIT_TRAPPING_EXCEPTIONS FP_INIT_ROUNDMODE +#endif + +/* Initialize any machine-specific state used in FP_HANDLE_EXCEPTIONS. */ #ifndef FP_INIT_EXCEPTIONS -# define FP_INIT_EXCEPTIONS FP_INIT_ROUNDMODE +# define FP_INIT_EXCEPTIONS FP_INIT_TRAPPING_EXCEPTIONS #endif #ifndef FP_HANDLE_EXCEPTIONS # define FP_HANDLE_EXCEPTIONS do {} while (0) #endif +/* Whether to flush subnormal inputs to zero with the same sign. */ +#ifndef FP_DENORM_ZERO +# define FP_DENORM_ZERO 0 +#endif + #ifndef FP_INHIBIT_RESULTS /* By default we write the results always. - * sfp-machine may override this and e.g. - * check if some exceptions are unmasked - * and inhibit it in such a case. - */ + sfp-machine may override this and e.g. + check if some exceptions are unmasked + and inhibit it in such a case. */ # define FP_INHIBIT_RESULTS 0 #endif #define FP_SET_EXCEPTION(ex) \ _fex |= (ex) -#define FP_CLEAR_EXCEPTIONS \ - _fex = 0 - #define FP_CUR_EXCEPTIONS \ (_fex) @@ -161,6 +241,19 @@ # undef FP_ROUNDMODE # define FP_ROUNDMODE FP_RND_ZERO +# undef _FP_TININESS_AFTER_ROUNDING +# define _FP_TININESS_AFTER_ROUNDING 0 + +#endif + +/* A file using soft-fp may define FP_NO_EXACT_UNDERFLOW before + including soft-fp.h to indicate that, although a macro used there + could allow for the case of exact underflow requiring the underflow + exception to be raised if traps are enabled, for the particular + arguments used in that file no exact underflow can occur. */ +#ifdef FP_NO_EXACT_UNDERFLOW +# undef FP_TRAPPING_EXCEPTIONS +# define FP_TRAPPING_EXCEPTIONS 0 #endif #define _FP_ROUND_NEAREST(wc, X) \ @@ -258,10 +351,4 @@ typedef USItype UHWtype; # endif #endif -#ifdef _LIBC -# include <stdlib.h> -#else -extern void abort (void); -#endif - -#endif +#endif /* !SOFT_FP_H */ diff --git a/soft-fp/sqrtdf2.c b/soft-fp/sqrtdf2.c index db43ddebb3..3a34298bd4 100644 --- a/soft-fp/sqrtdf2.c +++ b/soft-fp/sqrtdf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return sqrt(a) - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/sqrtsf2.c b/soft-fp/sqrtsf2.c index 4a551dc7c3..a1aabd1f5d 100644 --- a/soft-fp/sqrtsf2.c +++ b/soft-fp/sqrtsf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return sqrt(a) - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/sqrttf2.c b/soft-fp/sqrttf2.c index e0bec11104..b354b502b4 100644 --- a/soft-fp/sqrttf2.c +++ b/soft-fp/sqrttf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return sqrt(a) - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/subdf3.c b/soft-fp/subdf3.c index ef82c86285..a217d27450 100644 --- a/soft-fp/subdf3.c +++ b/soft-fp/subdf3.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a - b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/subsf3.c b/soft-fp/subsf3.c index 8d36e284c7..aedae8847e 100644 --- a/soft-fp/subsf3.c +++ b/soft-fp/subsf3.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a - b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/subtf3.c b/soft-fp/subtf3.c index 490ff9cefb..387ada7433 100644 --- a/soft-fp/subtf3.c +++ b/soft-fp/subtf3.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return a - b - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/truncdfsf2.c b/soft-fp/truncdfsf2.c index e6ccb59079..348941c78c 100644 --- a/soft-fp/truncdfsf2.c +++ b/soft-fp/truncdfsf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Truncate IEEE double into IEEE single - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/trunctfdf2.c b/soft-fp/trunctfdf2.c index 781b5b90b0..10a899c5f9 100644 --- a/soft-fp/trunctfdf2.c +++ b/soft-fp/trunctfdf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Truncate IEEE quad into IEEE double - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/trunctfsf2.c b/soft-fp/trunctfsf2.c index 76437c4d34..57f54fbdf4 100644 --- a/soft-fp/trunctfsf2.c +++ b/soft-fp/trunctfsf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Truncate IEEE quad into IEEE single - Copyright (C) 1997-2014 Free Software Foundation, Inc. + Copyright (C) 1997-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Richard Henderson (rth@cygnus.com) and Jakub Jelinek (jj@ultra.linux.cz). diff --git a/soft-fp/trunctfxf2.c b/soft-fp/trunctfxf2.c index 1782aaa7d8..b87729ef55 100644 --- a/soft-fp/trunctfxf2.c +++ b/soft-fp/trunctfxf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Truncate IEEE quad into IEEE extended - Copyright (C) 2007-2014 Free Software Foundation, Inc. + Copyright (C) 2007-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Uros Bizjak (ubizjak@gmail.com). diff --git a/soft-fp/unorddf2.c b/soft-fp/unorddf2.c index ceacb9e91d..d101e05efe 100644 --- a/soft-fp/unorddf2.c +++ b/soft-fp/unorddf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return 1 iff a or b is a NaN, 0 otherwise. - Copyright (C) 2006-2014 Free Software Foundation, Inc. + Copyright (C) 2006-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Joseph Myers (joseph@codesourcery.com). @@ -41,9 +41,7 @@ __unorddf2 (DFtype a, DFtype b) FP_INIT_EXCEPTIONS; FP_UNPACK_RAW_D (A, a); FP_UNPACK_RAW_D (B, b); - FP_CMP_UNORD_D (r, A, B); - if (r && (FP_ISSIGNAN_D (A) || FP_ISSIGNAN_D (B))) - FP_SET_EXCEPTION (FP_EX_INVALID); + FP_CMP_UNORD_D (r, A, B, 1); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/unordsf2.c b/soft-fp/unordsf2.c index 057f2c43a7..900994774b 100644 --- a/soft-fp/unordsf2.c +++ b/soft-fp/unordsf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return 1 iff a or b is a NaN, 0 otherwise. - Copyright (C) 2006-2014 Free Software Foundation, Inc. + Copyright (C) 2006-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Joseph Myers (joseph@codesourcery.com). @@ -41,9 +41,7 @@ __unordsf2 (SFtype a, SFtype b) FP_INIT_EXCEPTIONS; FP_UNPACK_RAW_S (A, a); FP_UNPACK_RAW_S (B, b); - FP_CMP_UNORD_S (r, A, B); - if (r && (FP_ISSIGNAN_S (A) || FP_ISSIGNAN_S (B))) - FP_SET_EXCEPTION (FP_EX_INVALID); + FP_CMP_UNORD_S (r, A, B, 1); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/unordtf2.c b/soft-fp/unordtf2.c index 433a84fd5e..05aaf04325 100644 --- a/soft-fp/unordtf2.c +++ b/soft-fp/unordtf2.c @@ -1,6 +1,6 @@ /* Software floating-point emulation. Return 1 iff a or b is a NaN, 0 otherwise. - Copyright (C) 2006-2014 Free Software Foundation, Inc. + Copyright (C) 2006-2015 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Joseph Myers (joseph@codesourcery.com). @@ -41,9 +41,7 @@ __unordtf2 (TFtype a, TFtype b) FP_INIT_EXCEPTIONS; FP_UNPACK_RAW_Q (A, a); FP_UNPACK_RAW_Q (B, b); - FP_CMP_UNORD_Q (r, A, B); - if (r && (FP_ISSIGNAN_Q (A) || FP_ISSIGNAN_Q (B))) - FP_SET_EXCEPTION (FP_EX_INVALID); + FP_CMP_UNORD_Q (r, A, B, 1); FP_HANDLE_EXCEPTIONS; return r; |