diff options
| author | Joseph Myers <joseph@codesourcery.com> | 2013-10-16 01:22:21 +0000 |
|---|---|---|
| committer | Joseph Myers <joseph@codesourcery.com> | 2013-10-16 01:22:21 +0000 |
| commit | 51ca9e29af1a71b7dc175b78ee2d3564f9416fab (patch) | |
| tree | d81896c6c8a309a2ad0e46064673b92f3c1317b0 /soft-fp | |
| parent | 9ebb0332fc8a6c9cf07f9b1b7ea0220759b5cdab (diff) | |
| download | glibc-51ca9e29af1a71b7dc175b78ee2d3564f9416fab.tar.gz glibc-51ca9e29af1a71b7dc175b78ee2d3564f9416fab.tar.xz glibc-51ca9e29af1a71b7dc175b78ee2d3564f9416fab.zip | |
soft-fp: fix horizontal whitespace.
Diffstat (limited to 'soft-fp')
87 files changed, 1785 insertions, 1783 deletions
diff --git a/soft-fp/adddf3.c b/soft-fp/adddf3.c index 2f11c9cea5..5aadfa3318 100644 --- a/soft-fp/adddf3.c +++ b/soft-fp/adddf3.c @@ -32,19 +32,19 @@ #include "double.h" DFtype -__adddf3(DFtype a, DFtype b) +__adddf3 (DFtype a, DFtype b) { FP_DECL_EX; - FP_DECL_D(A); - FP_DECL_D(B); - FP_DECL_D(R); + FP_DECL_D (A); + FP_DECL_D (B); + FP_DECL_D (R); DFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_SEMIRAW_D(A, a); - FP_UNPACK_SEMIRAW_D(B, b); - FP_ADD_D(R, A, B); - FP_PACK_SEMIRAW_D(r, R); + FP_UNPACK_SEMIRAW_D (A, a); + FP_UNPACK_SEMIRAW_D (B, b); + FP_ADD_D (R, A, B); + FP_PACK_SEMIRAW_D (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/addsf3.c b/soft-fp/addsf3.c index abd8dfa0da..ac571bad06 100644 --- a/soft-fp/addsf3.c +++ b/soft-fp/addsf3.c @@ -32,19 +32,19 @@ #include "single.h" SFtype -__addsf3(SFtype a, SFtype b) +__addsf3 (SFtype a, SFtype b) { FP_DECL_EX; - FP_DECL_S(A); - FP_DECL_S(B); - FP_DECL_S(R); + FP_DECL_S (A); + FP_DECL_S (B); + FP_DECL_S (R); SFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_SEMIRAW_S(A, a); - FP_UNPACK_SEMIRAW_S(B, b); - FP_ADD_S(R, A, B); - FP_PACK_SEMIRAW_S(r, R); + FP_UNPACK_SEMIRAW_S (A, a); + FP_UNPACK_SEMIRAW_S (B, b); + FP_ADD_S (R, A, B); + FP_PACK_SEMIRAW_S (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/addtf3.c b/soft-fp/addtf3.c index 819b7d1db3..1c0d266c66 100644 --- a/soft-fp/addtf3.c +++ b/soft-fp/addtf3.c @@ -32,19 +32,19 @@ #include "quad.h" TFtype -__addtf3(TFtype a, TFtype b) +__addtf3 (TFtype a, TFtype b) { FP_DECL_EX; - FP_DECL_Q(A); - FP_DECL_Q(B); - FP_DECL_Q(R); + FP_DECL_Q (A); + FP_DECL_Q (B); + FP_DECL_Q (R); TFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_SEMIRAW_Q(A, a); - FP_UNPACK_SEMIRAW_Q(B, b); - FP_ADD_Q(R, A, B); - FP_PACK_SEMIRAW_Q(r, R); + FP_UNPACK_SEMIRAW_Q (A, a); + FP_UNPACK_SEMIRAW_Q (B, b); + FP_ADD_Q (R, A, B); + FP_PACK_SEMIRAW_Q (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/divdf3.c b/soft-fp/divdf3.c index 4e7d28f917..d357bf0222 100644 --- a/soft-fp/divdf3.c +++ b/soft-fp/divdf3.c @@ -32,19 +32,19 @@ #include "double.h" DFtype -__divdf3(DFtype a, DFtype b) +__divdf3 (DFtype a, DFtype b) { FP_DECL_EX; - FP_DECL_D(A); - FP_DECL_D(B); - FP_DECL_D(R); + FP_DECL_D (A); + FP_DECL_D (B); + FP_DECL_D (R); DFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_D(A, a); - FP_UNPACK_D(B, b); - FP_DIV_D(R, A, B); - FP_PACK_D(r, R); + FP_UNPACK_D (A, a); + FP_UNPACK_D (B, b); + FP_DIV_D (R, A, B); + FP_PACK_D (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/divsf3.c b/soft-fp/divsf3.c index 0ed726bf96..b53b4031d7 100644 --- a/soft-fp/divsf3.c +++ b/soft-fp/divsf3.c @@ -32,19 +32,19 @@ #include "single.h" SFtype -__divsf3(SFtype a, SFtype b) +__divsf3 (SFtype a, SFtype b) { FP_DECL_EX; - FP_DECL_S(A); - FP_DECL_S(B); - FP_DECL_S(R); + FP_DECL_S (A); + FP_DECL_S (B); + FP_DECL_S (R); SFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_S(A, a); - FP_UNPACK_S(B, b); - FP_DIV_S(R, A, B); - FP_PACK_S(r, R); + FP_UNPACK_S (A, a); + FP_UNPACK_S (B, b); + FP_DIV_S (R, A, B); + FP_PACK_S (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/divtf3.c b/soft-fp/divtf3.c index a255f68432..5b7175da54 100644 --- a/soft-fp/divtf3.c +++ b/soft-fp/divtf3.c @@ -32,19 +32,19 @@ #include "quad.h" TFtype -__divtf3(TFtype a, TFtype b) +__divtf3 (TFtype a, TFtype b) { FP_DECL_EX; - FP_DECL_Q(A); - FP_DECL_Q(B); - FP_DECL_Q(R); + FP_DECL_Q (A); + FP_DECL_Q (B); + FP_DECL_Q (R); TFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_Q(A, a); - FP_UNPACK_Q(B, b); - FP_DIV_Q(R, A, B); - FP_PACK_Q(r, R); + FP_UNPACK_Q (A, a); + FP_UNPACK_Q (B, b); + FP_DIV_Q (R, A, B); + FP_PACK_Q (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/double.h b/soft-fp/double.h index 4975ff4c35..ef4576707a 100644 --- a/soft-fp/double.h +++ b/soft-fp/double.h @@ -51,22 +51,22 @@ #define _FP_EXPMAX_D 2047 #define _FP_QNANBIT_D \ - ((_FP_W_TYPE)1 << (_FP_FRACBITS_D-2) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-2) % _FP_W_TYPE_SIZE) #define _FP_QNANBIT_SH_D \ - ((_FP_W_TYPE)1 << (_FP_FRACBITS_D-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE) #define _FP_IMPLBIT_D \ - ((_FP_W_TYPE)1 << (_FP_FRACBITS_D-1) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-1) % _FP_W_TYPE_SIZE) #define _FP_IMPLBIT_SH_D \ - ((_FP_W_TYPE)1 << (_FP_FRACBITS_D-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE) #define _FP_OVERFLOW_D \ - ((_FP_W_TYPE)1 << _FP_WFRACBITS_D % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << _FP_WFRACBITS_D % _FP_W_TYPE_SIZE) #define _FP_WFRACBITS_DW_D (2 * _FP_WFRACBITS_D) #define _FP_WFRACXBITS_DW_D (_FP_FRACTBITS_DW_D - _FP_WFRACBITS_DW_D) #define _FP_HIGHBIT_DW_D \ - ((_FP_W_TYPE)1 << (_FP_WFRACBITS_DW_D - 1) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_D - 1) % _FP_W_TYPE_SIZE) -typedef float DFtype __attribute__((mode(DF))); +typedef float DFtype __attribute__ ((mode (DF))); #if _FP_W_TYPE_SIZE < 64 @@ -86,108 +86,108 @@ union _FP_UNION_D unsigned exp : _FP_EXPBITS_D; unsigned sign : 1; # endif - } bits __attribute__((packed)); + } bits __attribute__ ((packed)); }; -# 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_PACK_RAW_DP(val,X) \ +# 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_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) \ +# define FP_UNPACK_D(X, val) \ do \ { \ - _FP_UNPACK_RAW_2(D,X,val); \ - _FP_UNPACK_CANONICAL(D,2,X); \ + _FP_UNPACK_RAW_2 (D, X, val); \ + _FP_UNPACK_CANONICAL (D, 2, X); \ } \ while (0) -# define FP_UNPACK_DP(X,val) \ +# define FP_UNPACK_DP(X, val) \ do \ { \ - _FP_UNPACK_RAW_2_P(D,X,val); \ - _FP_UNPACK_CANONICAL(D,2,X); \ + _FP_UNPACK_RAW_2_P (D, X, val); \ + _FP_UNPACK_CANONICAL (D, 2, X); \ } \ while (0) -# define FP_UNPACK_SEMIRAW_D(X,val) \ +# define FP_UNPACK_SEMIRAW_D(X, val) \ do \ { \ - _FP_UNPACK_RAW_2(D,X,val); \ - _FP_UNPACK_SEMIRAW(D,2,X); \ + _FP_UNPACK_RAW_2 (D, X, val); \ + _FP_UNPACK_SEMIRAW (D, 2, X); \ } \ while (0) -# define FP_UNPACK_SEMIRAW_DP(X,val) \ +# define FP_UNPACK_SEMIRAW_DP(X, val) \ do \ { \ - _FP_UNPACK_RAW_2_P(D,X,val); \ - _FP_UNPACK_SEMIRAW(D,2,X); \ + _FP_UNPACK_RAW_2_P (D, X, val); \ + _FP_UNPACK_SEMIRAW (D, 2, X); \ } \ while (0) -# define FP_PACK_D(val,X) \ +# define FP_PACK_D(val, X) \ do \ { \ - _FP_PACK_CANONICAL(D,2,X); \ - _FP_PACK_RAW_2(D,val,X); \ + _FP_PACK_CANONICAL (D, 2, X); \ + _FP_PACK_RAW_2 (D, val, X); \ } \ while (0) -# define FP_PACK_DP(val,X) \ +# define FP_PACK_DP(val, X) \ do \ { \ - _FP_PACK_CANONICAL(D,2,X); \ + _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) -# define FP_PACK_SEMIRAW_D(val,X) \ +# define FP_PACK_SEMIRAW_D(val, X) \ do \ { \ - _FP_PACK_SEMIRAW(D,2,X); \ - _FP_PACK_RAW_2(D,val,X); \ + _FP_PACK_SEMIRAW (D, 2, X); \ + _FP_PACK_RAW_2 (D, val, X); \ } \ while (0) -# define FP_PACK_SEMIRAW_DP(val,X) \ +# define FP_PACK_SEMIRAW_DP(val, X) \ do \ { \ - _FP_PACK_SEMIRAW(D,2,X); \ + _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) -# define FP_ISSIGNAN_D(X) _FP_ISSIGNAN(D,2,X) -# define FP_NEG_D(R,X) _FP_NEG(D,2,R,X) -# define FP_ADD_D(R,X,Y) _FP_ADD(D,2,R,X,Y) -# define FP_SUB_D(R,X,Y) _FP_SUB(D,2,R,X,Y) -# 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_FMA_D(R,X,Y,Z) _FP_FMA(D,2,4,R,X,Y,Z) +# define FP_ISSIGNAN_D(X) _FP_ISSIGNAN (D, 2, X) +# define FP_NEG_D(R, X) _FP_NEG (D, 2, R, X) +# define FP_ADD_D(R, X, Y) _FP_ADD (D, 2, R, X, Y) +# define FP_SUB_D(R, X, Y) _FP_SUB (D, 2, R, X, Y) +# 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_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) _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_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_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) +# define _FP_FRAC_HIGH_D(X) _FP_FRAC_HIGH_2 (X) +# define _FP_FRAC_HIGH_RAW_D(X) _FP_FRAC_HIGH_2 (X) -# define _FP_FRAC_HIGH_DW_D(X) _FP_FRAC_HIGH_4(X) +# define _FP_FRAC_HIGH_DW_D(X) _FP_FRAC_HIGH_4 (X) #else @@ -205,110 +205,110 @@ union _FP_UNION_D unsigned exp : _FP_EXPBITS_D; unsigned sign : 1; # endif - } bits __attribute__((packed)); + } bits __attribute__ ((packed)); }; -# 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_PACK_RAW_DP(val,X) \ +# 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_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) \ +# define FP_UNPACK_D(X, val) \ do \ { \ - _FP_UNPACK_RAW_1(D,X,val); \ - _FP_UNPACK_CANONICAL(D,1,X); \ + _FP_UNPACK_RAW_1 (D, X, val); \ + _FP_UNPACK_CANONICAL (D, 1, X); \ } \ while (0) -# define FP_UNPACK_DP(X,val) \ +# define FP_UNPACK_DP(X, val) \ do \ { \ - _FP_UNPACK_RAW_1_P(D,X,val); \ - _FP_UNPACK_CANONICAL(D,1,X); \ + _FP_UNPACK_RAW_1_P (D, X, val); \ + _FP_UNPACK_CANONICAL (D, 1, X); \ } \ while (0) -# define FP_UNPACK_SEMIRAW_D(X,val) \ +# define FP_UNPACK_SEMIRAW_D(X, val) \ do \ { \ - _FP_UNPACK_RAW_1(D,X,val); \ - _FP_UNPACK_SEMIRAW(D,1,X); \ + _FP_UNPACK_RAW_1 (D, X, val); \ + _FP_UNPACK_SEMIRAW (D, 1, X); \ } \ while (0) -# define FP_UNPACK_SEMIRAW_DP(X,val) \ +# define FP_UNPACK_SEMIRAW_DP(X, val) \ do \ { \ - _FP_UNPACK_RAW_1_P(D,X,val); \ - _FP_UNPACK_SEMIRAW(D,1,X); \ + _FP_UNPACK_RAW_1_P (D, X, val); \ + _FP_UNPACK_SEMIRAW (D, 1, X); \ } \ while (0) -# define FP_PACK_D(val,X) \ +# define FP_PACK_D(val, X) \ do \ { \ - _FP_PACK_CANONICAL(D,1,X); \ - _FP_PACK_RAW_1(D,val,X); \ + _FP_PACK_CANONICAL (D, 1, X); \ + _FP_PACK_RAW_1 (D, val, X); \ } \ while (0) -# define FP_PACK_DP(val,X) \ +# define FP_PACK_DP(val, X) \ do \ { \ - _FP_PACK_CANONICAL(D,1,X); \ + _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) -# define FP_PACK_SEMIRAW_D(val,X) \ +# define FP_PACK_SEMIRAW_D(val, X) \ do \ { \ - _FP_PACK_SEMIRAW(D,1,X); \ - _FP_PACK_RAW_1(D,val,X); \ + _FP_PACK_SEMIRAW (D, 1, X); \ + _FP_PACK_RAW_1 (D, val, X); \ } \ while (0) -# define FP_PACK_SEMIRAW_DP(val,X) \ +# define FP_PACK_SEMIRAW_DP(val, X) \ do \ { \ - _FP_PACK_SEMIRAW(D,1,X); \ + _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) -# define FP_ISSIGNAN_D(X) _FP_ISSIGNAN(D,1,X) -# define FP_NEG_D(R,X) _FP_NEG(D,1,R,X) -# define FP_ADD_D(R,X,Y) _FP_ADD(D,1,R,X,Y) -# define FP_SUB_D(R,X,Y) _FP_SUB(D,1,R,X,Y) -# 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_FMA_D(R,X,Y,Z) _FP_FMA(D,1,2,R,X,Y,Z) +# define FP_ISSIGNAN_D(X) _FP_ISSIGNAN (D, 1, X) +# define FP_NEG_D(R, X) _FP_NEG (D, 1, R, X) +# define FP_ADD_D(R, X, Y) _FP_ADD (D, 1, R, X, Y) +# define FP_SUB_D(R, X, Y) _FP_SUB (D, 1, R, X, Y) +# 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_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) _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_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_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) +# define _FP_FRAC_HIGH_D(X) _FP_FRAC_HIGH_1 (X) +# define _FP_FRAC_HIGH_RAW_D(X) _FP_FRAC_HIGH_1 (X) -# define _FP_FRAC_HIGH_DW_D(X) _FP_FRAC_HIGH_2(X) +# define _FP_FRAC_HIGH_DW_D(X) _FP_FRAC_HIGH_2 (X) #endif /* W_TYPE_SIZE < 64 */ diff --git a/soft-fp/eqdf2.c b/soft-fp/eqdf2.c index cc193ee26c..e8cfd7666a 100644 --- a/soft-fp/eqdf2.c +++ b/soft-fp/eqdf2.c @@ -32,22 +32,22 @@ #include "double.h" CMPtype -__eqdf2(DFtype a, DFtype b) +__eqdf2 (DFtype a, DFtype b) { FP_DECL_EX; - FP_DECL_D(A); - FP_DECL_D(B); + FP_DECL_D (A); + FP_DECL_D (B); CMPtype r; 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_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_HANDLE_EXCEPTIONS; return r; } -strong_alias(__eqdf2, __nedf2); +strong_alias (__eqdf2, __nedf2); diff --git a/soft-fp/eqsf2.c b/soft-fp/eqsf2.c index 39901d159d..0bdb7fb223 100644 --- a/soft-fp/eqsf2.c +++ b/soft-fp/eqsf2.c @@ -32,22 +32,22 @@ #include "single.h" CMPtype -__eqsf2(SFtype a, SFtype b) +__eqsf2 (SFtype a, SFtype b) { FP_DECL_EX; - FP_DECL_S(A); - FP_DECL_S(B); + FP_DECL_S (A); + FP_DECL_S (B); CMPtype r; 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_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_HANDLE_EXCEPTIONS; return r; } -strong_alias(__eqsf2, __nesf2); +strong_alias (__eqsf2, __nesf2); diff --git a/soft-fp/eqtf2.c b/soft-fp/eqtf2.c index e4ef829fef..edbc6f6832 100644 --- a/soft-fp/eqtf2.c +++ b/soft-fp/eqtf2.c @@ -32,22 +32,22 @@ #include "quad.h" CMPtype -__eqtf2(TFtype a, TFtype b) +__eqtf2 (TFtype a, TFtype b) { FP_DECL_EX; - FP_DECL_Q(A); - FP_DECL_Q(B); + FP_DECL_Q (A); + FP_DECL_Q (B); CMPtype r; 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_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_HANDLE_EXCEPTIONS; return r; } -strong_alias(__eqtf2, __netf2); +strong_alias (__eqtf2, __netf2); diff --git a/soft-fp/extenddftf2.c b/soft-fp/extenddftf2.c index a57e984b6c..2471fda954 100644 --- a/soft-fp/extenddftf2.c +++ b/soft-fp/extenddftf2.c @@ -33,21 +33,21 @@ #include "quad.h" TFtype -__extenddftf2(DFtype a) +__extenddftf2 (DFtype a) { FP_DECL_EX; - FP_DECL_D(A); - FP_DECL_Q(R); + FP_DECL_D (A); + FP_DECL_Q (R); TFtype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_D(A, a); + FP_UNPACK_RAW_D (A, a); #if (2 * _FP_W_TYPE_SIZE) < _FP_FRACBITS_Q - FP_EXTEND(Q,D,4,2,R,A); + FP_EXTEND (Q, D, 4, 2, R, A); #else - FP_EXTEND(Q,D,2,1,R,A); + FP_EXTEND (Q, D, 2, 1, R, A); #endif - FP_PACK_RAW_Q(r, R); + FP_PACK_RAW_Q (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/extended.h b/soft-fp/extended.h index e030b6ba98..1189f7c7d2 100644 --- a/soft-fp/extended.h +++ b/soft-fp/extended.h @@ -48,22 +48,22 @@ #define _FP_EXPMAX_E 32767 #define _FP_QNANBIT_E \ - ((_FP_W_TYPE)1 << (_FP_FRACBITS_E-2) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-2) % _FP_W_TYPE_SIZE) #define _FP_QNANBIT_SH_E \ - ((_FP_W_TYPE)1 << (_FP_FRACBITS_E-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE) #define _FP_IMPLBIT_E \ - ((_FP_W_TYPE)1 << (_FP_FRACBITS_E-1) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-1) % _FP_W_TYPE_SIZE) #define _FP_IMPLBIT_SH_E \ - ((_FP_W_TYPE)1 << (_FP_FRACBITS_E-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE) #define _FP_OVERFLOW_E \ - ((_FP_W_TYPE)1 << (_FP_WFRACBITS_E % _FP_W_TYPE_SIZE)) + ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_E % _FP_W_TYPE_SIZE)) #define _FP_WFRACBITS_DW_E (2 * _FP_WFRACBITS_E) #define _FP_WFRACXBITS_DW_E (_FP_FRACTBITS_DW_E - _FP_WFRACBITS_DW_E) #define _FP_HIGHBIT_DW_E \ - ((_FP_W_TYPE)1 << (_FP_WFRACBITS_DW_E - 1) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_E - 1) % _FP_W_TYPE_SIZE) -typedef float XFtype __attribute__((mode(XF))); +typedef float XFtype __attribute__ ((mode (XF))); #if _FP_W_TYPE_SIZE < 64 @@ -85,11 +85,11 @@ union _FP_UNION_E unsigned exp : _FP_EXPBITS_E; unsigned sign : 1; # endif /* not bigendian */ - } bits __attribute__((packed)); + } bits __attribute__ ((packed)); }; -# define FP_DECL_E(X) _FP_DECL(4,X) +# define FP_DECL_E(X) _FP_DECL (4, X) # define FP_UNPACK_RAW_E(X, val) \ do \ @@ -109,7 +109,7 @@ union _FP_UNION_E # define FP_UNPACK_RAW_EP(X, val) \ do \ { \ - union _FP_UNION_E *_flo = (union _FP_UNION_E *)(val); \ + union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val); \ \ X##_f[2] = 0; \ X##_f[3] = 0; \ @@ -138,97 +138,97 @@ union _FP_UNION_E } \ 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 *_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; \ + } \ + } \ while (0) -# define FP_UNPACK_E(X,val) \ +# define FP_UNPACK_E(X, val) \ do \ { \ - FP_UNPACK_RAW_E(X,val); \ - _FP_UNPACK_CANONICAL(E,4,X); \ + FP_UNPACK_RAW_E (X, val); \ + _FP_UNPACK_CANONICAL (E, 4, X); \ } \ while (0) -# define FP_UNPACK_EP(X,val) \ +# define FP_UNPACK_EP(X, val) \ do \ { \ - FP_UNPACK_RAW_EP(X,val); \ - _FP_UNPACK_CANONICAL(E,4,X); \ + FP_UNPACK_RAW_EP (X, val); \ + _FP_UNPACK_CANONICAL (E, 4, X); \ } \ while (0) -# define FP_UNPACK_SEMIRAW_E(X,val) \ +# define FP_UNPACK_SEMIRAW_E(X, val) \ do \ { \ - FP_UNPACK_RAW_E(X,val); \ - _FP_UNPACK_SEMIRAW(E,4,X); \ + FP_UNPACK_RAW_E (X, val); \ + _FP_UNPACK_SEMIRAW (E, 4, X); \ } \ while (0) -# define FP_UNPACK_SEMIRAW_EP(X,val) \ +# define FP_UNPACK_SEMIRAW_EP(X, val) \ do \ { \ - FP_UNPACK_RAW_EP(X,val); \ - _FP_UNPACK_SEMIRAW(E,4,X); \ + FP_UNPACK_RAW_EP (X, val); \ + _FP_UNPACK_SEMIRAW (E, 4, X); \ } \ while (0) -# define FP_PACK_E(val,X) \ +# define FP_PACK_E(val, X) \ do \ { \ - _FP_PACK_CANONICAL(E,4,X); \ - FP_PACK_RAW_E(val,X); \ + _FP_PACK_CANONICAL (E, 4, X); \ + FP_PACK_RAW_E (val, X); \ } \ while (0) -# define FP_PACK_EP(val,X) \ +# define FP_PACK_EP(val, X) \ do \ { \ - _FP_PACK_CANONICAL(E,4,X); \ - FP_PACK_RAW_EP(val,X); \ + _FP_PACK_CANONICAL (E, 4, X); \ + FP_PACK_RAW_EP (val, X); \ } \ while (0) -# define FP_PACK_SEMIRAW_E(val,X) \ +# define FP_PACK_SEMIRAW_E(val, X) \ do \ { \ - _FP_PACK_SEMIRAW(E,4,X); \ - FP_PACK_RAW_E(val,X); \ + _FP_PACK_SEMIRAW (E, 4, X); \ + FP_PACK_RAW_E (val, X); \ } \ while (0) -# define FP_PACK_SEMIRAW_EP(val,X) \ +# define FP_PACK_SEMIRAW_EP(val, X) \ do \ { \ - _FP_PACK_SEMIRAW(E,4,X); \ - FP_PACK_RAW_EP(val,X); \ + _FP_PACK_SEMIRAW (E, 4, X); \ + FP_PACK_RAW_EP (val, X); \ } \ while (0) -# define FP_ISSIGNAN_E(X) _FP_ISSIGNAN(E,4,X) -# define FP_NEG_E(R,X) _FP_NEG(E,4,R,X) -# define FP_ADD_E(R,X,Y) _FP_ADD(E,4,R,X,Y) -# define FP_SUB_E(R,X,Y) _FP_SUB(E,4,R,X,Y) -# define FP_MUL_E(R,X,Y) _FP_MUL(E,4,R,X,Y) -# define FP_DIV_E(R,X,Y) _FP_DIV(E,4,R,X,Y) -# 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) +# define FP_ISSIGNAN_E(X) _FP_ISSIGNAN (E, 4, X) +# define FP_NEG_E(R, X) _FP_NEG (E, 4, R, X) +# define FP_ADD_E(R, X, Y) _FP_ADD (E, 4, R, X, Y) +# define FP_SUB_E(R, X, Y) _FP_SUB (E, 4, R, X, Y) +# define FP_MUL_E(R, X, Y) _FP_MUL (E, 4, R, X, Y) +# define FP_DIV_E(R, X, Y) _FP_DIV (E, 4, R, X, Y) +# 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: @@ -244,8 +244,8 @@ union _FP_UNION_E # define _FP_SQRT_MEAT_E(R, S, T, X, q) \ do \ { \ - q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1); \ - _FP_FRAC_SRL_4(X, (_FP_WORKBITS)); \ + 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; \ @@ -255,10 +255,10 @@ union _FP_UNION_E X##_f[1] -= T##_f[1]; \ R##_f[1] += q; \ } \ - _FP_FRAC_SLL_2(X, 1); \ + _FP_FRAC_SLL_2 (X, 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; \ @@ -269,13 +269,13 @@ union _FP_UNION_E { \ S##_f[0] = T##_f[0] + q; \ S##_f[1] += (T##_f[0] > S##_f[0]); \ - _FP_FRAC_DEC_2(X, T); \ + _FP_FRAC_DEC_2 (X, T); \ R##_f[0] += q; \ } \ - _FP_FRAC_SLL_2(X, 1); \ + _FP_FRAC_SLL_2 (X, 1); \ q >>= 1; \ } \ - _FP_FRAC_SLL_4(R, (_FP_WORKBITS)); \ + _FP_FRAC_SLL_4 (R, (_FP_WORKBITS)); \ if (X##_f[0] | X##_f[1]) \ { \ if (S##_f[1] < X##_f[1] \ @@ -287,12 +287,12 @@ 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) _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_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_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]) @@ -318,7 +318,7 @@ union _FP_UNION_E } bits; }; -# define FP_DECL_E(X) _FP_DECL(2,X) +# define FP_DECL_E(X) _FP_DECL (2, X) # define FP_UNPACK_RAW_E(X, val) \ do \ @@ -336,7 +336,7 @@ union _FP_UNION_E # define FP_UNPACK_RAW_EP(X, val) \ do \ { \ - union _FP_UNION_E *_flo = (union _FP_UNION_E *)(val); \ + union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val); \ \ X##_f0 = _flo->bits.frac; \ X##_f1 = 0; \ @@ -362,97 +362,97 @@ union _FP_UNION_E } \ 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 *_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; \ + } \ + } \ while (0) -# define FP_UNPACK_E(X,val) \ +# define FP_UNPACK_E(X, val) \ do \ { \ - FP_UNPACK_RAW_E(X,val); \ - _FP_UNPACK_CANONICAL(E,2,X); \ + FP_UNPACK_RAW_E (X, val); \ + _FP_UNPACK_CANONICAL (E, 2, X); \ } \ while (0) -# define FP_UNPACK_EP(X,val) \ +# define FP_UNPACK_EP(X, val) \ do \ { \ - FP_UNPACK_RAW_EP(X,val); \ - _FP_UNPACK_CANONICAL(E,2,X); \ + FP_UNPACK_RAW_EP (X, val); \ + _FP_UNPACK_CANONICAL (E, 2, X); \ } \ while (0) -# define FP_UNPACK_SEMIRAW_E(X,val) \ +# define FP_UNPACK_SEMIRAW_E(X, val) \ do \ { \ - FP_UNPACK_RAW_E(X,val); \ - _FP_UNPACK_SEMIRAW(E,2,X); \ + FP_UNPACK_RAW_E (X, val); \ + _FP_UNPACK_SEMIRAW (E, 2, X); \ } \ while (0) -# define FP_UNPACK_SEMIRAW_EP(X,val) \ +# define FP_UNPACK_SEMIRAW_EP(X, val) \ do \ { \ - FP_UNPACK_RAW_EP(X,val); \ - _FP_UNPACK_SEMIRAW(E,2,X); \ + FP_UNPACK_RAW_EP (X, val); \ + _FP_UNPACK_SEMIRAW (E, 2, X); \ } \ while (0) -# define FP_PACK_E(val,X) \ +# define FP_PACK_E(val, X) \ do \ { \ - _FP_PACK_CANONICAL(E,2,X); \ - FP_PACK_RAW_E(val,X); \ + _FP_PACK_CANONICAL (E, 2, X); \ + FP_PACK_RAW_E (val, X); \ } \ while (0) -# define FP_PACK_EP(val,X) \ +# define FP_PACK_EP(val, X) \ do \ { \ - _FP_PACK_CANONICAL(E,2,X); \ - FP_PACK_RAW_EP(val,X); \ + _FP_PACK_CANONICAL (E, 2, X); \ + FP_PACK_RAW_EP (val, X); \ } \ while (0) -# define FP_PACK_SEMIRAW_E(val,X) \ +# define FP_PACK_SEMIRAW_E(val, X) \ do \ { \ - _FP_PACK_SEMIRAW(E,2,X); \ - FP_PACK_RAW_E(val,X); \ + _FP_PACK_SEMIRAW (E, 2, X); \ + FP_PACK_RAW_E (val, X); \ } \ while (0) -# define FP_PACK_SEMIRAW_EP(val,X) \ +# define FP_PACK_SEMIRAW_EP(val, X) \ do \ { \ - _FP_PACK_SEMIRAW(E,2,X); \ - FP_PACK_RAW_EP(val,X); \ + _FP_PACK_SEMIRAW (E, 2, X); \ + FP_PACK_RAW_EP (val, X); \ } \ while (0) -# define FP_ISSIGNAN_E(X) _FP_ISSIGNAN(E,2,X) -# define FP_NEG_E(R,X) _FP_NEG(E,2,R,X) -# define FP_ADD_E(R,X,Y) _FP_ADD(E,2,R,X,Y) -# define FP_SUB_E(R,X,Y) _FP_SUB(E,2,R,X,Y) -# define FP_MUL_E(R,X,Y) _FP_MUL(E,2,R,X,Y) -# define FP_DIV_E(R,X,Y) _FP_DIV(E,2,R,X,Y) -# 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) +# define FP_ISSIGNAN_E(X) _FP_ISSIGNAN (E, 2, X) +# define FP_NEG_E(R, X) _FP_NEG (E, 2, R, X) +# define FP_ADD_E(R, X, Y) _FP_ADD (E, 2, R, X, Y) +# define FP_SUB_E(R, X, Y) _FP_SUB (E, 2, R, X, Y) +# define FP_MUL_E(R, X, Y) _FP_MUL (E, 2, R, X, Y) +# define FP_DIV_E(R, X, Y) _FP_DIV (E, 2, R, X, Y) +# 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: @@ -465,8 +465,8 @@ union _FP_UNION_E # define _FP_SQRT_MEAT_E(R, S, T, X, q) \ do \ { \ - q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1); \ - _FP_FRAC_SRL_2(X, (_FP_WORKBITS)); \ + q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \ + _FP_FRAC_SRL_2 (X, (_FP_WORKBITS)); \ while (q) \ { \ T##_f0 = S##_f0 + q; \ @@ -476,10 +476,10 @@ union _FP_UNION_E X##_f0 -= T##_f0; \ R##_f0 += q; \ } \ - _FP_FRAC_SLL_1(X, 1); \ + _FP_FRAC_SLL_1 (X, 1); \ q >>= 1; \ } \ - _FP_FRAC_SLL_2(R, (_FP_WORKBITS)); \ + _FP_FRAC_SLL_2 (R, (_FP_WORKBITS)); \ if (X##_f0) \ { \ if (S##_f0 < X##_f0) \ @@ -489,12 +489,12 @@ 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) _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_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_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) diff --git a/soft-fp/extendsfdf2.c b/soft-fp/extendsfdf2.c index 08affea8aa..2276de527f 100644 --- a/soft-fp/extendsfdf2.c +++ b/soft-fp/extendsfdf2.c @@ -33,21 +33,21 @@ #include "double.h" DFtype -__extendsfdf2(SFtype a) +__extendsfdf2 (SFtype a) { FP_DECL_EX; - FP_DECL_S(A); - FP_DECL_D(R); + FP_DECL_S (A); + FP_DECL_D (R); DFtype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_S(A, a); + FP_UNPACK_RAW_S (A, a); #if _FP_W_TYPE_SIZE < _FP_FRACBITS_D - FP_EXTEND(D,S,2,1,R,A); + FP_EXTEND (D, S, 2, 1, R, A); #else - FP_EXTEND(D,S,1,1,R,A); + FP_EXTEND (D, S, 1, 1, R, A); #endif - FP_PACK_RAW_D(r, R); + FP_PACK_RAW_D (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/extendsftf2.c b/soft-fp/extendsftf2.c index b5dafe8900..51f60c4569 100644 --- a/soft-fp/extendsftf2.c +++ b/soft-fp/extendsftf2.c @@ -33,21 +33,21 @@ #include "quad.h" TFtype -__extendsftf2(SFtype a) +__extendsftf2 (SFtype a) { FP_DECL_EX; - FP_DECL_S(A); - FP_DECL_Q(R); + FP_DECL_S (A); + FP_DECL_Q (R); TFtype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_S(A, a); + FP_UNPACK_RAW_S (A, a); #if (2 * _FP_W_TYPE_SIZE) < _FP_FRACBITS_Q - FP_EXTEND(Q,S,4,1,R,A); + FP_EXTEND (Q, S, 4, 1, R, A); #else - FP_EXTEND(Q,S,2,1,R,A); + FP_EXTEND (Q, S, 2, 1, R, A); #endif - FP_PACK_RAW_Q(r, R); + FP_PACK_RAW_Q (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/extendxftf2.c b/soft-fp/extendxftf2.c index 40eaaec6db..684052d874 100644 --- a/soft-fp/extendxftf2.c +++ b/soft-fp/extendxftf2.c @@ -32,21 +32,21 @@ #include "quad.h" TFtype -__extendxftf2(XFtype a) +__extendxftf2 (XFtype a) { FP_DECL_EX; - FP_DECL_E(A); - FP_DECL_Q(R); + FP_DECL_E (A); + FP_DECL_Q (R); TFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_RAW_E(A, a); + FP_UNPACK_RAW_E (A, a); #if (2 * _FP_W_TYPE_SIZE) < _FP_FRACBITS_Q - FP_EXTEND(Q,E,4,4,R,A); + FP_EXTEND (Q, E, 4, 4, R, A); #else - FP_EXTEND(Q,E,2,2,R,A); + FP_EXTEND (Q, E, 2, 2, R, A); #endif - FP_PACK_RAW_Q(r, R); + FP_PACK_RAW_Q (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixdfdi.c b/soft-fp/fixdfdi.c index 617c2c9886..7b926b3d69 100644 --- a/soft-fp/fixdfdi.c +++ b/soft-fp/fixdfdi.c @@ -32,15 +32,15 @@ #include "double.h" DItype -__fixdfdi(DFtype a) +__fixdfdi (DFtype a) { FP_DECL_EX; - FP_DECL_D(A); + FP_DECL_D (A); UDItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_D(A, a); - FP_TO_INT_D(r, A, DI_BITS, 1); + FP_UNPACK_RAW_D (A, a); + FP_TO_INT_D (r, A, DI_BITS, 1); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixdfsi.c b/soft-fp/fixdfsi.c index 78f8afa19c..79b2d21505 100644 --- a/soft-fp/fixdfsi.c +++ b/soft-fp/fixdfsi.c @@ -32,15 +32,15 @@ #include "double.h" SItype -__fixdfsi(DFtype a) +__fixdfsi (DFtype a) { FP_DECL_EX; - FP_DECL_D(A); + FP_DECL_D (A); USItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_D(A, a); - FP_TO_INT_D(r, A, SI_BITS, 1); + FP_UNPACK_RAW_D (A, a); + FP_TO_INT_D (r, A, SI_BITS, 1); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixdfti.c b/soft-fp/fixdfti.c index 8d27cd5ffa..b5fe4f99fc 100644 --- a/soft-fp/fixdfti.c +++ b/soft-fp/fixdfti.c @@ -31,15 +31,15 @@ #include "double.h" TItype -__fixdfti(DFtype a) +__fixdfti (DFtype a) { FP_DECL_EX; - FP_DECL_D(A); + FP_DECL_D (A); UTItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_D(A, a); - FP_TO_INT_D(r, A, TI_BITS, 1); + FP_UNPACK_RAW_D (A, a); + FP_TO_INT_D (r, A, TI_BITS, 1); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixsfdi.c b/soft-fp/fixsfdi.c index c34bec5a93..df6b9c728a 100644 --- a/soft-fp/fixsfdi.c +++ b/soft-fp/fixsfdi.c @@ -32,15 +32,15 @@ #include "single.h" DItype -__fixsfdi(SFtype a) +__fixsfdi (SFtype a) { FP_DECL_EX; - FP_DECL_S(A); + FP_DECL_S (A); UDItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_S(A, a); - FP_TO_INT_S(r, A, DI_BITS, 1); + FP_UNPACK_RAW_S (A, a); + FP_TO_INT_S (r, A, DI_BITS, 1); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixsfsi.c b/soft-fp/fixsfsi.c index 2e287946cd..4c0bfd39db 100644 --- a/soft-fp/fixsfsi.c +++ b/soft-fp/fixsfsi.c @@ -32,15 +32,15 @@ #include "single.h" SItype -__fixsfsi(SFtype a) +__fixsfsi (SFtype a) { FP_DECL_EX; - FP_DECL_S(A); + FP_DECL_S (A); USItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_S(A, a); - FP_TO_INT_S(r, A, SI_BITS, 1); + FP_UNPACK_RAW_S (A, a); + FP_TO_INT_S (r, A, SI_BITS, 1); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixsfti.c b/soft-fp/fixsfti.c index 91efb52489..6b5229fe91 100644 --- a/soft-fp/fixsfti.c +++ b/soft-fp/fixsfti.c @@ -31,15 +31,15 @@ #include "single.h" TItype -__fixsfti(SFtype a) +__fixsfti (SFtype a) { FP_DECL_EX; - FP_DECL_S(A); + FP_DECL_S (A); UTItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_S(A, a); - FP_TO_INT_S(r, A, TI_BITS, 1); + FP_UNPACK_RAW_S (A, a); + FP_TO_INT_S (r, A, TI_BITS, 1); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixtfdi.c b/soft-fp/fixtfdi.c index 2a6814e53d..a65173aa78 100644 --- a/soft-fp/fixtfdi.c +++ b/soft-fp/fixtfdi.c @@ -32,15 +32,15 @@ #include "quad.h" DItype -__fixtfdi(TFtype a) +__fixtfdi (TFtype a) { FP_DECL_EX; - FP_DECL_Q(A); + FP_DECL_Q (A); UDItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_Q(A, a); - FP_TO_INT_Q(r, A, DI_BITS, 1); + FP_UNPACK_RAW_Q (A, a); + FP_TO_INT_Q (r, A, DI_BITS, 1); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixtfsi.c b/soft-fp/fixtfsi.c index e2096cb6e5..bc0ea0b87d 100644 --- a/soft-fp/fixtfsi.c +++ b/soft-fp/fixtfsi.c @@ -32,15 +32,15 @@ #include "quad.h" SItype -__fixtfsi(TFtype a) +__fixtfsi (TFtype a) { FP_DECL_EX; - FP_DECL_Q(A); + FP_DECL_Q (A); USItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_Q(A, a); - FP_TO_INT_Q(r, A, SI_BITS, 1); + FP_UNPACK_RAW_Q (A, a); + FP_TO_INT_Q (r, A, SI_BITS, 1); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixtfti.c b/soft-fp/fixtfti.c index 2fd65a009d..573ca0ed11 100644 --- a/soft-fp/fixtfti.c +++ b/soft-fp/fixtfti.c @@ -31,15 +31,15 @@ #include "quad.h" TItype -__fixtfti(TFtype a) +__fixtfti (TFtype a) { FP_DECL_EX; - FP_DECL_Q(A); + FP_DECL_Q (A); UTItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_Q(A, a); - FP_TO_INT_Q(r, A, TI_BITS, 1); + FP_UNPACK_RAW_Q (A, a); + FP_TO_INT_Q (r, A, TI_BITS, 1); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixunsdfdi.c b/soft-fp/fixunsdfdi.c index ae4e5f541a..8831cc3d19 100644 --- a/soft-fp/fixunsdfdi.c +++ b/soft-fp/fixunsdfdi.c @@ -32,15 +32,15 @@ #include "double.h" UDItype -__fixunsdfdi(DFtype a) +__fixunsdfdi (DFtype a) { FP_DECL_EX; - FP_DECL_D(A); + FP_DECL_D (A); UDItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_D(A, a); - FP_TO_INT_D(r, A, DI_BITS, 0); + FP_UNPACK_RAW_D (A, a); + FP_TO_INT_D (r, A, DI_BITS, 0); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixunsdfsi.c b/soft-fp/fixunsdfsi.c index 09a0c7618e..ff3744467a 100644 --- a/soft-fp/fixunsdfsi.c +++ b/soft-fp/fixunsdfsi.c @@ -32,15 +32,15 @@ #include "double.h" USItype -__fixunsdfsi(DFtype a) +__fixunsdfsi (DFtype a) { FP_DECL_EX; - FP_DECL_D(A); + FP_DECL_D (A); USItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_D(A, a); - FP_TO_INT_D(r, A, SI_BITS, 0); + FP_UNPACK_RAW_D (A, a); + FP_TO_INT_D (r, A, SI_BITS, 0); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixunsdfti.c b/soft-fp/fixunsdfti.c index f3370c65e3..f124a7c6a8 100644 --- a/soft-fp/fixunsdfti.c +++ b/soft-fp/fixunsdfti.c @@ -31,15 +31,15 @@ #include "double.h" UTItype -__fixunsdfti(DFtype a) +__fixunsdfti (DFtype a) { FP_DECL_EX; - FP_DECL_D(A); + FP_DECL_D (A); UTItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_D(A, a); - FP_TO_INT_D(r, A, TI_BITS, 0); + FP_UNPACK_RAW_D (A, a); + FP_TO_INT_D (r, A, TI_BITS, 0); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixunssfdi.c b/soft-fp/fixunssfdi.c index 9560767720..4261c5e6a7 100644 --- a/soft-fp/fixunssfdi.c +++ b/soft-fp/fixunssfdi.c @@ -32,15 +32,15 @@ #include "single.h" UDItype -__fixunssfdi(SFtype a) +__fixunssfdi (SFtype a) { FP_DECL_EX; - FP_DECL_S(A); + FP_DECL_S (A); UDItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_S(A, a); - FP_TO_INT_S(r, A, DI_BITS, 0); + FP_UNPACK_RAW_S (A, a); + FP_TO_INT_S (r, A, DI_BITS, 0); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixunssfsi.c b/soft-fp/fixunssfsi.c index 3e56d54155..b4bb890299 100644 --- a/soft-fp/fixunssfsi.c +++ b/soft-fp/fixunssfsi.c @@ -32,15 +32,15 @@ #include "single.h" USItype -__fixunssfsi(SFtype a) +__fixunssfsi (SFtype a) { FP_DECL_EX; - FP_DECL_S(A); + FP_DECL_S (A); USItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_S(A, a); - FP_TO_INT_S(r, A, SI_BITS, 0); + FP_UNPACK_RAW_S (A, a); + FP_TO_INT_S (r, A, SI_BITS, 0); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixunssfti.c b/soft-fp/fixunssfti.c index 694f7e422e..36d01b0cfe 100644 --- a/soft-fp/fixunssfti.c +++ b/soft-fp/fixunssfti.c @@ -31,15 +31,15 @@ #include "single.h" UTItype -__fixunssfti(SFtype a) +__fixunssfti (SFtype a) { FP_DECL_EX; - FP_DECL_S(A); + FP_DECL_S (A); UTItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_S(A, a); - FP_TO_INT_S(r, A, TI_BITS, 0); + FP_UNPACK_RAW_S (A, a); + FP_TO_INT_S (r, A, TI_BITS, 0); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixunstfdi.c b/soft-fp/fixunstfdi.c index d4a0b7d707..b2355a2ae9 100644 --- a/soft-fp/fixunstfdi.c +++ b/soft-fp/fixunstfdi.c @@ -32,15 +32,15 @@ #include "quad.h" UDItype -__fixunstfdi(TFtype a) +__fixunstfdi (TFtype a) { FP_DECL_EX; - FP_DECL_Q(A); + FP_DECL_Q (A); UDItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_Q(A, a); - FP_TO_INT_Q(r, A, DI_BITS, 0); + FP_UNPACK_RAW_Q (A, a); + FP_TO_INT_Q (r, A, DI_BITS, 0); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixunstfsi.c b/soft-fp/fixunstfsi.c index 47d51b0478..efa1418da1 100644 --- a/soft-fp/fixunstfsi.c +++ b/soft-fp/fixunstfsi.c @@ -32,15 +32,15 @@ #include "quad.h" USItype -__fixunstfsi(TFtype a) +__fixunstfsi (TFtype a) { FP_DECL_EX; - FP_DECL_Q(A); + FP_DECL_Q (A); USItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_Q(A, a); - FP_TO_INT_Q(r, A, SI_BITS, 0); + FP_UNPACK_RAW_Q (A, a); + FP_TO_INT_Q (r, A, SI_BITS, 0); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fixunstfti.c b/soft-fp/fixunstfti.c index 6dd8697183..efe0cf5c5d 100644 --- a/soft-fp/fixunstfti.c +++ b/soft-fp/fixunstfti.c @@ -31,15 +31,15 @@ #include "quad.h" UTItype -__fixunstfti(TFtype a) +__fixunstfti (TFtype a) { FP_DECL_EX; - FP_DECL_Q(A); + FP_DECL_Q (A); UTItype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_Q(A, a); - FP_TO_INT_Q(r, A, TI_BITS, 0); + FP_UNPACK_RAW_Q (A, a); + FP_TO_INT_Q (r, A, TI_BITS, 0); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/floatdidf.c b/soft-fp/floatdidf.c index 4413e68de4..fc8719abd7 100644 --- a/soft-fp/floatdidf.c +++ b/soft-fp/floatdidf.c @@ -32,15 +32,15 @@ #include "double.h" DFtype -__floatdidf(DItype i) +__floatdidf (DItype i) { FP_DECL_EX; - FP_DECL_D(A); + FP_DECL_D (A); DFtype a; FP_INIT_ROUNDMODE; - FP_FROM_INT_D(A, i, DI_BITS, UDItype); - FP_PACK_RAW_D(a, A); + FP_FROM_INT_D (A, i, DI_BITS, UDItype); + FP_PACK_RAW_D (a, A); FP_HANDLE_EXCEPTIONS; return a; diff --git a/soft-fp/floatdisf.c b/soft-fp/floatdisf.c index 2b54d1fc78..b6b6b42525 100644 --- a/soft-fp/floatdisf.c +++ b/soft-fp/floatdisf.c @@ -32,15 +32,15 @@ #include "single.h" SFtype -__floatdisf(DItype i) +__floatdisf (DItype i) { FP_DECL_EX; - FP_DECL_S(A); + FP_DECL_S (A); SFtype a; FP_INIT_ROUNDMODE; - FP_FROM_INT_S(A, i, DI_BITS, UDItype); - FP_PACK_RAW_S(a, A); + FP_FROM_INT_S (A, i, DI_BITS, UDItype); + FP_PACK_RAW_S (a, A); FP_HANDLE_EXCEPTIONS; return a; diff --git a/soft-fp/floatditf.c b/soft-fp/floatditf.c index 760183f84d..fc3fba361f 100644 --- a/soft-fp/floatditf.c +++ b/soft-fp/floatditf.c @@ -33,13 +33,13 @@ #include "quad.h" TFtype -__floatditf(DItype i) +__floatditf (DItype i) { - FP_DECL_Q(A); + FP_DECL_Q (A); TFtype a; - FP_FROM_INT_Q(A, i, DI_BITS, UDItype); - FP_PACK_RAW_Q(a, A); + FP_FROM_INT_Q (A, i, DI_BITS, UDItype); + FP_PACK_RAW_Q (a, A); return a; } diff --git a/soft-fp/floatsidf.c b/soft-fp/floatsidf.c index 04cc2e2782..7df5265ffc 100644 --- a/soft-fp/floatsidf.c +++ b/soft-fp/floatsidf.c @@ -33,13 +33,13 @@ #include "double.h" DFtype -__floatsidf(SItype i) +__floatsidf (SItype i) { - FP_DECL_D(A); + FP_DECL_D (A); DFtype a; - FP_FROM_INT_D(A, i, SI_BITS, USItype); - FP_PACK_RAW_D(a, A); + FP_FROM_INT_D (A, i, SI_BITS, USItype); + FP_PACK_RAW_D (a, A); return a; } diff --git a/soft-fp/floatsisf.c b/soft-fp/floatsisf.c index d22c733c51..b55fd3329e 100644 --- a/soft-fp/floatsisf.c +++ b/soft-fp/floatsisf.c @@ -32,15 +32,15 @@ #include "single.h" SFtype -__floatsisf(SItype i) +__floatsisf (SItype i) { FP_DECL_EX; - FP_DECL_S(A); + FP_DECL_S (A); SFtype a; FP_INIT_ROUNDMODE; - FP_FROM_INT_S(A, i, SI_BITS, USItype); - FP_PACK_RAW_S(a, A); + FP_FROM_INT_S (A, i, SI_BITS, USItype); + FP_PACK_RAW_S (a, A); FP_HANDLE_EXCEPTIONS; return a; diff --git a/soft-fp/floatsitf.c b/soft-fp/floatsitf.c index d5f107f8c5..d7c3078e4b 100644 --- a/soft-fp/floatsitf.c +++ b/soft-fp/floatsitf.c @@ -33,13 +33,13 @@ #include "quad.h" TFtype -__floatsitf(SItype i) +__floatsitf (SItype i) { - FP_DECL_Q(A); + FP_DECL_Q (A); TFtype a; - FP_FROM_INT_Q(A, i, SI_BITS, USItype); - FP_PACK_RAW_Q(a, A); + FP_FROM_INT_Q (A, i, SI_BITS, USItype); + FP_PACK_RAW_Q (a, A); return a; } diff --git a/soft-fp/floattidf.c b/soft-fp/floattidf.c index 004fab45e0..a28181b23a 100644 --- a/soft-fp/floattidf.c +++ b/soft-fp/floattidf.c @@ -31,15 +31,15 @@ #include "double.h" DFtype -__floattidf(TItype i) +__floattidf (TItype i) { FP_DECL_EX; - FP_DECL_D(A); + FP_DECL_D (A); DFtype a; FP_INIT_ROUNDMODE; - FP_FROM_INT_D(A, i, TI_BITS, UTItype); - FP_PACK_RAW_D(a, A); + FP_FROM_INT_D (A, i, TI_BITS, UTItype); + FP_PACK_RAW_D (a, A); FP_HANDLE_EXCEPTIONS; return a; diff --git a/soft-fp/floattisf.c b/soft-fp/floattisf.c index 929da426c8..da81047945 100644 --- a/soft-fp/floattisf.c +++ b/soft-fp/floattisf.c @@ -31,15 +31,15 @@ #include "single.h" SFtype -__floattisf(TItype i) +__floattisf (TItype i) { FP_DECL_EX; - FP_DECL_S(A); + FP_DECL_S (A); SFtype a; FP_INIT_ROUNDMODE; - FP_FROM_INT_S(A, i, TI_BITS, UTItype); - FP_PACK_RAW_S(a, A); + FP_FROM_INT_S (A, i, TI_BITS, UTItype); + FP_PACK_RAW_S (a, A); FP_HANDLE_EXCEPTIONS; return a; diff --git a/soft-fp/floattitf.c b/soft-fp/floattitf.c index 1952a852f0..ffe217a622 100644 --- a/soft-fp/floattitf.c +++ b/soft-fp/floattitf.c @@ -31,15 +31,15 @@ #include "quad.h" TFtype -__floattitf(TItype i) +__floattitf (TItype i) { FP_DECL_EX; - FP_DECL_Q(A); + FP_DECL_Q (A); TFtype a; FP_INIT_ROUNDMODE; - FP_FROM_INT_Q(A, i, TI_BITS, UTItype); - FP_PACK_RAW_Q(a, A); + FP_FROM_INT_Q (A, i, TI_BITS, UTItype); + FP_PACK_RAW_Q (a, A); FP_HANDLE_EXCEPTIONS; return a; diff --git a/soft-fp/floatundidf.c b/soft-fp/floatundidf.c index f40457b5d4..8a041f827a 100644 --- a/soft-fp/floatundidf.c +++ b/soft-fp/floatundidf.c @@ -32,15 +32,15 @@ #include "double.h" DFtype -__floatundidf(UDItype i) +__floatundidf (UDItype i) { FP_DECL_EX; - FP_DECL_D(A); + FP_DECL_D (A); DFtype a; FP_INIT_ROUNDMODE; - FP_FROM_INT_D(A, i, DI_BITS, UDItype); - FP_PACK_RAW_D(a, A); + FP_FROM_INT_D (A, i, DI_BITS, UDItype); + FP_PACK_RAW_D (a, A); FP_HANDLE_EXCEPTIONS; return a; diff --git a/soft-fp/floatundisf.c b/soft-fp/floatundisf.c index 51b69e69b9..8dc750851a 100644 --- a/soft-fp/floatundisf.c +++ b/soft-fp/floatundisf.c @@ -32,15 +32,15 @@ #include "single.h" SFtype -__floatundisf(UDItype i) +__floatundisf (UDItype i) { FP_DECL_EX; - FP_DECL_S(A); + FP_DECL_S (A); SFtype a; FP_INIT_ROUNDMODE; - FP_FROM_INT_S(A, i, DI_BITS, UDItype); - FP_PACK_RAW_S(a, A); + FP_FROM_INT_S (A, i, DI_BITS, UDItype); + FP_PACK_RAW_S (a, A); FP_HANDLE_EXCEPTIONS; return a; diff --git a/soft-fp/floatunditf.c b/soft-fp/floatunditf.c index e178dea304..cc8a3fe06c 100644 --- a/soft-fp/floatunditf.c +++ b/soft-fp/floatunditf.c @@ -33,13 +33,13 @@ #include "quad.h" TFtype -__floatunditf(UDItype i) +__floatunditf (UDItype i) { - FP_DECL_Q(A); + FP_DECL_Q (A); TFtype a; - FP_FROM_INT_Q(A, i, DI_BITS, UDItype); - FP_PACK_RAW_Q(a, A); + FP_FROM_INT_Q (A, i, DI_BITS, UDItype); + FP_PACK_RAW_Q (a, A); return a; } diff --git a/soft-fp/floatunsidf.c b/soft-fp/floatunsidf.c index d9d3b5bd9a..059029640c 100644 --- a/soft-fp/floatunsidf.c +++ b/soft-fp/floatunsidf.c @@ -33,13 +33,13 @@ #include "double.h" DFtype -__floatunsidf(USItype i) +__floatunsidf (USItype i) { - FP_DECL_D(A); + FP_DECL_D (A); DFtype a; - FP_FROM_INT_D(A, i, SI_BITS, USItype); - FP_PACK_RAW_D(a, A); + FP_FROM_INT_D (A, i, SI_BITS, USItype); + FP_PACK_RAW_D (a, A); return a; } diff --git a/soft-fp/floatunsisf.c b/soft-fp/floatunsisf.c index eb81ea0cae..91c1e4d1a9 100644 --- a/soft-fp/floatunsisf.c +++ b/soft-fp/floatunsisf.c @@ -32,15 +32,15 @@ #include "single.h" SFtype -__floatunsisf(USItype i) +__floatunsisf (USItype i) { FP_DECL_EX; - FP_DECL_S(A); + FP_DECL_S (A); SFtype a; FP_INIT_ROUNDMODE; - FP_FROM_INT_S(A, i, SI_BITS, USItype); - FP_PACK_RAW_S(a, A); + FP_FROM_INT_S (A, i, SI_BITS, USItype); + FP_PACK_RAW_S (a, A); FP_HANDLE_EXCEPTIONS; return a; diff --git a/soft-fp/floatunsitf.c b/soft-fp/floatunsitf.c index e94ae926b7..b1eecfd7c9 100644 --- a/soft-fp/floatunsitf.c +++ b/soft-fp/floatunsitf.c @@ -33,13 +33,13 @@ #include "quad.h" TFtype -__floatunsitf(USItype i) +__floatunsitf (USItype i) { - FP_DECL_Q(A); + FP_DECL_Q (A); TFtype a; - FP_FROM_INT_Q(A, i, SI_BITS, USItype); - FP_PACK_RAW_Q(a, A); + FP_FROM_INT_Q (A, i, SI_BITS, USItype); + FP_PACK_RAW_Q (a, A); return a; } diff --git a/soft-fp/floatuntidf.c b/soft-fp/floatuntidf.c index f9654ba8d7..6a8981daec 100644 --- a/soft-fp/floatuntidf.c +++ b/soft-fp/floatuntidf.c @@ -31,15 +31,15 @@ #include "double.h" DFtype -__floatuntidf(UTItype i) +__floatuntidf (UTItype i) { FP_DECL_EX; - FP_DECL_D(A); + FP_DECL_D (A); DFtype a; FP_INIT_ROUNDMODE; - FP_FROM_INT_D(A, i, TI_BITS, UTItype); - FP_PACK_RAW_D(a, A); + FP_FROM_INT_D (A, i, TI_BITS, UTItype); + FP_PACK_RAW_D (a, A); FP_HANDLE_EXCEPTIONS; return a; diff --git a/soft-fp/floatuntisf.c b/soft-fp/floatuntisf.c index d690e7312b..94d0593f26 100644 --- a/soft-fp/floatuntisf.c +++ b/soft-fp/floatuntisf.c @@ -31,15 +31,15 @@ #include "single.h" SFtype -__floatuntisf(UTItype i) +__floatuntisf (UTItype i) { FP_DECL_EX; - FP_DECL_S(A); + FP_DECL_S (A); SFtype a; FP_INIT_ROUNDMODE; - FP_FROM_INT_S(A, i, TI_BITS, UTItype); - FP_PACK_RAW_S(a, A); + FP_FROM_INT_S (A, i, TI_BITS, UTItype); + FP_PACK_RAW_S (a, A); FP_HANDLE_EXCEPTIONS; return a; diff --git a/soft-fp/floatuntitf.c b/soft-fp/floatuntitf.c index 0c04b05a45..424bfef8fa 100644 --- a/soft-fp/floatuntitf.c +++ b/soft-fp/floatuntitf.c @@ -31,15 +31,15 @@ #include "quad.h" TFtype -__floatuntitf(UTItype i) +__floatuntitf (UTItype i) { FP_DECL_EX; - FP_DECL_Q(A); + FP_DECL_Q (A); TFtype a; FP_INIT_ROUNDMODE; - FP_FROM_INT_Q(A, i, TI_BITS, UTItype); - FP_PACK_RAW_Q(a, A); + FP_FROM_INT_Q (A, i, TI_BITS, UTItype); + FP_PACK_RAW_Q (a, A); FP_HANDLE_EXCEPTIONS; return a; diff --git a/soft-fp/fmadf4.c b/soft-fp/fmadf4.c index bc02756ccc..709c47bb4b 100644 --- a/soft-fp/fmadf4.c +++ b/soft-fp/fmadf4.c @@ -33,18 +33,18 @@ double __fma (double a, double b, double c) { FP_DECL_EX; - FP_DECL_D(A); - FP_DECL_D(B); - FP_DECL_D(C); - FP_DECL_D(R); + FP_DECL_D (A); + FP_DECL_D (B); + FP_DECL_D (C); + FP_DECL_D (R); double r; FP_INIT_ROUNDMODE; - FP_UNPACK_D(A, a); - FP_UNPACK_D(B, b); - FP_UNPACK_D(C, c); - FP_FMA_D(R, A, B, C); - FP_PACK_D(r, R); + FP_UNPACK_D (A, a); + FP_UNPACK_D (B, b); + FP_UNPACK_D (C, c); + FP_FMA_D (R, A, B, C); + FP_PACK_D (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fmasf4.c b/soft-fp/fmasf4.c index fbf7e78e8a..6af3701429 100644 --- a/soft-fp/fmasf4.c +++ b/soft-fp/fmasf4.c @@ -33,18 +33,18 @@ float __fmaf (float a, float b, float c) { FP_DECL_EX; - FP_DECL_S(A); - FP_DECL_S(B); - FP_DECL_S(C); - FP_DECL_S(R); + FP_DECL_S (A); + FP_DECL_S (B); + FP_DECL_S (C); + FP_DECL_S (R); float r; FP_INIT_ROUNDMODE; - FP_UNPACK_S(A, a); - FP_UNPACK_S(B, b); - FP_UNPACK_S(C, c); - FP_FMA_S(R, A, B, C); - FP_PACK_S(r, R); + FP_UNPACK_S (A, a); + FP_UNPACK_S (B, b); + FP_UNPACK_S (C, c); + FP_FMA_S (R, A, B, C); + FP_PACK_S (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/fmatf4.c b/soft-fp/fmatf4.c index c96ab65036..1427b2542f 100644 --- a/soft-fp/fmatf4.c +++ b/soft-fp/fmatf4.c @@ -33,18 +33,18 @@ long double __fmal (long double a, long double b, long double c) { FP_DECL_EX; - FP_DECL_Q(A); - FP_DECL_Q(B); - FP_DECL_Q(C); - FP_DECL_Q(R); + FP_DECL_Q (A); + FP_DECL_Q (B); + FP_DECL_Q (C); + FP_DECL_Q (R); long double r; FP_INIT_ROUNDMODE; - FP_UNPACK_Q(A, a); - FP_UNPACK_Q(B, b); - FP_UNPACK_Q(C, c); - FP_FMA_Q(R, A, B, C); - FP_PACK_Q(r, R); + FP_UNPACK_Q (A, a); + FP_UNPACK_Q (B, b); + FP_UNPACK_Q (C, c); + FP_FMA_Q (R, A, B, C); + FP_PACK_Q (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/gedf2.c b/soft-fp/gedf2.c index 6445c152b7..5b6fad2849 100644 --- a/soft-fp/gedf2.c +++ b/soft-fp/gedf2.c @@ -32,22 +32,22 @@ #include "double.h" CMPtype -__gedf2(DFtype a, DFtype b) +__gedf2 (DFtype a, DFtype b) { FP_DECL_EX; - FP_DECL_D(A); - FP_DECL_D(B); + FP_DECL_D (A); + FP_DECL_D (B); CMPtype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_D(A, a); - FP_UNPACK_RAW_D(B, b); - FP_CMP_D(r, A, B, -2); + 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_SET_EXCEPTION (FP_EX_INVALID); FP_HANDLE_EXCEPTIONS; return r; } -strong_alias(__gedf2, __gtdf2); +strong_alias (__gedf2, __gtdf2); diff --git a/soft-fp/gesf2.c b/soft-fp/gesf2.c index 96a06e9005..4e5d9393f1 100644 --- a/soft-fp/gesf2.c +++ b/soft-fp/gesf2.c @@ -32,22 +32,22 @@ #include "single.h" CMPtype -__gesf2(SFtype a, SFtype b) +__gesf2 (SFtype a, SFtype b) { FP_DECL_EX; - FP_DECL_S(A); - FP_DECL_S(B); + FP_DECL_S (A); + FP_DECL_S (B); CMPtype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_S(A, a); - FP_UNPACK_RAW_S(B, b); - FP_CMP_S(r, A, B, -2); + 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_SET_EXCEPTION (FP_EX_INVALID); FP_HANDLE_EXCEPTIONS; return r; } -strong_alias(__gesf2, __gtsf2); +strong_alias (__gesf2, __gtsf2); diff --git a/soft-fp/getf2.c b/soft-fp/getf2.c index 579ce64f64..ed02f459ea 100644 --- a/soft-fp/getf2.c +++ b/soft-fp/getf2.c @@ -32,22 +32,22 @@ #include "quad.h" CMPtype -__getf2(TFtype a, TFtype b) +__getf2 (TFtype a, TFtype b) { FP_DECL_EX; - FP_DECL_Q(A); - FP_DECL_Q(B); + FP_DECL_Q (A); + FP_DECL_Q (B); CMPtype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_Q(A, a); - FP_UNPACK_RAW_Q(B, b); - FP_CMP_Q(r, A, B, -2); + 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_SET_EXCEPTION (FP_EX_INVALID); FP_HANDLE_EXCEPTIONS; return r; } -strong_alias(__getf2, __gttf2); +strong_alias (__getf2, __gttf2); diff --git a/soft-fp/ledf2.c b/soft-fp/ledf2.c index abf53d9701..476f1c4701 100644 --- a/soft-fp/ledf2.c +++ b/soft-fp/ledf2.c @@ -32,22 +32,22 @@ #include "double.h" CMPtype -__ledf2(DFtype a, DFtype b) +__ledf2 (DFtype a, DFtype b) { FP_DECL_EX; - FP_DECL_D(A); - FP_DECL_D(B); + FP_DECL_D (A); + FP_DECL_D (B); CMPtype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_D(A, a); - FP_UNPACK_RAW_D(B, b); - FP_CMP_D(r, A, B, 2); + 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_SET_EXCEPTION (FP_EX_INVALID); FP_HANDLE_EXCEPTIONS; return r; } -strong_alias(__ledf2, __ltdf2); +strong_alias (__ledf2, __ltdf2); diff --git a/soft-fp/lesf2.c b/soft-fp/lesf2.c index 9f18e6956c..ac2f748a36 100644 --- a/soft-fp/lesf2.c +++ b/soft-fp/lesf2.c @@ -32,22 +32,22 @@ #include "single.h" CMPtype -__lesf2(SFtype a, SFtype b) +__lesf2 (SFtype a, SFtype b) { FP_DECL_EX; - FP_DECL_S(A); - FP_DECL_S(B); + FP_DECL_S (A); + FP_DECL_S (B); CMPtype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_S(A, a); - FP_UNPACK_RAW_S(B, b); - FP_CMP_S(r, A, B, 2); + 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_SET_EXCEPTION (FP_EX_INVALID); FP_HANDLE_EXCEPTIONS; return r; } -strong_alias(__lesf2, __ltsf2); +strong_alias (__lesf2, __ltsf2); diff --git a/soft-fp/letf2.c b/soft-fp/letf2.c index 028bdd2d3b..a41055b949 100644 --- a/soft-fp/letf2.c +++ b/soft-fp/letf2.c @@ -32,22 +32,22 @@ #include "quad.h" CMPtype -__letf2(TFtype a, TFtype b) +__letf2 (TFtype a, TFtype b) { FP_DECL_EX; - FP_DECL_Q(A); - FP_DECL_Q(B); + FP_DECL_Q (A); + FP_DECL_Q (B); CMPtype r; FP_INIT_EXCEPTIONS; - FP_UNPACK_RAW_Q(A, a); - FP_UNPACK_RAW_Q(B, b); - FP_CMP_Q(r, A, B, 2); + 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_SET_EXCEPTION (FP_EX_INVALID); FP_HANDLE_EXCEPTIONS; return r; } -strong_alias(__letf2, __lttf2); +strong_alias (__letf2, __lttf2); diff --git a/soft-fp/muldf3.c b/soft-fp/muldf3.c index 96e6a3b45e..dee3f76e5b 100644 --- a/soft-fp/muldf3.c +++ b/soft-fp/muldf3.c @@ -32,19 +32,19 @@ #include "double.h" DFtype -__muldf3(DFtype a, DFtype b) +__muldf3 (DFtype a, DFtype b) { FP_DECL_EX; - FP_DECL_D(A); - FP_DECL_D(B); - FP_DECL_D(R); + FP_DECL_D (A); + FP_DECL_D (B); + FP_DECL_D (R); DFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_D(A, a); - FP_UNPACK_D(B, b); - FP_MUL_D(R, A, B); - FP_PACK_D(r, R); + FP_UNPACK_D (A, a); + FP_UNPACK_D (B, b); + FP_MUL_D (R, A, B); + FP_PACK_D (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/mulsf3.c b/soft-fp/mulsf3.c index b602f219d7..f983b30347 100644 --- a/soft-fp/mulsf3.c +++ b/soft-fp/mulsf3.c @@ -32,19 +32,19 @@ #include "single.h" SFtype -__mulsf3(SFtype a, SFtype b) +__mulsf3 (SFtype a, SFtype b) { FP_DECL_EX; - FP_DECL_S(A); - FP_DECL_S(B); - FP_DECL_S(R); + FP_DECL_S (A); + FP_DECL_S (B); + FP_DECL_S (R); SFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_S(A, a); - FP_UNPACK_S(B, b); - FP_MUL_S(R, A, B); - FP_PACK_S(r, R); + FP_UNPACK_S (A, a); + FP_UNPACK_S (B, b); + FP_MUL_S (R, A, B); + FP_PACK_S (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/multf3.c b/soft-fp/multf3.c index 9b898e290e..1306c63f8a 100644 --- a/soft-fp/multf3.c +++ b/soft-fp/multf3.c @@ -32,19 +32,19 @@ #include "quad.h" TFtype -__multf3(TFtype a, TFtype b) +__multf3 (TFtype a, TFtype b) { FP_DECL_EX; - FP_DECL_Q(A); - FP_DECL_Q(B); - FP_DECL_Q(R); + FP_DECL_Q (A); + FP_DECL_Q (B); + FP_DECL_Q (R); TFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_Q(A, a); - FP_UNPACK_Q(B, b); - FP_MUL_Q(R, A, B); - FP_PACK_Q(r, R); + FP_UNPACK_Q (A, a); + FP_UNPACK_Q (B, b); + FP_MUL_Q (R, A, B); + FP_PACK_Q (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/negdf2.c b/soft-fp/negdf2.c index c1b858ba39..d74c16c1ed 100644 --- a/soft-fp/negdf2.c +++ b/soft-fp/negdf2.c @@ -32,15 +32,15 @@ #include "double.h" DFtype -__negdf2(DFtype a) +__negdf2 (DFtype a) { - FP_DECL_D(A); - FP_DECL_D(R); + FP_DECL_D (A); + FP_DECL_D (R); DFtype r; - FP_UNPACK_RAW_D(A, a); - FP_NEG_D(R, A); - FP_PACK_RAW_D(r, R); + FP_UNPACK_RAW_D (A, a); + FP_NEG_D (R, A); + FP_PACK_RAW_D (r, R); return r; } diff --git a/soft-fp/negsf2.c b/soft-fp/negsf2.c index 1a08d34a8e..0316105a5d 100644 --- a/soft-fp/negsf2.c +++ b/soft-fp/negsf2.c @@ -32,15 +32,15 @@ #include "single.h" SFtype -__negsf2(SFtype a) +__negsf2 (SFtype a) { - FP_DECL_S(A); - FP_DECL_S(R); + FP_DECL_S (A); + FP_DECL_S (R); SFtype r; - FP_UNPACK_RAW_S(A, a); - FP_NEG_S(R, A); - FP_PACK_RAW_S(r, R); + FP_UNPACK_RAW_S (A, a); + FP_NEG_S (R, A); + FP_PACK_RAW_S (r, R); return r; } diff --git a/soft-fp/negtf2.c b/soft-fp/negtf2.c index eb28eba501..8540af24d2 100644 --- a/soft-fp/negtf2.c +++ b/soft-fp/negtf2.c @@ -32,15 +32,15 @@ #include "quad.h" TFtype -__negtf2(TFtype a) +__negtf2 (TFtype a) { - FP_DECL_Q(A); - FP_DECL_Q(R); + FP_DECL_Q (A); + FP_DECL_Q (R); TFtype r; - FP_UNPACK_RAW_Q(A, a); - FP_NEG_Q(R, A); - FP_PACK_RAW_Q(r, R); + FP_UNPACK_RAW_Q (A, a); + FP_NEG_Q (R, A); + FP_PACK_RAW_Q (r, R); return r; } diff --git a/soft-fp/op-1.h b/soft-fp/op-1.h index e4d84bfecc..8ccb46a796 100644 --- a/soft-fp/op-1.h +++ b/soft-fp/op-1.h @@ -31,61 +31,61 @@ <http://www.gnu.org/licenses/>. */ #define _FP_FRAC_DECL_1(X) _FP_W_TYPE X##_f -#define _FP_FRAC_COPY_1(D,S) (D##_f = S##_f) -#define _FP_FRAC_SET_1(X,I) (X##_f = I) +#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) #define _FP_FRAC_LOW_1(X) (X##_f) -#define _FP_FRAC_WORD_1(X,w) (X##_f) +#define _FP_FRAC_WORD_1(X, w) (X##_f) -#define _FP_FRAC_ADDI_1(X,I) (X##_f += I) -#define _FP_FRAC_SLL_1(X,N) \ +#define _FP_FRAC_ADDI_1(X, I) (X##_f += I) +#define _FP_FRAC_SLL_1(X, N) \ do \ { \ - if (__builtin_constant_p(N) && (N) == 1) \ + if (__builtin_constant_p (N) && (N) == 1) \ X##_f += X##_f; \ else \ X##_f <<= (N); \ } \ while (0) -#define _FP_FRAC_SRL_1(X,N) (X##_f >>= N) +#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) \ +#define __FP_FRAC_SRST_1(X, S, N, sz) \ do \ { \ - S = (__builtin_constant_p(N) && (N) == 1 \ + S = (__builtin_constant_p (N) && (N) == 1 \ ? X & 1 \ : (X << (_FP_W_TYPE_SIZE - (N))) != 0); \ X = X >> (N); \ } \ while (0) -#define __FP_FRAC_SRS_1(X,N,sz) \ - (X = (X >> (N) | (__builtin_constant_p(N) && (N) == 1 \ +#define __FP_FRAC_SRS_1(X, N, sz) \ + (X = (X >> (N) | (__builtin_constant_p (N) && (N) == 1 \ ? X & 1 \ : (X << (_FP_W_TYPE_SIZE - (N))) != 0))) -#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_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) /* Predicates */ -#define _FP_FRAC_NEGP_1(X) ((_FP_WS_TYPE)X##_f < 0) +#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) -#define _FP_FRAC_CLEAR_OVERP_1(fs,X) (X##_f &= ~_FP_OVERFLOW_##fs) -#define _FP_FRAC_HIGHBIT_DW_1(fs,X) (X##_f & _FP_HIGHBIT_DW_##fs) +#define _FP_FRAC_OVERP_1(fs, X) (X##_f & _FP_OVERFLOW_##fs) +#define _FP_FRAC_CLEAR_OVERP_1(fs, X) (X##_f &= ~_FP_OVERFLOW_##fs) +#define _FP_FRAC_HIGHBIT_DW_1(fs, X) (X##_f & _FP_HIGHBIT_DW_##fs) #define _FP_FRAC_EQ_1(X, Y) (X##_f == Y##_f) #define _FP_FRAC_GE_1(X, Y) (X##_f >= Y##_f) #define _FP_FRAC_GT_1(X, Y) (X##_f > Y##_f) #define _FP_ZEROFRAC_1 0 #define _FP_MINFRAC_1 1 -#define _FP_MAXFRAC_1 (~(_FP_WS_TYPE)0) +#define _FP_MAXFRAC_1 (~(_FP_WS_TYPE) 0) /* * Unpack the raw bits of a native fp value. Do not classify or @@ -107,7 +107,7 @@ #define _FP_UNPACK_RAW_1_P(fs, X, val) \ do \ { \ - union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *)(val); \ + union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val); \ \ X##_f = _flo->bits.frac; \ X##_e = _flo->bits.exp; \ @@ -135,7 +135,7 @@ #define _FP_PACK_RAW_1_P(fs, val, X) \ do \ { \ - union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *)(val); \ + union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val); \ \ _flo->bits.frac = X##_f; \ _flo->bits.exp = X##_e; \ @@ -161,11 +161,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) @@ -174,19 +174,19 @@ #define _FP_MUL_MEAT_DW_1_wide(wfracbits, R, X, Y, doit) \ do \ { \ - doit(R##_f1, R##_f0, X##_f, Y##_f); \ + doit (R##_f1, R##_f0, X##_f, Y##_f); \ } \ while (0) #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 (_Z); \ + _FP_MUL_MEAT_DW_1_wide (wfracbits, _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); \ + _FP_FRAC_SRS_2 (_Z, wfracbits-1, 2*wfracbits); \ R##_f = _Z_f0; \ } \ while (0) @@ -197,13 +197,13 @@ do \ { \ _FP_W_TYPE _xh, _xl, _yh, _yl; \ - _FP_FRAC_DECL_2(_a); \ + _FP_FRAC_DECL_2 (_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); \ + _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); \ + _yl = Y##_f & (((_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2)) - 1); \ \ /* multiply the pieces */ \ R##_f0 = _xl * _yl; \ @@ -213,21 +213,21 @@ \ /* reassemble into two full words */ \ if ((_a_f0 += _a_f1) < _a_f1) \ - R##_f1 += (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE/2); \ + 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_FRAC_ADD_2 (R, R, _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); \ + _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); \ + _FP_FRAC_SRS_2 (_z, wfracbits - 1, 2*wfracbits); \ R##_f = _z_f0; \ } \ while (0) @@ -249,7 +249,7 @@ X##_f <<= (X##_f < Y##_f \ ? R##_e--, _FP_WFRACBITS_##fs \ : _FP_WFRACBITS_##fs - 1); \ - doit(_q, _r, X##_f, Y##_f); \ + doit (_q, _r, X##_f, Y##_f); \ R##_f = _q | (_r != 0); \ } \ while (0) @@ -280,7 +280,7 @@ _nh = X##_f >> 1; \ } \ \ - udiv_qrnnd(_q, _r, _nh, _nl, _y); \ + udiv_qrnnd (_q, _r, _nh, _nl, _y); \ R##_f = _q | (_r != 0); \ } \ while (0) @@ -300,7 +300,7 @@ _nl = X##_f << (_FP_WFRACBITS_##fs - 1); \ _nh = X##_f >> (_FP_WFRACXBITS_##fs + 1); \ } \ - udiv_qrnnd(_q, _r, _nh, _nl, Y##_f); \ + udiv_qrnnd (_q, _r, _nh, _nl, Y##_f); \ R##_f = _q | (_r != 0); \ } \ while (0) @@ -324,7 +324,7 @@ X##_f -= T##_f; \ R##_f += q; \ } \ - _FP_FRAC_SLL_1(X, 1); \ + _FP_FRAC_SLL_1 (X, 1); \ q >>= 1; \ } \ if (X##_f) \ diff --git a/soft-fp/op-2.h b/soft-fp/op-2.h index 0704035845..5ef4217de1 100644 --- a/soft-fp/op-2.h +++ b/soft-fp/op-2.h @@ -31,113 +31,113 @@ <http://www.gnu.org/licenses/>. */ #define _FP_FRAC_DECL_2(X) _FP_W_TYPE X##_f0, X##_f1 -#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_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) #define _FP_FRAC_LOW_2(X) (X##_f0) -#define _FP_FRAC_WORD_2(X,w) (X##_f##w) - -#define _FP_FRAC_SLL_2(X,N) \ - (void)(((N) < _FP_W_TYPE_SIZE) \ - ? ({ \ - if (__builtin_constant_p(N) && (N) == 1) \ - { \ - X##_f1 = X##_f1 + X##_f1 + (((_FP_WS_TYPE)(X##_f0)) < 0); \ - X##_f0 += X##_f0; \ - } \ - else \ - { \ - X##_f1 = X##_f1 << (N) | X##_f0 >> (_FP_W_TYPE_SIZE - (N)); \ - X##_f0 <<= (N); \ - } \ - 0; \ - }) \ - : ({ \ - X##_f1 = X##_f0 << ((N) - _FP_W_TYPE_SIZE); \ - X##_f0 = 0; \ - })) - - -#define _FP_FRAC_SRL_2(X,N) \ - (void)(((N) < _FP_W_TYPE_SIZE) \ - ? ({ \ - X##_f0 = X##_f0 >> (N) | X##_f1 << (_FP_W_TYPE_SIZE - (N)); \ - X##_f1 >>= (N); \ - }) \ - : ({ \ - X##_f0 = X##_f1 >> ((N) - _FP_W_TYPE_SIZE); \ - X##_f1 = 0; \ - })) +#define _FP_FRAC_WORD_2(X, w) (X##_f##w) + +#define _FP_FRAC_SLL_2(X, N) \ + (void) (((N) < _FP_W_TYPE_SIZE) \ + ? ({ \ + if (__builtin_constant_p (N) && (N) == 1) \ + { \ + X##_f1 = X##_f1 + X##_f1 + (((_FP_WS_TYPE) (X##_f0)) < 0); \ + X##_f0 += X##_f0; \ + } \ + else \ + { \ + X##_f1 = X##_f1 << (N) | X##_f0 >> (_FP_W_TYPE_SIZE - (N)); \ + X##_f0 <<= (N); \ + } \ + 0; \ + }) \ + : ({ \ + X##_f1 = X##_f0 << ((N) - _FP_W_TYPE_SIZE); \ + X##_f0 = 0; \ + })) + + +#define _FP_FRAC_SRL_2(X, N) \ + (void) (((N) < _FP_W_TYPE_SIZE) \ + ? ({ \ + X##_f0 = X##_f0 >> (N) | X##_f1 << (_FP_W_TYPE_SIZE - (N)); \ + X##_f1 >>= (N); \ + }) \ + : ({ \ + X##_f0 = X##_f1 >> ((N) - _FP_W_TYPE_SIZE); \ + X##_f1 = 0; \ + })) /* Right shift with sticky-lsb. */ -#define _FP_FRAC_SRST_2(X,S, N,sz) \ - (void)(((N) < _FP_W_TYPE_SIZE) \ - ? ({ \ - S = (__builtin_constant_p(N) && (N) == 1 \ - ? X##_f0 & 1 \ - : (X##_f0 << (_FP_W_TYPE_SIZE - (N))) != 0); \ - X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N)); \ - X##_f1 >>= (N); \ - }) \ - : ({ \ - S = ((((N) == _FP_W_TYPE_SIZE \ - ? 0 \ - : (X##_f1 << (2*_FP_W_TYPE_SIZE - (N)))) \ - | X##_f0) != 0); \ - X##_f0 = (X##_f1 >> ((N) - _FP_W_TYPE_SIZE)); \ - X##_f1 = 0; \ - })) - -#define _FP_FRAC_SRS_2(X,N,sz) \ - (void)(((N) < _FP_W_TYPE_SIZE) \ - ? ({ \ - X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N) \ - | (__builtin_constant_p(N) && (N) == 1 \ - ? X##_f0 & 1 \ - : (X##_f0 << (_FP_W_TYPE_SIZE - (N))) != 0)); \ - X##_f1 >>= (N); \ - }) \ - : ({ \ - X##_f0 = (X##_f1 >> ((N) - _FP_W_TYPE_SIZE) \ - | ((((N) == _FP_W_TYPE_SIZE \ - ? 0 \ - : (X##_f1 << (2*_FP_W_TYPE_SIZE - (N)))) \ - | X##_f0) != 0)); \ - X##_f1 = 0; \ - })) - -#define _FP_FRAC_ADDI_2(X,I) \ - __FP_FRAC_ADDI_2(X##_f1, X##_f0, I) - -#define _FP_FRAC_ADD_2(R,X,Y) \ - __FP_FRAC_ADD_2(R##_f1, R##_f0, X##_f1, X##_f0, Y##_f1, Y##_f0) - -#define _FP_FRAC_SUB_2(R,X,Y) \ - __FP_FRAC_SUB_2(R##_f1, R##_f0, X##_f1, X##_f0, Y##_f1, Y##_f0) - -#define _FP_FRAC_DEC_2(X,Y) \ - __FP_FRAC_DEC_2(X##_f1, X##_f0, Y##_f1, Y##_f0) - -#define _FP_FRAC_CLZ_2(R,X) \ +#define _FP_FRAC_SRST_2(X, S, N, sz) \ + (void) (((N) < _FP_W_TYPE_SIZE) \ + ? ({ \ + S = (__builtin_constant_p (N) && (N) == 1 \ + ? X##_f0 & 1 \ + : (X##_f0 << (_FP_W_TYPE_SIZE - (N))) != 0); \ + X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N)); \ + X##_f1 >>= (N); \ + }) \ + : ({ \ + S = ((((N) == _FP_W_TYPE_SIZE \ + ? 0 \ + : (X##_f1 << (2*_FP_W_TYPE_SIZE - (N)))) \ + | X##_f0) != 0); \ + X##_f0 = (X##_f1 >> ((N) - _FP_W_TYPE_SIZE)); \ + X##_f1 = 0; \ + })) + +#define _FP_FRAC_SRS_2(X, N, sz) \ + (void) (((N) < _FP_W_TYPE_SIZE) \ + ? ({ \ + X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N) \ + | (__builtin_constant_p (N) && (N) == 1 \ + ? X##_f0 & 1 \ + : (X##_f0 << (_FP_W_TYPE_SIZE - (N))) != 0)); \ + X##_f1 >>= (N); \ + }) \ + : ({ \ + X##_f0 = (X##_f1 >> ((N) - _FP_W_TYPE_SIZE) \ + | ((((N) == _FP_W_TYPE_SIZE \ + ? 0 \ + : (X##_f1 << (2*_FP_W_TYPE_SIZE - (N)))) \ + | X##_f0) != 0)); \ + X##_f1 = 0; \ + })) + +#define _FP_FRAC_ADDI_2(X, I) \ + __FP_FRAC_ADDI_2 (X##_f1, X##_f0, I) + +#define _FP_FRAC_ADD_2(R, X, Y) \ + __FP_FRAC_ADD_2 (R##_f1, R##_f0, X##_f1, X##_f0, Y##_f1, Y##_f0) + +#define _FP_FRAC_SUB_2(R, X, Y) \ + __FP_FRAC_SUB_2 (R##_f1, R##_f0, X##_f1, X##_f0, Y##_f1, Y##_f0) + +#define _FP_FRAC_DEC_2(X, Y) \ + __FP_FRAC_DEC_2 (X##_f1, X##_f0, Y##_f1, Y##_f0) + +#define _FP_FRAC_CLZ_2(R, X) \ do \ { \ if (X##_f1) \ - __FP_CLZ(R,X##_f1); \ + __FP_CLZ (R, X##_f1); \ else \ { \ - __FP_CLZ(R,X##_f0); \ + __FP_CLZ (R, X##_f0); \ R += _FP_W_TYPE_SIZE; \ } \ } \ - while(0) + while (0) /* Predicates */ -#define _FP_FRAC_NEGP_2(X) ((_FP_WS_TYPE)X##_f1 < 0) +#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) -#define _FP_FRAC_CLEAR_OVERP_2(fs,X) (_FP_FRAC_HIGH_##fs(X) &= ~_FP_OVERFLOW_##fs) -#define _FP_FRAC_HIGHBIT_DW_2(fs,X) \ - (_FP_FRAC_HIGH_DW_##fs(X) & _FP_HIGHBIT_DW_##fs) +#define _FP_FRAC_OVERP_2(fs, X) (_FP_FRAC_HIGH_##fs (X) & _FP_OVERFLOW_##fs) +#define _FP_FRAC_CLEAR_OVERP_2(fs, X) (_FP_FRAC_HIGH_##fs (X) &= ~_FP_OVERFLOW_##fs) +#define _FP_FRAC_HIGHBIT_DW_2(fs, X) \ + (_FP_FRAC_HIGH_DW_##fs (X) & _FP_HIGHBIT_DW_##fs) #define _FP_FRAC_EQ_2(X, Y) (X##_f1 == Y##_f1 && X##_f0 == Y##_f0) #define _FP_FRAC_GT_2(X, Y) \ (X##_f1 > Y##_f1 || (X##_f1 == Y##_f1 && X##_f0 > Y##_f0)) @@ -146,26 +146,26 @@ #define _FP_ZEROFRAC_2 0, 0 #define _FP_MINFRAC_2 0, 1 -#define _FP_MAXFRAC_2 (~(_FP_WS_TYPE)0), (~(_FP_WS_TYPE)0) +#define _FP_MAXFRAC_2 (~(_FP_WS_TYPE) 0), (~(_FP_WS_TYPE) 0) /* * Internals */ -#define __FP_FRAC_SET_2(X,I1,I0) (X##_f0 = I0, X##_f1 = I1) +#define __FP_FRAC_SET_2(X, I1, I0) (X##_f0 = I0, X##_f1 = I1) #define __FP_CLZ_2(R, xh, xl) \ do \ { \ if (xh) \ - __FP_CLZ(R,xh); \ + __FP_CLZ (R, xh); \ else \ { \ - __FP_CLZ(R,xl); \ + __FP_CLZ (R, xl); \ R += _FP_W_TYPE_SIZE; \ } \ } \ - while(0) + while (0) #if 0 @@ -194,14 +194,14 @@ #else # undef __FP_FRAC_ADDI_2 -# define __FP_FRAC_ADDI_2(xh, xl, i) add_ssaaaa(xh, xl, xh, xl, 0, i) +# define __FP_FRAC_ADDI_2(xh, xl, i) add_ssaaaa (xh, xl, xh, xl, 0, i) # undef __FP_FRAC_ADD_2 # define __FP_FRAC_ADD_2 add_ssaaaa # undef __FP_FRAC_SUB_2 # define __FP_FRAC_SUB_2 sub_ddmmss # undef __FP_FRAC_DEC_2 # define __FP_FRAC_DEC_2(xh, xl, yh, yl) \ - sub_ddmmss(xh, xl, xh, xl, yh, yl) + sub_ddmmss (xh, xl, xh, xl, yh, yl) #endif @@ -226,7 +226,7 @@ #define _FP_UNPACK_RAW_2_P(fs, X, val) \ do \ { \ - union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *)(val); \ + union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val); \ \ X##_f0 = _flo->bits.frac0; \ X##_f1 = _flo->bits.frac1; \ @@ -257,7 +257,7 @@ #define _FP_PACK_RAW_2_P(fs, val, X) \ do \ { \ - union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *)(val); \ + union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val); \ \ _flo->bits.frac0 = X##_f0; \ _flo->bits.frac1 = X##_f1; \ @@ -276,38 +276,38 @@ #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 (_b); \ + _FP_FRAC_DECL_2 (_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 (_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); \ \ - __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,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,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, _b_f1, _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, 3), _FP_FRAC_WORD_4 (R, 2), \ + _FP_FRAC_WORD_4 (R, 1)); \ } \ while (0) #define _FP_MUL_MEAT_2_wide(wfracbits, R, X, Y, doit) \ do \ { \ - _FP_FRAC_DECL_4(_z); \ + _FP_FRAC_DECL_4 (_z); \ \ - _FP_MUL_MEAT_DW_2_wide(wfracbits, _z, X, Y, doit); \ + _FP_MUL_MEAT_DW_2_wide (wfracbits, _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 (_z, wfracbits-1, 2*wfracbits); \ + R##_f0 = _FP_FRAC_WORD_4 (_z, 0); \ + R##_f1 = _FP_FRAC_WORD_4 (_z, 1); \ } \ while (0) @@ -318,8 +318,8 @@ #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_FRAC_DECL_2 (_b); \ + _FP_FRAC_DECL_2 (_c); \ _FP_W_TYPE _d; \ int _c1, _c2; \ \ @@ -327,43 +327,43 @@ _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); \ + 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); \ \ _b_f0 &= -_c2; \ _b_f1 &= -_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, \ - 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_FRAC_ADDI_2(_FP_FRAC_WORD_4(R,3),_FP_FRAC_WORD_4(R,2), \ - _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)); \ - __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_ADD_2(_FP_FRAC_WORD_4(R,3), _FP_FRAC_WORD_4(R,2), \ - _c_f1, _c_f0, \ - _FP_FRAC_WORD_4(R,3), _FP_FRAC_WORD_4(R,2)); \ + __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, \ + 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_FRAC_ADDI_2 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \ + _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)); \ + __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_ADD_2 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \ + _c_f1, _c_f0, \ + _FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2)); \ } \ while (0) #define _FP_MUL_MEAT_2_wide_3mul(wfracbits, R, X, Y, doit) \ do \ { \ - _FP_FRAC_DECL_4(_z); \ + _FP_FRAC_DECL_4 (_z); \ \ - _FP_MUL_MEAT_DW_2_wide_3mul(wfracbits, _z, X, Y, doit); \ + _FP_MUL_MEAT_DW_2_wide_3mul (wfracbits, _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 (_z, wfracbits-1, 2*wfracbits); \ + R##_f0 = _FP_FRAC_WORD_4 (_z, 0); \ + R##_f1 = _FP_FRAC_WORD_4 (_z, 1); \ } \ while (0) @@ -376,21 +376,21 @@ _y[0] = Y##_f0; \ _y[1] = Y##_f1; \ \ - mpn_mul_n(R##_f, _x, _y, 2); \ + mpn_mul_n (R##_f, _x, _y, 2); \ } \ while (0) #define _FP_MUL_MEAT_2_gmp(wfracbits, R, X, Y) \ do \ { \ - _FP_FRAC_DECL_4(_z); \ + _FP_FRAC_DECL_4 (_z); \ \ - _FP_MUL_MEAT_DW_2_gmp(wfracbits, _z, X, Y); \ + _FP_MUL_MEAT_DW_2_gmp (wfracbits, _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); \ + _FP_FRAC_SRS_4 (_z, wfracbits-1, 2*wfracbits); \ R##_f0 = _z_f[0]; \ R##_f1 = _z_f[1]; \ } \ @@ -429,20 +429,20 @@ UDItype _t240, _u240, _v240, _w240, _x240, _y240 = 0; \ \ if (wfracbits < 106 || wfracbits > 120) \ - abort(); \ + abort (); \ \ setfetz; \ \ - _e240 = (double)(long)(X##_f0 & 0xffffff); \ - _j240 = (double)(long)(Y##_f0 & 0xffffff); \ - _d240 = (double)(long)((X##_f0 >> 24) & 0xffffff); \ - _i240 = (double)(long)((Y##_f0 >> 24) & 0xffffff); \ - _c240 = (double)(long)(((X##_f1 << 16) & 0xffffff) | (X##_f0 >> 48)); \ - _h240 = (double)(long)(((Y##_f1 << 16) & 0xffffff) | (Y##_f0 >> 48)); \ - _b240 = (double)(long)((X##_f1 >> 8) & 0xffffff); \ - _g240 = (double)(long)((Y##_f1 >> 8) & 0xffffff); \ - _a240 = (double)(long)(X##_f1 >> 32); \ - _f240 = (double)(long)(Y##_f1 >> 32); \ + _e240 = (double) (long) (X##_f0 & 0xffffff); \ + _j240 = (double) (long) (Y##_f0 & 0xffffff); \ + _d240 = (double) (long) ((X##_f0 >> 24) & 0xffffff); \ + _i240 = (double) (long) ((Y##_f0 >> 24) & 0xffffff); \ + _c240 = (double) (long) (((X##_f1 << 16) & 0xffffff) | (X##_f0 >> 48)); \ + _h240 = (double) (long) (((Y##_f1 << 16) & 0xffffff) | (Y##_f0 >> 48)); \ + _b240 = (double) (long) ((X##_f1 >> 8) & 0xffffff); \ + _g240 = (double) (long) ((Y##_f1 >> 8) & 0xffffff); \ + _a240 = (double) (long) (X##_f1 >> 32); \ + _f240 = (double) (long) (Y##_f1 >> 32); \ _e240 *= _const[3]; \ _j240 *= _const[3]; \ _d240 *= _const[2]; \ @@ -484,7 +484,7 @@ _y240 = 1; \ if (_p240.d != 0.0) \ _y240 = 1; \ - _t240 = (DItype)_k240; \ + _t240 = (DItype) _k240; \ _u240 = _l240.i; \ _v240 = _m240.i; \ _w240 = _n240.i; \ @@ -508,7 +508,7 @@ do \ { \ _FP_W_TYPE _n_f2, _n_f1, _n_f0, _r_f1, _r_f0, _m_f1, _m_f0; \ - if (_FP_FRAC_GE_2(X, Y)) \ + if (_FP_FRAC_GE_2 (X, Y)) \ { \ _n_f2 = X##_f1 >> 1; \ _n_f1 = X##_f1 << (_FP_W_TYPE_SIZE - 1) | X##_f0 >> 1; \ @@ -524,22 +524,22 @@ \ /* Normalize, i.e. make the most significant bit of the \ denominator set. */ \ - _FP_FRAC_SLL_2(Y, _FP_WFRACXBITS_##fs); \ + _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); \ + 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)) \ + if (_FP_FRAC_GT_2 (_m, _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 (_r, Y, _r); \ + if (_FP_FRAC_GE_2 (_r, Y) && _FP_FRAC_GT_2 (_m, _r)) \ { \ R##_f1--; \ - _FP_FRAC_ADD_2(_r, Y, _r); \ + _FP_FRAC_ADD_2 (_r, Y, _r); \ } \ } \ - _FP_FRAC_DEC_2(_r, _m); \ + _FP_FRAC_DEC_2 (_r, _m); \ \ if (_r_f1 == Y##_f1) \ { \ @@ -554,20 +554,20 @@ } \ else \ { \ - udiv_qrnnd(R##_f0, _r_f1, _r_f1, _r_f0, Y##_f1); \ - umul_ppmm(_m_f1, _m_f0, R##_f0, Y##_f0); \ + 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)) \ + if (_FP_FRAC_GT_2 (_m, _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 (_r, Y, _r); \ + if (_FP_FRAC_GE_2 (_r, Y) && _FP_FRAC_GT_2 (_m, _r)) \ { \ R##_f0--; \ - _FP_FRAC_ADD_2(_r, Y, _r); \ + _FP_FRAC_ADD_2 (_r, Y, _r); \ } \ } \ - if (!_FP_FRAC_EQ_2(_r, _m)) \ + if (!_FP_FRAC_EQ_2 (_r, _m)) \ R##_f0 |= _FP_WORK_STICKY; \ } \ } \ @@ -592,10 +592,10 @@ X##_f1 -= T##_f1; \ R##_f1 += q; \ } \ - _FP_FRAC_SLL_2(X, 1); \ + _FP_FRAC_SLL_2 (X, 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 != _FP_WORK_ROUND) \ { \ T##_f0 = S##_f0 + q; \ @@ -605,10 +605,10 @@ { \ S##_f0 = T##_f0 + q; \ S##_f1 += (T##_f0 > S##_f0); \ - _FP_FRAC_DEC_2(X, T); \ + _FP_FRAC_DEC_2 (X, T); \ R##_f0 += q; \ } \ - _FP_FRAC_SLL_2(X, 1); \ + _FP_FRAC_SLL_2 (X, 1); \ q >>= 1; \ } \ if (X##_f0 | X##_f1) \ @@ -628,13 +628,13 @@ */ #define _FP_FRAC_ASSEMBLE_2(r, X, rsize) \ - (void)((rsize <= _FP_W_TYPE_SIZE) \ - ? ({ r = X##_f0; }) \ - : ({ \ - r = X##_f1; \ - r <<= _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; \ + })) #define _FP_FRAC_DISASSEMBLE_2(X, r, rsize) \ do \ @@ -652,4 +652,4 @@ #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) +#define _FP_FRAC_COPY_2_2(D, S) _FP_FRAC_COPY_2 (D, S) diff --git a/soft-fp/op-4.h b/soft-fp/op-4.h index 18b7cfdca6..3515bdc497 100644 --- a/soft-fp/op-4.h +++ b/soft-fp/op-4.h @@ -31,15 +31,15 @@ <http://www.gnu.org/licenses/>. */ #define _FP_FRAC_DECL_4(X) _FP_W_TYPE X##_f[4] -#define _FP_FRAC_COPY_4(D,S) \ +#define _FP_FRAC_COPY_4(D, S) \ (D##_f[0] = S##_f[0], D##_f[1] = S##_f[1], \ D##_f[2] = S##_f[2], D##_f[3] = S##_f[3]) -#define _FP_FRAC_SET_4(X,I) __FP_FRAC_SET_4(X, I) +#define _FP_FRAC_SET_4(X, I) __FP_FRAC_SET_4 (X, I) #define _FP_FRAC_HIGH_4(X) (X##_f[3]) #define _FP_FRAC_LOW_4(X) (X##_f[0]) -#define _FP_FRAC_WORD_4(X,w) (X##_f[w]) +#define _FP_FRAC_WORD_4(X, w) (X##_f[w]) -#define _FP_FRAC_SLL_4(X,N) \ +#define _FP_FRAC_SLL_4(X, N) \ do \ { \ _FP_I_TYPE _up, _down, _skip, _i; \ @@ -62,7 +62,7 @@ while (0) /* This one was broken too */ -#define _FP_FRAC_SRL_4(X,N) \ +#define _FP_FRAC_SRL_4(X, N) \ do \ { \ _FP_I_TYPE _up, _down, _skip, _i; \ @@ -90,7 +90,7 @@ * 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) \ +#define _FP_FRAC_SRST_4(X, S, N, size) \ do \ { \ _FP_I_TYPE _up, _down, _skip, _i; \ @@ -117,48 +117,48 @@ } \ while (0) -#define _FP_FRAC_SRS_4(X,N,size) \ +#define _FP_FRAC_SRS_4(X, N, size) \ do \ { \ int _sticky; \ - _FP_FRAC_SRST_4(X, _sticky, N, size); \ + _FP_FRAC_SRST_4 (X, _sticky, N, size); \ X##_f[0] |= _sticky; \ } \ while (0) -#define _FP_FRAC_ADD_4(R,X,Y) \ - __FP_FRAC_ADD_4(R##_f[3], R##_f[2], R##_f[1], R##_f[0], \ - X##_f[3], X##_f[2], X##_f[1], X##_f[0], \ - Y##_f[3], Y##_f[2], Y##_f[1], Y##_f[0]) +#define _FP_FRAC_ADD_4(R, X, Y) \ + __FP_FRAC_ADD_4 (R##_f[3], R##_f[2], R##_f[1], R##_f[0], \ + X##_f[3], X##_f[2], X##_f[1], X##_f[0], \ + Y##_f[3], Y##_f[2], Y##_f[1], Y##_f[0]) -#define _FP_FRAC_SUB_4(R,X,Y) \ - __FP_FRAC_SUB_4(R##_f[3], R##_f[2], R##_f[1], R##_f[0], \ - X##_f[3], X##_f[2], X##_f[1], X##_f[0], \ - Y##_f[3], Y##_f[2], Y##_f[1], Y##_f[0]) +#define _FP_FRAC_SUB_4(R, X, Y) \ + __FP_FRAC_SUB_4 (R##_f[3], R##_f[2], R##_f[1], R##_f[0], \ + X##_f[3], X##_f[2], X##_f[1], X##_f[0], \ + Y##_f[3], Y##_f[2], Y##_f[1], Y##_f[0]) -#define _FP_FRAC_DEC_4(X,Y) \ - __FP_FRAC_DEC_4(X##_f[3], X##_f[2], X##_f[1], X##_f[0], \ - Y##_f[3], Y##_f[2], Y##_f[1], Y##_f[0]) +#define _FP_FRAC_DEC_4(X, Y) \ + __FP_FRAC_DEC_4 (X##_f[3], X##_f[2], X##_f[1], X##_f[0], \ + Y##_f[3], Y##_f[2], Y##_f[1], Y##_f[0]) -#define _FP_FRAC_ADDI_4(X,I) \ - __FP_FRAC_ADDI_4(X##_f[3], X##_f[2], X##_f[1], X##_f[0], I) +#define _FP_FRAC_ADDI_4(X, I) \ + __FP_FRAC_ADDI_4 (X##_f[3], X##_f[2], X##_f[1], X##_f[0], I) -#define _FP_ZEROFRAC_4 0,0,0,0 -#define _FP_MINFRAC_4 0,0,0,1 -#define _FP_MAXFRAC_4 (~(_FP_WS_TYPE)0), (~(_FP_WS_TYPE)0), (~(_FP_WS_TYPE)0), (~(_FP_WS_TYPE)0) +#define _FP_ZEROFRAC_4 0, 0, 0, 0 +#define _FP_MINFRAC_4 0, 0, 0, 1 +#define _FP_MAXFRAC_4 (~(_FP_WS_TYPE) 0), (~(_FP_WS_TYPE) 0), (~(_FP_WS_TYPE) 0), (~(_FP_WS_TYPE) 0) #define _FP_FRAC_ZEROP_4(X) ((X##_f[0] | X##_f[1] | X##_f[2] | X##_f[3]) == 0) -#define _FP_FRAC_NEGP_4(X) ((_FP_WS_TYPE)X##_f[3] < 0) -#define _FP_FRAC_OVERP_4(fs,X) (_FP_FRAC_HIGH_##fs(X) & _FP_OVERFLOW_##fs) -#define _FP_FRAC_HIGHBIT_DW_4(fs,X) \ - (_FP_FRAC_HIGH_DW_##fs(X) & _FP_HIGHBIT_DW_##fs) -#define _FP_FRAC_CLEAR_OVERP_4(fs,X) (_FP_FRAC_HIGH_##fs(X) &= ~_FP_OVERFLOW_##fs) +#define _FP_FRAC_NEGP_4(X) ((_FP_WS_TYPE) X##_f[3] < 0) +#define _FP_FRAC_OVERP_4(fs, X) (_FP_FRAC_HIGH_##fs (X) & _FP_OVERFLOW_##fs) +#define _FP_FRAC_HIGHBIT_DW_4(fs, X) \ + (_FP_FRAC_HIGH_DW_##fs (X) & _FP_HIGHBIT_DW_##fs) +#define _FP_FRAC_CLEAR_OVERP_4(fs, X) (_FP_FRAC_HIGH_##fs (X) &= ~_FP_OVERFLOW_##fs) -#define _FP_FRAC_EQ_4(X,Y) \ +#define _FP_FRAC_EQ_4(X, Y) \ (X##_f[0] == Y##_f[0] && X##_f[1] == Y##_f[1] \ && X##_f[2] == Y##_f[2] && X##_f[3] == Y##_f[3]) -#define _FP_FRAC_GT_4(X,Y) \ +#define _FP_FRAC_GT_4(X, Y) \ (X##_f[3] > Y##_f[3] \ || (X##_f[3] == Y##_f[3] \ && (X##_f[2] > Y##_f[2] \ @@ -167,7 +167,7 @@ || (X##_f[1] == Y##_f[1] \ && X##_f[0] > Y##_f[0])))))) -#define _FP_FRAC_GE_4(X,Y) \ +#define _FP_FRAC_GE_4(X, Y) \ (X##_f[3] > Y##_f[3] \ || (X##_f[3] == Y##_f[3] \ && (X##_f[2] > Y##_f[2] \ @@ -177,28 +177,28 @@ && X##_f[0] >= Y##_f[0])))))) -#define _FP_FRAC_CLZ_4(R,X) \ +#define _FP_FRAC_CLZ_4(R, X) \ 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]); \ + __FP_CLZ (R, X##_f[2]); \ R += _FP_W_TYPE_SIZE; \ } \ else if (X##_f[1]) \ { \ - __FP_CLZ(R,X##_f[1]); \ + __FP_CLZ (R, X##_f[1]); \ R += _FP_W_TYPE_SIZE*2; \ } \ else \ { \ - __FP_CLZ(R,X##_f[0]); \ + __FP_CLZ (R, X##_f[0]); \ R += _FP_W_TYPE_SIZE*3; \ } \ } \ - while(0) + while (0) #define _FP_UNPACK_RAW_4(fs, X, val) \ @@ -218,7 +218,7 @@ #define _FP_UNPACK_RAW_4_P(fs, X, val) \ do \ { \ - union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *)(val); \ + union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val); \ \ X##_f[0] = _flo->bits.frac0; \ X##_f[1] = _flo->bits.frac1; \ @@ -246,7 +246,7 @@ #define _FP_PACK_RAW_4_P(fs, val, X) \ do \ { \ - union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *)(val); \ + union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val); \ \ _flo->bits.frac0 = X##_f[0]; \ _flo->bits.frac1 = X##_f[1]; \ @@ -266,121 +266,121 @@ #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 (_b); \ + _FP_FRAC_DECL_2 (_c); \ + _FP_FRAC_DECL_2 (_d); \ + _FP_FRAC_DECL_2 (_e); \ + _FP_FRAC_DECL_2 (_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]); \ - __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, \ - 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,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, \ - 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,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,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]); \ - __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, \ - 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,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,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,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]); \ - __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, \ - 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,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,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, \ - 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,7),_FP_FRAC_WORD_8(R,6), \ - _FP_FRAC_WORD_8(R,5)); \ - doit(_b_f1, _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_FRAC_WORD_8(R,7),_FP_FRAC_WORD_8(R,6)); \ + 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]); \ + __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, \ + 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, 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, \ + 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, 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, 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]); \ + __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, \ + 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, 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, 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, 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]); \ + __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, \ + 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, 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, 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, \ + 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, 7), _FP_FRAC_WORD_8 (R, 6), \ + _FP_FRAC_WORD_8 (R, 5)); \ + doit (_b_f1, _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_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6)); \ } \ while (0) #define _FP_MUL_MEAT_4_wide(wfracbits, R, X, Y, doit) \ do \ { \ - _FP_FRAC_DECL_8(_z); \ + _FP_FRAC_DECL_8 (_z); \ \ - _FP_MUL_MEAT_DW_4_wide(wfracbits, _z, X, Y, doit); \ + _FP_MUL_MEAT_DW_4_wide (wfracbits, _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 (_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)); \ } \ while (0) #define _FP_MUL_MEAT_DW_4_gmp(wfracbits, R, X, Y) \ do \ { \ - mpn_mul_n(R##_f, _x_f, _y_f, 4); \ + mpn_mul_n (R##_f, _x_f, _y_f, 4); \ } \ while (0) #define _FP_MUL_MEAT_4_gmp(wfracbits, R, X, Y) \ do \ { \ - _FP_FRAC_DECL_8(_z); \ + _FP_FRAC_DECL_8 (_z); \ \ - _FP_MUL_MEAT_DW_4_gmp(wfracbits, _z, X, Y); \ + _FP_MUL_MEAT_DW_4_gmp (wfracbits, _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 (_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)); \ } \ while (0) @@ -388,16 +388,16 @@ * 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; \ - 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); \ - } \ +#define umul_ppppmnnn(p3, p2, p1, p0, m, n2, n1, n0) \ + do \ + { \ + UWtype _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); \ + } \ while (0) /* @@ -408,20 +408,20 @@ do \ { \ int _i; \ - _FP_FRAC_DECL_4(_n); \ - _FP_FRAC_DECL_4(_m); \ - _FP_FRAC_SET_4(_n, _FP_ZEROFRAC_4); \ - if (_FP_FRAC_GE_4(X, Y)) \ + _FP_FRAC_DECL_4 (_n); \ + _FP_FRAC_DECL_4 (_m); \ + _FP_FRAC_SET_4 (_n, _FP_ZEROFRAC_4); \ + if (_FP_FRAC_GE_4 (X, Y)) \ { \ _n_f[3] = X##_f[0] << (_FP_W_TYPE_SIZE - 1); \ - _FP_FRAC_SRL_4(X, 1); \ + _FP_FRAC_SRL_4 (X, 1); \ } \ else \ R##_e--; \ \ /* Normalize, i.e. make the most significant bit of the \ denominator set. */ \ - _FP_FRAC_SLL_4(Y, _FP_WFRACXBITS_##fs); \ + _FP_FRAC_SLL_4 (Y, _FP_WFRACXBITS_##fs); \ \ for (_i = 3; ; _i--) \ { \ @@ -434,38 +434,38 @@ R##_f[_i] = -1; \ if (!_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]); \ - _FP_FRAC_SUB_4(X, Y, X); \ + __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]); \ + _FP_FRAC_SUB_4 (X, Y, X); \ if (X##_f[3] > Y##_f[3]) \ { \ R##_f[_i] = -2; \ - _FP_FRAC_ADD_4(X, Y, X); \ + _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[_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]); \ 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)) \ + if (_FP_FRAC_GT_4 (_m, X)) \ { \ R##_f[_i]--; \ - _FP_FRAC_ADD_4(X, Y, X); \ - if (_FP_FRAC_GE_4(X, Y) && _FP_FRAC_GT_4(_m, X)) \ + _FP_FRAC_ADD_4 (X, Y, X); \ + if (_FP_FRAC_GE_4 (X, Y) && _FP_FRAC_GT_4 (_m, X)) \ { \ R##_f[_i]--; \ - _FP_FRAC_ADD_4(X, Y, X); \ + _FP_FRAC_ADD_4 (X, Y, X); \ } \ } \ - _FP_FRAC_DEC_4(X, _m); \ + _FP_FRAC_DEC_4 (X, _m); \ if (!_i) \ { \ - if (!_FP_FRAC_EQ_4(X, _m)) \ + if (!_FP_FRAC_EQ_4 (X, _m)) \ R##_f[0] |= _FP_WORK_STICKY; \ break; \ } \ @@ -493,10 +493,10 @@ X##_f[3] -= T##_f[3]; \ R##_f[3] += q; \ } \ - _FP_FRAC_SLL_4(X, 1); \ + _FP_FRAC_SLL_4 (X, 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; \ @@ -506,14 +506,14 @@ { \ 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]); \ + __FP_FRAC_DEC_2 (X##_f[3], X##_f[2], \ + T##_f[3], T##_f[2]); \ R##_f[2] += q; \ } \ - _FP_FRAC_SLL_4(X, 1); \ + _FP_FRAC_SLL_4 (X, 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; \ @@ -528,35 +528,35 @@ 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]); \ + __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; \ } \ - _FP_FRAC_SLL_4(X, 1); \ + _FP_FRAC_SLL_4 (X, 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 != _FP_WORK_ROUND) \ { \ 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)) \ + if (_FP_FRAC_GE_4 (X, T)) \ { \ 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); \ + _FP_FRAC_DEC_4 (X, T); \ R##_f[0] += q; \ } \ - _FP_FRAC_SLL_4(X, 1); \ + _FP_FRAC_SLL_4 (X, 1); \ q >>= 1; \ } \ - if (!_FP_FRAC_ZEROP_4(X)) \ + if (!_FP_FRAC_ZEROP_4 (X)) \ { \ - if (_FP_FRAC_GT_4(X,S)) \ + if (_FP_FRAC_GT_4 (X, S)) \ R##_f[0] |= _FP_WORK_ROUND; \ R##_f[0] |= _FP_WORK_STICKY; \ } \ @@ -568,11 +568,11 @@ * Internals */ -#define __FP_FRAC_SET_4(X,I3,I2,I1,I0) \ +#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) #ifndef __FP_FRAC_ADD_3 -# define __FP_FRAC_ADD_3(r2,r1,r0,x2,x1,x0,y2,y1,y0) \ +# define __FP_FRAC_ADD_3(r2, r1, r0, x2, x1, x0, y2, y1, y0) \ do \ { \ _FP_W_TYPE __FP_FRAC_ADD_3_c1, __FP_FRAC_ADD_3_c2; \ @@ -588,63 +588,63 @@ #endif #ifndef __FP_FRAC_ADD_4 -# define __FP_FRAC_ADD_4(r3,r2,r1,r0,x3,x2,x1,x0,y3,y2,y1,y0) \ - do \ - { \ - _FP_W_TYPE _c1, _c2, _c3; \ - r0 = x0 + y0; \ - _c1 = r0 < x0; \ - r1 = x1 + y1; \ - _c2 = r1 < x1; \ - r1 += _c1; \ - _c2 |= r1 < _c1; \ - r2 = x2 + y2; \ - _c3 = r2 < x2; \ - r2 += _c2; \ - _c3 |= r2 < _c2; \ - r3 = x3 + y3 + _c3; \ - } \ +# define __FP_FRAC_ADD_4(r3, r2, r1, r0, x3, x2, x1, x0, y3, y2, y1, y0) \ + do \ + { \ + _FP_W_TYPE _c1, _c2, _c3; \ + r0 = x0 + y0; \ + _c1 = r0 < x0; \ + r1 = x1 + y1; \ + _c2 = r1 < x1; \ + r1 += _c1; \ + _c2 |= r1 < _c1; \ + r2 = x2 + y2; \ + _c3 = r2 < x2; \ + r2 += _c2; \ + _c3 |= r2 < _c2; \ + r3 = x3 + y3 + _c3; \ + } \ while (0) #endif #ifndef __FP_FRAC_SUB_3 -# define __FP_FRAC_SUB_3(r2,r1,r0,x2,x1,x0,y2,y1,y0) \ - do \ - { \ - _FP_W_TYPE _c1, _c2; \ - r0 = x0 - y0; \ - _c1 = r0 > x0; \ - r1 = x1 - y1; \ - _c2 = r1 > x1; \ - r1 -= _c1; \ - _c2 |= _c1 && (y1 == x1); \ - r2 = x2 - y2 - _c2; \ - } \ - while (0) -#endif - -#ifndef __FP_FRAC_SUB_4 -# define __FP_FRAC_SUB_4(r3,r2,r1,r0,x3,x2,x1,x0,y3,y2,y1,y0) \ +# define __FP_FRAC_SUB_3(r2, r1, r0, x2, x1, x0, y2, y1, y0) \ do \ { \ - _FP_W_TYPE _c1, _c2, _c3; \ + _FP_W_TYPE _c1, _c2; \ r0 = x0 - y0; \ _c1 = r0 > x0; \ r1 = x1 - y1; \ _c2 = r1 > x1; \ r1 -= _c1; \ _c2 |= _c1 && (y1 == x1); \ - r2 = x2 - y2; \ - _c3 = r2 > x2; \ - r2 -= _c2; \ - _c3 |= _c2 && (y2 == x2); \ - r3 = x3 - y3 - _c3; \ + r2 = x2 - y2 - _c2; \ } \ while (0) #endif +#ifndef __FP_FRAC_SUB_4 +# define __FP_FRAC_SUB_4(r3, r2, r1, r0, x3, x2, x1, x0, y3, y2, y1, y0) \ + do \ + { \ + _FP_W_TYPE _c1, _c2, _c3; \ + r0 = x0 - y0; \ + _c1 = r0 > x0; \ + r1 = x1 - y1; \ + _c2 = r1 > x1; \ + r1 -= _c1; \ + _c2 |= _c1 && (y1 == x1); \ + r2 = x2 - y2; \ + _c3 = r2 > x2; \ + r2 -= _c2; \ + _c3 |= _c2 && (y2 == x2); \ + r3 = x3 - y3 - _c3; \ + } \ + while (0) +#endif + #ifndef __FP_FRAC_DEC_3 -# define __FP_FRAC_DEC_3(x2,x1,x0,y2,y1,y0) \ +# define __FP_FRAC_DEC_3(x2, x1, x0, y2, y1, y0) \ do \ { \ UWtype _t0, _t1, _t2; \ @@ -655,18 +655,18 @@ #endif #ifndef __FP_FRAC_DEC_4 -# define __FP_FRAC_DEC_4(x3,x2,x1,x0,y3,y2,y1,y0) \ +# 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); \ + __FP_FRAC_SUB_4 (x3, x2, x1, x0, _t3, _t2, _t1, _t0, y3, y2, y1, y0); \ } \ while (0) #endif #ifndef __FP_FRAC_ADDI_4 -# define __FP_FRAC_ADDI_4(x3,x2,x1,x0,i) \ +# define __FP_FRAC_ADDI_4(x3, x2, x1, x0, i) \ do \ { \ UWtype _t; \ @@ -759,4 +759,4 @@ } \ while (0) -#define _FP_FRAC_COPY_4_4(D,S) _FP_FRAC_COPY_4(D,S) +#define _FP_FRAC_COPY_4_4(D, S) _FP_FRAC_COPY_4 (D, S) diff --git a/soft-fp/op-8.h b/soft-fp/op-8.h index 1cfe819453..f1b23db80d 100644 --- a/soft-fp/op-8.h +++ b/soft-fp/op-8.h @@ -34,9 +34,9 @@ #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_WORD_8(X, w) (X##_f[w]) -#define _FP_FRAC_SLL_8(X,N) \ +#define _FP_FRAC_SLL_8(X, N) \ do \ { \ _FP_I_TYPE _up, _down, _skip, _i; \ @@ -58,7 +58,7 @@ } \ while (0) -#define _FP_FRAC_SRL_8(X,N) \ +#define _FP_FRAC_SRL_8(X, N) \ do \ { \ _FP_I_TYPE _up, _down, _skip, _i; \ @@ -86,7 +86,7 @@ * 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) \ +#define _FP_FRAC_SRS_8(X, N, size) \ do \ { \ _FP_I_TYPE _up, _down, _skip, _i; \ diff --git a/soft-fp/op-common.h b/soft-fp/op-common.h index 89fec5d878..9a9a8f5256 100644 --- a/soft-fp/op-common.h +++ b/soft-fp/op-common.h @@ -30,20 +30,20 @@ <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##_c __attribute__ ((unused)); \ + _FP_I_TYPE X##_s __attribute__ ((unused)); \ _FP_I_TYPE X##_e; \ - _FP_FRAC_DECL_##wc(X) + _FP_FRAC_DECL_##wc (X) /* Test whether the qNaN bit denotes a signaling NaN. */ -#define _FP_FRAC_SNANP(fs, X) \ - ((_FP_QNANNEGATEDP) \ - ? (_FP_FRAC_HIGH_RAW_##fs(X) & _FP_QNANBIT_##fs) \ - : !(_FP_FRAC_HIGH_RAW_##fs(X) & _FP_QNANBIT_##fs)) -#define _FP_FRAC_SNANP_SEMIRAW(fs, X) \ - ((_FP_QNANNEGATEDP) \ - ? (_FP_FRAC_HIGH_##fs(X) & _FP_QNANBIT_SH_##fs) \ - : !(_FP_FRAC_HIGH_##fs(X) & _FP_QNANBIT_SH_##fs)) +#define _FP_FRAC_SNANP(fs, X) \ + ((_FP_QNANNEGATEDP) \ + ? (_FP_FRAC_HIGH_RAW_##fs (X) & _FP_QNANBIT_##fs) \ + : !(_FP_FRAC_HIGH_RAW_##fs (X) & _FP_QNANBIT_##fs)) +#define _FP_FRAC_SNANP_SEMIRAW(fs, X) \ + ((_FP_QNANNEGATEDP) \ + ? (_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 @@ -56,37 +56,37 @@ switch (X##_e) \ { \ default: \ - _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_IMPLBIT_##fs; \ - _FP_FRAC_SLL_##wc(X, _FP_WORKBITS); \ + _FP_FRAC_HIGH_RAW_##fs (X) |= _FP_IMPLBIT_##fs; \ + _FP_FRAC_SLL_##wc (X, _FP_WORKBITS); \ X##_e -= _FP_EXPBIAS_##fs; \ X##_c = FP_CLS_NORMAL; \ break; \ \ case 0: \ - if (_FP_FRAC_ZEROP_##wc(X)) \ + if (_FP_FRAC_ZEROP_##wc (X)) \ X##_c = FP_CLS_ZERO; \ else \ { \ /* a denormalized number */ \ _FP_I_TYPE _shift; \ - _FP_FRAC_CLZ_##wc(_shift, X); \ + _FP_FRAC_CLZ_##wc (_shift, X); \ _shift -= _FP_FRACXBITS_##fs; \ - _FP_FRAC_SLL_##wc(X, (_shift+_FP_WORKBITS)); \ + _FP_FRAC_SLL_##wc (X, (_shift+_FP_WORKBITS)); \ X##_e -= _FP_EXPBIAS_##fs - 1 + _shift; \ X##_c = FP_CLS_NORMAL; \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ } \ break; \ \ case _FP_EXPMAX_##fs: \ - if (_FP_FRAC_ZEROP_##wc(X)) \ + if (_FP_FRAC_ZEROP_##wc (X)) \ X##_c = FP_CLS_INF; \ else \ { \ X##_c = FP_CLS_NAN; \ /* Check for signaling NaN */ \ - if (_FP_FRAC_SNANP(fs, X)) \ - FP_SET_EXCEPTION(FP_EX_INVALID); \ + if (_FP_FRAC_SNANP (fs, X)) \ + FP_SET_EXCEPTION (FP_EX_INVALID); \ } \ break; \ } \ @@ -96,7 +96,7 @@ /* Finish unpacking an fp value in semi-raw mode: the mantissa is shifted by _FP_WORKBITS but the implicit MSB is not inserted and other classification is not done. */ -#define _FP_UNPACK_SEMIRAW(fs, wc, X) _FP_FRAC_SLL_##wc(X, _FP_WORKBITS) +#define _FP_UNPACK_SEMIRAW(fs, wc, X) _FP_FRAC_SLL_##wc (X, _FP_WORKBITS) /* A semi-raw value has overflowed to infinity. Adjust the mantissa and exponent appropriately. */ @@ -108,15 +108,15 @@ || (FP_ROUNDMODE == FP_RND_MINF && X##_s)) \ { \ X##_e = _FP_EXPMAX_##fs; \ - _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \ + _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \ } \ else \ { \ X##_e = _FP_EXPMAX_##fs - 1; \ - _FP_FRAC_SET_##wc(X, _FP_MAXFRAC_##wc); \ + _FP_FRAC_SET_##wc (X, _FP_MAXFRAC_##wc); \ } \ - FP_SET_EXCEPTION(FP_EX_INEXACT); \ - FP_SET_EXCEPTION(FP_EX_OVERFLOW); \ + FP_SET_EXCEPTION (FP_EX_INEXACT); \ + FP_SET_EXCEPTION (FP_EX_OVERFLOW); \ } \ while (0) @@ -126,9 +126,9 @@ 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_FRAC_ZEROP_##wc (X) \ + && _FP_FRAC_SNANP_SEMIRAW (fs, X)) \ + FP_SET_EXCEPTION (FP_EX_INVALID); \ } \ while (0) @@ -138,10 +138,10 @@ do \ { \ /* _FP_CHOOSENAN expects raw values, so shift as required. */ \ - _FP_FRAC_SRL_##wc(X, _FP_WORKBITS); \ - _FP_FRAC_SRL_##wc(Y, _FP_WORKBITS); \ - _FP_CHOOSENAN(fs, wc, R, X, Y, OP); \ - _FP_FRAC_SLL_##wc(R, _FP_WORKBITS); \ + _FP_FRAC_SRL_##wc (X, _FP_WORKBITS); \ + _FP_FRAC_SRL_##wc (Y, _FP_WORKBITS); \ + _FP_CHOOSENAN (fs, wc, R, X, Y, OP); \ + _FP_FRAC_SLL_##wc (R, _FP_WORKBITS); \ } \ while (0) @@ -153,15 +153,15 @@ { \ if (_FP_QNANNEGATEDP) \ { \ - _FP_FRAC_HIGH_RAW_##fs(X) &= _FP_QNANBIT_##fs - 1; \ - if (_FP_FRAC_ZEROP_##wc(X)) \ + _FP_FRAC_HIGH_RAW_##fs (X) &= _FP_QNANBIT_##fs - 1; \ + if (_FP_FRAC_ZEROP_##wc (X)) \ { \ X##_s = _FP_NANSIGN_##fs; \ - _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs); \ + _FP_FRAC_SET_##wc (X, _FP_NANFRAC_##fs); \ } \ } \ else \ - _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_QNANBIT_##fs; \ + _FP_FRAC_HIGH_RAW_##fs (X) |= _FP_QNANBIT_##fs; \ } \ while (0) #define _FP_SETQNAN_SEMIRAW(fs, wc, X) \ @@ -169,16 +169,16 @@ { \ if (_FP_QNANNEGATEDP) \ { \ - _FP_FRAC_HIGH_##fs(X) &= _FP_QNANBIT_SH_##fs - 1; \ - if (_FP_FRAC_ZEROP_##wc(X)) \ + _FP_FRAC_HIGH_##fs (X) &= _FP_QNANBIT_SH_##fs - 1; \ + if (_FP_FRAC_ZEROP_##wc (X)) \ { \ X##_s = _FP_NANSIGN_##fs; \ - _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs); \ - _FP_FRAC_SLL_##wc(X, _FP_WORKBITS); \ + _FP_FRAC_SET_##wc (X, _FP_NANFRAC_##fs); \ + _FP_FRAC_SLL_##wc (X, _FP_WORKBITS); \ } \ } \ else \ - _FP_FRAC_HIGH_##fs(X) |= _FP_QNANBIT_SH_##fs; \ + _FP_FRAC_HIGH_##fs (X) |= _FP_QNANBIT_SH_##fs; \ } \ while (0) @@ -191,31 +191,31 @@ #define _FP_PACK_SEMIRAW(fs, wc, X) \ do \ { \ - _FP_ROUND(wc, X); \ - if (X##_e == 0 && !_FP_FRAC_ZEROP_##wc(X)) \ + _FP_ROUND (wc, X); \ + if (X##_e == 0 && !_FP_FRAC_ZEROP_##wc (X)) \ { \ if ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT) \ || (FP_TRAPPING_EXCEPTIONS & FP_EX_UNDERFLOW)) \ - FP_SET_EXCEPTION(FP_EX_UNDERFLOW); \ + FP_SET_EXCEPTION (FP_EX_UNDERFLOW); \ } \ - if (_FP_FRAC_HIGH_##fs(X) \ + if (_FP_FRAC_HIGH_##fs (X) \ & (_FP_OVERFLOW_##fs >> 1)) \ { \ - _FP_FRAC_HIGH_##fs(X) &= ~(_FP_OVERFLOW_##fs >> 1); \ + _FP_FRAC_HIGH_##fs (X) &= ~(_FP_OVERFLOW_##fs >> 1); \ X##_e++; \ if (X##_e == _FP_EXPMAX_##fs) \ - _FP_OVERFLOW_SEMIRAW(fs, wc, X); \ + _FP_OVERFLOW_SEMIRAW (fs, wc, X); \ } \ - _FP_FRAC_SRL_##wc(X, _FP_WORKBITS); \ - if (X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X)) \ + _FP_FRAC_SRL_##wc (X, _FP_WORKBITS); \ + if (X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (X)) \ { \ if (!_FP_KEEPNANFRACP) \ { \ - _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs); \ + _FP_FRAC_SET_##wc (X, _FP_NANFRAC_##fs); \ X##_s = _FP_NANSIGN_##fs; \ } \ else \ - _FP_SETQNAN(fs, wc, X); \ + _FP_SETQNAN (fs, wc, X); \ } \ } \ while (0) @@ -236,13 +236,13 @@ X##_e += _FP_EXPBIAS_##fs; \ if (X##_e > 0) \ { \ - _FP_ROUND(wc, X); \ - if (_FP_FRAC_OVERP_##wc(fs, X)) \ + _FP_ROUND (wc, X); \ + if (_FP_FRAC_OVERP_##wc (fs, X)) \ { \ - _FP_FRAC_CLEAR_OVERP_##wc(fs, X); \ + _FP_FRAC_CLEAR_OVERP_##wc (fs, X); \ X##_e++; \ } \ - _FP_FRAC_SRL_##wc(X, _FP_WORKBITS); \ + _FP_FRAC_SRL_##wc (X, _FP_WORKBITS); \ if (X##_e >= _FP_EXPMAX_##fs) \ { \ /* overflow */ \ @@ -264,16 +264,16 @@ { \ /* Overflow to infinity */ \ X##_e = _FP_EXPMAX_##fs; \ - _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \ + _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \ } \ else \ { \ /* Overflow to maximum normal */ \ X##_e = _FP_EXPMAX_##fs - 1; \ - _FP_FRAC_SET_##wc(X, _FP_MAXFRAC_##wc); \ + _FP_FRAC_SET_##wc (X, _FP_MAXFRAC_##wc); \ } \ - FP_SET_EXCEPTION(FP_EX_OVERFLOW); \ - FP_SET_EXCEPTION(FP_EX_INEXACT); \ + FP_SET_EXCEPTION (FP_EX_OVERFLOW); \ + FP_SET_EXCEPTION (FP_EX_INEXACT); \ } \ } \ else \ @@ -282,58 +282,58 @@ X##_e = -X##_e + 1; \ if (X##_e <= _FP_WFRACBITS_##fs) \ { \ - _FP_FRAC_SRS_##wc(X, X##_e, _FP_WFRACBITS_##fs); \ - _FP_ROUND(wc, X); \ - if (_FP_FRAC_HIGH_##fs(X) \ + _FP_FRAC_SRS_##wc (X, X##_e, _FP_WFRACBITS_##fs); \ + _FP_ROUND (wc, X); \ + if (_FP_FRAC_HIGH_##fs (X) \ & (_FP_OVERFLOW_##fs >> 1)) \ { \ X##_e = 1; \ - _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \ - FP_SET_EXCEPTION(FP_EX_INEXACT); \ + _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \ + FP_SET_EXCEPTION (FP_EX_INEXACT); \ } \ else \ { \ X##_e = 0; \ - _FP_FRAC_SRL_##wc(X, _FP_WORKBITS); \ + _FP_FRAC_SRL_##wc (X, _FP_WORKBITS); \ } \ if ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT) \ || (FP_TRAPPING_EXCEPTIONS & FP_EX_UNDERFLOW)) \ - FP_SET_EXCEPTION(FP_EX_UNDERFLOW); \ + FP_SET_EXCEPTION (FP_EX_UNDERFLOW); \ } \ else \ { \ /* underflow to zero */ \ X##_e = 0; \ - if (!_FP_FRAC_ZEROP_##wc(X)) \ + if (!_FP_FRAC_ZEROP_##wc (X)) \ { \ - _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc); \ - _FP_ROUND(wc, X); \ - _FP_FRAC_LOW_##wc(X) >>= (_FP_WORKBITS); \ + _FP_FRAC_SET_##wc (X, _FP_MINFRAC_##wc); \ + _FP_ROUND (wc, X); \ + _FP_FRAC_LOW_##wc (X) >>= (_FP_WORKBITS); \ } \ - FP_SET_EXCEPTION(FP_EX_UNDERFLOW); \ + FP_SET_EXCEPTION (FP_EX_UNDERFLOW); \ } \ } \ break; \ \ case FP_CLS_ZERO: \ X##_e = 0; \ - _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \ + _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \ break; \ \ case FP_CLS_INF: \ X##_e = _FP_EXPMAX_##fs; \ - _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \ + _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \ break; \ \ case FP_CLS_NAN: \ X##_e = _FP_EXPMAX_##fs; \ if (!_FP_KEEPNANFRACP) \ { \ - _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs); \ + _FP_FRAC_SET_##wc (X, _FP_NANFRAC_##fs); \ X##_s = _FP_NANSIGN_##fs; \ } \ else \ - _FP_SETQNAN(fs, wc, X); \ + _FP_SETQNAN (fs, wc, X); \ break; \ } \ } \ @@ -347,8 +347,8 @@ int __ret = 0; \ if (X##_e == _FP_EXPMAX_##fs) \ { \ - if (!_FP_FRAC_ZEROP_##wc(X) \ - && _FP_FRAC_SNANP(fs, X)) \ + if (!_FP_FRAC_ZEROP_##wc (X) \ + && _FP_FRAC_SNANP (fs, X)) \ __ret = 1; \ } \ __ret; \ @@ -373,25 +373,25 @@ if (Y##_e == 0) \ { \ /* Y is zero or denormalized. */ \ - if (_FP_FRAC_ZEROP_##wc(Y)) \ + if (_FP_FRAC_ZEROP_##wc (Y)) \ { \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X); \ - _FP_FRAC_COPY_##wc(R, X); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \ + _FP_FRAC_COPY_##wc (R, X); \ goto add_done; \ } \ else \ { \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ ediff--; \ if (ediff == 0) \ { \ - _FP_FRAC_ADD_##wc(R, X, Y); \ + _FP_FRAC_ADD_##wc (R, X, Y); \ goto add3; \ } \ if (X##_e == _FP_EXPMAX_##fs) \ { \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X); \ - _FP_FRAC_COPY_##wc(R, X); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \ + _FP_FRAC_COPY_##wc (R, X); \ goto add_done; \ } \ goto add1; \ @@ -400,22 +400,22 @@ else if (X##_e == _FP_EXPMAX_##fs) \ { \ /* X is NaN or Inf, Y is normal. */ \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X); \ - _FP_FRAC_COPY_##wc(R, X); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \ + _FP_FRAC_COPY_##wc (R, X); \ goto add_done; \ } \ \ /* Insert implicit MSB of Y. */ \ - _FP_FRAC_HIGH_##fs(Y) |= _FP_IMPLBIT_SH_##fs; \ + _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); \ - else if (!_FP_FRAC_ZEROP_##wc(Y)) \ - _FP_FRAC_SET_##wc(Y, _FP_MINFRAC_##wc); \ - _FP_FRAC_ADD_##wc(R, X, Y); \ + _FP_FRAC_SRS_##wc (Y, 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) \ { \ @@ -424,25 +424,25 @@ if (X##_e == 0) \ { \ /* X is zero or denormalized. */ \ - if (_FP_FRAC_ZEROP_##wc(X)) \ + if (_FP_FRAC_ZEROP_##wc (X)) \ { \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y); \ - _FP_FRAC_COPY_##wc(R, Y); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \ + _FP_FRAC_COPY_##wc (R, Y); \ goto add_done; \ } \ else \ { \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ ediff--; \ if (ediff == 0) \ { \ - _FP_FRAC_ADD_##wc(R, Y, X); \ + _FP_FRAC_ADD_##wc (R, Y, X); \ goto add3; \ } \ if (Y##_e == _FP_EXPMAX_##fs) \ { \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y); \ - _FP_FRAC_COPY_##wc(R, Y); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \ + _FP_FRAC_COPY_##wc (R, Y); \ goto add_done; \ } \ goto add2; \ @@ -451,54 +451,54 @@ else if (Y##_e == _FP_EXPMAX_##fs) \ { \ /* Y is NaN or Inf, X is normal. */ \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y); \ - _FP_FRAC_COPY_##wc(R, Y); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \ + _FP_FRAC_COPY_##wc (R, Y); \ goto add_done; \ } \ \ /* Insert implicit MSB of X. */ \ - _FP_FRAC_HIGH_##fs(X) |= _FP_IMPLBIT_SH_##fs; \ + _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); \ - else if (!_FP_FRAC_ZEROP_##wc(X)) \ - _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc); \ - _FP_FRAC_ADD_##wc(R, Y, X); \ + _FP_FRAC_SRS_##wc (X, 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. */ \ - if (!_FP_EXP_NORMAL(fs, wc, X)) \ + if (!_FP_EXP_NORMAL (fs, wc, X)) \ { \ if (X##_e == 0) \ { \ /* X and Y are zero or denormalized. */ \ R##_e = 0; \ - if (_FP_FRAC_ZEROP_##wc(X)) \ + if (_FP_FRAC_ZEROP_##wc (X)) \ { \ - if (!_FP_FRAC_ZEROP_##wc(Y)) \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ - _FP_FRAC_COPY_##wc(R, Y); \ + if (!_FP_FRAC_ZEROP_##wc (Y)) \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ + _FP_FRAC_COPY_##wc (R, Y); \ goto add_done; \ } \ - else if (_FP_FRAC_ZEROP_##wc(Y)) \ + else if (_FP_FRAC_ZEROP_##wc (Y)) \ { \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ - _FP_FRAC_COPY_##wc(R, X); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ + _FP_FRAC_COPY_##wc (R, X); \ goto add_done; \ } \ else \ { \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ - _FP_FRAC_ADD_##wc(R, X, Y); \ - if (_FP_FRAC_HIGH_##fs(R) & _FP_IMPLBIT_SH_##fs) \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ + _FP_FRAC_ADD_##wc (R, X, Y); \ + if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs) \ { \ /* Normalized result. */ \ - _FP_FRAC_HIGH_##fs(R) \ - &= ~(_FP_W_TYPE)_FP_IMPLBIT_SH_##fs; \ + _FP_FRAC_HIGH_##fs (R) \ + &= ~(_FP_W_TYPE) _FP_IMPLBIT_SH_##fs; \ R##_e = 1; \ } \ goto add_done; \ @@ -507,39 +507,39 @@ else \ { \ /* X and Y are NaN or Inf. */ \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X); \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \ R##_e = _FP_EXPMAX_##fs; \ - if (_FP_FRAC_ZEROP_##wc(X)) \ - _FP_FRAC_COPY_##wc(R, Y); \ - else if (_FP_FRAC_ZEROP_##wc(Y)) \ - _FP_FRAC_COPY_##wc(R, X); \ + if (_FP_FRAC_ZEROP_##wc (X)) \ + _FP_FRAC_COPY_##wc (R, Y); \ + else if (_FP_FRAC_ZEROP_##wc (Y)) \ + _FP_FRAC_COPY_##wc (R, X); \ else \ - _FP_CHOOSENAN_SEMIRAW(fs, wc, R, X, Y, OP); \ + _FP_CHOOSENAN_SEMIRAW (fs, wc, R, X, Y, OP); \ goto add_done; \ } \ } \ /* The exponents of X and Y, both normal, are equal. The \ implicit MSBs will always add to increase the \ exponent. */ \ - _FP_FRAC_ADD_##wc(R, X, Y); \ + _FP_FRAC_ADD_##wc (R, X, Y); \ R##_e = X##_e + 1; \ - _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs); \ + _FP_FRAC_SRS_##wc (R, 1, _FP_WFRACBITS_##fs); \ if (R##_e == _FP_EXPMAX_##fs) \ /* Overflow to infinity (depending on rounding mode). */ \ - _FP_OVERFLOW_SEMIRAW(fs, wc, R); \ + _FP_OVERFLOW_SEMIRAW (fs, wc, R); \ goto add_done; \ } \ add3: \ - if (_FP_FRAC_HIGH_##fs(R) & _FP_IMPLBIT_SH_##fs) \ + if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs) \ { \ /* Overflow. */ \ - _FP_FRAC_HIGH_##fs(R) &= ~(_FP_W_TYPE)_FP_IMPLBIT_SH_##fs; \ + _FP_FRAC_HIGH_##fs (R) &= ~(_FP_W_TYPE) _FP_IMPLBIT_SH_##fs; \ R##_e++; \ - _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs); \ + _FP_FRAC_SRS_##wc (R, 1, _FP_WFRACBITS_##fs); \ if (R##_e == _FP_EXPMAX_##fs) \ /* Overflow to infinity (depending on rounding mode). */ \ - _FP_OVERFLOW_SEMIRAW(fs, wc, R); \ + _FP_OVERFLOW_SEMIRAW (fs, wc, R); \ } \ add_done: ; \ } \ @@ -554,25 +554,25 @@ if (Y##_e == 0) \ { \ /* Y is zero or denormalized. */ \ - if (_FP_FRAC_ZEROP_##wc(Y)) \ + if (_FP_FRAC_ZEROP_##wc (Y)) \ { \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X); \ - _FP_FRAC_COPY_##wc(R, X); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \ + _FP_FRAC_COPY_##wc (R, X); \ goto sub_done; \ } \ else \ { \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ ediff--; \ if (ediff == 0) \ { \ - _FP_FRAC_SUB_##wc(R, X, Y); \ + _FP_FRAC_SUB_##wc (R, X, Y); \ goto sub3; \ } \ if (X##_e == _FP_EXPMAX_##fs) \ { \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X); \ - _FP_FRAC_COPY_##wc(R, X); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \ + _FP_FRAC_COPY_##wc (R, X); \ goto sub_done; \ } \ goto sub1; \ @@ -581,22 +581,22 @@ else if (X##_e == _FP_EXPMAX_##fs) \ { \ /* X is NaN or Inf, Y is normal. */ \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X); \ - _FP_FRAC_COPY_##wc(R, X); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \ + _FP_FRAC_COPY_##wc (R, X); \ goto sub_done; \ } \ \ /* Insert implicit MSB of Y. */ \ - _FP_FRAC_HIGH_##fs(Y) |= _FP_IMPLBIT_SH_##fs; \ + _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); \ - else if (!_FP_FRAC_ZEROP_##wc(Y)) \ - _FP_FRAC_SET_##wc(Y, _FP_MINFRAC_##wc); \ - _FP_FRAC_SUB_##wc(R, X, Y); \ + _FP_FRAC_SRS_##wc (Y, 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) \ { \ @@ -606,25 +606,25 @@ if (X##_e == 0) \ { \ /* X is zero or denormalized. */ \ - if (_FP_FRAC_ZEROP_##wc(X)) \ + if (_FP_FRAC_ZEROP_##wc (X)) \ { \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y); \ - _FP_FRAC_COPY_##wc(R, Y); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \ + _FP_FRAC_COPY_##wc (R, Y); \ goto sub_done; \ } \ else \ { \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ ediff--; \ if (ediff == 0) \ { \ - _FP_FRAC_SUB_##wc(R, Y, X); \ + _FP_FRAC_SUB_##wc (R, Y, X); \ goto sub3; \ } \ if (Y##_e == _FP_EXPMAX_##fs) \ { \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y); \ - _FP_FRAC_COPY_##wc(R, Y); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \ + _FP_FRAC_COPY_##wc (R, Y); \ goto sub_done; \ } \ goto sub2; \ @@ -633,63 +633,63 @@ else if (Y##_e == _FP_EXPMAX_##fs) \ { \ /* Y is NaN or Inf, X is normal. */ \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y); \ - _FP_FRAC_COPY_##wc(R, Y); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \ + _FP_FRAC_COPY_##wc (R, Y); \ goto sub_done; \ } \ \ /* Insert implicit MSB of X. */ \ - _FP_FRAC_HIGH_##fs(X) |= _FP_IMPLBIT_SH_##fs; \ + _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); \ - else if (!_FP_FRAC_ZEROP_##wc(X)) \ - _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc); \ - _FP_FRAC_SUB_##wc(R, Y, X); \ + _FP_FRAC_SRS_##wc (X, 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); \ } \ else \ { \ /* ediff == 0. */ \ - if (!_FP_EXP_NORMAL(fs, wc, X)) \ + if (!_FP_EXP_NORMAL (fs, wc, X)) \ { \ if (X##_e == 0) \ { \ /* X and Y are zero or denormalized. */ \ R##_e = 0; \ - if (_FP_FRAC_ZEROP_##wc(X)) \ + if (_FP_FRAC_ZEROP_##wc (X)) \ { \ - _FP_FRAC_COPY_##wc(R, Y); \ - if (_FP_FRAC_ZEROP_##wc(Y)) \ + _FP_FRAC_COPY_##wc (R, Y); \ + if (_FP_FRAC_ZEROP_##wc (Y)) \ R##_s = (FP_ROUNDMODE == FP_RND_MINF); \ else \ { \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ R##_s = Y##_s; \ } \ goto sub_done; \ } \ - else if (_FP_FRAC_ZEROP_##wc(Y)) \ + else if (_FP_FRAC_ZEROP_##wc (Y)) \ { \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ - _FP_FRAC_COPY_##wc(R, X); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ + _FP_FRAC_COPY_##wc (R, X); \ R##_s = X##_s; \ goto sub_done; \ } \ else \ { \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ - _FP_FRAC_SUB_##wc(R, X, Y); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ + _FP_FRAC_SUB_##wc (R, X, Y); \ R##_s = X##_s; \ - if (_FP_FRAC_HIGH_##fs(R) & _FP_IMPLBIT_SH_##fs) \ + if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs) \ { \ /* |X| < |Y|, negate result. */ \ - _FP_FRAC_SUB_##wc(R, Y, X); \ + _FP_FRAC_SUB_##wc (R, Y, X); \ R##_s = Y##_s; \ } \ - else if (_FP_FRAC_ZEROP_##wc(R)) \ + else if (_FP_FRAC_ZEROP_##wc (R)) \ R##_s = (FP_ROUNDMODE == FP_RND_MINF); \ goto sub_done; \ } \ @@ -697,38 +697,38 @@ else \ { \ /* X and Y are NaN or Inf, of opposite signs. */ \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X); \ - _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \ + _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \ R##_e = _FP_EXPMAX_##fs; \ - if (_FP_FRAC_ZEROP_##wc(X)) \ + if (_FP_FRAC_ZEROP_##wc (X)) \ { \ - if (_FP_FRAC_ZEROP_##wc(Y)) \ + if (_FP_FRAC_ZEROP_##wc (Y)) \ { \ /* Inf - Inf. */ \ 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_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \ + _FP_FRAC_SLL_##wc (R, _FP_WORKBITS); \ + FP_SET_EXCEPTION (FP_EX_INVALID); \ } \ else \ { \ /* Inf - NaN. */ \ R##_s = Y##_s; \ - _FP_FRAC_COPY_##wc(R, Y); \ + _FP_FRAC_COPY_##wc (R, Y); \ } \ } \ else \ { \ - if (_FP_FRAC_ZEROP_##wc(Y)) \ + if (_FP_FRAC_ZEROP_##wc (Y)) \ { \ /* NaN - Inf. */ \ R##_s = X##_s; \ - _FP_FRAC_COPY_##wc(R, X); \ + _FP_FRAC_COPY_##wc (R, X); \ } \ else \ { \ /* NaN - NaN. */ \ - _FP_CHOOSENAN_SEMIRAW(fs, wc, R, X, Y, OP); \ + _FP_CHOOSENAN_SEMIRAW (fs, wc, R, X, Y, OP); \ } \ } \ goto sub_done; \ @@ -737,15 +737,15 @@ /* The exponents of X and Y, both normal, are equal. The \ implicit MSBs cancel. */ \ R##_e = X##_e; \ - _FP_FRAC_SUB_##wc(R, X, Y); \ + _FP_FRAC_SUB_##wc (R, X, Y); \ R##_s = X##_s; \ - if (_FP_FRAC_HIGH_##fs(R) & _FP_IMPLBIT_SH_##fs) \ + if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs) \ { \ /* |X| < |Y|, negate result. */ \ - _FP_FRAC_SUB_##wc(R, Y, X); \ + _FP_FRAC_SUB_##wc (R, Y, X); \ R##_s = Y##_s; \ } \ - else if (_FP_FRAC_ZEROP_##wc(R)) \ + else if (_FP_FRAC_ZEROP_##wc (R)) \ { \ R##_e = 0; \ R##_s = (FP_ROUNDMODE == FP_RND_MINF); \ @@ -754,27 +754,27 @@ goto norm; \ } \ sub3: \ - if (_FP_FRAC_HIGH_##fs(R) & _FP_IMPLBIT_SH_##fs) \ + if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs) \ { \ int 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; \ + _FP_FRAC_HIGH_##fs (R) &= _FP_IMPLBIT_SH_##fs - 1; \ norm: \ - _FP_FRAC_CLZ_##wc(diff, R); \ + _FP_FRAC_CLZ_##wc (diff, R); \ diff -= _FP_WFRACXBITS_##fs; \ - _FP_FRAC_SLL_##wc(R, diff); \ + _FP_FRAC_SLL_##wc (R, diff); \ if (R##_e <= diff) \ { \ /* R is denormalized. */ \ diff = diff - R##_e + 1; \ - _FP_FRAC_SRS_##wc(R, diff, _FP_WFRACBITS_##fs); \ + _FP_FRAC_SRS_##wc (R, diff, _FP_WFRACBITS_##fs); \ R##_e = 0; \ } \ else \ { \ R##_e -= diff; \ - _FP_FRAC_HIGH_##fs(R) &= ~(_FP_W_TYPE)_FP_IMPLBIT_SH_##fs; \ + _FP_FRAC_HIGH_##fs (R) &= ~(_FP_W_TYPE) _FP_IMPLBIT_SH_##fs; \ } \ } \ sub_done: ; \ @@ -782,13 +782,13 @@ } \ while (0) -#define _FP_ADD(fs, wc, R, X, Y) _FP_ADD_INTERNAL(fs, wc, R, X, Y, '+') +#define _FP_ADD(fs, wc, R, X, Y) _FP_ADD_INTERNAL (fs, wc, R, X, Y, '+') #define _FP_SUB(fs, wc, R, X, Y) \ do \ { \ - if (!(Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y))) \ + if (!(Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (Y))) \ Y##_s ^= 1; \ - _FP_ADD_INTERNAL(fs, wc, R, X, Y, '-'); \ + _FP_ADD_INTERNAL (fs, wc, R, X, Y, '-'); \ } \ while (0) @@ -800,7 +800,7 @@ #define _FP_NEG(fs, wc, R, X) \ do \ { \ - _FP_FRAC_COPY_##wc(R, X); \ + _FP_FRAC_COPY_##wc (R, X); \ R##_e = X##_e; \ R##_s = 1 ^ X##_s; \ } \ @@ -816,57 +816,57 @@ { \ R##_s = X##_s ^ Y##_s; \ R##_e = X##_e + Y##_e + 1; \ - switch (_FP_CLS_COMBINE(X##_c, Y##_c)) \ + switch (_FP_CLS_COMBINE (X##_c, Y##_c)) \ { \ - case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL): \ + case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_NORMAL): \ R##_c = FP_CLS_NORMAL; \ \ - _FP_MUL_MEAT_##fs(R,X,Y); \ + _FP_MUL_MEAT_##fs (R, X, Y); \ \ - if (_FP_FRAC_OVERP_##wc(fs, R)) \ - _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs); \ + if (_FP_FRAC_OVERP_##wc (fs, R)) \ + _FP_FRAC_SRS_##wc (R, 1, _FP_WFRACBITS_##fs); \ else \ R##_e--; \ break; \ \ - case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN): \ - _FP_CHOOSENAN(fs, wc, R, X, Y, '*'); \ + case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NAN): \ + _FP_CHOOSENAN (fs, wc, R, 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): \ + 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): \ R##_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(R, X); \ + 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 (R, X); \ R##_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): \ + 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): \ R##_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(R, Y); \ + case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_INF): \ + case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_ZERO): \ + _FP_FRAC_COPY_##wc (R, Y); \ R##_c = Y##_c; \ break; \ \ - case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO): \ - case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF): \ + case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_ZERO): \ + case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_INF): \ 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_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \ + FP_SET_EXCEPTION (FP_EX_INVALID); \ break; \ \ default: \ - abort(); \ + abort (); \ } \ } \ while (0) @@ -877,18 +877,18 @@ #define _FP_FMA(fs, wc, dwc, R, X, Y, Z) \ do \ { \ - FP_DECL_##fs(T); \ + FP_DECL_##fs (T); \ T##_s = X##_s ^ Y##_s; \ T##_e = X##_e + Y##_e + 1; \ - switch (_FP_CLS_COMBINE(X##_c, Y##_c)) \ + switch (_FP_CLS_COMBINE (X##_c, Y##_c)) \ { \ - case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL): \ + case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_NORMAL): \ switch (Z##_c) \ { \ case FP_CLS_INF: \ case FP_CLS_NAN: \ R##_s = Z##_s; \ - _FP_FRAC_COPY_##wc(R, Z); \ + _FP_FRAC_COPY_##wc (R, Z); \ R##_c = Z##_c; \ break; \ \ @@ -897,47 +897,47 @@ R##_s = T##_s; \ R##_e = T##_e; \ \ - _FP_MUL_MEAT_##fs(R, X, Y); \ + _FP_MUL_MEAT_##fs (R, X, Y); \ \ - if (_FP_FRAC_OVERP_##wc(fs, R)) \ - _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs); \ + if (_FP_FRAC_OVERP_##wc (fs, R)) \ + _FP_FRAC_SRS_##wc (R, 1, _FP_WFRACBITS_##fs); \ else \ R##_e--; \ 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); \ + _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; \ + int tsh = _FP_FRAC_HIGHBIT_DW_##dwc (fs, TD) == 0; \ T##_e -= tsh; \ int ediff = T##_e - Z##_e; \ if (ediff >= 0) \ { \ int shift = _FP_WFRACBITS_##fs - tsh - ediff; \ if (shift <= -_FP_WFRACBITS_##fs) \ - _FP_FRAC_SET_##dwc(ZD, _FP_MINFRAC_##dwc); \ + _FP_FRAC_SET_##dwc (ZD, _FP_MINFRAC_##dwc); \ else \ { \ - _FP_FRAC_COPY_##dwc##_##wc(ZD, Z); \ + _FP_FRAC_COPY_##dwc##_##wc (ZD, Z); \ if (shift < 0) \ - _FP_FRAC_SRS_##dwc(ZD, -shift, \ - _FP_WFRACBITS_DW_##fs); \ + _FP_FRAC_SRS_##dwc (ZD, -shift, \ + _FP_WFRACBITS_DW_##fs); \ else if (shift > 0) \ - _FP_FRAC_SLL_##dwc(ZD, shift); \ + _FP_FRAC_SLL_##dwc (ZD, shift); \ } \ R##_s = T##_s; \ if (T##_s == Z##_s) \ - _FP_FRAC_ADD_##dwc(RD, TD, ZD); \ + _FP_FRAC_ADD_##dwc (RD, TD, ZD); \ else \ { \ - _FP_FRAC_SUB_##dwc(RD, TD, ZD); \ - if (_FP_FRAC_NEGP_##dwc(RD)) \ + _FP_FRAC_SUB_##dwc (RD, TD, ZD); \ + if (_FP_FRAC_NEGP_##dwc (RD)) \ { \ R##_s = Z##_s; \ - _FP_FRAC_SUB_##dwc(RD, ZD, TD); \ + _FP_FRAC_SUB_##dwc (RD, ZD, TD); \ } \ } \ } \ @@ -945,140 +945,140 @@ { \ R##_e = Z##_e; \ R##_s = Z##_s; \ - _FP_FRAC_COPY_##dwc##_##wc(ZD, Z); \ - _FP_FRAC_SLL_##dwc(ZD, _FP_WFRACBITS_##fs); \ + _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); \ + _FP_FRAC_SET_##dwc (TD, _FP_MINFRAC_##dwc); \ else if (shift > 0) \ - _FP_FRAC_SRS_##dwc(TD, shift, \ - _FP_WFRACBITS_DW_##fs); \ + _FP_FRAC_SRS_##dwc (TD, shift, \ + _FP_WFRACBITS_DW_##fs); \ if (Z##_s == T##_s) \ - _FP_FRAC_ADD_##dwc(RD, ZD, TD); \ + _FP_FRAC_ADD_##dwc (RD, ZD, TD); \ else \ - _FP_FRAC_SUB_##dwc(RD, ZD, TD); \ + _FP_FRAC_SUB_##dwc (RD, ZD, TD); \ } \ - if (_FP_FRAC_ZEROP_##dwc(RD)) \ + if (_FP_FRAC_ZEROP_##dwc (RD)) \ { \ if (T##_s == Z##_s) \ R##_s = Z##_s; \ else \ R##_s = (FP_ROUNDMODE == FP_RND_MINF); \ - _FP_FRAC_SET_##wc(R, _FP_ZEROFRAC_##wc); \ + _FP_FRAC_SET_##wc (R, _FP_ZEROFRAC_##wc); \ R##_c = FP_CLS_ZERO; \ } \ else \ { \ int rlz; \ - _FP_FRAC_CLZ_##dwc(rlz, RD); \ + _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, \ - _FP_WFRACBITS_DW_##fs); \ + _FP_FRAC_SRS_##dwc (RD, shift, \ + _FP_WFRACBITS_DW_##fs); \ else if (shift < 0) \ - _FP_FRAC_SLL_##dwc(RD, -shift); \ - _FP_FRAC_COPY_##wc##_##dwc(R, RD); \ + _FP_FRAC_SLL_##dwc (RD, -shift); \ + _FP_FRAC_COPY_##wc##_##dwc (R, RD); \ R##_c = FP_CLS_NORMAL; \ } \ break; \ } \ goto done_fma; \ \ - case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN): \ - _FP_CHOOSENAN(fs, wc, T, X, Y, '*'); \ + case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NAN): \ + _FP_CHOOSENAN (fs, wc, 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): \ + 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; \ \ - 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); \ + 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; \ 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): \ + 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; \ \ - 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); \ + 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; \ break; \ \ - case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO): \ - case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF): \ + 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_FRAC_SET_##wc (T, _FP_NANFRAC_##fs); \ + FP_SET_EXCEPTION (FP_EX_INVALID); \ break; \ \ default: \ - abort(); \ + abort (); \ } \ \ /* T = X * Y is zero, infinity or NaN. */ \ - switch (_FP_CLS_COMBINE(T##_c, Z##_c)) \ + switch (_FP_CLS_COMBINE (T##_c, Z##_c)) \ { \ - case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN): \ - _FP_CHOOSENAN(fs, wc, R, T, Z, '+'); \ + case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NAN): \ + _FP_CHOOSENAN (fs, wc, R, T, Z, '+'); \ 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): \ - case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NORMAL): \ - case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO): \ + 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): \ + 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); \ + _FP_FRAC_COPY_##wc (R, T); \ R##_c = T##_c; \ break; \ \ - case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NAN): \ - case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NAN): \ - case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NORMAL): \ - case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF): \ + case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NAN): \ + case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NAN): \ + case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NORMAL): \ + case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_INF): \ R##_s = Z##_s; \ - _FP_FRAC_COPY_##wc(R, Z); \ + _FP_FRAC_COPY_##wc (R, Z); \ R##_c = Z##_c; \ break; \ \ - case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF): \ + case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_INF): \ if (T##_s == Z##_s) \ { \ R##_s = Z##_s; \ - _FP_FRAC_COPY_##wc(R, Z); \ + _FP_FRAC_COPY_##wc (R, Z); \ R##_c = Z##_c; \ } \ else \ { \ 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_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \ + FP_SET_EXCEPTION (FP_EX_INVALID); \ } \ break; \ \ - case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO): \ + case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_ZERO): \ if (T##_s == Z##_s) \ R##_s = Z##_s; \ else \ R##_s = (FP_ROUNDMODE == FP_RND_MINF); \ - _FP_FRAC_COPY_##wc(R, Z); \ + _FP_FRAC_COPY_##wc (R, Z); \ R##_c = Z##_c; \ break; \ \ default: \ - abort(); \ + abort (); \ } \ done_fma: ; \ } \ @@ -1094,57 +1094,57 @@ { \ R##_s = X##_s ^ Y##_s; \ R##_e = X##_e - Y##_e; \ - switch (_FP_CLS_COMBINE(X##_c, Y##_c)) \ + switch (_FP_CLS_COMBINE (X##_c, Y##_c)) \ { \ - case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL): \ + case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_NORMAL): \ R##_c = FP_CLS_NORMAL; \ \ - _FP_DIV_MEAT_##fs(R,X,Y); \ + _FP_DIV_MEAT_##fs (R, X, Y); \ break; \ \ - case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN): \ - _FP_CHOOSENAN(fs, wc, R, X, Y, '/'); \ + case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NAN): \ + _FP_CHOOSENAN (fs, wc, R, 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): \ + 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): \ R##_s = X##_s; \ - _FP_FRAC_COPY_##wc(R, X); \ + _FP_FRAC_COPY_##wc (R, X); \ R##_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): \ + 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): \ R##_s = Y##_s; \ - _FP_FRAC_COPY_##wc(R, Y); \ + _FP_FRAC_COPY_##wc (R, Y); \ R##_c = Y##_c; \ break; \ \ - case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_INF): \ - case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF): \ - case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NORMAL): \ + case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_INF): \ + case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_INF): \ + case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NORMAL): \ R##_c = FP_CLS_ZERO; \ break; \ \ - case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_ZERO): \ - FP_SET_EXCEPTION(FP_EX_DIVZERO); \ - case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO): \ - case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NORMAL): \ + case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_ZERO): \ + FP_SET_EXCEPTION (FP_EX_DIVZERO); \ + case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_ZERO): \ + case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NORMAL): \ R##_c = FP_CLS_INF; \ break; \ \ - case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF): \ - case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO): \ + case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_INF): \ + case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_ZERO): \ 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_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \ + FP_SET_EXCEPTION (FP_EX_INVALID); \ break; \ \ default: \ - abort(); \ + abort (); \ } \ } \ while (0) @@ -1159,8 +1159,8 @@ do \ { \ /* NANs are unordered */ \ - if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X)) \ - || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y))) \ + if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (X)) \ + || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (Y))) \ { \ ret = un; \ } \ @@ -1169,8 +1169,8 @@ int __is_zero_x; \ int __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; \ + __is_zero_x = (!X##_e && _FP_FRAC_ZEROP_##wc (X)) ? 1 : 0; \ + __is_zero_y = (!Y##_e && _FP_FRAC_ZEROP_##wc (Y)) ? 1 : 0; \ \ if (__is_zero_x && __is_zero_y) \ ret = 0; \ @@ -1184,9 +1184,9 @@ ret = X##_s ? -1 : 1; \ else if (X##_e < Y##_e) \ ret = X##_s ? 1 : -1; \ - else if (_FP_FRAC_GT_##wc(X, Y)) \ + else if (_FP_FRAC_GT_##wc (X, Y)) \ ret = X##_s ? -1 : 1; \ - else if (_FP_FRAC_GT_##wc(Y, X)) \ + else if (_FP_FRAC_GT_##wc (Y, X)) \ ret = X##_s ? 1 : -1; \ else \ ret = 0; \ @@ -1201,16 +1201,16 @@ do \ { \ /* NANs are unordered */ \ - if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X)) \ - || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y))) \ + if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (X)) \ + || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (Y))) \ { \ ret = 1; \ } \ else \ { \ ret = !(X##_e == Y##_e \ - && _FP_FRAC_EQ_##wc(X, Y) \ - && (X##_s == Y##_s || (!X##_e && _FP_FRAC_ZEROP_##wc(X)))); \ + && _FP_FRAC_EQ_##wc (X, Y) \ + && (X##_s == Y##_s || (!X##_e && _FP_FRAC_ZEROP_##wc (X)))); \ } \ } \ while (0) @@ -1220,8 +1220,8 @@ #define _FP_CMP_UNORD(fs, wc, ret, X, Y) \ do \ { \ - ret = ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X)) \ - || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y))); \ + ret = ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (X)) \ + || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (Y))); \ } \ while (0) @@ -1232,13 +1232,13 @@ #define _FP_SQRT(fs, wc, R, X) \ do \ { \ - _FP_FRAC_DECL_##wc(T); \ - _FP_FRAC_DECL_##wc(S); \ + _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); \ + _FP_FRAC_COPY_##wc (R, X); \ R##_s = X##_s; \ R##_c = FP_CLS_NAN; \ break; \ @@ -1247,8 +1247,8 @@ { \ 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_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \ + FP_SET_EXCEPTION (FP_EX_INVALID); \ } \ else \ { \ @@ -1266,18 +1266,18 @@ { \ 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_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); \ + _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); \ + _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); \ + _FP_SQRT_MEAT_##wc (R, S, T, X, q); \ } \ } \ while (0) @@ -1305,14 +1305,14 @@ r = 0; \ if (X##_e == 0) \ { \ - if (!_FP_FRAC_ZEROP_##wc(X)) \ + if (!_FP_FRAC_ZEROP_##wc (X)) \ { \ - FP_SET_EXCEPTION(FP_EX_INEXACT); \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ + FP_SET_EXCEPTION (FP_EX_INEXACT); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ } \ } \ else \ - FP_SET_EXCEPTION(FP_EX_INEXACT); \ + FP_SET_EXCEPTION (FP_EX_INEXACT); \ } \ else if (X##_e >= _FP_EXPBIAS_##fs + rsize - (rsigned > 0 || X##_s) \ || (!rsigned && X##_s)) \ @@ -1334,40 +1334,40 @@ /* Possibly converting to most negative integer; check the \ mantissa. */ \ int inexact = 0; \ - (void)((_FP_FRACBITS_##fs > rsize) \ - ? ({ \ - _FP_FRAC_SRST_##wc(X, inexact, \ - _FP_FRACBITS_##fs - rsize, \ - _FP_FRACBITS_##fs); \ - 0; \ - }) \ - : 0); \ - if (!_FP_FRAC_ZEROP_##wc(X)) \ - FP_SET_EXCEPTION(FP_EX_INVALID); \ + (void) ((_FP_FRACBITS_##fs > rsize) \ + ? ({ \ + _FP_FRAC_SRST_##wc (X, 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_INEXACT); \ + FP_SET_EXCEPTION (FP_EX_INEXACT); \ } \ else \ - FP_SET_EXCEPTION(FP_EX_INVALID); \ + FP_SET_EXCEPTION (FP_EX_INVALID); \ } \ else \ { \ - _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_IMPLBIT_##fs; \ + _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); \ + _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_FRACBITS_##fs + _FP_EXPBIAS_##fs - 1 \ - - X##_e), \ - _FP_FRACBITS_##fs); \ + _FP_FRAC_SRST_##wc (X, 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_SET_EXCEPTION (FP_EX_INEXACT); \ + _FP_FRAC_ASSEMBLE_##wc (r, X, rsize); \ } \ if (rsigned && X##_s) \ r = -r; \ @@ -1385,31 +1385,32 @@ rtype ur_; \ \ if ((X##_s = (r < 0))) \ - r = -(rtype)r; \ + r = -(rtype) r; \ \ ur_ = (rtype) r; \ - (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_; \ - }) \ - : ((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))); \ + (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_; \ + }) \ + : ((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))); \ \ if (rsize - 1 + _FP_EXPBIAS_##fs >= _FP_EXPMAX_##fs \ && X##_e >= _FP_EXPMAX_##fs) \ { \ /* Exponent too big; overflow to infinity. (May also \ happen after rounding below.) */ \ - _FP_OVERFLOW_SEMIRAW(fs, wc, X); \ + _FP_OVERFLOW_SEMIRAW (fs, wc, X); \ goto pack_semiraw; \ } \ \ @@ -1417,10 +1418,10 @@ || X##_e < _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs) \ { \ /* Exactly representable; shift left. */ \ - _FP_FRAC_DISASSEMBLE_##wc(X, ur_, rsize); \ + _FP_FRAC_DISASSEMBLE_##wc (X, 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)); \ + _FP_FRAC_SLL_##wc (X, (_FP_EXPBIAS_##fs \ + + _FP_FRACBITS_##fs - 1 - X##_e)); \ } \ else \ { \ @@ -1432,20 +1433,20 @@ | ((ur_ << (rsize - (X##_e - _FP_EXPBIAS_##fs \ - _FP_WFRACBITS_##fs + 1))) \ != 0)); \ - _FP_FRAC_DISASSEMBLE_##wc(X, ur_, rsize); \ + _FP_FRAC_DISASSEMBLE_##wc (X, 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)); \ - _FP_FRAC_HIGH_##fs(X) &= ~(_FP_W_TYPE)_FP_IMPLBIT_SH_##fs; \ + _FP_FRAC_SLL_##wc (X, (_FP_EXPBIAS_##fs \ + + _FP_WFRACBITS_##fs - 1 - X##_e)); \ + _FP_FRAC_HIGH_##fs (X) &= ~(_FP_W_TYPE) _FP_IMPLBIT_SH_##fs; \ pack_semiraw: \ - _FP_PACK_SEMIRAW(fs, wc, X); \ + _FP_PACK_SEMIRAW (fs, wc, X); \ } \ } \ else \ { \ X##_s = 0; \ X##_e = 0; \ - _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \ + _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \ } \ } \ while (0) @@ -1453,7 +1454,7 @@ /* 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) \ +#define FP_EXTEND(dfs, sfs, dwc, swc, D, S) \ do \ { \ if (_FP_FRACBITS_##dfs < _FP_FRACBITS_##sfs \ @@ -1461,36 +1462,36 @@ < _FP_EXPMAX_##sfs - _FP_EXPBIAS_##sfs) \ || (_FP_EXPBIAS_##dfs < _FP_EXPBIAS_##sfs + _FP_FRACBITS_##sfs - 1 \ && _FP_EXPBIAS_##dfs != _FP_EXPBIAS_##sfs)) \ - abort(); \ + abort (); \ D##_s = S##_s; \ - _FP_FRAC_COPY_##dwc##_##swc(D, S); \ - if (_FP_EXP_NORMAL(sfs, swc, S)) \ + _FP_FRAC_COPY_##dwc##_##swc (D, S); \ + if (_FP_EXP_NORMAL (sfs, swc, S)) \ { \ D##_e = S##_e + _FP_EXPBIAS_##dfs - _FP_EXPBIAS_##sfs; \ - _FP_FRAC_SLL_##dwc(D, (_FP_FRACBITS_##dfs - _FP_FRACBITS_##sfs)); \ + _FP_FRAC_SLL_##dwc (D, (_FP_FRACBITS_##dfs - _FP_FRACBITS_##sfs)); \ } \ else \ { \ if (S##_e == 0) \ { \ - if (_FP_FRAC_ZEROP_##swc(S)) \ + if (_FP_FRAC_ZEROP_##swc (S)) \ D##_e = 0; \ else if (_FP_EXPBIAS_##dfs \ < _FP_EXPBIAS_##sfs + _FP_FRACBITS_##sfs - 1) \ { \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ - _FP_FRAC_SLL_##dwc(D, (_FP_FRACBITS_##dfs \ - - _FP_FRACBITS_##sfs)); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ + _FP_FRAC_SLL_##dwc (D, (_FP_FRACBITS_##dfs \ + - _FP_FRACBITS_##sfs)); \ D##_e = 0; \ } \ else \ { \ int _lz; \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ - _FP_FRAC_CLZ_##swc(_lz, S); \ - _FP_FRAC_SLL_##dwc(D, \ - _lz + _FP_FRACBITS_##dfs \ - - _FP_FRACTBITS_##sfs); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ + _FP_FRAC_CLZ_##swc (_lz, S); \ + _FP_FRAC_SLL_##dwc (D, \ + _lz + _FP_FRACBITS_##dfs \ + - _FP_FRACTBITS_##sfs); \ D##_e = (_FP_EXPBIAS_##dfs - _FP_EXPBIAS_##sfs + 1 \ + _FP_FRACXBITS_##sfs - _lz); \ } \ @@ -1498,12 +1499,12 @@ else \ { \ D##_e = _FP_EXPMAX_##dfs; \ - if (!_FP_FRAC_ZEROP_##swc(S)) \ + if (!_FP_FRAC_ZEROP_##swc (S)) \ { \ - if (_FP_FRAC_SNANP(sfs, S)) \ - FP_SET_EXCEPTION(FP_EX_INVALID); \ - _FP_FRAC_SLL_##dwc(D, (_FP_FRACBITS_##dfs \ - - _FP_FRACBITS_##sfs)); \ + if (_FP_FRAC_SNANP (sfs, S)) \ + FP_SET_EXCEPTION (FP_EX_INVALID); \ + _FP_FRAC_SLL_##dwc (D, (_FP_FRACBITS_##dfs \ + - _FP_FRACBITS_##sfs)); \ } \ } \ } \ @@ -1512,42 +1513,43 @@ /* 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) \ +#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(); \ + abort (); \ D##_s = S##_s; \ - if (_FP_EXP_NORMAL(sfs, swc, S)) \ + if (_FP_EXP_NORMAL (sfs, swc, S)) \ { \ D##_e = S##_e + _FP_EXPBIAS_##dfs - _FP_EXPBIAS_##sfs; \ if (D##_e >= _FP_EXPMAX_##dfs) \ - _FP_OVERFLOW_SEMIRAW(dfs, dwc, D); \ + _FP_OVERFLOW_SEMIRAW (dfs, dwc, D); \ else \ { \ if (D##_e <= 0) \ { \ if (D##_e < 1 - _FP_FRACBITS_##dfs) \ { \ - _FP_FRAC_SET_##swc(S, _FP_ZEROFRAC_##swc); \ - _FP_FRAC_LOW_##swc(S) |= 1; \ + _FP_FRAC_SET_##swc (S, _FP_ZEROFRAC_##swc); \ + _FP_FRAC_LOW_##swc (S) |= 1; \ } \ else \ { \ - _FP_FRAC_HIGH_##sfs(S) |= _FP_IMPLBIT_SH_##sfs; \ - _FP_FRAC_SRS_##swc(S, (_FP_WFRACBITS_##sfs \ - - _FP_WFRACBITS_##dfs + 1 - D##_e), \ - _FP_WFRACBITS_##sfs); \ + _FP_FRAC_HIGH_##sfs (S) |= _FP_IMPLBIT_SH_##sfs; \ + _FP_FRAC_SRS_##swc (S, (_FP_WFRACBITS_##sfs \ + - _FP_WFRACBITS_##dfs \ + + 1 - D##_e), \ + _FP_WFRACBITS_##sfs); \ } \ D##_e = 0; \ } \ else \ - _FP_FRAC_SRS_##swc(S, (_FP_WFRACBITS_##sfs \ - - _FP_WFRACBITS_##dfs), \ - _FP_WFRACBITS_##sfs); \ - _FP_FRAC_COPY_##dwc##_##swc(D, S); \ + _FP_FRAC_SRS_##swc (S, (_FP_WFRACBITS_##sfs \ + - _FP_WFRACBITS_##dfs), \ + _FP_WFRACBITS_##sfs); \ + _FP_FRAC_COPY_##dwc##_##swc (D, S); \ } \ } \ else \ @@ -1555,41 +1557,41 @@ if (S##_e == 0) \ { \ D##_e = 0; \ - if (_FP_FRAC_ZEROP_##swc(S)) \ - _FP_FRAC_SET_##dwc(D, _FP_ZEROFRAC_##dwc); \ + if (_FP_FRAC_ZEROP_##swc (S)) \ + _FP_FRAC_SET_##dwc (D, _FP_ZEROFRAC_##dwc); \ else \ { \ - FP_SET_EXCEPTION(FP_EX_DENORM); \ + FP_SET_EXCEPTION (FP_EX_DENORM); \ if (_FP_EXPBIAS_##sfs \ < _FP_EXPBIAS_##dfs + _FP_FRACBITS_##dfs - 1) \ { \ - _FP_FRAC_SRS_##swc(S, (_FP_WFRACBITS_##sfs \ - - _FP_WFRACBITS_##dfs), \ - _FP_WFRACBITS_##sfs); \ - _FP_FRAC_COPY_##dwc##_##swc(D, S); \ + _FP_FRAC_SRS_##swc (S, (_FP_WFRACBITS_##sfs \ + - _FP_WFRACBITS_##dfs), \ + _FP_WFRACBITS_##sfs); \ + _FP_FRAC_COPY_##dwc##_##swc (D, S); \ } \ else \ { \ - _FP_FRAC_SET_##dwc(D, _FP_ZEROFRAC_##dwc); \ - _FP_FRAC_LOW_##dwc(D) |= 1; \ + _FP_FRAC_SET_##dwc (D, _FP_ZEROFRAC_##dwc); \ + _FP_FRAC_LOW_##dwc (D) |= 1; \ } \ } \ } \ else \ { \ D##_e = _FP_EXPMAX_##dfs; \ - if (_FP_FRAC_ZEROP_##swc(S)) \ - _FP_FRAC_SET_##dwc(D, _FP_ZEROFRAC_##dwc); \ + if (_FP_FRAC_ZEROP_##swc (S)) \ + _FP_FRAC_SET_##dwc (D, _FP_ZEROFRAC_##dwc); \ else \ { \ - _FP_CHECK_SIGNAN_SEMIRAW(sfs, swc, S); \ - _FP_FRAC_SRL_##swc(S, (_FP_WFRACBITS_##sfs \ - - _FP_WFRACBITS_##dfs)); \ - _FP_FRAC_COPY_##dwc##_##swc(D, S); \ + _FP_CHECK_SIGNAN_SEMIRAW (sfs, swc, S); \ + _FP_FRAC_SRL_##swc (S, (_FP_WFRACBITS_##sfs \ + - _FP_WFRACBITS_##dfs)); \ + _FP_FRAC_COPY_##dwc##_##swc (D, S); \ /* Semi-raw NaN must have all workbits cleared. */ \ - _FP_FRAC_LOW_##dwc(D) \ + _FP_FRAC_LOW_##dwc (D) \ &= ~(_FP_W_TYPE) ((1 << _FP_WORKBITS) - 1); \ - _FP_SETQNAN_SEMIRAW(dfs, dwc, D); \ + _FP_SETQNAN_SEMIRAW (dfs, dwc, D); \ } \ } \ } \ diff --git a/soft-fp/quad.h b/soft-fp/quad.h index a651ad9c9f..5002da5a53 100644 --- a/soft-fp/quad.h +++ b/soft-fp/quad.h @@ -51,22 +51,22 @@ #define _FP_EXPMAX_Q 32767 #define _FP_QNANBIT_Q \ - ((_FP_W_TYPE)1 << (_FP_FRACBITS_Q-2) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_FRACBITS_Q-2) % _FP_W_TYPE_SIZE) #define _FP_QNANBIT_SH_Q \ - ((_FP_W_TYPE)1 << (_FP_FRACBITS_Q-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_FRACBITS_Q-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE) #define _FP_IMPLBIT_Q \ - ((_FP_W_TYPE)1 << (_FP_FRACBITS_Q-1) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_FRACBITS_Q-1) % _FP_W_TYPE_SIZE) #define _FP_IMPLBIT_SH_Q \ - ((_FP_W_TYPE)1 << (_FP_FRACBITS_Q-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_FRACBITS_Q-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE) #define _FP_OVERFLOW_Q \ - ((_FP_W_TYPE)1 << (_FP_WFRACBITS_Q % _FP_W_TYPE_SIZE)) + ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_Q % _FP_W_TYPE_SIZE)) #define _FP_WFRACBITS_DW_Q (2 * _FP_WFRACBITS_Q) #define _FP_WFRACXBITS_DW_Q (_FP_FRACTBITS_DW_Q - _FP_WFRACBITS_DW_Q) #define _FP_HIGHBIT_DW_Q \ - ((_FP_W_TYPE)1 << (_FP_WFRACBITS_DW_Q - 1) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_Q - 1) % _FP_W_TYPE_SIZE) -typedef float TFtype __attribute__((mode(TF))); +typedef float TFtype __attribute__ ((mode (TF))); #if _FP_W_TYPE_SIZE < 64 @@ -90,114 +90,114 @@ union _FP_UNION_Q unsigned exp : _FP_EXPBITS_Q; unsigned sign : 1; # endif /* not bigendian */ - } bits __attribute__((packed)); + } bits __attribute__ ((packed)); }; -# 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_PACK_RAW_QP(val,X) \ +# 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_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) \ +# define FP_UNPACK_Q(X, val) \ do \ { \ - _FP_UNPACK_RAW_4(Q,X,val); \ - _FP_UNPACK_CANONICAL(Q,4,X); \ + _FP_UNPACK_RAW_4 (Q, X, val); \ + _FP_UNPACK_CANONICAL (Q, 4, X); \ } \ while (0) -# define FP_UNPACK_QP(X,val) \ +# define FP_UNPACK_QP(X, val) \ do \ { \ - _FP_UNPACK_RAW_4_P(Q,X,val); \ - _FP_UNPACK_CANONICAL(Q,4,X); \ + _FP_UNPACK_RAW_4_P (Q, X, val); \ + _FP_UNPACK_CANONICAL (Q, 4, X); \ } \ while (0) -# define FP_UNPACK_SEMIRAW_Q(X,val) \ +# define FP_UNPACK_SEMIRAW_Q(X, val) \ do \ { \ - _FP_UNPACK_RAW_4(Q,X,val); \ - _FP_UNPACK_SEMIRAW(Q,4,X); \ + _FP_UNPACK_RAW_4 (Q, X, val); \ + _FP_UNPACK_SEMIRAW (Q, 4, X); \ } \ while (0) -# define FP_UNPACK_SEMIRAW_QP(X,val) \ +# define FP_UNPACK_SEMIRAW_QP(X, val) \ do \ { \ - _FP_UNPACK_RAW_4_P(Q,X,val); \ - _FP_UNPACK_SEMIRAW(Q,4,X); \ + _FP_UNPACK_RAW_4_P (Q, X, val); \ + _FP_UNPACK_SEMIRAW (Q, 4, X); \ } \ while (0) -# define FP_PACK_Q(val,X) \ +# define FP_PACK_Q(val, X) \ do \ { \ - _FP_PACK_CANONICAL(Q,4,X); \ - _FP_PACK_RAW_4(Q,val,X); \ + _FP_PACK_CANONICAL (Q, 4, X); \ + _FP_PACK_RAW_4 (Q, val, X); \ } \ while (0) -# define FP_PACK_QP(val,X) \ +# define FP_PACK_QP(val, X) \ do \ { \ - _FP_PACK_CANONICAL(Q,4,X); \ + _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) -# define FP_PACK_SEMIRAW_Q(val,X) \ +# define FP_PACK_SEMIRAW_Q(val, X) \ do \ { \ - _FP_PACK_SEMIRAW(Q,4,X); \ - _FP_PACK_RAW_4(Q,val,X); \ + _FP_PACK_SEMIRAW (Q, 4, X); \ + _FP_PACK_RAW_4 (Q, val, X); \ } \ while (0) -# define FP_PACK_SEMIRAW_QP(val,X) \ +# define FP_PACK_SEMIRAW_QP(val, X) \ do \ { \ - _FP_PACK_SEMIRAW(Q,4,X); \ + _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) -# define FP_ISSIGNAN_Q(X) _FP_ISSIGNAN(Q,4,X) -# define FP_NEG_Q(R,X) _FP_NEG(Q,4,R,X) -# define FP_ADD_Q(R,X,Y) _FP_ADD(Q,4,R,X,Y) -# define FP_SUB_Q(R,X,Y) _FP_SUB(Q,4,R,X,Y) -# 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_FMA_Q(R,X,Y,Z) _FP_FMA(Q,4,8,R,X,Y,Z) +# define FP_ISSIGNAN_Q(X) _FP_ISSIGNAN (Q, 4, X) +# define FP_NEG_Q(R, X) _FP_NEG (Q, 4, R, X) +# define FP_ADD_Q(R, X, Y) _FP_ADD (Q, 4, R, X, Y) +# define FP_SUB_Q(R, X, Y) _FP_SUB (Q, 4, R, X, Y) +# 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_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) _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_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_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) +# define _FP_FRAC_HIGH_Q(X) _FP_FRAC_HIGH_4 (X) +# define _FP_FRAC_HIGH_RAW_Q(X) _FP_FRAC_HIGH_4 (X) -# define _FP_FRAC_HIGH_DW_Q(X) _FP_FRAC_HIGH_8(X) +# define _FP_FRAC_HIGH_DW_Q(X) _FP_FRAC_HIGH_8 (X) #else /* not _FP_W_TYPE_SIZE < 64 */ union _FP_UNION_Q { - TFtype flt /* __attribute__((mode(TF))) */ ; + TFtype flt /* __attribute__ ((mode (TF))) */ ; struct _FP_STRUCT_LAYOUT { _FP_W_TYPE a, b; @@ -218,104 +218,104 @@ union _FP_UNION_Q } bits; }; -# 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_PACK_RAW_QP(val,X) \ +# 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_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) \ +# define FP_UNPACK_Q(X, val) \ do \ { \ - _FP_UNPACK_RAW_2(Q,X,val); \ - _FP_UNPACK_CANONICAL(Q,2,X); \ + _FP_UNPACK_RAW_2 (Q, X, val); \ + _FP_UNPACK_CANONICAL (Q, 2, X); \ } \ while (0) -# define FP_UNPACK_QP(X,val) \ +# define FP_UNPACK_QP(X, val) \ do \ { \ - _FP_UNPACK_RAW_2_P(Q,X,val); \ - _FP_UNPACK_CANONICAL(Q,2,X); \ + _FP_UNPACK_RAW_2_P (Q, X, val); \ + _FP_UNPACK_CANONICAL (Q, 2, X); \ } \ while (0) -# define FP_UNPACK_SEMIRAW_Q(X,val) \ +# define FP_UNPACK_SEMIRAW_Q(X, val) \ do \ { \ - _FP_UNPACK_RAW_2(Q,X,val); \ - _FP_UNPACK_SEMIRAW(Q,2,X); \ + _FP_UNPACK_RAW_2 (Q, X, val); \ + _FP_UNPACK_SEMIRAW (Q, 2, X); \ } \ while (0) -# define FP_UNPACK_SEMIRAW_QP(X,val) \ +# define FP_UNPACK_SEMIRAW_QP(X, val) \ do \ { \ - _FP_UNPACK_RAW_2_P(Q,X,val); \ - _FP_UNPACK_SEMIRAW(Q,2,X); \ + _FP_UNPACK_RAW_2_P (Q, X, val); \ + _FP_UNPACK_SEMIRAW (Q, 2, X); \ } \ while (0) -# define FP_PACK_Q(val,X) \ +# define FP_PACK_Q(val, X) \ do \ { \ - _FP_PACK_CANONICAL(Q,2,X); \ - _FP_PACK_RAW_2(Q,val,X); \ + _FP_PACK_CANONICAL (Q, 2, X); \ + _FP_PACK_RAW_2 (Q, val, X); \ } \ while (0) -# define FP_PACK_QP(val,X) \ +# define FP_PACK_QP(val, X) \ do \ { \ - _FP_PACK_CANONICAL(Q,2,X); \ + _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) -# define FP_PACK_SEMIRAW_Q(val,X) \ +# define FP_PACK_SEMIRAW_Q(val, X) \ do \ { \ - _FP_PACK_SEMIRAW(Q,2,X); \ - _FP_PACK_RAW_2(Q,val,X); \ + _FP_PACK_SEMIRAW (Q, 2, X); \ + _FP_PACK_RAW_2 (Q, val, X); \ } \ while (0) -# define FP_PACK_SEMIRAW_QP(val,X) \ +# define FP_PACK_SEMIRAW_QP(val, X) \ do \ { \ - _FP_PACK_SEMIRAW(Q,2,X); \ + _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) -# define FP_ISSIGNAN_Q(X) _FP_ISSIGNAN(Q,2,X) -# define FP_NEG_Q(R,X) _FP_NEG(Q,2,R,X) -# define FP_ADD_Q(R,X,Y) _FP_ADD(Q,2,R,X,Y) -# define FP_SUB_Q(R,X,Y) _FP_SUB(Q,2,R,X,Y) -# 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_FMA_Q(R,X,Y,Z) _FP_FMA(Q,2,4,R,X,Y,Z) +# define FP_ISSIGNAN_Q(X) _FP_ISSIGNAN (Q, 2, X) +# define FP_NEG_Q(R, X) _FP_NEG (Q, 2, R, X) +# define FP_ADD_Q(R, X, Y) _FP_ADD (Q, 2, R, X, Y) +# define FP_SUB_Q(R, X, Y) _FP_SUB (Q, 2, R, X, Y) +# 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_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) _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_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_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) +# define _FP_FRAC_HIGH_Q(X) _FP_FRAC_HIGH_2 (X) +# define _FP_FRAC_HIGH_RAW_Q(X) _FP_FRAC_HIGH_2 (X) -# define _FP_FRAC_HIGH_DW_Q(X) _FP_FRAC_HIGH_4(X) +# define _FP_FRAC_HIGH_DW_Q(X) _FP_FRAC_HIGH_4 (X) #endif /* not _FP_W_TYPE_SIZE < 64 */ diff --git a/soft-fp/single.h b/soft-fp/single.h index 2d1b84ba9c..af60c96e68 100644 --- a/soft-fp/single.h +++ b/soft-fp/single.h @@ -49,21 +49,21 @@ #define _FP_EXPBITS_S 8 #define _FP_EXPBIAS_S 127 #define _FP_EXPMAX_S 255 -#define _FP_QNANBIT_S ((_FP_W_TYPE)1 << (_FP_FRACBITS_S-2)) -#define _FP_QNANBIT_SH_S ((_FP_W_TYPE)1 << (_FP_FRACBITS_S-2+_FP_WORKBITS)) -#define _FP_IMPLBIT_S ((_FP_W_TYPE)1 << (_FP_FRACBITS_S-1)) -#define _FP_IMPLBIT_SH_S ((_FP_W_TYPE)1 << (_FP_FRACBITS_S-1+_FP_WORKBITS)) -#define _FP_OVERFLOW_S ((_FP_W_TYPE)1 << (_FP_WFRACBITS_S)) +#define _FP_QNANBIT_S ((_FP_W_TYPE) 1 << (_FP_FRACBITS_S-2)) +#define _FP_QNANBIT_SH_S ((_FP_W_TYPE) 1 << (_FP_FRACBITS_S-2+_FP_WORKBITS)) +#define _FP_IMPLBIT_S ((_FP_W_TYPE) 1 << (_FP_FRACBITS_S-1)) +#define _FP_IMPLBIT_SH_S ((_FP_W_TYPE) 1 << (_FP_FRACBITS_S-1+_FP_WORKBITS)) +#define _FP_OVERFLOW_S ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_S)) #define _FP_WFRACBITS_DW_S (2 * _FP_WFRACBITS_S) #define _FP_WFRACXBITS_DW_S (_FP_FRACTBITS_DW_S - _FP_WFRACBITS_DW_S) #define _FP_HIGHBIT_DW_S \ - ((_FP_W_TYPE)1 << (_FP_WFRACBITS_DW_S - 1) % _FP_W_TYPE_SIZE) + ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_S - 1) % _FP_W_TYPE_SIZE) /* The implementation of _FP_MUL_MEAT_S and _FP_DIV_MEAT_S should be chosen by the target machine. */ -typedef float SFtype __attribute__((mode(SF))); +typedef float SFtype __attribute__ ((mode (SF))); union _FP_UNION_S { @@ -79,114 +79,114 @@ union _FP_UNION_S unsigned exp : _FP_EXPBITS_S; unsigned sign : 1; #endif - } bits __attribute__((packed)); + } bits __attribute__ ((packed)); }; -#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_PACK_RAW_SP(val,X) \ +#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_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) \ +#define FP_UNPACK_S(X, val) \ do \ { \ - _FP_UNPACK_RAW_1(S,X,val); \ - _FP_UNPACK_CANONICAL(S,1,X); \ + _FP_UNPACK_RAW_1 (S, X, val); \ + _FP_UNPACK_CANONICAL (S, 1, X); \ } \ while (0) -#define FP_UNPACK_SP(X,val) \ +#define FP_UNPACK_SP(X, val) \ do \ { \ - _FP_UNPACK_RAW_1_P(S,X,val); \ - _FP_UNPACK_CANONICAL(S,1,X); \ + _FP_UNPACK_RAW_1_P (S, X, val); \ + _FP_UNPACK_CANONICAL (S, 1, X); \ } \ while (0) -#define FP_UNPACK_SEMIRAW_S(X,val) \ +#define FP_UNPACK_SEMIRAW_S(X, val) \ do \ { \ - _FP_UNPACK_RAW_1(S,X,val); \ - _FP_UNPACK_SEMIRAW(S,1,X); \ + _FP_UNPACK_RAW_1 (S, X, val); \ + _FP_UNPACK_SEMIRAW (S, 1, X); \ } \ while (0) -#define FP_UNPACK_SEMIRAW_SP(X,val) \ +#define FP_UNPACK_SEMIRAW_SP(X, val) \ do \ { \ - _FP_UNPACK_RAW_1_P(S,X,val); \ - _FP_UNPACK_SEMIRAW(S,1,X); \ + _FP_UNPACK_RAW_1_P (S, X, val); \ + _FP_UNPACK_SEMIRAW (S, 1, X); \ } \ while (0) -#define FP_PACK_S(val,X) \ +#define FP_PACK_S(val, X) \ do \ { \ - _FP_PACK_CANONICAL(S,1,X); \ - _FP_PACK_RAW_1(S,val,X); \ + _FP_PACK_CANONICAL (S, 1, X); \ + _FP_PACK_RAW_1 (S, val, X); \ } \ while (0) -#define FP_PACK_SP(val,X) \ +#define FP_PACK_SP(val, X) \ do \ { \ - _FP_PACK_CANONICAL(S,1,X); \ + _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) -#define FP_PACK_SEMIRAW_S(val,X) \ +#define FP_PACK_SEMIRAW_S(val, X) \ do \ { \ - _FP_PACK_SEMIRAW(S,1,X); \ - _FP_PACK_RAW_1(S,val,X); \ + _FP_PACK_SEMIRAW (S, 1, X); \ + _FP_PACK_RAW_1 (S, val, X); \ } \ while (0) -#define FP_PACK_SEMIRAW_SP(val,X) \ +#define FP_PACK_SEMIRAW_SP(val, X) \ do \ { \ - _FP_PACK_SEMIRAW(S,1,X); \ + _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) -#define FP_ISSIGNAN_S(X) _FP_ISSIGNAN(S,1,X) -#define FP_NEG_S(R,X) _FP_NEG(S,1,R,X) -#define FP_ADD_S(R,X,Y) _FP_ADD(S,1,R,X,Y) -#define FP_SUB_S(R,X,Y) _FP_SUB(S,1,R,X,Y) -#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_ISSIGNAN_S(X) _FP_ISSIGNAN (S, 1, X) +#define FP_NEG_S(R, X) _FP_NEG (S, 1, R, X) +#define FP_ADD_S(R, X, Y) _FP_ADD (S, 1, R, X, Y) +#define FP_SUB_S(R, X, Y) _FP_SUB (S, 1, R, X, Y) +#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) #if _FP_W_TYPE_SIZE < 64 -# define FP_FMA_S(R, X, Y, Z) _FP_FMA(S, 1, 2, R, X, Y, Z) +# define FP_FMA_S(R, X, Y, Z) _FP_FMA (S, 1, 2, R, X, Y, Z) #else -# define FP_FMA_S(R, X, Y, Z) _FP_FMA(S, 1, 1, R, X, Y, Z) +# 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) _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_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_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) +#define _FP_FRAC_HIGH_S(X) _FP_FRAC_HIGH_1 (X) +#define _FP_FRAC_HIGH_RAW_S(X) _FP_FRAC_HIGH_1 (X) #if _FP_W_TYPE_SIZE < 64 -# define _FP_FRAC_HIGH_DW_S(X) _FP_FRAC_HIGH_2(X) +# define _FP_FRAC_HIGH_DW_S(X) _FP_FRAC_HIGH_2 (X) #else -# define _FP_FRAC_HIGH_DW_S(X) _FP_FRAC_HIGH_1(X) +# define _FP_FRAC_HIGH_DW_S(X) _FP_FRAC_HIGH_1 (X) #endif diff --git a/soft-fp/soft-fp.h b/soft-fp/soft-fp.h index 02a1a279ea..696fc8676c 100644 --- a/soft-fp/soft-fp.h +++ b/soft-fp/soft-fp.h @@ -48,10 +48,10 @@ #endif #define _FP_WORKBITS 3 -#define _FP_WORK_LSB ((_FP_W_TYPE)1 << 3) -#define _FP_WORK_ROUND ((_FP_W_TYPE)1 << 2) -#define _FP_WORK_GUARD ((_FP_W_TYPE)1 << 1) -#define _FP_WORK_STICKY ((_FP_W_TYPE)1 << 0) +#define _FP_WORK_LSB ((_FP_W_TYPE) 1 << 3) +#define _FP_WORK_ROUND ((_FP_W_TYPE) 1 << 2) +#define _FP_WORK_GUARD ((_FP_W_TYPE) 1 << 1) +#define _FP_WORK_STICKY ((_FP_W_TYPE) 1 << 0) #ifndef FP_RND_NEAREST # define FP_RND_NEAREST 0 @@ -166,48 +166,48 @@ #define _FP_ROUND_NEAREST(wc, X) \ do \ { \ - if ((_FP_FRAC_LOW_##wc(X) & 15) != _FP_WORK_ROUND) \ - _FP_FRAC_ADDI_##wc(X, _FP_WORK_ROUND); \ + if ((_FP_FRAC_LOW_##wc (X) & 15) != _FP_WORK_ROUND) \ + _FP_FRAC_ADDI_##wc (X, _FP_WORK_ROUND); \ } \ while (0) -#define _FP_ROUND_ZERO(wc, X) (void)0 +#define _FP_ROUND_ZERO(wc, X) (void) 0 -#define _FP_ROUND_PINF(wc, X) \ - do \ - { \ - if (!X##_s && (_FP_FRAC_LOW_##wc(X) & 7)) \ - _FP_FRAC_ADDI_##wc(X, _FP_WORK_LSB); \ - } \ +#define _FP_ROUND_PINF(wc, X) \ + do \ + { \ + if (!X##_s && (_FP_FRAC_LOW_##wc (X) & 7)) \ + _FP_FRAC_ADDI_##wc (X, _FP_WORK_LSB); \ + } \ while (0) #define _FP_ROUND_MINF(wc, X) \ do \ { \ - if (X##_s && (_FP_FRAC_LOW_##wc(X) & 7)) \ - _FP_FRAC_ADDI_##wc(X, _FP_WORK_LSB); \ + if (X##_s && (_FP_FRAC_LOW_##wc (X) & 7)) \ + _FP_FRAC_ADDI_##wc (X, _FP_WORK_LSB); \ } \ while (0) #define _FP_ROUND(wc, X) \ do \ { \ - if (_FP_FRAC_LOW_##wc(X) & 7) \ + if (_FP_FRAC_LOW_##wc (X) & 7) \ { \ - FP_SET_EXCEPTION(FP_EX_INEXACT); \ + FP_SET_EXCEPTION (FP_EX_INEXACT); \ switch (FP_ROUNDMODE) \ { \ case FP_RND_NEAREST: \ - _FP_ROUND_NEAREST(wc,X); \ + _FP_ROUND_NEAREST (wc, X); \ break; \ case FP_RND_ZERO: \ - _FP_ROUND_ZERO(wc,X); \ + _FP_ROUND_ZERO (wc, X); \ break; \ case FP_RND_PINF: \ - _FP_ROUND_PINF(wc,X); \ + _FP_ROUND_PINF (wc, X); \ break; \ case FP_RND_MINF: \ - _FP_ROUND_MINF(wc,X); \ + _FP_ROUND_MINF (wc, X); \ break; \ } \ } \ @@ -219,7 +219,7 @@ #define FP_CLS_INF 2 #define FP_CLS_NAN 3 -#define _FP_CLS_COMBINE(x,y) (((x) << 2) | (y)) +#define _FP_CLS_COMBINE(x, y) (((x) << 2) | (y)) #include "op-1.h" #include "op-2.h" @@ -231,14 +231,14 @@ #define UWtype _FP_W_TYPE #define W_TYPE_SIZE _FP_W_TYPE_SIZE -typedef int QItype __attribute__((mode(QI))); -typedef int SItype __attribute__((mode(SI))); -typedef int DItype __attribute__((mode(DI))); -typedef unsigned int UQItype __attribute__((mode(QI))); -typedef unsigned int USItype __attribute__((mode(SI))); -typedef unsigned int UDItype __attribute__((mode(DI))); +typedef int QItype __attribute__ ((mode (QI))); +typedef int SItype __attribute__ ((mode (SI))); +typedef int DItype __attribute__ ((mode (DI))); +typedef unsigned int UQItype __attribute__ ((mode (QI))); +typedef unsigned int USItype __attribute__ ((mode (SI))); +typedef unsigned int UDItype __attribute__ ((mode (DI))); #if _FP_W_TYPE_SIZE == 32 -typedef unsigned int UHWtype __attribute__((mode(HI))); +typedef unsigned int UHWtype __attribute__ ((mode (HI))); #elif _FP_W_TYPE_SIZE == 64 typedef USItype UHWtype; #endif @@ -247,8 +247,8 @@ typedef USItype UHWtype; # define CMPtype int #endif -#define SI_BITS (__CHAR_BIT__ * (int)sizeof(SItype)) -#define DI_BITS (__CHAR_BIT__ * (int)sizeof(DItype)) +#define SI_BITS (__CHAR_BIT__ * (int) sizeof (SItype)) +#define DI_BITS (__CHAR_BIT__ * (int) sizeof (DItype)) #ifndef umul_ppmm # ifdef _LIBC diff --git a/soft-fp/sqrtdf2.c b/soft-fp/sqrtdf2.c index a5ee2996e9..266e1925af 100644 --- a/soft-fp/sqrtdf2.c +++ b/soft-fp/sqrtdf2.c @@ -32,17 +32,17 @@ #include "double.h" DFtype -__sqrtdf2(DFtype a) +__sqrtdf2 (DFtype a) { FP_DECL_EX; - FP_DECL_D(A); - FP_DECL_D(R); + FP_DECL_D (A); + FP_DECL_D (R); DFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_D(A, a); - FP_SQRT_D(R, A); - FP_PACK_D(r, R); + FP_UNPACK_D (A, a); + FP_SQRT_D (R, A); + FP_PACK_D (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/sqrtsf2.c b/soft-fp/sqrtsf2.c index 30e267290e..ded6e87f53 100644 --- a/soft-fp/sqrtsf2.c +++ b/soft-fp/sqrtsf2.c @@ -32,17 +32,17 @@ #include "single.h" SFtype -__sqrtsf2(SFtype a) +__sqrtsf2 (SFtype a) { FP_DECL_EX; - FP_DECL_S(A); - FP_DECL_S(R); + FP_DECL_S (A); + FP_DECL_S (R); SFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_S(A, a); - FP_SQRT_S(R, A); - FP_PACK_S(r, R); + FP_UNPACK_S (A, a); + FP_SQRT_S (R, A); + FP_PACK_S (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/sqrttf2.c b/soft-fp/sqrttf2.c index 0e43d3d0c3..9f3e7187b0 100644 --- a/soft-fp/sqrttf2.c +++ b/soft-fp/sqrttf2.c @@ -32,17 +32,17 @@ #include "quad.h" TFtype -__sqrttf2(TFtype a) +__sqrttf2 (TFtype a) { FP_DECL_EX; - FP_DECL_Q(A); - FP_DECL_Q(R); + FP_DECL_Q (A); + FP_DECL_Q (R); TFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_Q(A, a); - FP_SQRT_Q(R, A); - FP_PACK_Q(r, R); + FP_UNPACK_Q (A, a); + FP_SQRT_Q (R, A); + FP_PACK_Q (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/subdf3.c b/soft-fp/subdf3.c index 8898f9f7a4..6846e98dbd 100644 --- a/soft-fp/subdf3.c +++ b/soft-fp/subdf3.c @@ -32,19 +32,19 @@ #include "double.h" DFtype -__subdf3(DFtype a, DFtype b) +__subdf3 (DFtype a, DFtype b) { FP_DECL_EX; - FP_DECL_D(A); - FP_DECL_D(B); - FP_DECL_D(R); + FP_DECL_D (A); + FP_DECL_D (B); + FP_DECL_D (R); DFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_SEMIRAW_D(A, a); - FP_UNPACK_SEMIRAW_D(B, b); - FP_SUB_D(R, A, B); - FP_PACK_SEMIRAW_D(r, R); + FP_UNPACK_SEMIRAW_D (A, a); + FP_UNPACK_SEMIRAW_D (B, b); + FP_SUB_D (R, A, B); + FP_PACK_SEMIRAW_D (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/subsf3.c b/soft-fp/subsf3.c index 05c933ba6c..d46ddf58ae 100644 --- a/soft-fp/subsf3.c +++ b/soft-fp/subsf3.c @@ -32,19 +32,19 @@ #include "single.h" SFtype -__subsf3(SFtype a, SFtype b) +__subsf3 (SFtype a, SFtype b) { FP_DECL_EX; - FP_DECL_S(A); - FP_DECL_S(B); - FP_DECL_S(R); + FP_DECL_S (A); + FP_DECL_S (B); + FP_DECL_S (R); SFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_SEMIRAW_S(A, a); - FP_UNPACK_SEMIRAW_S(B, b); - FP_SUB_S(R, A, B); - FP_PACK_SEMIRAW_S(r, R); + FP_UNPACK_SEMIRAW_S (A, a); + FP_UNPACK_SEMIRAW_S (B, b); + FP_SUB_S (R, A, B); + FP_PACK_SEMIRAW_S (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/subtf3.c b/soft-fp/subtf3.c index 68d41e6567..88c6edeb61 100644 --- a/soft-fp/subtf3.c +++ b/soft-fp/subtf3.c @@ -32,19 +32,19 @@ #include "quad.h" TFtype -__subtf3(TFtype a, TFtype b) +__subtf3 (TFtype a, TFtype b) { FP_DECL_EX; - FP_DECL_Q(A); - FP_DECL_Q(B); - FP_DECL_Q(R); + FP_DECL_Q (A); + FP_DECL_Q (B); + FP_DECL_Q (R); TFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_SEMIRAW_Q(A, a); - FP_UNPACK_SEMIRAW_Q(B, b); - FP_SUB_Q(R, A, B); - FP_PACK_SEMIRAW_Q(r, R); + FP_UNPACK_SEMIRAW_Q (A, a); + FP_UNPACK_SEMIRAW_Q (B, b); + FP_SUB_Q (R, A, B); + FP_PACK_SEMIRAW_Q (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/truncdfsf2.c b/soft-fp/truncdfsf2.c index f8b7d17cd2..3ec56fdf8a 100644 --- a/soft-fp/truncdfsf2.c +++ b/soft-fp/truncdfsf2.c @@ -33,21 +33,21 @@ #include "double.h" SFtype -__truncdfsf2(DFtype a) +__truncdfsf2 (DFtype a) { FP_DECL_EX; - FP_DECL_D(A); - FP_DECL_S(R); + FP_DECL_D (A); + FP_DECL_S (R); SFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_SEMIRAW_D(A, a); + FP_UNPACK_SEMIRAW_D (A, a); #if _FP_W_TYPE_SIZE < _FP_FRACBITS_D - FP_TRUNC(S,D,1,2,R,A); + FP_TRUNC (S, D, 1, 2, R, A); #else - FP_TRUNC(S,D,1,1,R,A); + FP_TRUNC (S, D, 1, 1, R, A); #endif - FP_PACK_SEMIRAW_S(r, R); + FP_PACK_SEMIRAW_S (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/trunctfdf2.c b/soft-fp/trunctfdf2.c index 2f61705010..e970210129 100644 --- a/soft-fp/trunctfdf2.c +++ b/soft-fp/trunctfdf2.c @@ -33,21 +33,21 @@ #include "quad.h" DFtype -__trunctfdf2(TFtype a) +__trunctfdf2 (TFtype a) { FP_DECL_EX; - FP_DECL_Q(A); - FP_DECL_D(R); + FP_DECL_Q (A); + FP_DECL_D (R); DFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_SEMIRAW_Q(A, a); + FP_UNPACK_SEMIRAW_Q (A, a); #if (2 * _FP_W_TYPE_SIZE) < _FP_FRACBITS_Q - FP_TRUNC(D,Q,2,4,R,A); + FP_TRUNC (D, Q, 2, 4, R, A); #else - FP_TRUNC(D,Q,1,2,R,A); + FP_TRUNC (D, Q, 1, 2, R, A); #endif - FP_PACK_SEMIRAW_D(r, R); + FP_PACK_SEMIRAW_D (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/trunctfsf2.c b/soft-fp/trunctfsf2.c index aa4e7b353a..d8a3728a0d 100644 --- a/soft-fp/trunctfsf2.c +++ b/soft-fp/trunctfsf2.c @@ -33,21 +33,21 @@ #include "quad.h" SFtype -__trunctfsf2(TFtype a) +__trunctfsf2 (TFtype a) { FP_DECL_EX; - FP_DECL_Q(A); - FP_DECL_S(R); + FP_DECL_Q (A); + FP_DECL_S (R); SFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_SEMIRAW_Q(A, a); + FP_UNPACK_SEMIRAW_Q (A, a); #if (2 * _FP_W_TYPE_SIZE) < _FP_FRACBITS_Q - FP_TRUNC(S,Q,1,4,R,A); + FP_TRUNC (S, Q, 1, 4, R, A); #else - FP_TRUNC(S,Q,1,2,R,A); + FP_TRUNC (S, Q, 1, 2, R, A); #endif - FP_PACK_SEMIRAW_S(r, R); + FP_PACK_SEMIRAW_S (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/trunctfxf2.c b/soft-fp/trunctfxf2.c index 37b73b2ae2..750bec1808 100644 --- a/soft-fp/trunctfxf2.c +++ b/soft-fp/trunctfxf2.c @@ -32,21 +32,21 @@ #include "quad.h" XFtype -__trunctfxf2(TFtype a) +__trunctfxf2 (TFtype a) { FP_DECL_EX; - FP_DECL_Q(A); - FP_DECL_E(R); + FP_DECL_Q (A); + FP_DECL_E (R); XFtype r; FP_INIT_ROUNDMODE; - FP_UNPACK_SEMIRAW_Q(A, a); + FP_UNPACK_SEMIRAW_Q (A, a); #if (2 * _FP_W_TYPE_SIZE) < _FP_FRACBITS_Q - FP_TRUNC(E,Q,4,4,R,A); + FP_TRUNC (E, Q, 4, 4, R, A); #else - FP_TRUNC(E,Q,2,2,R,A); + FP_TRUNC (E, Q, 2, 2, R, A); #endif - FP_PACK_SEMIRAW_E(r, R); + FP_PACK_SEMIRAW_E (r, R); FP_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/unorddf2.c b/soft-fp/unorddf2.c index 9c8e2f9027..641c869725 100644 --- a/soft-fp/unorddf2.c +++ b/soft-fp/unorddf2.c @@ -31,19 +31,19 @@ #include "double.h" CMPtype -__unorddf2(DFtype a, DFtype b) +__unorddf2 (DFtype a, DFtype b) { FP_DECL_EX; - FP_DECL_D(A); - FP_DECL_D(B); + FP_DECL_D (A); + FP_DECL_D (B); CMPtype r; 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_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_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/unordsf2.c b/soft-fp/unordsf2.c index fd475992f5..f271421283 100644 --- a/soft-fp/unordsf2.c +++ b/soft-fp/unordsf2.c @@ -31,19 +31,19 @@ #include "single.h" CMPtype -__unordsf2(SFtype a, SFtype b) +__unordsf2 (SFtype a, SFtype b) { FP_DECL_EX; - FP_DECL_S(A); - FP_DECL_S(B); + FP_DECL_S (A); + FP_DECL_S (B); CMPtype r; 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_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_HANDLE_EXCEPTIONS; return r; diff --git a/soft-fp/unordtf2.c b/soft-fp/unordtf2.c index 443cd79ec5..38cc1a78b2 100644 --- a/soft-fp/unordtf2.c +++ b/soft-fp/unordtf2.c @@ -31,19 +31,19 @@ #include "quad.h" CMPtype -__unordtf2(TFtype a, TFtype b) +__unordtf2 (TFtype a, TFtype b) { FP_DECL_EX; - FP_DECL_Q(A); - FP_DECL_Q(B); + FP_DECL_Q (A); + FP_DECL_Q (B); CMPtype r; 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_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_HANDLE_EXCEPTIONS; return r; |