procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

float128-cmp-invalid.c, [...]: New tests.

Browse source 
gcc/testsuite:
	* gcc.dg/torture/float128-cmp-invalid.c,
	gcc.dg/torture/float128-div-underflow.c,
	gcc.dg/torture/float128-extend-nan.c,
	gcc.dg/torture/fp-int-convert-float128-timode-3.c: New tests.

libgcc:
	* soft-fp/README: Update.
	* soft-fp/adddf3.c: Update from glibc.
	* 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/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/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.

From-SVN: r204489
This commit is contained in:
Joseph Myers 2013-11-06 22:46:39 +00:00 • committed by Joseph Myers
parent 3c40bae1c5
commit 9954c743b9
88 changed files with 4681 additions and 3680 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
gcc/testsuite/ChangeLog
View file

@ -1,3 +1,10 @@
2013-11-06 Joseph Myers <joseph@codesourcery.com>
* gcc.dg/torture/float128-cmp-invalid.c,
gcc.dg/torture/float128-div-underflow.c,
gcc.dg/torture/float128-extend-nan.c,
gcc.dg/torture/fp-int-convert-float128-timode-3.c: New tests.
2013-11-06 Oleg Endo <olegendo@gcc.gnu.org>
* gcc.target/sh/pr51244-11.c: Remove target line.

18
gcc/testsuite/gcc.dg/torture/float128-cmp-invalid.c Normal file
View file

@ -0,0 +1,18 @@
/* Test for "invalid" exceptions from __float128 comparisons. */
/* { dg-do run { target i?86-*-* x86_64-*-* ia64-*-* } } */
/* { dg-options "" } */
#include <fenv.h>
#include <stdlib.h>
int
main (void)
{
volatile __float128 a = __builtin_nan (""), b = 0;
volatile int r = a < b;
if (!fetestexcept (FE_INVALID))
abort ();
if (r)
abort ();
exit (0);
}

18
gcc/testsuite/gcc.dg/torture/float128-div-underflow.c Normal file
View file

@ -0,0 +1,18 @@
/* Test for spurious underflow from __float128 division. */
/* { dg-do run { target i?86-*-* x86_64-*-* ia64-*-* } } */
/* { dg-options "" } */
#include <fenv.h>
#include <stdlib.h>
int
main (void)
{
volatile __float128 a = 0x0.fffp-16382q, b = 0x0.fffp0q, c;
c = a / b;
if (fetestexcept (FE_UNDERFLOW | FE_INEXACT))
abort ();
if (c != 0x1p-16382q)
abort ();
exit (0);
}

22
gcc/testsuite/gcc.dg/torture/float128-extend-nan.c Normal file
View file

@ -0,0 +1,22 @@
/* Test extensions to __float128 quiet signaling NaNs. */
/* { dg-do run { target i?86-*-* x86_64-*-* ia64-*-* } } */
/* { dg-options "-fsignaling-nans" } */
#include <fenv.h>
#include <float.h>
#include <stdlib.h>
volatile long double a = __builtin_nansl ("");
int
main (void)
{
#if LDBL_MANT_DIG < 113
volatile __float128 r = a;
feclearexcept (FE_INVALID);
r += 1;
if (fetestexcept (FE_INVALID))
abort ();
#endif
exit (0);
}

23
gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-timode-3.c Normal file
View file

@ -0,0 +1,23 @@
/* Test for correct rounding of conversions from __int128 to
__float128. */
/* { dg-do run { target i?86-*-* x86_64-*-* ia64-*-* } } */
/* { dg-require-effective-target int128 } */
/* { dg-options "-frounding-math" } */
#include <fenv.h>
#include <stdlib.h>
int
main (void)
{
volatile unsigned long long h = -1ULL;
volatile unsigned __int128 u128 = (((unsigned __int128) h) << 64) | h;
volatile __int128 s128 = u128 >> 1;
fesetround (FE_TOWARDZERO);
__float128 ru = u128, rs = s128;
if (ru != 0x1.ffffffffffffffffffffffffffffp127q)
abort ();
if (rs != 0x1.ffffffffffffffffffffffffffffp126q)
abort ();
exit (0);
}

85
libgcc/ChangeLog
View file

@ -1,3 +1,88 @@
2013-11-06 Joseph Myers <joseph@codesourcery.com>
* soft-fp/README: Update.
* soft-fp/adddf3.c: Update from glibc.
* 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/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/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-11-05 Uros Bizjak <ubizjak@gmail.com>
* config/i386/32/sfp-machine.h (_FP_MUL_MEAT_S): Define.

9
libgcc/soft-fp/README
View file

@ -1,5 +1,4 @@
Except for conversions involving TImode and conversions involving
XFmode, the files in this directory are part of the GNU C Library, not part
of GCC. As described at <http://gcc.gnu.org/codingconventions.html>, changes
should be made to the GNU C Library and the changed files then imported
into GCC.
The files in this directory are part of the GNU C Library, not part of
GCC. As described at <http://gcc.gnu.org/codingconventions.html>,
changes should be made to the GNU C Library and the changed files then
imported into GCC.

15
libgcc/soft-fp/adddf3.c
View file

@ -31,17 +31,20 @@
#include "soft-fp.h"
#include "double.h"
DFtype __adddf3(DFtype a, DFtype b)
DFtype
__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;

15
libgcc/soft-fp/addsf3.c
View file

@ -31,17 +31,20 @@
#include "soft-fp.h"
#include "single.h"
SFtype __addsf3(SFtype a, SFtype b)
SFtype
__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;

15
libgcc/soft-fp/addtf3.c
View file

@ -31,17 +31,20 @@
#include "soft-fp.h"
#include "quad.h"
TFtype __addtf3(TFtype a, TFtype b)
TFtype
__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;

15
libgcc/soft-fp/divdf3.c
View file

@ -31,17 +31,20 @@
#include "soft-fp.h"
#include "double.h"
DFtype __divdf3(DFtype a, DFtype b)
DFtype
__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;

15
libgcc/soft-fp/divsf3.c
View file

@ -31,17 +31,20 @@
#include "soft-fp.h"
#include "single.h"
SFtype __divsf3(SFtype a, SFtype b)
SFtype
__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;

15
libgcc/soft-fp/divtf3.c
View file

@ -31,17 +31,20 @@
#include "soft-fp.h"
#include "quad.h"
TFtype __divtf3(TFtype a, TFtype b)
TFtype
__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;

353
libgcc/soft-fp/double.h
View file

@ -31,13 +31,15 @@
<http://www.gnu.org/licenses/>. */
#if _FP_W_TYPE_SIZE < 32
#error "Here's a nickel kid. Go buy yourself a real computer."
# error "Here's a nickel kid. Go buy yourself a real computer."
#endif
#if _FP_W_TYPE_SIZE < 64
#define _FP_FRACTBITS_D (2 * _FP_W_TYPE_SIZE)
# define _FP_FRACTBITS_D (2 * _FP_W_TYPE_SIZE)
# define _FP_FRACTBITS_DW_D (4 * _FP_W_TYPE_SIZE)
#else
#define _FP_FRACTBITS_D _FP_W_TYPE_SIZE
# define _FP_FRACTBITS_D _FP_W_TYPE_SIZE
# define _FP_FRACTBITS_DW_D (2 * _FP_W_TYPE_SIZE)
#endif
#define _FP_FRACBITS_D 53
@ -49,215 +51,264 @@
#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)
typedef float DFtype __attribute__((mode(DF)));
#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)
typedef float DFtype __attribute__ ((mode (DF)));
#if _FP_W_TYPE_SIZE < 64
union _FP_UNION_D
{
DFtype flt;
struct _FP_STRUCT_LAYOUT {
#if __BYTE_ORDER == __BIG_ENDIAN
struct _FP_STRUCT_LAYOUT
{
# if __BYTE_ORDER == __BIG_ENDIAN
unsigned sign : 1;
unsigned exp : _FP_EXPBITS_D;
unsigned frac1 : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0) - _FP_W_TYPE_SIZE;
unsigned frac0 : _FP_W_TYPE_SIZE;
#else
# else
unsigned frac0 : _FP_W_TYPE_SIZE;
unsigned frac1 : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0) - _FP_W_TYPE_SIZE;
unsigned exp : _FP_EXPBITS_D;
unsigned sign : 1;
#endif
} bits __attribute__((packed));
# endif
} 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) \
do { \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_2_P(D,val,X); \
} while (0)
# 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); \
} \
while (0)
#define FP_UNPACK_D(X,val) \
do { \
_FP_UNPACK_RAW_2(D,X,val); \
_FP_UNPACK_CANONICAL(D,2,X); \
} while (0)
# define FP_UNPACK_D(X, val) \
do \
{ \
_FP_UNPACK_RAW_2 (D, X, val); \
_FP_UNPACK_CANONICAL (D, 2, X); \
} \
while (0)
#define FP_UNPACK_DP(X,val) \
do { \
_FP_UNPACK_RAW_2_P(D,X,val); \
_FP_UNPACK_CANONICAL(D,2,X); \
} while (0)
# define FP_UNPACK_DP(X, val) \
do \
{ \
_FP_UNPACK_RAW_2_P (D, X, val); \
_FP_UNPACK_CANONICAL (D, 2, X); \
} \
while (0)
#define FP_UNPACK_SEMIRAW_D(X,val) \
do { \
_FP_UNPACK_RAW_2(D,X,val); \
_FP_UNPACK_SEMIRAW(D,2,X); \
} while (0)
# define FP_UNPACK_SEMIRAW_D(X, val) \
do \
{ \
_FP_UNPACK_RAW_2 (D, X, val); \
_FP_UNPACK_SEMIRAW (D, 2, X); \
} \
while (0)
#define FP_UNPACK_SEMIRAW_DP(X,val) \
do { \
_FP_UNPACK_RAW_2_P(D,X,val); \
_FP_UNPACK_SEMIRAW(D,2,X); \
} while (0)
# define FP_UNPACK_SEMIRAW_DP(X, val) \
do \
{ \
_FP_UNPACK_RAW_2_P (D, X, val); \
_FP_UNPACK_SEMIRAW (D, 2, X); \
} \
while (0)
#define FP_PACK_D(val,X) \
do { \
_FP_PACK_CANONICAL(D,2,X); \
_FP_PACK_RAW_2(D,val,X); \
} while (0)
# define FP_PACK_D(val, X) \
do \
{ \
_FP_PACK_CANONICAL (D, 2, X); \
_FP_PACK_RAW_2 (D, val, X); \
} \
while (0)
#define FP_PACK_DP(val,X) \
do { \
_FP_PACK_CANONICAL(D,2,X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_2_P(D,val,X); \
} while (0)
# define FP_PACK_DP(val, X) \
do \
{ \
_FP_PACK_CANONICAL (D, 2, X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_2_P (D, val, X); \
} \
while (0)
#define FP_PACK_SEMIRAW_D(val,X) \
do { \
_FP_PACK_SEMIRAW(D,2,X); \
_FP_PACK_RAW_2(D,val,X); \
} while (0)
# define FP_PACK_SEMIRAW_D(val, X) \
do \
{ \
_FP_PACK_SEMIRAW (D, 2, X); \
_FP_PACK_RAW_2 (D, val, X); \
} \
while (0)
#define FP_PACK_SEMIRAW_DP(val,X) \
do { \
_FP_PACK_SEMIRAW(D,2,X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_2_P(D,val,X); \
} while (0)
# define FP_PACK_SEMIRAW_DP(val, X) \
do \
{ \
_FP_PACK_SEMIRAW (D, 2, X); \
if (!FP_INHIBIT_RESULTS) \
_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_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)
#else
union _FP_UNION_D
{
DFtype flt;
struct _FP_STRUCT_LAYOUT {
#if __BYTE_ORDER == __BIG_ENDIAN
struct _FP_STRUCT_LAYOUT
{
# if __BYTE_ORDER == __BIG_ENDIAN
unsigned sign : 1;
unsigned exp : _FP_EXPBITS_D;
_FP_W_TYPE frac : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0);
#else
# else
_FP_W_TYPE frac : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0);
unsigned exp : _FP_EXPBITS_D;
unsigned sign : 1;
#endif
} bits __attribute__((packed));
# endif
} 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) \
do { \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_1_P(D,val,X); \
} while (0)
# 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); \
} \
while (0)
#define FP_UNPACK_D(X,val) \
do { \
_FP_UNPACK_RAW_1(D,X,val); \
_FP_UNPACK_CANONICAL(D,1,X); \
} while (0)
# define FP_UNPACK_D(X, val) \
do \
{ \
_FP_UNPACK_RAW_1 (D, X, val); \
_FP_UNPACK_CANONICAL (D, 1, X); \
} \
while (0)
#define FP_UNPACK_DP(X,val) \
do { \
_FP_UNPACK_RAW_1_P(D,X,val); \
_FP_UNPACK_CANONICAL(D,1,X); \
} while (0)
# define FP_UNPACK_DP(X, val) \
do \
{ \
_FP_UNPACK_RAW_1_P (D, X, val); \
_FP_UNPACK_CANONICAL (D, 1, X); \
} \
while (0)
#define FP_UNPACK_SEMIRAW_D(X,val) \
do { \
_FP_UNPACK_RAW_1(D,X,val); \
_FP_UNPACK_SEMIRAW(D,1,X); \
} while (0)
# define FP_UNPACK_SEMIRAW_D(X, val) \
do \
{ \
_FP_UNPACK_RAW_1 (D, X, val); \
_FP_UNPACK_SEMIRAW (D, 1, X); \
} \
while (0)
#define FP_UNPACK_SEMIRAW_DP(X,val) \
do { \
_FP_UNPACK_RAW_1_P(D,X,val); \
_FP_UNPACK_SEMIRAW(D,1,X); \
} while (0)
# define FP_UNPACK_SEMIRAW_DP(X, val) \
do \
{ \
_FP_UNPACK_RAW_1_P (D, X, val); \
_FP_UNPACK_SEMIRAW (D, 1, X); \
} \
while (0)
#define FP_PACK_D(val,X) \
do { \
_FP_PACK_CANONICAL(D,1,X); \
_FP_PACK_RAW_1(D,val,X); \
} while (0)
# define FP_PACK_D(val, X) \
do \
{ \
_FP_PACK_CANONICAL (D, 1, X); \
_FP_PACK_RAW_1 (D, val, X); \
} \
while (0)
#define FP_PACK_DP(val,X) \
do { \
_FP_PACK_CANONICAL(D,1,X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_1_P(D,val,X); \
} while (0)
# define FP_PACK_DP(val, X) \
do \
{ \
_FP_PACK_CANONICAL (D, 1, X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_1_P (D, val, X); \
} \
while (0)
#define FP_PACK_SEMIRAW_D(val,X) \
do { \
_FP_PACK_SEMIRAW(D,1,X); \
_FP_PACK_RAW_1(D,val,X); \
} while (0)
# define FP_PACK_SEMIRAW_D(val, X) \
do \
{ \
_FP_PACK_SEMIRAW (D, 1, X); \
_FP_PACK_RAW_1 (D, val, X); \
} \
while (0)
#define FP_PACK_SEMIRAW_DP(val,X) \
do { \
_FP_PACK_SEMIRAW(D,1,X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_1_P(D,val,X); \
} while (0)
# define FP_PACK_SEMIRAW_DP(val, X) \
do \
{ \
_FP_PACK_SEMIRAW (D, 1, X); \
if (!FP_INHIBIT_RESULTS) \
_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_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)
#endif /* W_TYPE_SIZE < 64 */

19
libgcc/soft-fp/eqdf2.c
View file

@ -31,20 +31,23 @@
#include "soft-fp.h"
#include "double.h"
CMPtype __eqdf2(DFtype a, DFtype b)
CMPtype
__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_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_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_HANDLE_EXCEPTIONS;
return r;
}
strong_alias(__eqdf2, __nedf2);
strong_alias (__eqdf2, __nedf2);

19
libgcc/soft-fp/eqsf2.c
View file

@ -31,20 +31,23 @@
#include "soft-fp.h"
#include "single.h"
CMPtype __eqsf2(SFtype a, SFtype b)
CMPtype
__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_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_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_HANDLE_EXCEPTIONS;
return r;
}
strong_alias(__eqsf2, __nesf2);
strong_alias (__eqsf2, __nesf2);

19
libgcc/soft-fp/eqtf2.c
View file

@ -31,20 +31,23 @@
#include "soft-fp.h"
#include "quad.h"
CMPtype __eqtf2(TFtype a, TFtype b)
CMPtype
__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_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_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_HANDLE_EXCEPTIONS;
return r;
}
strong_alias(__eqtf2, __netf2);
strong_alias (__eqtf2, __netf2);

17
libgcc/soft-fp/extenddftf2.c
View file

@ -32,21 +32,22 @@
#include "double.h"
#include "quad.h"
TFtype __extenddftf2(DFtype a)
TFtype
__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_ROUNDMODE;
FP_UNPACK_RAW_D(A, a);
FP_INIT_EXCEPTIONS;
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;

676
libgcc/soft-fp/extended.h
View file

@ -28,13 +28,15 @@
<http://www.gnu.org/licenses/>. */
#if _FP_W_TYPE_SIZE < 32
#error "Here's a nickel, kid. Go buy yourself a real computer."
# error "Here's a nickel, kid. Go buy yourself a real computer."
#endif
#if _FP_W_TYPE_SIZE < 64
#define _FP_FRACTBITS_E (4*_FP_W_TYPE_SIZE)
# define _FP_FRACTBITS_E (4*_FP_W_TYPE_SIZE)
# define _FP_FRACTBITS_DW_E (8*_FP_W_TYPE_SIZE)
#else
#define _FP_FRACTBITS_E (2*_FP_W_TYPE_SIZE)
# define _FP_FRACTBITS_E (2*_FP_W_TYPE_SIZE)
# define _FP_FRACTBITS_DW_E (4*_FP_W_TYPE_SIZE)
#endif
#define _FP_FRACBITS_E 64
@ -46,152 +48,187 @@
#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))
typedef float XFtype __attribute__((mode(XF)));
#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)
typedef float XFtype __attribute__ ((mode (XF)));
#if _FP_W_TYPE_SIZE < 64
union _FP_UNION_E
{
XFtype flt;
struct _FP_STRUCT_LAYOUT
{
#if __BYTE_ORDER == __BIG_ENDIAN
unsigned long pad1 : _FP_W_TYPE_SIZE;
unsigned long pad2 : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
unsigned long sign : 1;
unsigned long exp : _FP_EXPBITS_E;
unsigned long frac1 : _FP_W_TYPE_SIZE;
unsigned long frac0 : _FP_W_TYPE_SIZE;
#else
unsigned long frac0 : _FP_W_TYPE_SIZE;
unsigned long frac1 : _FP_W_TYPE_SIZE;
unsigned exp : _FP_EXPBITS_E;
unsigned sign : 1;
#endif /* not bigendian */
} bits __attribute__((packed));
XFtype flt;
struct _FP_STRUCT_LAYOUT
{
# if __BYTE_ORDER == __BIG_ENDIAN
unsigned long pad1 : _FP_W_TYPE_SIZE;
unsigned long pad2 : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
unsigned long sign : 1;
unsigned long exp : _FP_EXPBITS_E;
unsigned long frac1 : _FP_W_TYPE_SIZE;
unsigned long frac0 : _FP_W_TYPE_SIZE;
# else
unsigned long frac0 : _FP_W_TYPE_SIZE;
unsigned long frac1 : _FP_W_TYPE_SIZE;
unsigned exp : _FP_EXPBITS_E;
unsigned sign : 1;
# endif /* not bigendian */
} 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 { \
union _FP_UNION_E _flo; _flo.flt = (val); \
\
X##_f[2] = 0; X##_f[3] = 0; \
X##_f[0] = _flo.bits.frac0; \
X##_f[1] = _flo.bits.frac1; \
X##_e = _flo.bits.exp; \
X##_s = _flo.bits.sign; \
} while (0)
# define FP_UNPACK_RAW_E(X, val) \
do \
{ \
union _FP_UNION_E _flo; \
_flo.flt = (val); \
\
X##_f[2] = 0; \
X##_f[3] = 0; \
X##_f[0] = _flo.bits.frac0; \
X##_f[1] = _flo.bits.frac1; \
X##_e = _flo.bits.exp; \
X##_s = _flo.bits.sign; \
} \
while (0)
#define FP_UNPACK_RAW_EP(X, val) \
do { \
union _FP_UNION_E *_flo = \
(union _FP_UNION_E *)(val); \
\
X##_f[2] = 0; X##_f[3] = 0; \
X##_f[0] = _flo->bits.frac0; \
X##_f[1] = _flo->bits.frac1; \
X##_e = _flo->bits.exp; \
X##_s = _flo->bits.sign; \
} while (0)
# define FP_UNPACK_RAW_EP(X, val) \
do \
{ \
union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val); \
\
X##_f[2] = 0; \
X##_f[3] = 0; \
X##_f[0] = _flo->bits.frac0; \
X##_f[1] = _flo->bits.frac1; \
X##_e = _flo->bits.exp; \
X##_s = _flo->bits.sign; \
} \
while (0)
#define FP_PACK_RAW_E(val, X) \
do { \
union _FP_UNION_E _flo; \
\
if (X##_e) X##_f[1] |= _FP_IMPLBIT_E; \
else X##_f[1] &= ~(_FP_IMPLBIT_E); \
_flo.bits.frac0 = X##_f[0]; \
_flo.bits.frac1 = X##_f[1]; \
_flo.bits.exp = X##_e; \
_flo.bits.sign = X##_s; \
\
(val) = _flo.flt; \
} while (0)
# define FP_PACK_RAW_E(val, X) \
do \
{ \
union _FP_UNION_E _flo; \
\
if (X##_e) \
X##_f[1] |= _FP_IMPLBIT_E; \
else \
X##_f[1] &= ~(_FP_IMPLBIT_E); \
_flo.bits.frac0 = X##_f[0]; \
_flo.bits.frac1 = X##_f[1]; \
_flo.bits.exp = X##_e; \
_flo.bits.sign = X##_s; \
\
(val) = _flo.flt; \
} \
while (0)
#define FP_PACK_RAW_EP(val, X) \
do { \
if (!FP_INHIBIT_RESULTS) \
{ \
union _FP_UNION_E *_flo = \
(union _FP_UNION_E *)(val); \
\
if (X##_e) X##_f[1] |= _FP_IMPLBIT_E; \
else X##_f[1] &= ~(_FP_IMPLBIT_E); \
_flo->bits.frac0 = X##_f[0]; \
_flo->bits.frac1 = X##_f[1]; \
_flo->bits.exp = X##_e; \
_flo->bits.sign = X##_s; \
} \
} 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; \
} \
} \
while (0)
#define FP_UNPACK_E(X,val) \
do { \
FP_UNPACK_RAW_E(X,val); \
_FP_UNPACK_CANONICAL(E,4,X); \
} while (0)
# define FP_UNPACK_E(X, val) \
do \
{ \
FP_UNPACK_RAW_E (X, val); \
_FP_UNPACK_CANONICAL (E, 4, X); \
} \
while (0)
#define FP_UNPACK_EP(X,val) \
do { \
FP_UNPACK_RAW_EP(X,val); \
_FP_UNPACK_CANONICAL(E,4,X); \
} while (0)
# define FP_UNPACK_EP(X, val) \
do \
{ \
FP_UNPACK_RAW_EP (X, val); \
_FP_UNPACK_CANONICAL (E, 4, X); \
} \
while (0)
#define FP_UNPACK_SEMIRAW_E(X,val) \
do { \
FP_UNPACK_RAW_E(X,val); \
_FP_UNPACK_SEMIRAW(E,4,X); \
} while (0)
# define FP_UNPACK_SEMIRAW_E(X, val) \
do \
{ \
FP_UNPACK_RAW_E (X, val); \
_FP_UNPACK_SEMIRAW (E, 4, X); \
} \
while (0)
#define FP_UNPACK_SEMIRAW_EP(X,val) \
do { \
FP_UNPACK_RAW_EP(X,val); \
_FP_UNPACK_SEMIRAW(E,4,X); \
} while (0)
# define FP_UNPACK_SEMIRAW_EP(X, val) \
do \
{ \
FP_UNPACK_RAW_EP (X, val); \
_FP_UNPACK_SEMIRAW (E, 4, X); \
} \
while (0)
#define FP_PACK_E(val,X) \
do { \
_FP_PACK_CANONICAL(E,4,X); \
FP_PACK_RAW_E(val,X); \
} while (0)
# define FP_PACK_E(val, X) \
do \
{ \
_FP_PACK_CANONICAL (E, 4, X); \
FP_PACK_RAW_E (val, X); \
} \
while (0)
#define FP_PACK_EP(val,X) \
do { \
_FP_PACK_CANONICAL(E,4,X); \
FP_PACK_RAW_EP(val,X); \
} while (0)
# define FP_PACK_EP(val, X) \
do \
{ \
_FP_PACK_CANONICAL (E, 4, X); \
FP_PACK_RAW_EP (val, X); \
} \
while (0)
#define FP_PACK_SEMIRAW_E(val,X) \
do { \
_FP_PACK_SEMIRAW(E,4,X); \
FP_PACK_RAW_E(val,X); \
} while (0)
# define FP_PACK_SEMIRAW_E(val, X) \
do \
{ \
_FP_PACK_SEMIRAW (E, 4, X); \
FP_PACK_RAW_E (val, X); \
} \
while (0)
#define FP_PACK_SEMIRAW_EP(val,X) \
do { \
_FP_PACK_SEMIRAW(E,4,X); \
FP_PACK_RAW_EP(val,X); \
} while (0)
# define FP_PACK_SEMIRAW_EP(val, X) \
do \
{ \
_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_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:
@ -204,185 +241,218 @@ union _FP_UNION_E
* in two UWtype registers instead of four.
*/
#define _FP_SQRT_MEAT_E(R, S, T, X, q) \
do { \
q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1); \
_FP_FRAC_SRL_4(X, (_FP_WORKBITS)); \
while (q) \
{ \
T##_f[1] = S##_f[1] + q; \
if (T##_f[1] <= X##_f[1]) \
{ \
S##_f[1] = T##_f[1] + q; \
X##_f[1] -= T##_f[1]; \
R##_f[1] += q; \
} \
_FP_FRAC_SLL_2(X, 1); \
q >>= 1; \
} \
q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1); \
while (q) \
{ \
T##_f[0] = S##_f[0] + q; \
T##_f[1] = S##_f[1]; \
if (T##_f[1] < X##_f[1] || \
(T##_f[1] == X##_f[1] && \
T##_f[0] <= X##_f[0])) \
{ \
S##_f[0] = T##_f[0] + q; \
S##_f[1] += (T##_f[0] > S##_f[0]); \
_FP_FRAC_DEC_2(X, T); \
R##_f[0] += q; \
} \
_FP_FRAC_SLL_2(X, 1); \
q >>= 1; \
} \
_FP_FRAC_SLL_4(R, (_FP_WORKBITS)); \
if (X##_f[0] | X##_f[1]) \
{ \
if (S##_f[1] < X##_f[1] || \
(S##_f[1] == X##_f[1] && \
S##_f[0] < X##_f[0])) \
R##_f[0] |= _FP_WORK_ROUND; \
R##_f[0] |= _FP_WORK_STICKY; \
} \
} while (0)
# 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)); \
while (q) \
{ \
T##_f[1] = S##_f[1] + q; \
if (T##_f[1] <= X##_f[1]) \
{ \
S##_f[1] = T##_f[1] + q; \
X##_f[1] -= T##_f[1]; \
R##_f[1] += q; \
} \
_FP_FRAC_SLL_2 (X, 1); \
q >>= 1; \
} \
q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \
while (q) \
{ \
T##_f[0] = S##_f[0] + q; \
T##_f[1] = S##_f[1]; \
if (T##_f[1] < X##_f[1] \
|| (T##_f[1] == X##_f[1] \
&& T##_f[0] <= X##_f[0])) \
{ \
S##_f[0] = T##_f[0] + q; \
S##_f[1] += (T##_f[0] > S##_f[0]); \
_FP_FRAC_DEC_2 (X, T); \
R##_f[0] += q; \
} \
_FP_FRAC_SLL_2 (X, 1); \
q >>= 1; \
} \
_FP_FRAC_SLL_4 (R, (_FP_WORKBITS)); \
if (X##_f[0] | X##_f[1]) \
{ \
if (S##_f[1] < X##_f[1] \
|| (S##_f[1] == X##_f[1] \
&& S##_f[0] < X##_f[0])) \
R##_f[0] |= _FP_WORK_ROUND; \
R##_f[0] |= _FP_WORK_STICKY; \
} \
} \
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])
# define _FP_FRAC_HIGH_E(X) (X##_f[2])
# define _FP_FRAC_HIGH_RAW_E(X) (X##_f[1])
# define _FP_FRAC_HIGH_DW_E(X) (X##_f[4])
#else /* not _FP_W_TYPE_SIZE < 64 */
union _FP_UNION_E
{
XFtype flt;
struct _FP_STRUCT_LAYOUT {
#if __BYTE_ORDER == __BIG_ENDIAN
struct _FP_STRUCT_LAYOUT
{
# if __BYTE_ORDER == __BIG_ENDIAN
_FP_W_TYPE pad : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
unsigned sign : 1;
unsigned exp : _FP_EXPBITS_E;
_FP_W_TYPE frac : _FP_W_TYPE_SIZE;
#else
# else
_FP_W_TYPE frac : _FP_W_TYPE_SIZE;
unsigned exp : _FP_EXPBITS_E;
unsigned sign : 1;
#endif
# endif
} 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 { \
union _FP_UNION_E _flo; _flo.flt = (val); \
# define FP_UNPACK_RAW_E(X, val) \
do \
{ \
union _FP_UNION_E _flo; \
_flo.flt = (val); \
\
X##_f0 = _flo.bits.frac; \
X##_f1 = 0; \
X##_e = _flo.bits.exp; \
X##_s = _flo.bits.sign; \
} \
while (0)
# define FP_UNPACK_RAW_EP(X, val) \
do \
{ \
union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val); \
\
X##_f0 = _flo.bits.frac; \
X##_f1 = 0; \
X##_e = _flo.bits.exp; \
X##_s = _flo.bits.sign; \
} while (0)
X##_f0 = _flo->bits.frac; \
X##_f1 = 0; \
X##_e = _flo->bits.exp; \
X##_s = _flo->bits.sign; \
} \
while (0)
#define FP_UNPACK_RAW_EP(X, val) \
do { \
union _FP_UNION_E *_flo = \
(union _FP_UNION_E *)(val); \
\
X##_f0 = _flo->bits.frac; \
X##_f1 = 0; \
X##_e = _flo->bits.exp; \
X##_s = _flo->bits.sign; \
} while (0)
# define FP_PACK_RAW_E(val, X) \
do \
{ \
union _FP_UNION_E _flo; \
\
if (X##_e) \
X##_f0 |= _FP_IMPLBIT_E; \
else \
X##_f0 &= ~(_FP_IMPLBIT_E); \
_flo.bits.frac = X##_f0; \
_flo.bits.exp = X##_e; \
_flo.bits.sign = X##_s; \
\
(val) = _flo.flt; \
} \
while (0)
#define FP_PACK_RAW_E(val, X) \
do { \
union _FP_UNION_E _flo; \
\
if (X##_e) X##_f0 |= _FP_IMPLBIT_E; \
else X##_f0 &= ~(_FP_IMPLBIT_E); \
_flo.bits.frac = X##_f0; \
_flo.bits.exp = X##_e; \
_flo.bits.sign = X##_s; \
\
(val) = _flo.flt; \
} while (0)
#define FP_PACK_RAW_EP(fs, val, X) \
do { \
if (!FP_INHIBIT_RESULTS) \
{ \
union _FP_UNION_E *_flo = \
(union _FP_UNION_E *)(val); \
\
if (X##_e) X##_f0 |= _FP_IMPLBIT_E; \
else X##_f0 &= ~(_FP_IMPLBIT_E); \
_flo->bits.frac = X##_f0; \
_flo->bits.exp = X##_e; \
_flo->bits.sign = X##_s; \
} \
} 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; \
} \
} \
while (0)
#define FP_UNPACK_E(X,val) \
do { \
FP_UNPACK_RAW_E(X,val); \
_FP_UNPACK_CANONICAL(E,2,X); \
} while (0)
# define FP_UNPACK_E(X, val) \
do \
{ \
FP_UNPACK_RAW_E (X, val); \
_FP_UNPACK_CANONICAL (E, 2, X); \
} \
while (0)
#define FP_UNPACK_EP(X,val) \
do { \
FP_UNPACK_RAW_EP(X,val); \
_FP_UNPACK_CANONICAL(E,2,X); \
} while (0)
# define FP_UNPACK_EP(X, val) \
do \
{ \
FP_UNPACK_RAW_EP (X, val); \
_FP_UNPACK_CANONICAL (E, 2, X); \
} \
while (0)
#define FP_UNPACK_SEMIRAW_E(X,val) \
do { \
FP_UNPACK_RAW_E(X,val); \
_FP_UNPACK_SEMIRAW(E,2,X); \
} while (0)
# define FP_UNPACK_SEMIRAW_E(X, val) \
do \
{ \
FP_UNPACK_RAW_E (X, val); \
_FP_UNPACK_SEMIRAW (E, 2, X); \
} \
while (0)
#define FP_UNPACK_SEMIRAW_EP(X,val) \
do { \
FP_UNPACK_RAW_EP(X,val); \
_FP_UNPACK_SEMIRAW(E,2,X); \
} while (0)
# define FP_UNPACK_SEMIRAW_EP(X, val) \
do \
{ \
FP_UNPACK_RAW_EP (X, val); \
_FP_UNPACK_SEMIRAW (E, 2, X); \
} \
while (0)
#define FP_PACK_E(val,X) \
do { \
_FP_PACK_CANONICAL(E,2,X); \
FP_PACK_RAW_E(val,X); \
} while (0)
# define FP_PACK_E(val, X) \
do \
{ \
_FP_PACK_CANONICAL (E, 2, X); \
FP_PACK_RAW_E (val, X); \
} \
while (0)
#define FP_PACK_EP(val,X) \
do { \
_FP_PACK_CANONICAL(E,2,X); \
FP_PACK_RAW_EP(val,X); \
} while (0)
# define FP_PACK_EP(val, X) \
do \
{ \
_FP_PACK_CANONICAL (E, 2, X); \
FP_PACK_RAW_EP (val, X); \
} \
while (0)
#define FP_PACK_SEMIRAW_E(val,X) \
do { \
_FP_PACK_SEMIRAW(E,2,X); \
FP_PACK_RAW_E(val,X); \
} while (0)
# define FP_PACK_SEMIRAW_E(val, X) \
do \
{ \
_FP_PACK_SEMIRAW (E, 2, X); \
FP_PACK_RAW_E (val, X); \
} \
while (0)
#define FP_PACK_SEMIRAW_EP(val,X) \
do { \
_FP_PACK_SEMIRAW(E,2,X); \
FP_PACK_RAW_EP(val,X); \
} while (0)
# define FP_PACK_SEMIRAW_EP(val, X) \
do \
{ \
_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_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:
@ -392,39 +462,43 @@ union _FP_UNION_E
* in one UWtype registers instead of two, although we don't
* have to.
*/
#define _FP_SQRT_MEAT_E(R, S, T, X, q) \
do { \
q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1); \
_FP_FRAC_SRL_2(X, (_FP_WORKBITS)); \
while (q) \
{ \
T##_f0 = S##_f0 + q; \
if (T##_f0 <= X##_f0) \
{ \
S##_f0 = T##_f0 + q; \
X##_f0 -= T##_f0; \
R##_f0 += q; \
} \
_FP_FRAC_SLL_1(X, 1); \
q >>= 1; \
} \
_FP_FRAC_SLL_2(R, (_FP_WORKBITS)); \
if (X##_f0) \
{ \
if (S##_f0 < X##_f0) \
R##_f0 |= _FP_WORK_ROUND; \
R##_f0 |= _FP_WORK_STICKY; \
} \
} while (0)
# 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)); \
while (q) \
{ \
T##_f0 = S##_f0 + q; \
if (T##_f0 <= X##_f0) \
{ \
S##_f0 = T##_f0 + q; \
X##_f0 -= T##_f0; \
R##_f0 += q; \
} \
_FP_FRAC_SLL_1 (X, 1); \
q >>= 1; \
} \
_FP_FRAC_SLL_2 (R, (_FP_WORKBITS)); \
if (X##_f0) \
{ \
if (S##_f0 < X##_f0) \
R##_f0 |= _FP_WORK_ROUND; \
R##_f0 |= _FP_WORK_STICKY; \
} \
} \
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)
# define _FP_FRAC_HIGH_E(X) (X##_f1)
# define _FP_FRAC_HIGH_RAW_E(X) (X##_f0)
# define _FP_FRAC_HIGH_DW_E(X) (X##_f[2])
#endif /* not _FP_W_TYPE_SIZE < 64 */

17
libgcc/soft-fp/extendsfdf2.c
View file

@ -32,21 +32,22 @@
#include "single.h"
#include "double.h"
DFtype __extendsfdf2(SFtype a)
DFtype
__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_ROUNDMODE;
FP_UNPACK_RAW_S(A, a);
FP_INIT_EXCEPTIONS;
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;

17
libgcc/soft-fp/extendsftf2.c
View file

@ -32,21 +32,22 @@
#include "single.h"
#include "quad.h"
TFtype __extendsftf2(SFtype a)
TFtype
__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_ROUNDMODE;
FP_UNPACK_RAW_S(A, a);
FP_INIT_EXCEPTIONS;
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;

22
libgcc/soft-fp/extendxftf2.c
View file

@ -1,6 +1,6 @@
/* Software floating-point emulation.
Return a converted to IEEE quad
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Uros Bizjak (ubizjak@gmail.com).
@ -24,29 +24,29 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "soft-fp.h"
#include "extended.h"
#include "quad.h"
TFtype __extendxftf2(XFtype a)
TFtype
__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;

10
libgcc/soft-fp/fixdfdi.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "double.h"
DItype __fixdfdi(DFtype a)
DItype
__fixdfdi (DFtype a)
{
FP_DECL_EX;
FP_DECL_D(A);
FP_DECL_D (A);
UDItype r;
FP_UNPACK_RAW_D(A, a);
FP_TO_INT_D(r, A, DI_BITS, 1);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_D (A, a);
FP_TO_INT_D (r, A, DI_BITS, 1);
FP_HANDLE_EXCEPTIONS;
return r;

10
libgcc/soft-fp/fixdfsi.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "double.h"
SItype __fixdfsi(DFtype a)
SItype
__fixdfsi (DFtype a)
{
FP_DECL_EX;
FP_DECL_D(A);
FP_DECL_D (A);
USItype r;
FP_UNPACK_RAW_D(A, a);
FP_TO_INT_D(r, A, SI_BITS, 1);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_D (A, a);
FP_TO_INT_D (r, A, SI_BITS, 1);
FP_HANDLE_EXCEPTIONS;
return r;

17
libgcc/soft-fp/fixdfti.c
View file

@ -1,6 +1,6 @@
/* Software floating-point emulation.
Convert IEEE double to 128bit signed integer
Copyright (C) 2007, 2008 Free Software Foundation, Inc.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Uros Bizjak (ubizjak@gmail.com).
@ -24,21 +24,22 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "soft-fp.h"
#include "double.h"
TItype __fixdfti(DFtype a)
TItype
__fixdfti (DFtype a)
{
FP_DECL_EX;
FP_DECL_D(A);
FP_DECL_D (A);
UTItype r;
FP_UNPACK_RAW_D(A, a);
FP_TO_INT_D(r, A, TI_BITS, 1);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_D (A, a);
FP_TO_INT_D (r, A, TI_BITS, 1);
FP_HANDLE_EXCEPTIONS;
return r;

10
libgcc/soft-fp/fixsfdi.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "single.h"
DItype __fixsfdi(SFtype a)
DItype
__fixsfdi (SFtype a)
{
FP_DECL_EX;
FP_DECL_S(A);
FP_DECL_S (A);
UDItype r;
FP_UNPACK_RAW_S(A, a);
FP_TO_INT_S(r, A, DI_BITS, 1);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_S (A, a);
FP_TO_INT_S (r, A, DI_BITS, 1);
FP_HANDLE_EXCEPTIONS;
return r;

10
libgcc/soft-fp/fixsfsi.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "single.h"
SItype __fixsfsi(SFtype a)
SItype
__fixsfsi (SFtype a)
{
FP_DECL_EX;
FP_DECL_S(A);
FP_DECL_S (A);
USItype r;
FP_UNPACK_RAW_S(A, a);
FP_TO_INT_S(r, A, SI_BITS, 1);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_S (A, a);
FP_TO_INT_S (r, A, SI_BITS, 1);
FP_HANDLE_EXCEPTIONS;
return r;

17
libgcc/soft-fp/fixsfti.c
View file

@ -1,6 +1,6 @@
/* Software floating-point emulation.
Convert IEEE single to 128bit signed integer
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Uros Bizjak (ubizjak@gmail.com).
@ -24,21 +24,22 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "soft-fp.h"
#include "single.h"
TItype __fixsfti(SFtype a)
TItype
__fixsfti (SFtype a)
{
FP_DECL_EX;
FP_DECL_S(A);
FP_DECL_S (A);
UTItype r;
FP_UNPACK_RAW_S(A, a);
FP_TO_INT_S(r, A, TI_BITS, 1);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_S (A, a);
FP_TO_INT_S (r, A, TI_BITS, 1);
FP_HANDLE_EXCEPTIONS;
return r;

10
libgcc/soft-fp/fixtfdi.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "quad.h"
DItype __fixtfdi(TFtype a)
DItype
__fixtfdi (TFtype a)
{
FP_DECL_EX;
FP_DECL_Q(A);
FP_DECL_Q (A);
UDItype r;
FP_UNPACK_RAW_Q(A, a);
FP_TO_INT_Q(r, A, DI_BITS, 1);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_Q (A, a);
FP_TO_INT_Q (r, A, DI_BITS, 1);
FP_HANDLE_EXCEPTIONS;
return r;

10
libgcc/soft-fp/fixtfsi.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "quad.h"
SItype __fixtfsi(TFtype a)
SItype
__fixtfsi (TFtype a)
{
FP_DECL_EX;
FP_DECL_Q(A);
FP_DECL_Q (A);
USItype r;
FP_UNPACK_RAW_Q(A, a);
FP_TO_INT_Q(r, A, SI_BITS, 1);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_Q (A, a);
FP_TO_INT_Q (r, A, SI_BITS, 1);
FP_HANDLE_EXCEPTIONS;
return r;

17
libgcc/soft-fp/fixtfti.c
View file

@ -1,6 +1,6 @@
/* Software floating-point emulation.
Convert IEEE quad to 128bit signed integer
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Uros Bizjak (ubizjak@gmail.com).
@ -24,21 +24,22 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "soft-fp.h"
#include "quad.h"
TItype __fixtfti(TFtype a)
TItype
__fixtfti (TFtype a)
{
FP_DECL_EX;
FP_DECL_Q(A);
FP_DECL_Q (A);
UTItype r;
FP_UNPACK_RAW_Q(A, a);
FP_TO_INT_Q(r, A, TI_BITS, 1);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_Q (A, a);
FP_TO_INT_Q (r, A, TI_BITS, 1);
FP_HANDLE_EXCEPTIONS;
return r;

10
libgcc/soft-fp/fixunsdfdi.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "double.h"
UDItype __fixunsdfdi(DFtype a)
UDItype
__fixunsdfdi (DFtype a)
{
FP_DECL_EX;
FP_DECL_D(A);
FP_DECL_D (A);
UDItype r;
FP_UNPACK_RAW_D(A, a);
FP_TO_INT_D(r, A, DI_BITS, 0);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_D (A, a);
FP_TO_INT_D (r, A, DI_BITS, 0);
FP_HANDLE_EXCEPTIONS;
return r;

10
libgcc/soft-fp/fixunsdfsi.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "double.h"
USItype __fixunsdfsi(DFtype a)
USItype
__fixunsdfsi (DFtype a)
{
FP_DECL_EX;
FP_DECL_D(A);
FP_DECL_D (A);
USItype r;
FP_UNPACK_RAW_D(A, a);
FP_TO_INT_D(r, A, SI_BITS, 0);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_D (A, a);
FP_TO_INT_D (r, A, SI_BITS, 0);
FP_HANDLE_EXCEPTIONS;
return r;

17
libgcc/soft-fp/fixunsdfti.c
View file

@ -1,6 +1,6 @@
/* Software floating-point emulation.
Convert IEEE double to 128bit unsigned integer
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Uros Bizjak (ubizjak@gmail.com).
@ -24,21 +24,22 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "soft-fp.h"
#include "double.h"
UTItype __fixunsdfti(DFtype a)
UTItype
__fixunsdfti (DFtype a)
{
FP_DECL_EX;
FP_DECL_D(A);
FP_DECL_D (A);
UTItype r;
FP_UNPACK_RAW_D(A, a);
FP_TO_INT_D(r, A, TI_BITS, 0);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_D (A, a);
FP_TO_INT_D (r, A, TI_BITS, 0);
FP_HANDLE_EXCEPTIONS;
return r;

10
libgcc/soft-fp/fixunssfdi.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "single.h"
UDItype __fixunssfdi(SFtype a)
UDItype
__fixunssfdi (SFtype a)
{
FP_DECL_EX;
FP_DECL_S(A);
FP_DECL_S (A);
UDItype r;
FP_UNPACK_RAW_S(A, a);
FP_TO_INT_S(r, A, DI_BITS, 0);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_S (A, a);
FP_TO_INT_S (r, A, DI_BITS, 0);
FP_HANDLE_EXCEPTIONS;
return r;

10
libgcc/soft-fp/fixunssfsi.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "single.h"
USItype __fixunssfsi(SFtype a)
USItype
__fixunssfsi (SFtype a)
{
FP_DECL_EX;
FP_DECL_S(A);
FP_DECL_S (A);
USItype r;
FP_UNPACK_RAW_S(A, a);
FP_TO_INT_S(r, A, SI_BITS, 0);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_S (A, a);
FP_TO_INT_S (r, A, SI_BITS, 0);
FP_HANDLE_EXCEPTIONS;
return r;

17
libgcc/soft-fp/fixunssfti.c
View file

@ -1,6 +1,6 @@
/* Software floating-point emulation.
Convert IEEE single to 128bit unsigned integer
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Uros Bizjak (ubizjak@gmail.com).
@ -24,21 +24,22 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "soft-fp.h"
#include "single.h"
UTItype __fixunssfti(SFtype a)
UTItype
__fixunssfti (SFtype a)
{
FP_DECL_EX;
FP_DECL_S(A);
FP_DECL_S (A);
UTItype r;
FP_UNPACK_RAW_S(A, a);
FP_TO_INT_S(r, A, TI_BITS, 0);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_S (A, a);
FP_TO_INT_S (r, A, TI_BITS, 0);
FP_HANDLE_EXCEPTIONS;
return r;

10
libgcc/soft-fp/fixunstfdi.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "quad.h"
UDItype __fixunstfdi(TFtype a)
UDItype
__fixunstfdi (TFtype a)
{
FP_DECL_EX;
FP_DECL_Q(A);
FP_DECL_Q (A);
UDItype r;
FP_UNPACK_RAW_Q(A, a);
FP_TO_INT_Q(r, A, DI_BITS, 0);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_Q (A, a);
FP_TO_INT_Q (r, A, DI_BITS, 0);
FP_HANDLE_EXCEPTIONS;
return r;

10
libgcc/soft-fp/fixunstfsi.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "quad.h"
USItype __fixunstfsi(TFtype a)
USItype
__fixunstfsi (TFtype a)
{
FP_DECL_EX;
FP_DECL_Q(A);
FP_DECL_Q (A);
USItype r;
FP_UNPACK_RAW_Q(A, a);
FP_TO_INT_Q(r, A, SI_BITS, 0);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_Q (A, a);
FP_TO_INT_Q (r, A, SI_BITS, 0);
FP_HANDLE_EXCEPTIONS;
return r;

17
libgcc/soft-fp/fixunstfti.c
View file

@ -1,6 +1,6 @@
/* Software floating-point emulation.
Convert IEEE quad to 128bit unsigned integer
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Uros Bizjak (ubizjak@gmail.com).
@ -24,21 +24,22 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "soft-fp.h"
#include "quad.h"
UTItype __fixunstfti(TFtype a)
UTItype
__fixunstfti (TFtype a)
{
FP_DECL_EX;
FP_DECL_Q(A);
FP_DECL_Q (A);
UTItype r;
FP_UNPACK_RAW_Q(A, a);
FP_TO_INT_Q(r, A, TI_BITS, 0);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_Q (A, a);
FP_TO_INT_Q (r, A, TI_BITS, 0);
FP_HANDLE_EXCEPTIONS;
return r;

10
libgcc/soft-fp/floatdidf.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "double.h"
DFtype __floatdidf(DItype i)
DFtype
__floatdidf (DItype i)
{
FP_DECL_EX;
FP_DECL_D(A);
FP_DECL_D (A);
DFtype a;
FP_FROM_INT_D(A, i, DI_BITS, UDItype);
FP_PACK_RAW_D(a, A);
FP_INIT_ROUNDMODE;
FP_FROM_INT_D (A, i, DI_BITS, UDItype);
FP_PACK_RAW_D (a, A);
FP_HANDLE_EXCEPTIONS;
return a;

10
libgcc/soft-fp/floatdisf.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "single.h"
SFtype __floatdisf(DItype i)
SFtype
__floatdisf (DItype i)
{
FP_DECL_EX;
FP_DECL_S(A);
FP_DECL_S (A);
SFtype a;
FP_FROM_INT_S(A, i, DI_BITS, UDItype);
FP_PACK_RAW_S(a, A);
FP_INIT_ROUNDMODE;
FP_FROM_INT_S (A, i, DI_BITS, UDItype);
FP_PACK_RAW_S (a, A);
FP_HANDLE_EXCEPTIONS;
return a;

12
libgcc/soft-fp/floatditf.c
View file

@ -28,18 +28,18 @@
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#define FP_NO_EXCEPTIONS
#include "soft-fp.h"
#include "quad.h"
TFtype __floatditf(DItype i)
TFtype
__floatditf (DItype i)
{
FP_DECL_EX;
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_HANDLE_EXCEPTIONS;
FP_FROM_INT_Q (A, i, DI_BITS, UDItype);
FP_PACK_RAW_Q (a, A);
return a;
}

12
libgcc/soft-fp/floatsidf.c
View file

@ -28,18 +28,18 @@
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#define FP_NO_EXCEPTIONS
#include "soft-fp.h"
#include "double.h"
DFtype __floatsidf(SItype i)
DFtype
__floatsidf (SItype i)
{
FP_DECL_EX;
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_HANDLE_EXCEPTIONS;
FP_FROM_INT_D (A, i, SI_BITS, USItype);
FP_PACK_RAW_D (a, A);
return a;
}

10
libgcc/soft-fp/floatsisf.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "single.h"
SFtype __floatsisf(SItype i)
SFtype
__floatsisf (SItype i)
{
FP_DECL_EX;
FP_DECL_S(A);
FP_DECL_S (A);
SFtype a;
FP_FROM_INT_S(A, i, SI_BITS, USItype);
FP_PACK_RAW_S(a, A);
FP_INIT_ROUNDMODE;
FP_FROM_INT_S (A, i, SI_BITS, USItype);
FP_PACK_RAW_S (a, A);
FP_HANDLE_EXCEPTIONS;
return a;

12
libgcc/soft-fp/floatsitf.c
View file

@ -28,18 +28,18 @@
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#define FP_NO_EXCEPTIONS
#include "soft-fp.h"
#include "quad.h"
TFtype __floatsitf(SItype i)
TFtype
__floatsitf (SItype i)
{
FP_DECL_EX;
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_HANDLE_EXCEPTIONS;
FP_FROM_INT_Q (A, i, SI_BITS, USItype);
FP_PACK_RAW_Q (a, A);
return a;
}

17
libgcc/soft-fp/floattidf.c
View file

@ -1,6 +1,6 @@
/* Software floating-point emulation.
Convert a 128bit signed integer to IEEE double
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Uros Bizjak (ubizjak@gmail.com).
@ -24,21 +24,22 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "soft-fp.h"
#include "double.h"
DFtype __floattidf(TItype i)
DFtype
__floattidf (TItype i)
{
FP_DECL_EX;
FP_DECL_D(A);
FP_DECL_D (A);
DFtype a;
FP_FROM_INT_D(A, i, TI_BITS, UTItype);
FP_PACK_RAW_D(a, A);
FP_INIT_ROUNDMODE;
FP_FROM_INT_D (A, i, TI_BITS, UTItype);
FP_PACK_RAW_D (a, A);
FP_HANDLE_EXCEPTIONS;
return a;

17
libgcc/soft-fp/floattisf.c
View file

@ -1,6 +1,6 @@
/* Software floating-point emulation.
Convert a 128bit signed integer to IEEE single
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Uros Bizjak (ubizjak@gmail.com).
@ -24,21 +24,22 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "soft-fp.h"
#include "single.h"
SFtype __floattisf(TItype i)
SFtype
__floattisf (TItype i)
{
FP_DECL_EX;
FP_DECL_S(A);
FP_DECL_S (A);
SFtype a;
FP_FROM_INT_S(A, i, TI_BITS, UTItype);
FP_PACK_RAW_S(a, A);
FP_INIT_ROUNDMODE;
FP_FROM_INT_S (A, i, TI_BITS, UTItype);
FP_PACK_RAW_S (a, A);
FP_HANDLE_EXCEPTIONS;
return a;

17
libgcc/soft-fp/floattitf.c
View file

@ -1,6 +1,6 @@
/* Software floating-point emulation.
Convert a 128bit signed integer to IEEE quad
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Uros Bizjak (ubizjak@gmail.com).
@ -24,21 +24,22 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "soft-fp.h"
#include "quad.h"
TFtype __floattitf(TItype i)
TFtype
__floattitf (TItype i)
{
FP_DECL_EX;
FP_DECL_Q(A);
FP_DECL_Q (A);
TFtype a;
FP_FROM_INT_Q(A, i, TI_BITS, UTItype);
FP_PACK_RAW_Q(a, A);
FP_INIT_ROUNDMODE;
FP_FROM_INT_Q (A, i, TI_BITS, UTItype);
FP_PACK_RAW_Q (a, A);
FP_HANDLE_EXCEPTIONS;
return a;

10
libgcc/soft-fp/floatundidf.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "double.h"
DFtype __floatundidf(UDItype i)
DFtype
__floatundidf (UDItype i)
{
FP_DECL_EX;
FP_DECL_D(A);
FP_DECL_D (A);
DFtype a;
FP_FROM_INT_D(A, i, DI_BITS, UDItype);
FP_PACK_RAW_D(a, A);
FP_INIT_ROUNDMODE;
FP_FROM_INT_D (A, i, DI_BITS, UDItype);
FP_PACK_RAW_D (a, A);
FP_HANDLE_EXCEPTIONS;
return a;

10
libgcc/soft-fp/floatundisf.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "single.h"
SFtype __floatundisf(UDItype i)
SFtype
__floatundisf (UDItype i)
{
FP_DECL_EX;
FP_DECL_S(A);
FP_DECL_S (A);
SFtype a;
FP_FROM_INT_S(A, i, DI_BITS, UDItype);
FP_PACK_RAW_S(a, A);
FP_INIT_ROUNDMODE;
FP_FROM_INT_S (A, i, DI_BITS, UDItype);
FP_PACK_RAW_S (a, A);
FP_HANDLE_EXCEPTIONS;
return a;

11
libgcc/soft-fp/floatunditf.c
View file

@ -28,19 +28,18 @@
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#define FP_NO_EXCEPTIONS
#include "soft-fp.h"
#include "quad.h"
TFtype
__floatunditf(UDItype i)
__floatunditf (UDItype i)
{
FP_DECL_EX;
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_HANDLE_EXCEPTIONS;
FP_FROM_INT_Q (A, i, DI_BITS, UDItype);
FP_PACK_RAW_Q (a, A);
return a;
}

12
libgcc/soft-fp/floatunsidf.c
View file

@ -28,18 +28,18 @@
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#define FP_NO_EXCEPTIONS
#include "soft-fp.h"
#include "double.h"
DFtype __floatunsidf(USItype i)
DFtype
__floatunsidf (USItype i)
{
FP_DECL_EX;
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_HANDLE_EXCEPTIONS;
FP_FROM_INT_D (A, i, SI_BITS, USItype);
FP_PACK_RAW_D (a, A);
return a;
}

10
libgcc/soft-fp/floatunsisf.c
View file

@ -31,14 +31,16 @@
#include "soft-fp.h"
#include "single.h"
SFtype __floatunsisf(USItype i)
SFtype
__floatunsisf (USItype i)
{
FP_DECL_EX;
FP_DECL_S(A);
FP_DECL_S (A);
SFtype a;
FP_FROM_INT_S(A, i, SI_BITS, USItype);
FP_PACK_RAW_S(a, A);
FP_INIT_ROUNDMODE;
FP_FROM_INT_S (A, i, SI_BITS, USItype);
FP_PACK_RAW_S (a, A);
FP_HANDLE_EXCEPTIONS;
return a;

11
libgcc/soft-fp/floatunsitf.c
View file

@ -28,19 +28,18 @@
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#define FP_NO_EXCEPTIONS
#include "soft-fp.h"
#include "quad.h"
TFtype
__floatunsitf(USItype i)
__floatunsitf (USItype i)
{
FP_DECL_EX;
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_HANDLE_EXCEPTIONS;
FP_FROM_INT_Q (A, i, SI_BITS, USItype);
FP_PACK_RAW_Q (a, A);
return a;
}

17
libgcc/soft-fp/floatuntidf.c
View file

@ -1,6 +1,6 @@
/* Software floating-point emulation.
Convert a 128bit unsigned integer to IEEE double
Copyright (C) 1997,1999, 2006 Free Software Foundation, Inc.
Copyright (C) 1997-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Uros Bizjak (ubizjak@gmail.com).
@ -24,21 +24,22 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "soft-fp.h"
#include "double.h"
DFtype __floatuntidf(UTItype i)
DFtype
__floatuntidf (UTItype i)
{
FP_DECL_EX;
FP_DECL_D(A);
FP_DECL_D (A);
DFtype a;
FP_FROM_INT_D(A, i, TI_BITS, UTItype);
FP_PACK_RAW_D(a, A);
FP_INIT_ROUNDMODE;
FP_FROM_INT_D (A, i, TI_BITS, UTItype);
FP_PACK_RAW_D (a, A);
FP_HANDLE_EXCEPTIONS;
return a;

17
libgcc/soft-fp/floatuntisf.c
View file

@ -1,6 +1,6 @@
/* Software floating-point emulation.
Convert a 128bit unsigned integer to IEEE single
Copyright (C) 2007, 2008 Free Software Foundation, Inc.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Uros Bizjak (ubizjak@gmail.com).
@ -24,21 +24,22 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "soft-fp.h"
#include "single.h"
SFtype __floatuntisf(UTItype i)
SFtype
__floatuntisf (UTItype i)
{
FP_DECL_EX;
FP_DECL_S(A);
FP_DECL_S (A);
SFtype a;
FP_FROM_INT_S(A, i, TI_BITS, UTItype);
FP_PACK_RAW_S(a, A);
FP_INIT_ROUNDMODE;
FP_FROM_INT_S (A, i, TI_BITS, UTItype);
FP_PACK_RAW_S (a, A);
FP_HANDLE_EXCEPTIONS;
return a;

17
libgcc/soft-fp/floatuntitf.c
View file

@ -1,6 +1,6 @@
/* Software floating-point emulation.
Convert a 128bit unsigned integer to IEEE quad
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Uros Bizjak (ubizjak@gmail.com).
@ -24,21 +24,22 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "soft-fp.h"
#include "quad.h"
TFtype __floatuntitf(UTItype i)
TFtype
__floatuntitf (UTItype i)
{
FP_DECL_EX;
FP_DECL_Q(A);
FP_DECL_Q (A);
TFtype a;
FP_FROM_INT_Q(A, i, TI_BITS, UTItype);
FP_PACK_RAW_Q(a, A);
FP_INIT_ROUNDMODE;
FP_FROM_INT_Q (A, i, TI_BITS, UTItype);
FP_PACK_RAW_Q (a, A);
FP_HANDLE_EXCEPTIONS;
return a;

19
libgcc/soft-fp/gedf2.c
View file

@ -31,20 +31,23 @@
#include "soft-fp.h"
#include "double.h"
CMPtype __gedf2(DFtype a, DFtype b)
CMPtype
__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_UNPACK_RAW_D(A, a);
FP_UNPACK_RAW_D(B, b);
FP_CMP_D(r, A, B, -2);
if (r == -2 && (FP_ISSIGNAN_D(A) || FP_ISSIGNAN_D(B)))
FP_SET_EXCEPTION(FP_EX_INVALID);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_D (A, a);
FP_UNPACK_RAW_D (B, b);
FP_CMP_D (r, A, B, -2);
if (r == -2)
FP_SET_EXCEPTION (FP_EX_INVALID);
FP_HANDLE_EXCEPTIONS;
return r;
}
strong_alias(__gedf2, __gtdf2);
strong_alias (__gedf2, __gtdf2);

19
libgcc/soft-fp/gesf2.c
View file

@ -31,20 +31,23 @@
#include "soft-fp.h"
#include "single.h"
CMPtype __gesf2(SFtype a, SFtype b)
CMPtype
__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_UNPACK_RAW_S(A, a);
FP_UNPACK_RAW_S(B, b);
FP_CMP_S(r, A, B, -2);
if (r == -2 && (FP_ISSIGNAN_S(A) || FP_ISSIGNAN_S(B)))
FP_SET_EXCEPTION(FP_EX_INVALID);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_S (A, a);
FP_UNPACK_RAW_S (B, b);
FP_CMP_S (r, A, B, -2);
if (r == -2)
FP_SET_EXCEPTION (FP_EX_INVALID);
FP_HANDLE_EXCEPTIONS;
return r;
}
strong_alias(__gesf2, __gtsf2);
strong_alias (__gesf2, __gtsf2);

19
libgcc/soft-fp/getf2.c
View file

@ -31,20 +31,23 @@
#include "soft-fp.h"
#include "quad.h"
CMPtype __getf2(TFtype a, TFtype b)
CMPtype
__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_UNPACK_RAW_Q(A, a);
FP_UNPACK_RAW_Q(B, b);
FP_CMP_Q(r, A, B, -2);
if (r == -2 && (FP_ISSIGNAN_Q(A) || FP_ISSIGNAN_Q(B)))
FP_SET_EXCEPTION(FP_EX_INVALID);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_Q (A, a);
FP_UNPACK_RAW_Q (B, b);
FP_CMP_Q (r, A, B, -2);
if (r == -2)
FP_SET_EXCEPTION (FP_EX_INVALID);
FP_HANDLE_EXCEPTIONS;
return r;
}
strong_alias(__getf2, __gttf2);
strong_alias (__getf2, __gttf2);

19
libgcc/soft-fp/ledf2.c
View file

@ -31,20 +31,23 @@
#include "soft-fp.h"
#include "double.h"
CMPtype __ledf2(DFtype a, DFtype b)
CMPtype
__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_UNPACK_RAW_D(A, a);
FP_UNPACK_RAW_D(B, b);
FP_CMP_D(r, A, B, 2);
if (r == 2 && (FP_ISSIGNAN_D(A) || FP_ISSIGNAN_D(B)))
FP_SET_EXCEPTION(FP_EX_INVALID);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_D (A, a);
FP_UNPACK_RAW_D (B, b);
FP_CMP_D (r, A, B, 2);
if (r == 2)
FP_SET_EXCEPTION (FP_EX_INVALID);
FP_HANDLE_EXCEPTIONS;
return r;
}
strong_alias(__ledf2, __ltdf2);
strong_alias (__ledf2, __ltdf2);

19
libgcc/soft-fp/lesf2.c
View file

@ -31,20 +31,23 @@
#include "soft-fp.h"
#include "single.h"
CMPtype __lesf2(SFtype a, SFtype b)
CMPtype
__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_UNPACK_RAW_S(A, a);
FP_UNPACK_RAW_S(B, b);
FP_CMP_S(r, A, B, 2);
if (r == 2 && (FP_ISSIGNAN_S(A) || FP_ISSIGNAN_S(B)))
FP_SET_EXCEPTION(FP_EX_INVALID);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_S (A, a);
FP_UNPACK_RAW_S (B, b);
FP_CMP_S (r, A, B, 2);
if (r == 2)
FP_SET_EXCEPTION (FP_EX_INVALID);
FP_HANDLE_EXCEPTIONS;
return r;
}
strong_alias(__lesf2, __ltsf2);
strong_alias (__lesf2, __ltsf2);

19
libgcc/soft-fp/letf2.c
View file

@ -31,20 +31,23 @@
#include "soft-fp.h"
#include "quad.h"
CMPtype __letf2(TFtype a, TFtype b)
CMPtype
__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_UNPACK_RAW_Q(A, a);
FP_UNPACK_RAW_Q(B, b);
FP_CMP_Q(r, A, B, 2);
if (r == 2 && (FP_ISSIGNAN_Q(A) || FP_ISSIGNAN_Q(B)))
FP_SET_EXCEPTION(FP_EX_INVALID);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_Q (A, a);
FP_UNPACK_RAW_Q (B, b);
FP_CMP_Q (r, A, B, 2);
if (r == 2)
FP_SET_EXCEPTION (FP_EX_INVALID);
FP_HANDLE_EXCEPTIONS;
return r;
}
strong_alias(__letf2, __lttf2);
strong_alias (__letf2, __lttf2);

15
libgcc/soft-fp/muldf3.c
View file

@ -31,17 +31,20 @@
#include "soft-fp.h"
#include "double.h"
DFtype __muldf3(DFtype a, DFtype b)
DFtype
__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;

15
libgcc/soft-fp/mulsf3.c
View file

@ -31,17 +31,20 @@
#include "soft-fp.h"
#include "single.h"
SFtype __mulsf3(SFtype a, SFtype b)
SFtype
__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;

15
libgcc/soft-fp/multf3.c
View file

@ -31,17 +31,20 @@
#include "soft-fp.h"
#include "quad.h"
TFtype __multf3(TFtype a, TFtype b)
TFtype
__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;

15
libgcc/soft-fp/negdf2.c
View file

@ -31,17 +31,16 @@
#include "soft-fp.h"
#include "double.h"
DFtype __negdf2(DFtype a)
DFtype
__negdf2 (DFtype a)
{
FP_DECL_EX;
FP_DECL_D(A); FP_DECL_D(R);
FP_DECL_D (A);
FP_DECL_D (R);
DFtype r;
FP_UNPACK_D(A, a);
FP_NEG_D(R, A);
FP_PACK_D(r, R);
FP_CLEAR_EXCEPTIONS;
FP_HANDLE_EXCEPTIONS;
FP_UNPACK_RAW_D (A, a);
FP_NEG_D (R, A);
FP_PACK_RAW_D (r, R);
return r;
}

15
libgcc/soft-fp/negsf2.c
View file

@ -31,17 +31,16 @@
#include "soft-fp.h"
#include "single.h"
SFtype __negsf2(SFtype a)
SFtype
__negsf2 (SFtype a)
{
FP_DECL_EX;
FP_DECL_S(A); FP_DECL_S(R);
FP_DECL_S (A);
FP_DECL_S (R);
SFtype r;
FP_UNPACK_S(A, a);
FP_NEG_S(R, A);
FP_PACK_S(r, R);
FP_CLEAR_EXCEPTIONS;
FP_HANDLE_EXCEPTIONS;
FP_UNPACK_RAW_S (A, a);
FP_NEG_S (R, A);
FP_PACK_RAW_S (r, R);
return r;
}

15
libgcc/soft-fp/negtf2.c
View file

@ -31,17 +31,16 @@
#include "soft-fp.h"
#include "quad.h"
TFtype __negtf2(TFtype a)
TFtype
__negtf2 (TFtype a)
{
FP_DECL_EX;
FP_DECL_Q(A); FP_DECL_Q(R);
FP_DECL_Q (A);
FP_DECL_Q (R);
TFtype r;
FP_UNPACK_Q(A, a);
FP_NEG_Q(R, A);
FP_PACK_Q(r, R);
FP_CLEAR_EXCEPTIONS;
FP_HANDLE_EXCEPTIONS;
FP_UNPACK_RAW_Q (A, a);
FP_NEG_Q (R, A);
FP_PACK_RAW_Q (r, R);
return r;
}

395
libgcc/soft-fp/op-1.h
View file

@ -31,103 +31,117 @@
<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) \
do { \
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_ADDI_1(X, I) (X##_f += I)
#define _FP_FRAC_SLL_1(X, N) \
do \
{ \
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)
/* Right shift with sticky-lsb. */
#define _FP_FRAC_SRST_1(X,S,N,sz) __FP_FRAC_SRST_1(X##_f, S, N, sz)
#define _FP_FRAC_SRS_1(X,N,sz) __FP_FRAC_SRS_1(X##_f, N, sz)
#define _FP_FRAC_SRST_1(X, S, N, sz) __FP_FRAC_SRST_1 (X##_f, S, N, sz)
#define _FP_FRAC_SRS_1(X, N, sz) __FP_FRAC_SRS_1 (X##_f, N, sz)
#define __FP_FRAC_SRST_1(X,S,N,sz) \
do { \
S = (__builtin_constant_p(N) && (N) == 1 \
? X & 1 : (X << (_FP_W_TYPE_SIZE - (N))) != 0); \
X = X >> (N); \
} while (0)
#define __FP_FRAC_SRST_1(X, S, N, sz) \
do \
{ \
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 \
? X & 1 : (X << (_FP_W_TYPE_SIZE - (N))) != 0)))
#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_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
* normalize the data.
*/
#define _FP_UNPACK_RAW_1(fs, X, val) \
do { \
union _FP_UNION_##fs _flo; _flo.flt = (val); \
\
X##_f = _flo.bits.frac; \
X##_e = _flo.bits.exp; \
X##_s = _flo.bits.sign; \
} while (0)
#define _FP_UNPACK_RAW_1(fs, X, val) \
do \
{ \
union _FP_UNION_##fs _flo; \
_flo.flt = (val); \
\
X##_f = _flo.bits.frac; \
X##_e = _flo.bits.exp; \
X##_s = _flo.bits.sign; \
} \
while (0)
#define _FP_UNPACK_RAW_1_P(fs, X, val) \
do { \
union _FP_UNION_##fs *_flo = \
(union _FP_UNION_##fs *)(val); \
\
X##_f = _flo->bits.frac; \
X##_e = _flo->bits.exp; \
X##_s = _flo->bits.sign; \
} while (0)
#define _FP_UNPACK_RAW_1_P(fs, X, val) \
do \
{ \
union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val); \
\
X##_f = _flo->bits.frac; \
X##_e = _flo->bits.exp; \
X##_s = _flo->bits.sign; \
} \
while (0)
/*
* Repack the raw bits of a native fp value.
*/
#define _FP_PACK_RAW_1(fs, val, X) \
do { \
union _FP_UNION_##fs _flo; \
\
_flo.bits.frac = X##_f; \
_flo.bits.exp = X##_e; \
_flo.bits.sign = X##_s; \
\
(val) = _flo.flt; \
} while (0)
#define _FP_PACK_RAW_1(fs, val, X) \
do \
{ \
union _FP_UNION_##fs _flo; \
\
_flo.bits.frac = X##_f; \
_flo.bits.exp = X##_e; \
_flo.bits.sign = X##_s; \
\
(val) = _flo.flt; \
} \
while (0)
#define _FP_PACK_RAW_1_P(fs, val, X) \
do { \
union _FP_UNION_##fs *_flo = \
(union _FP_UNION_##fs *)(val); \
\
_flo->bits.frac = X##_f; \
_flo->bits.exp = X##_e; \
_flo->bits.sign = X##_s; \
} while (0)
#define _FP_PACK_RAW_1_P(fs, val, X) \
do \
{ \
union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val); \
\
_flo->bits.frac = X##_f; \
_flo->bits.exp = X##_e; \
_flo->bits.sign = X##_s; \
} \
while (0)
/*
@ -137,57 +151,86 @@ do { \
/* Basic. Assuming the host word size is >= 2*FRACBITS, we can do the
multiplication immediately. */
#define _FP_MUL_MEAT_DW_1_imm(wfracbits, R, X, Y) \
do \
{ \
R##_f = X##_f * Y##_f; \
} \
while (0)
#define _FP_MUL_MEAT_1_imm(wfracbits, R, X, Y) \
do { \
R##_f = X##_f * Y##_f; \
/* 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); \
} while (0)
do \
{ \
_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); \
} \
while (0)
/* Given a 1W * 1W => 2W primitive, do the extended multiplication. */
#define _FP_MUL_MEAT_DW_1_wide(wfracbits, R, X, Y, doit) \
do \
{ \
doit (R##_f1, R##_f0, X##_f, Y##_f); \
} \
while (0)
#define _FP_MUL_MEAT_1_wide(wfracbits, R, X, Y, doit) \
do { \
_FP_W_TYPE _Z_f0, _Z_f1; \
doit(_Z_f1, _Z_f0, X##_f, Y##_f); \
/* Normalize since we know where the msb of the multiplicands \
were (bit B), we know that the msb of the of the product is \
at either 2B or 2B-1. */ \
_FP_FRAC_SRS_2(_Z, wfracbits-1, 2*wfracbits); \
R##_f = _Z_f0; \
} while (0)
do \
{ \
_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); \
R##_f = _Z_f0; \
} \
while (0)
/* Finally, a simple widening multiply algorithm. What fun! */
#define _FP_MUL_MEAT_1_hard(wfracbits, R, X, Y) \
do { \
_FP_W_TYPE _xh, _xl, _yh, _yl, _z_f0, _z_f1, _a_f0, _a_f1; \
#define _FP_MUL_MEAT_DW_1_hard(wfracbits, R, X, Y) \
do \
{ \
_FP_W_TYPE _xh, _xl, _yh, _yl; \
_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); \
_yh = Y##_f >> (_FP_W_TYPE_SIZE/2); \
_yl = Y##_f & (((_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE/2)) - 1); \
/* split the words in half */ \
_xh = X##_f >> (_FP_W_TYPE_SIZE/2); \
_xl = X##_f & (((_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2)) - 1); \
_yh = Y##_f >> (_FP_W_TYPE_SIZE/2); \
_yl = Y##_f & (((_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2)) - 1); \
\
/* multiply the pieces */ \
_z_f0 = _xl * _yl; \
_a_f0 = _xh * _yl; \
_a_f1 = _xl * _yh; \
_z_f1 = _xh * _yh; \
/* multiply the pieces */ \
R##_f0 = _xl * _yl; \
_a_f0 = _xh * _yl; \
_a_f1 = _xl * _yh; \
R##_f1 = _xh * _yh; \
\
/* reassemble into two full words */ \
if ((_a_f0 += _a_f1) < _a_f1) \
_z_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(_z, _z, _a); \
\
/* normalize */ \
_FP_FRAC_SRS_2(_z, wfracbits - 1, 2*wfracbits); \
R##_f = _z_f0; \
} while (0)
/* reassemble into two full words */ \
if ((_a_f0 += _a_f1) < _a_f1) \
R##_f1 += (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2); \
_a_f1 = _a_f0 >> (_FP_W_TYPE_SIZE/2); \
_a_f0 = _a_f0 << (_FP_W_TYPE_SIZE/2); \
_FP_FRAC_ADD_2 (R, R, _a); \
} \
while (0)
#define _FP_MUL_MEAT_1_hard(wfracbits, R, X, Y) \
do \
{ \
_FP_FRAC_DECL_2 (_z); \
_FP_MUL_MEAT_DW_1_hard (wfracbits, _z, X, Y); \
\
/* normalize */ \
_FP_FRAC_SRS_2 (_z, wfracbits - 1, 2*wfracbits); \
R##_f = _z_f0; \
} \
while (0)
/*
@ -199,15 +242,17 @@ do { \
C primitives or _FP_DIV_HELP_ldiv for the ISO function. Which you
choose will depend on what the compiler does with divrem4. */
#define _FP_DIV_MEAT_1_imm(fs, R, X, Y, doit) \
do { \
_FP_W_TYPE _q, _r; \
X##_f <<= (X##_f < Y##_f \
? R##_e--, _FP_WFRACBITS_##fs \
: _FP_WFRACBITS_##fs - 1); \
doit(_q, _r, X##_f, Y##_f); \
R##_f = _q | (_r != 0); \
} while (0)
#define _FP_DIV_MEAT_1_imm(fs, R, X, Y, doit) \
do \
{ \
_FP_W_TYPE _q, _r; \
X##_f <<= (X##_f < Y##_f \
? R##_e--, _FP_WFRACBITS_##fs \
: _FP_WFRACBITS_##fs - 1); \
doit (_q, _r, X##_f, Y##_f); \
R##_f = _q | (_r != 0); \
} \
while (0)
/* GCC's longlong.h defines a 2W / 1W => (1W,1W) primitive udiv_qrnnd
that may be useful in this situation. This first is for a primitive
@ -215,46 +260,50 @@ do { \
for UDIV_NEEDS_NORMALIZATION to tell which your machine needs. */
#define _FP_DIV_MEAT_1_udiv_norm(fs, R, X, Y) \
do { \
_FP_W_TYPE _nh, _nl, _q, _r, _y; \
do \
{ \
_FP_W_TYPE _nh, _nl, _q, _r, _y; \
\
/* Normalize Y -- i.e. make the most significant bit set. */ \
_y = Y##_f << _FP_WFRACXBITS_##fs; \
/* Normalize Y -- i.e. make the most significant bit set. */ \
_y = Y##_f << _FP_WFRACXBITS_##fs; \
\
/* Shift X op correspondingly high, that is, up one full word. */ \
if (X##_f < Y##_f) \
{ \
R##_e--; \
_nl = 0; \
_nh = X##_f; \
} \
else \
{ \
_nl = X##_f << (_FP_W_TYPE_SIZE - 1); \
_nh = X##_f >> 1; \
} \
/* Shift X op correspondingly high, that is, up one full word. */ \
if (X##_f < Y##_f) \
{ \
R##_e--; \
_nl = 0; \
_nh = X##_f; \
} \
else \
{ \
_nl = X##_f << (_FP_W_TYPE_SIZE - 1); \
_nh = X##_f >> 1; \
} \
\
udiv_qrnnd(_q, _r, _nh, _nl, _y); \
R##_f = _q | (_r != 0); \
} while (0)
udiv_qrnnd (_q, _r, _nh, _nl, _y); \
R##_f = _q | (_r != 0); \
} \
while (0)
#define _FP_DIV_MEAT_1_udiv(fs, R, X, Y) \
do { \
_FP_W_TYPE _nh, _nl, _q, _r; \
if (X##_f < Y##_f) \
{ \
R##_e--; \
_nl = X##_f << _FP_WFRACBITS_##fs; \
_nh = X##_f >> _FP_WFRACXBITS_##fs; \
} \
else \
{ \
_nl = X##_f << (_FP_WFRACBITS_##fs - 1); \
_nh = X##_f >> (_FP_WFRACXBITS_##fs + 1); \
} \
udiv_qrnnd(_q, _r, _nh, _nl, Y##_f); \
R##_f = _q | (_r != 0); \
} while (0)
do \
{ \
_FP_W_TYPE _nh, _nl, _q, _r; \
if (X##_f < Y##_f) \
{ \
R##_e--; \
_nl = X##_f << _FP_WFRACBITS_##fs; \
_nh = X##_f >> _FP_WFRACXBITS_##fs; \
} \
else \
{ \
_nl = X##_f << (_FP_WFRACBITS_##fs - 1); \
_nh = X##_f >> (_FP_WFRACXBITS_##fs + 1); \
} \
udiv_qrnnd (_q, _r, _nh, _nl, Y##_f); \
R##_f = _q | (_r != 0); \
} \
while (0)
/*
@ -263,27 +312,29 @@ do { \
* should be added for those machines where division is fast.
*/
#define _FP_SQRT_MEAT_1(R, S, T, X, q) \
do { \
while (q != _FP_WORK_ROUND) \
{ \
T##_f = S##_f + q; \
if (T##_f <= X##_f) \
{ \
S##_f = T##_f + q; \
X##_f -= T##_f; \
R##_f += q; \
} \
_FP_FRAC_SLL_1(X, 1); \
q >>= 1; \
} \
if (X##_f) \
{ \
if (S##_f < X##_f) \
R##_f |= _FP_WORK_ROUND; \
R##_f |= _FP_WORK_STICKY; \
} \
} while (0)
#define _FP_SQRT_MEAT_1(R, S, T, X, q) \
do \
{ \
while (q != _FP_WORK_ROUND) \
{ \
T##_f = S##_f + q; \
if (T##_f <= X##_f) \
{ \
S##_f = T##_f + q; \
X##_f -= T##_f; \
R##_f += q; \
} \
_FP_FRAC_SLL_1 (X, 1); \
q >>= 1; \
} \
if (X##_f) \
{ \
if (S##_f < X##_f) \
R##_f |= _FP_WORK_ROUND; \
R##_f |= _FP_WORK_STICKY; \
} \
} \
while (0)
/*
* Assembly/disassembly for converting to/from integral types.

957
libgcc/soft-fp/op-2.h
View file

File diff suppressed because it is too large Load diff

1149
libgcc/soft-fp/op-4.h
View file

File diff suppressed because it is too large Load diff

135
libgcc/soft-fp/op-8.h
View file

@ -34,47 +34,51 @@
#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) \
do { \
_FP_I_TYPE _up, _down, _skip, _i; \
_skip = (N) / _FP_W_TYPE_SIZE; \
_up = (N) % _FP_W_TYPE_SIZE; \
_down = _FP_W_TYPE_SIZE - _up; \
if (!_up) \
for (_i = 7; _i >= _skip; --_i) \
X##_f[_i] = X##_f[_i-_skip]; \
else \
{ \
for (_i = 7; _i > _skip; --_i) \
X##_f[_i] = X##_f[_i-_skip] << _up \
| X##_f[_i-_skip-1] >> _down; \
X##_f[_i--] = X##_f[0] << _up; \
} \
for (; _i >= 0; --_i) \
X##_f[_i] = 0; \
} while (0)
#define _FP_FRAC_SLL_8(X, N) \
do \
{ \
_FP_I_TYPE _up, _down, _skip, _i; \
_skip = (N) / _FP_W_TYPE_SIZE; \
_up = (N) % _FP_W_TYPE_SIZE; \
_down = _FP_W_TYPE_SIZE - _up; \
if (!_up) \
for (_i = 7; _i >= _skip; --_i) \
X##_f[_i] = X##_f[_i-_skip]; \
else \
{ \
for (_i = 7; _i > _skip; --_i) \
X##_f[_i] = (X##_f[_i-_skip] << _up \
| X##_f[_i-_skip-1] >> _down); \
X##_f[_i--] = X##_f[0] << _up; \
} \
for (; _i >= 0; --_i) \
X##_f[_i] = 0; \
} \
while (0)
#define _FP_FRAC_SRL_8(X,N) \
do { \
_FP_I_TYPE _up, _down, _skip, _i; \
_skip = (N) / _FP_W_TYPE_SIZE; \
_down = (N) % _FP_W_TYPE_SIZE; \
_up = _FP_W_TYPE_SIZE - _down; \
if (!_down) \
for (_i = 0; _i <= 7-_skip; ++_i) \
X##_f[_i] = X##_f[_i+_skip]; \
else \
{ \
for (_i = 0; _i < 7-_skip; ++_i) \
X##_f[_i] = X##_f[_i+_skip] >> _down \
| X##_f[_i+_skip+1] << _up; \
X##_f[_i++] = X##_f[7] >> _down; \
} \
for (; _i < 8; ++_i) \
X##_f[_i] = 0; \
} while (0)
#define _FP_FRAC_SRL_8(X, N) \
do \
{ \
_FP_I_TYPE _up, _down, _skip, _i; \
_skip = (N) / _FP_W_TYPE_SIZE; \
_down = (N) % _FP_W_TYPE_SIZE; \
_up = _FP_W_TYPE_SIZE - _down; \
if (!_down) \
for (_i = 0; _i <= 7-_skip; ++_i) \
X##_f[_i] = X##_f[_i+_skip]; \
else \
{ \
for (_i = 0; _i < 7-_skip; ++_i) \
X##_f[_i] = (X##_f[_i+_skip] >> _down \
| X##_f[_i+_skip+1] << _up); \
X##_f[_i++] = X##_f[7] >> _down; \
} \
for (; _i < 8; ++_i) \
X##_f[_i] = 0; \
} \
while (0)
/* Right shift with sticky-lsb.
@ -82,28 +86,31 @@
* but that if any of the bits that fall off the right hand side
* were one then we always set the LSbit.
*/
#define _FP_FRAC_SRS_8(X,N,size) \
do { \
_FP_I_TYPE _up, _down, _skip, _i; \
_FP_W_TYPE _s; \
_skip = (N) / _FP_W_TYPE_SIZE; \
_down = (N) % _FP_W_TYPE_SIZE; \
_up = _FP_W_TYPE_SIZE - _down; \
for (_s = _i = 0; _i < _skip; ++_i) \
_s |= X##_f[_i]; \
if (!_down) \
for (_i = 0; _i <= 7-_skip; ++_i) \
X##_f[_i] = X##_f[_i+_skip]; \
else \
{ \
_s |= X##_f[_i] << _up; \
for (_i = 0; _i < 7-_skip; ++_i) \
X##_f[_i] = X##_f[_i+_skip] >> _down \
| X##_f[_i+_skip+1] << _up; \
X##_f[_i++] = X##_f[7] >> _down; \
} \
for (; _i < 8; ++_i) \
X##_f[_i] = 0; \
/* don't fix the LSB until the very end when we're sure f[0] is stable */ \
X##_f[0] |= (_s != 0); \
} while (0)
#define _FP_FRAC_SRS_8(X, N, size) \
do \
{ \
_FP_I_TYPE _up, _down, _skip, _i; \
_FP_W_TYPE _s; \
_skip = (N) / _FP_W_TYPE_SIZE; \
_down = (N) % _FP_W_TYPE_SIZE; \
_up = _FP_W_TYPE_SIZE - _down; \
for (_s = _i = 0; _i < _skip; ++_i) \
_s |= X##_f[_i]; \
if (!_down) \
for (_i = 0; _i <= 7-_skip; ++_i) \
X##_f[_i] = X##_f[_i+_skip]; \
else \
{ \
_s |= X##_f[_i] << _up; \
for (_i = 0; _i < 7-_skip; ++_i) \
X##_f[_i] = (X##_f[_i+_skip] >> _down \
| X##_f[_i+_skip+1] << _up); \
X##_f[_i++] = X##_f[7] >> _down; \
} \
for (; _i < 8; ++_i) \
X##_f[_i] = 0; \
/* don't fix the LSB until the very end when we're sure f[0] is \
stable */ \
X##_f[0] |= (_s != 0); \
} \
while (0)

2699
libgcc/soft-fp/op-common.h
View file

File diff suppressed because it is too large Load diff

383
libgcc/soft-fp/quad.h
View file

@ -31,13 +31,15 @@
<http://www.gnu.org/licenses/>. */
#if _FP_W_TYPE_SIZE < 32
#error "Here's a nickel, kid. Go buy yourself a real computer."
# error "Here's a nickel, kid. Go buy yourself a real computer."
#endif
#if _FP_W_TYPE_SIZE < 64
#define _FP_FRACTBITS_Q (4*_FP_W_TYPE_SIZE)
# define _FP_FRACTBITS_Q (4*_FP_W_TYPE_SIZE)
# define _FP_FRACTBITS_DW_Q (8*_FP_W_TYPE_SIZE)
#else
#define _FP_FRACTBITS_Q (2*_FP_W_TYPE_SIZE)
# define _FP_FRACTBITS_Q (2*_FP_W_TYPE_SIZE)
# define _FP_FRACTBITS_DW_Q (4*_FP_W_TYPE_SIZE)
#endif
#define _FP_FRACBITS_Q 113
@ -49,222 +51,271 @@
#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))
typedef float TFtype __attribute__((mode(TF)));
#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)
typedef float TFtype __attribute__ ((mode (TF)));
#if _FP_W_TYPE_SIZE < 64
union _FP_UNION_Q
{
TFtype flt;
struct _FP_STRUCT_LAYOUT
{
#if __BYTE_ORDER == __BIG_ENDIAN
unsigned sign : 1;
unsigned exp : _FP_EXPBITS_Q;
unsigned long frac3 : _FP_FRACBITS_Q - (_FP_IMPLBIT_Q != 0)-(_FP_W_TYPE_SIZE * 3);
unsigned long frac2 : _FP_W_TYPE_SIZE;
unsigned long frac1 : _FP_W_TYPE_SIZE;
unsigned long frac0 : _FP_W_TYPE_SIZE;
#else
unsigned long frac0 : _FP_W_TYPE_SIZE;
unsigned long frac1 : _FP_W_TYPE_SIZE;
unsigned long frac2 : _FP_W_TYPE_SIZE;
unsigned long frac3 : _FP_FRACBITS_Q - (_FP_IMPLBIT_Q != 0)-(_FP_W_TYPE_SIZE * 3);
unsigned exp : _FP_EXPBITS_Q;
unsigned sign : 1;
#endif /* not bigendian */
} bits __attribute__((packed));
TFtype flt;
struct _FP_STRUCT_LAYOUT
{
# if __BYTE_ORDER == __BIG_ENDIAN
unsigned sign : 1;
unsigned exp : _FP_EXPBITS_Q;
unsigned long frac3 : _FP_FRACBITS_Q - (_FP_IMPLBIT_Q != 0)-(_FP_W_TYPE_SIZE * 3);
unsigned long frac2 : _FP_W_TYPE_SIZE;
unsigned long frac1 : _FP_W_TYPE_SIZE;
unsigned long frac0 : _FP_W_TYPE_SIZE;
# else
unsigned long frac0 : _FP_W_TYPE_SIZE;
unsigned long frac1 : _FP_W_TYPE_SIZE;
unsigned long frac2 : _FP_W_TYPE_SIZE;
unsigned long frac3 : _FP_FRACBITS_Q - (_FP_IMPLBIT_Q != 0)-(_FP_W_TYPE_SIZE * 3);
unsigned exp : _FP_EXPBITS_Q;
unsigned sign : 1;
# endif /* not bigendian */
} 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) \
do { \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_4_P(Q,val,X); \
} while (0)
# 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); \
} \
while (0)
#define FP_UNPACK_Q(X,val) \
do { \
_FP_UNPACK_RAW_4(Q,X,val); \
_FP_UNPACK_CANONICAL(Q,4,X); \
} while (0)
# define FP_UNPACK_Q(X, val) \
do \
{ \
_FP_UNPACK_RAW_4 (Q, X, val); \
_FP_UNPACK_CANONICAL (Q, 4, X); \
} \
while (0)
#define FP_UNPACK_QP(X,val) \
do { \
_FP_UNPACK_RAW_4_P(Q,X,val); \
_FP_UNPACK_CANONICAL(Q,4,X); \
} while (0)
# define FP_UNPACK_QP(X, val) \
do \
{ \
_FP_UNPACK_RAW_4_P (Q, X, val); \
_FP_UNPACK_CANONICAL (Q, 4, X); \
} \
while (0)
#define FP_UNPACK_SEMIRAW_Q(X,val) \
do { \
_FP_UNPACK_RAW_4(Q,X,val); \
_FP_UNPACK_SEMIRAW(Q,4,X); \
} while (0)
# define FP_UNPACK_SEMIRAW_Q(X, val) \
do \
{ \
_FP_UNPACK_RAW_4 (Q, X, val); \
_FP_UNPACK_SEMIRAW (Q, 4, X); \
} \
while (0)
#define FP_UNPACK_SEMIRAW_QP(X,val) \
do { \
_FP_UNPACK_RAW_4_P(Q,X,val); \
_FP_UNPACK_SEMIRAW(Q,4,X); \
} while (0)
# define FP_UNPACK_SEMIRAW_QP(X, val) \
do \
{ \
_FP_UNPACK_RAW_4_P (Q, X, val); \
_FP_UNPACK_SEMIRAW (Q, 4, X); \
} \
while (0)
#define FP_PACK_Q(val,X) \
do { \
_FP_PACK_CANONICAL(Q,4,X); \
_FP_PACK_RAW_4(Q,val,X); \
} while (0)
# define FP_PACK_Q(val, X) \
do \
{ \
_FP_PACK_CANONICAL (Q, 4, X); \
_FP_PACK_RAW_4 (Q, val, X); \
} \
while (0)
#define FP_PACK_QP(val,X) \
do { \
_FP_PACK_CANONICAL(Q,4,X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_4_P(Q,val,X); \
} while (0)
# define FP_PACK_QP(val, X) \
do \
{ \
_FP_PACK_CANONICAL (Q, 4, X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_4_P (Q, val, X); \
} \
while (0)
#define FP_PACK_SEMIRAW_Q(val,X) \
do { \
_FP_PACK_SEMIRAW(Q,4,X); \
_FP_PACK_RAW_4(Q,val,X); \
} while (0)
# define FP_PACK_SEMIRAW_Q(val, X) \
do \
{ \
_FP_PACK_SEMIRAW (Q, 4, X); \
_FP_PACK_RAW_4 (Q, val, X); \
} \
while (0)
#define FP_PACK_SEMIRAW_QP(val,X) \
do { \
_FP_PACK_SEMIRAW(Q,4,X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_4_P(Q,val,X); \
} while (0)
# define FP_PACK_SEMIRAW_QP(val, X) \
do \
{ \
_FP_PACK_SEMIRAW (Q, 4, X); \
if (!FP_INHIBIT_RESULTS) \
_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_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)
#else /* not _FP_W_TYPE_SIZE < 64 */
union _FP_UNION_Q
{
TFtype flt /* __attribute__((mode(TF))) */ ;
struct _FP_STRUCT_LAYOUT {
TFtype flt /* __attribute__ ((mode (TF))) */ ;
struct _FP_STRUCT_LAYOUT
{
_FP_W_TYPE a, b;
} longs;
struct _FP_STRUCT_LAYOUT {
#if __BYTE_ORDER == __BIG_ENDIAN
struct _FP_STRUCT_LAYOUT
{
# if __BYTE_ORDER == __BIG_ENDIAN
unsigned sign : 1;
unsigned exp : _FP_EXPBITS_Q;
_FP_W_TYPE frac1 : _FP_FRACBITS_Q - (_FP_IMPLBIT_Q != 0) - _FP_W_TYPE_SIZE;
_FP_W_TYPE frac0 : _FP_W_TYPE_SIZE;
#else
# else
_FP_W_TYPE frac0 : _FP_W_TYPE_SIZE;
_FP_W_TYPE frac1 : _FP_FRACBITS_Q - (_FP_IMPLBIT_Q != 0) - _FP_W_TYPE_SIZE;
unsigned exp : _FP_EXPBITS_Q;
unsigned sign : 1;
#endif
# endif
} 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) \
do { \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_2_P(Q,val,X); \
} while (0)
# 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); \
} \
while (0)
#define FP_UNPACK_Q(X,val) \
do { \
_FP_UNPACK_RAW_2(Q,X,val); \
_FP_UNPACK_CANONICAL(Q,2,X); \
} while (0)
# define FP_UNPACK_Q(X, val) \
do \
{ \
_FP_UNPACK_RAW_2 (Q, X, val); \
_FP_UNPACK_CANONICAL (Q, 2, X); \
} \
while (0)
#define FP_UNPACK_QP(X,val) \
do { \
_FP_UNPACK_RAW_2_P(Q,X,val); \
_FP_UNPACK_CANONICAL(Q,2,X); \
} while (0)
# define FP_UNPACK_QP(X, val) \
do \
{ \
_FP_UNPACK_RAW_2_P (Q, X, val); \
_FP_UNPACK_CANONICAL (Q, 2, X); \
} \
while (0)
#define FP_UNPACK_SEMIRAW_Q(X,val) \
do { \
_FP_UNPACK_RAW_2(Q,X,val); \
_FP_UNPACK_SEMIRAW(Q,2,X); \
} while (0)
# define FP_UNPACK_SEMIRAW_Q(X, val) \
do \
{ \
_FP_UNPACK_RAW_2 (Q, X, val); \
_FP_UNPACK_SEMIRAW (Q, 2, X); \
} \
while (0)
#define FP_UNPACK_SEMIRAW_QP(X,val) \
do { \
_FP_UNPACK_RAW_2_P(Q,X,val); \
_FP_UNPACK_SEMIRAW(Q,2,X); \
} while (0)
# define FP_UNPACK_SEMIRAW_QP(X, val) \
do \
{ \
_FP_UNPACK_RAW_2_P (Q, X, val); \
_FP_UNPACK_SEMIRAW (Q, 2, X); \
} \
while (0)
#define FP_PACK_Q(val,X) \
do { \
_FP_PACK_CANONICAL(Q,2,X); \
_FP_PACK_RAW_2(Q,val,X); \
} while (0)
# define FP_PACK_Q(val, X) \
do \
{ \
_FP_PACK_CANONICAL (Q, 2, X); \
_FP_PACK_RAW_2 (Q, val, X); \
} \
while (0)
#define FP_PACK_QP(val,X) \
do { \
_FP_PACK_CANONICAL(Q,2,X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_2_P(Q,val,X); \
} while (0)
# define FP_PACK_QP(val, X) \
do \
{ \
_FP_PACK_CANONICAL (Q, 2, X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_2_P (Q, val, X); \
} \
while (0)
#define FP_PACK_SEMIRAW_Q(val,X) \
do { \
_FP_PACK_SEMIRAW(Q,2,X); \
_FP_PACK_RAW_2(Q,val,X); \
} while (0)
# define FP_PACK_SEMIRAW_Q(val, X) \
do \
{ \
_FP_PACK_SEMIRAW (Q, 2, X); \
_FP_PACK_RAW_2 (Q, val, X); \
} \
while (0)
#define FP_PACK_SEMIRAW_QP(val,X) \
do { \
_FP_PACK_SEMIRAW(Q,2,X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_2_P(Q,val,X); \
} while (0)
# define FP_PACK_SEMIRAW_QP(val, X) \
do \
{ \
_FP_PACK_SEMIRAW (Q, 2, X); \
if (!FP_INHIBIT_RESULTS) \
_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_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)
#endif /* not _FP_W_TYPE_SIZE < 64 */

192
libgcc/soft-fp/single.h
View file

@ -31,11 +31,17 @@
<http://www.gnu.org/licenses/>. */
#if _FP_W_TYPE_SIZE < 32
#error "Here's a nickel kid. Go buy yourself a real computer."
# error "Here's a nickel kid. Go buy yourself a real computer."
#endif
#define _FP_FRACTBITS_S _FP_W_TYPE_SIZE
#if _FP_W_TYPE_SIZE < 64
# define _FP_FRACTBITS_DW_S (2 * _FP_W_TYPE_SIZE)
#else
# define _FP_FRACTBITS_DW_S _FP_W_TYPE_SIZE
#endif
#define _FP_FRACBITS_S 24
#define _FP_FRACXBITS_S (_FP_FRACTBITS_S - _FP_FRACBITS_S)
#define _FP_WFRACBITS_S (_FP_WORKBITS + _FP_FRACBITS_S)
@ -43,21 +49,27 @@
#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)
/* 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
{
SFtype flt;
struct _FP_STRUCT_LAYOUT {
struct _FP_STRUCT_LAYOUT
{
#if __BYTE_ORDER == __BIG_ENDIAN
unsigned sign : 1;
unsigned exp : _FP_EXPBITS_S;
@ -67,84 +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) \
do { \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_1_P(S,val,X); \
} while (0)
#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); \
} \
while (0)
#define FP_UNPACK_S(X,val) \
do { \
_FP_UNPACK_RAW_1(S,X,val); \
_FP_UNPACK_CANONICAL(S,1,X); \
} while (0)
#define FP_UNPACK_S(X, val) \
do \
{ \
_FP_UNPACK_RAW_1 (S, X, val); \
_FP_UNPACK_CANONICAL (S, 1, X); \
} \
while (0)
#define FP_UNPACK_SP(X,val) \
do { \
_FP_UNPACK_RAW_1_P(S,X,val); \
_FP_UNPACK_CANONICAL(S,1,X); \
} while (0)
#define FP_UNPACK_SP(X, val) \
do \
{ \
_FP_UNPACK_RAW_1_P (S, X, val); \
_FP_UNPACK_CANONICAL (S, 1, X); \
} \
while (0)
#define FP_UNPACK_SEMIRAW_S(X,val) \
do { \
_FP_UNPACK_RAW_1(S,X,val); \
_FP_UNPACK_SEMIRAW(S,1,X); \
} while (0)
#define FP_UNPACK_SEMIRAW_S(X, val) \
do \
{ \
_FP_UNPACK_RAW_1 (S, X, val); \
_FP_UNPACK_SEMIRAW (S, 1, X); \
} \
while (0)
#define FP_UNPACK_SEMIRAW_SP(X,val) \
do { \
_FP_UNPACK_RAW_1_P(S,X,val); \
_FP_UNPACK_SEMIRAW(S,1,X); \
} while (0)
#define FP_UNPACK_SEMIRAW_SP(X, val) \
do \
{ \
_FP_UNPACK_RAW_1_P (S, X, val); \
_FP_UNPACK_SEMIRAW (S, 1, X); \
} \
while (0)
#define FP_PACK_S(val,X) \
do { \
_FP_PACK_CANONICAL(S,1,X); \
_FP_PACK_RAW_1(S,val,X); \
} while (0)
#define FP_PACK_S(val, X) \
do \
{ \
_FP_PACK_CANONICAL (S, 1, X); \
_FP_PACK_RAW_1 (S, val, X); \
} \
while (0)
#define FP_PACK_SP(val,X) \
do { \
_FP_PACK_CANONICAL(S,1,X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_1_P(S,val,X); \
} while (0)
#define FP_PACK_SP(val, X) \
do \
{ \
_FP_PACK_CANONICAL (S, 1, X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_1_P (S, val, X); \
} \
while (0)
#define FP_PACK_SEMIRAW_S(val,X) \
do { \
_FP_PACK_SEMIRAW(S,1,X); \
_FP_PACK_RAW_1(S,val,X); \
} while (0)
#define FP_PACK_SEMIRAW_S(val, X) \
do \
{ \
_FP_PACK_SEMIRAW (S, 1, X); \
_FP_PACK_RAW_1 (S, val, X); \
} \
while (0)
#define FP_PACK_SEMIRAW_SP(val,X) \
do { \
_FP_PACK_SEMIRAW(S,1,X); \
if (!FP_INHIBIT_RESULTS) \
_FP_PACK_RAW_1_P(S,val,X); \
} while (0)
#define FP_PACK_SEMIRAW_SP(val, X) \
do \
{ \
_FP_PACK_SEMIRAW (S, 1, X); \
if (!FP_INHIBIT_RESULTS) \
_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)
#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)
#if _FP_W_TYPE_SIZE < 64
# 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)
#endif
#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_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_FRAC_HIGH_S(X) _FP_FRAC_HIGH_1(X)
#define _FP_FRAC_HIGH_RAW_S(X) _FP_FRAC_HIGH_1(X)
#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)
#if _FP_W_TYPE_SIZE < 64
# 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)
#endif

197
libgcc/soft-fp/soft-fp.h
View file

@ -33,25 +33,25 @@
#define SOFT_FP_H
#ifdef _LIBC
#include <sfp-machine.h>
# include <sfp-machine.h>
#else
#include "sfp-machine.h"
# include "sfp-machine.h"
#endif
/* Allow sfp-machine to have its own byte order definitions. */
#ifndef __BYTE_ORDER
#ifdef _LIBC
#include <endian.h>
#else
#error "endianness not defined by sfp-machine.h"
#endif
# ifdef _LIBC
# include <endian.h>
# else
# error "endianness not defined by sfp-machine.h"
# endif
#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
@ -65,22 +65,22 @@
/* By default don't care about exceptions. */
#ifndef FP_EX_INVALID
#define FP_EX_INVALID 0
# define FP_EX_INVALID 0
#endif
#ifndef FP_EX_OVERFLOW
#define FP_EX_OVERFLOW 0
# define FP_EX_OVERFLOW 0
#endif
#ifndef FP_EX_UNDERFLOW
#define FP_EX_UNDERFLOW 0
# define FP_EX_UNDERFLOW 0
#endif
#ifndef FP_EX_DIVZERO
#define FP_EX_DIVZERO 0
# define FP_EX_DIVZERO 0
#endif
#ifndef FP_EX_INEXACT
#define FP_EX_INEXACT 0
# define FP_EX_INEXACT 0
#endif
#ifndef FP_EX_DENORM
#define FP_EX_DENORM 0
# define FP_EX_DENORM 0
#endif
/* _FP_STRUCT_LAYOUT may be defined as an attribute to determine the
@ -90,23 +90,31 @@
differences in how consecutive bit-fields are laid out from the
default expected by soft-fp. */
#ifndef _FP_STRUCT_LAYOUT
#define _FP_STRUCT_LAYOUT
# define _FP_STRUCT_LAYOUT
#endif
#ifdef _FP_DECL_EX
#define FP_DECL_EX \
# define FP_DECL_EX \
int _fex = 0; \
_FP_DECL_EX
#else
#define FP_DECL_EX int _fex = 0
# define FP_DECL_EX int _fex = 0
#endif
/* Initialize any machine-specific state used in FP_ROUNDMODE,
FP_TRAPPING_EXCEPTIONS or FP_HANDLE_EXCEPTIONS. */
#ifndef FP_INIT_ROUNDMODE
#define FP_INIT_ROUNDMODE do {} while (0)
# define FP_INIT_ROUNDMODE do {} while (0)
#endif
/* Initialize any machine-specific state used in
FP_HANDLE_EXCEPTIONS. */
#ifndef FP_INIT_EXCEPTIONS
# define FP_INIT_EXCEPTIONS FP_INIT_ROUNDMODE
#endif
#ifndef FP_HANDLE_EXCEPTIONS
#define FP_HANDLE_EXCEPTIONS do {} while (0)
# define FP_HANDLE_EXCEPTIONS do {} while (0)
#endif
#ifndef FP_INHIBIT_RESULTS
@ -115,15 +123,12 @@
* check if some exceptions are unmasked
* and inhibit it in such a case.
*/
#define FP_INHIBIT_RESULTS 0
# define FP_INHIBIT_RESULTS 0
#endif
#define FP_SET_EXCEPTION(ex) \
_fex |= (ex)
#define FP_UNSET_EXCEPTION(ex) \
_fex &= ~(ex)
#define FP_CLEAR_EXCEPTIONS \
_fex = 0
@ -131,58 +136,90 @@
(_fex)
#ifndef FP_TRAPPING_EXCEPTIONS
#define FP_TRAPPING_EXCEPTIONS 0
# define FP_TRAPPING_EXCEPTIONS 0
#endif
#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); \
} while (0)
/* A file using soft-fp may define FP_NO_EXCEPTIONS before including
soft-fp.h to indicate that, although a macro used there could raise
exceptions, or do rounding and potentially thereby raise
exceptions, for some arguments, for the particular arguments used
in that file no exceptions or rounding can occur. Such a file
should not itself use macros relating to handling exceptions and
rounding modes; this is only for indirect uses (in particular, in
_FP_FROM_INT and the macros it calls). */
#ifdef FP_NO_EXCEPTIONS
#define _FP_ROUND_ZERO(wc, X) (void)0
# undef FP_SET_EXCEPTION
# define FP_SET_EXCEPTION(ex) do {} while (0)
# undef FP_CUR_EXCEPTIONS
# define FP_CUR_EXCEPTIONS 0
# undef FP_TRAPPING_EXCEPTIONS
# define FP_TRAPPING_EXCEPTIONS 0
# undef FP_ROUNDMODE
# define FP_ROUNDMODE FP_RND_ZERO
#endif
#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); \
} \
while (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); \
} while (0)
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); \
} 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); \
} \
while (0)
#define _FP_ROUND(wc, X) \
do { \
if (_FP_FRAC_LOW_##wc(X) & 7) \
{ \
FP_SET_EXCEPTION(FP_EX_INEXACT); \
switch (FP_ROUNDMODE) \
{ \
case FP_RND_NEAREST: \
_FP_ROUND_NEAREST(wc,X); \
break; \
case FP_RND_ZERO: \
_FP_ROUND_ZERO(wc,X); \
break; \
case FP_RND_PINF: \
_FP_ROUND_PINF(wc,X); \
break; \
case FP_RND_MINF: \
_FP_ROUND_MINF(wc,X); \
break; \
} \
} \
} while (0)
do \
{ \
if (_FP_FRAC_LOW_##wc (X) & 7) \
{ \
FP_SET_EXCEPTION (FP_EX_INEXACT); \
switch (FP_ROUNDMODE) \
{ \
case FP_RND_NEAREST: \
_FP_ROUND_NEAREST (wc, X); \
break; \
case FP_RND_ZERO: \
_FP_ROUND_ZERO (wc, X); \
break; \
case FP_RND_PINF: \
_FP_ROUND_PINF (wc, X); \
break; \
case FP_RND_MINF: \
_FP_ROUND_MINF (wc, X); \
break; \
} \
} \
} \
while (0)
#define FP_CLS_NORMAL 0
#define FP_CLS_ZERO 1
#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"
@ -194,35 +231,35 @@ do { \
#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
#ifndef CMPtype
#define CMPtype int
# 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
#include <stdlib/longlong.h>
#else
#include "longlong.h"
#endif
# ifdef _LIBC
# include <stdlib/longlong.h>
# else
# include "longlong.h"
# endif
#endif
#ifdef _LIBC
#include <stdlib.h>
# include <stdlib.h>
#else
extern void abort (void);
#endif

15
libgcc/soft-fp/subdf3.c
View file

@ -31,17 +31,20 @@
#include "soft-fp.h"
#include "double.h"
DFtype __subdf3(DFtype a, DFtype b)
DFtype
__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;

15
libgcc/soft-fp/subsf3.c
View file

@ -31,17 +31,20 @@
#include "soft-fp.h"
#include "single.h"
SFtype __subsf3(SFtype a, SFtype b)
SFtype
__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;

15
libgcc/soft-fp/subtf3.c
View file

@ -31,17 +31,20 @@
#include "soft-fp.h"
#include "quad.h"
TFtype __subtf3(TFtype a, TFtype b)
TFtype
__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;

15
libgcc/soft-fp/truncdfsf2.c
View file

@ -32,21 +32,22 @@
#include "single.h"
#include "double.h"
SFtype __truncdfsf2(DFtype a)
SFtype
__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;

15
libgcc/soft-fp/trunctfdf2.c
View file

@ -32,21 +32,22 @@
#include "double.h"
#include "quad.h"
DFtype __trunctfdf2(TFtype a)
DFtype
__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;

15
libgcc/soft-fp/trunctfsf2.c
View file

@ -32,21 +32,22 @@
#include "single.h"
#include "quad.h"
SFtype __trunctfsf2(TFtype a)
SFtype
__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;

22
libgcc/soft-fp/trunctfxf2.c
View file

@ -1,6 +1,6 @@
/* Software floating-point emulation.
Truncate IEEE quad into IEEE extended
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Uros Bizjak (ubizjak@gmail.com).
@ -24,29 +24,29 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "soft-fp.h"
#include "extended.h"
#include "quad.h"
XFtype __trunctfxf2(TFtype a)
XFtype
__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;

17
libgcc/soft-fp/unorddf2.c
View file

@ -30,14 +30,21 @@
#include "soft-fp.h"
#include "double.h"
CMPtype __unorddf2(DFtype a, DFtype b)
CMPtype
__unorddf2 (DFtype a, DFtype b)
{
FP_DECL_D(A); FP_DECL_D(B);
FP_DECL_EX;
FP_DECL_D (A);
FP_DECL_D (B);
CMPtype r;
FP_UNPACK_RAW_D(A, a);
FP_UNPACK_RAW_D(B, b);
FP_CMP_UNORD_D(r, A, B);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_D (A, a);
FP_UNPACK_RAW_D (B, b);
FP_CMP_UNORD_D (r, A, B);
if (r && (FP_ISSIGNAN_D (A) || FP_ISSIGNAN_D (B)))
FP_SET_EXCEPTION (FP_EX_INVALID);
FP_HANDLE_EXCEPTIONS;
return r;
}

18
libgcc/soft-fp/unordsf2.c
View file

@ -30,15 +30,21 @@
#include "soft-fp.h"
#include "single.h"
CMPtype __unordsf2(SFtype a, SFtype b)
CMPtype
__unordsf2 (SFtype a, SFtype b)
{
FP_DECL_S(A);
FP_DECL_S(B);
FP_DECL_EX;
FP_DECL_S (A);
FP_DECL_S (B);
CMPtype r;
FP_UNPACK_RAW_S(A, a);
FP_UNPACK_RAW_S(B, b);
FP_CMP_UNORD_S(r, A, B);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_S (A, a);
FP_UNPACK_RAW_S (B, b);
FP_CMP_UNORD_S (r, A, B);
if (r && (FP_ISSIGNAN_S (A) || FP_ISSIGNAN_S (B)))
FP_SET_EXCEPTION (FP_EX_INVALID);
FP_HANDLE_EXCEPTIONS;
return r;
}

18
libgcc/soft-fp/unordtf2.c
View file

@ -30,15 +30,21 @@
#include "soft-fp.h"
#include "quad.h"
CMPtype __unordtf2(TFtype a, TFtype b)
CMPtype
__unordtf2 (TFtype a, TFtype b)
{
FP_DECL_Q(A);
FP_DECL_Q(B);
FP_DECL_EX;
FP_DECL_Q (A);
FP_DECL_Q (B);
CMPtype r;
FP_UNPACK_RAW_Q(A, a);
FP_UNPACK_RAW_Q(B, b);
FP_CMP_UNORD_Q(r, A, B);
FP_INIT_EXCEPTIONS;
FP_UNPACK_RAW_Q (A, a);
FP_UNPACK_RAW_Q (B, b);
FP_CMP_UNORD_Q (r, A, B);
if (r && (FP_ISSIGNAN_Q (A) || FP_ISSIGNAN_Q (B)))
FP_SET_EXCEPTION (FP_EX_INVALID);
FP_HANDLE_EXCEPTIONS;
return r;
}