AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-31 15:01:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

soft-fp: fix horizontal whitespace.

Browse Source
This commit is contained in:
Joseph Myers 2013-10-16 01:22:21 +00:00
parent 9ebb0332fc
commit 51ca9e29af
88 changed files with 1866 additions and 1774 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
ChangeLog
View File

@ -1,3 +1,93 @@
2013-10-16 Joseph Myers <joseph@codesourcery.com>
* soft-fp/adddf3.c: Fix horizontal whitespace.
* soft-fp/addsf3.c: Likewise.
* soft-fp/addtf3.c: Likewise.
* soft-fp/divdf3.c: Likewise.
* soft-fp/divsf3.c: Likewise.
* soft-fp/divtf3.c: Likewise.
* soft-fp/double.h: Likewise.
* soft-fp/eqdf2.c: Likewise.
* soft-fp/eqsf2.c: Likewise.
* soft-fp/eqtf2.c: Likewise.
* soft-fp/extenddftf2.c: Likewise.
* soft-fp/extended.h: Likewise.
* soft-fp/extendsfdf2.c: Likewise.
* soft-fp/extendsftf2.c: Likewise.
* soft-fp/extendxftf2.c: Likewise.
* soft-fp/fixdfdi.c: Likewise.
* soft-fp/fixdfsi.c: Likewise.
* soft-fp/fixdfti.c: Likewise.
* soft-fp/fixsfdi.c: Likewise.
* soft-fp/fixsfsi.c: Likewise.
* soft-fp/fixsfti.c: Likewise.
* soft-fp/fixtfdi.c: Likewise.
* soft-fp/fixtfsi.c: Likewise.
* soft-fp/fixtfti.c: Likewise.
* soft-fp/fixunsdfdi.c: Likewise.
* soft-fp/fixunsdfsi.c: Likewise.
* soft-fp/fixunsdfti.c: Likewise.
* soft-fp/fixunssfdi.c: Likewise.
* soft-fp/fixunssfsi.c: Likewise.
* soft-fp/fixunssfti.c: Likewise.
* soft-fp/fixunstfdi.c: Likewise.
* soft-fp/fixunstfsi.c: Likewise.
* soft-fp/fixunstfti.c: Likewise.
* soft-fp/floatdidf.c: Likewise.
* soft-fp/floatdisf.c: Likewise.
* soft-fp/floatditf.c: Likewise.
* soft-fp/floatsidf.c: Likewise.
* soft-fp/floatsisf.c: Likewise.
* soft-fp/floatsitf.c: Likewise.
* soft-fp/floattidf.c: Likewise.
* soft-fp/floattisf.c: Likewise.
* soft-fp/floattitf.c: Likewise.
* soft-fp/floatundidf.c: Likewise.
* soft-fp/floatundisf.c: Likewise.
* soft-fp/floatunditf.c: Likewise.
* soft-fp/floatunsidf.c: Likewise.
* soft-fp/floatunsisf.c: Likewise.
* soft-fp/floatunsitf.c: Likewise.
* soft-fp/floatuntidf.c: Likewise.
* soft-fp/floatuntisf.c: Likewise.
* soft-fp/floatuntitf.c: Likewise.
* soft-fp/fmadf4.c: Likewise.
* soft-fp/fmasf4.c: Likewise.
* soft-fp/fmatf4.c: Likewise.
* soft-fp/gedf2.c: Likewise.
* soft-fp/gesf2.c: Likewise.
* soft-fp/getf2.c: Likewise.
* soft-fp/ledf2.c: Likewise.
* soft-fp/lesf2.c: Likewise.
* soft-fp/letf2.c: Likewise.
* soft-fp/muldf3.c: Likewise.
* soft-fp/mulsf3.c: Likewise.
* soft-fp/multf3.c: Likewise.
* soft-fp/negdf2.c: Likewise.
* soft-fp/negsf2.c: Likewise.
* soft-fp/negtf2.c: Likewise.
* soft-fp/op-1.h: Likewise.
* soft-fp/op-2.h: Likewise.
* soft-fp/op-4.h: Likewise.
* soft-fp/op-8.h: Likewise.
* soft-fp/op-common.h: Likewise.
* soft-fp/quad.h: Likewise.
* soft-fp/single.h: Likewise.
* soft-fp/soft-fp.h: Likewise.
* soft-fp/sqrtdf2.c: Likewise.
* soft-fp/sqrtsf2.c: Likewise.
* soft-fp/sqrttf2.c: Likewise.
* soft-fp/subdf3.c: Likewise.
* soft-fp/subsf3.c: Likewise.
* soft-fp/subtf3.c: Likewise.
* soft-fp/truncdfsf2.c: Likewise.
* soft-fp/trunctfdf2.c: Likewise.
* soft-fp/trunctfsf2.c: Likewise.
* soft-fp/trunctfxf2.c: Likewise.
* soft-fp/unorddf2.c: Likewise.
* soft-fp/unordsf2.c: Likewise.
* soft-fp/unordtf2.c: Likewise.
2013-10-15 Joseph Myers <joseph@codesourcery.com>
* soft-fp/op-2.h (_FP_DIV_MEAT_2_gmp): Remove macro.

16
soft-fp/adddf3.c
View File

@ -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;

16
soft-fp/addsf3.c
View File

@ -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;

16
soft-fp/addtf3.c
View File

@ -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;

16
soft-fp/divdf3.c
View File

@ -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;

16
soft-fp/divsf3.c
View File

@ -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;

16
soft-fp/divtf3.c
View File

@ -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;

206
soft-fp/double.h
View File

@ -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 */

18
soft-fp/eqdf2.c
View File

@ -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);

18
soft-fp/eqsf2.c
View File

@ -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);

18
soft-fp/eqtf2.c
View File

@ -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);

14
soft-fp/extenddftf2.c
View File

@ -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;

260
soft-fp/extended.h
View File

@ -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)

14
soft-fp/extendsfdf2.c
View File

@ -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;

14
soft-fp/extendsftf2.c
View File

@ -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;

14
soft-fp/extendxftf2.c
View File

@ -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;

8
soft-fp/fixdfdi.c
View File

@ -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;

8
soft-fp/fixdfsi.c
View File

@ -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;

8
soft-fp/fixdfti.c
View File

@ -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;

8
soft-fp/fixsfdi.c
View File

@ -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;

8
soft-fp/fixsfsi.c
View File

@ -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;

8
soft-fp/fixsfti.c
View File

@ -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;

8
soft-fp/fixtfdi.c
View File

@ -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;

8
soft-fp/fixtfsi.c
View File

@ -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;

8
soft-fp/fixtfti.c
View File

@ -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;

8
soft-fp/fixunsdfdi.c
View File

@ -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;

8
soft-fp/fixunsdfsi.c
View File

@ -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;

8
soft-fp/fixunsdfti.c
View File

@ -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;

8
soft-fp/fixunssfdi.c
View File

@ -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;

8
soft-fp/fixunssfsi.c
View File

@ -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;

8
soft-fp/fixunssfti.c
View File

@ -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;

8
soft-fp/fixunstfdi.c
View File

@ -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;

8
soft-fp/fixunstfsi.c
View File

@ -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;

8
soft-fp/fixunstfti.c
View File

@ -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;

8
soft-fp/floatdidf.c
View File

@ -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;

8
soft-fp/floatdisf.c
View File

@ -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;

8
soft-fp/floatditf.c
View File

@ -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;
}

8
soft-fp/floatsidf.c
View File

@ -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;
}

8
soft-fp/floatsisf.c
View File

@ -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;

8
soft-fp/floatsitf.c
View File

@ -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;
}

8
soft-fp/floattidf.c
View File

@ -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;

8
soft-fp/floattisf.c
View File

@ -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;

8
soft-fp/floattitf.c
View File

@ -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;

8
soft-fp/floatundidf.c
View File

@ -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;

8
soft-fp/floatundisf.c
View File

@ -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;

8
soft-fp/floatunditf.c
View File

@ -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;
}

8
soft-fp/floatunsidf.c
View File

@ -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;
}

8
soft-fp/floatunsisf.c
View File

@ -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;

8
soft-fp/floatunsitf.c
View File

@ -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;
}

8
soft-fp/floatuntidf.c
View File

@ -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;

8
soft-fp/floatuntisf.c
View File

@ -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;

8
soft-fp/floatuntitf.c
View File

@ -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;

18
soft-fp/fmadf4.c
View File

@ -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;

18
soft-fp/fmasf4.c
View File

@ -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;

18
soft-fp/fmatf4.c
View File

@ -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;

16
soft-fp/gedf2.c
View File

@ -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);

16
soft-fp/gesf2.c
View File

@ -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);

16
soft-fp/getf2.c
View File

@ -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);

16
soft-fp/ledf2.c
View File

@ -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);

16
soft-fp/lesf2.c
View File

@ -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);

16
soft-fp/letf2.c
View File

@ -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);

16
soft-fp/muldf3.c
View File

@ -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;

16
soft-fp/mulsf3.c
View File

@ -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;

16
soft-fp/multf3.c
View File

@ -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;

12
soft-fp/negdf2.c
View File

@ -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;
}

12
soft-fp/negsf2.c
View File

@ -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;
}

12
soft-fp/negtf2.c
View File

@ -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;
}

84
soft-fp/op-1.h
View File

@ -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) \

360
soft-fp/op-2.h
View File

@ -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_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_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_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_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_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_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_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_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_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_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)

434
soft-fp/op-4.h
View File

@ -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)

8
soft-fp/op-8.h
View File

@ -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; \

900
soft-fp/op-common.h
View File

File diff suppressed because it is too large Load Diff

206
soft-fp/quad.h
View File

@ -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 */

114
soft-fp/single.h
View File

@ -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

62
soft-fp/soft-fp.h
View File

@ -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

12
soft-fp/sqrtdf2.c
View File

@ -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;

12
soft-fp/sqrtsf2.c
View File

@ -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;

12
soft-fp/sqrttf2.c
View File

@ -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;

16
soft-fp/subdf3.c
View File

@ -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;

16
soft-fp/subsf3.c
View File

@ -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;

16
soft-fp/subtf3.c
View File

@ -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;

14
soft-fp/truncdfsf2.c
View File

@ -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;

14
soft-fp/trunctfdf2.c
View File

@ -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;

14
soft-fp/trunctfsf2.c
View File

@ -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;

14
soft-fp/trunctfxf2.c
View File

@ -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;

16
soft-fp/unorddf2.c
View File

@ -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;

16
soft-fp/unordsf2.c
View File

@ -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;

16
soft-fp/unordtf2.c
View File

@ -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;