[mirror_qemu.git] / fpu / softfloat.h

/*============================================================================

This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic
Package, Release 2b.

Written by John R. Hauser.  This work was made possible in part by the
International Computer Science Institute, located at Suite 600, 1947 Center
Street, Berkeley, California 94704.  Funding was partially provided by the
National Science Foundation under grant MIP-9311980.  The original version
of this code was written as part of a project to build a fixed-point vector
processor in collaboration with the University of California at Berkeley,
overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
arithmetic/SoftFloat.html'.

THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.

Derivative works are acceptable, even for commercial purposes, so long as
(1) the source code for the derivative work includes prominent notice that
the work is derivative, and (2) the source code includes prominent notice with
these four paragraphs for those parts of this code that are retained.

=============================================================================*/

#ifndef SOFTFLOAT_H
#define SOFTFLOAT_H

#if defined(HOST_SOLARIS) && defined(NEEDS_LIBSUNMATH)
#include <sunmath.h>
#endif

#include <inttypes.h>
#include "config.h"

/*----------------------------------------------------------------------------
| Each of the following `typedef's defines the most convenient type that holds
| integers of at least as many bits as specified.  For example, `uint8' should
| be the most convenient type that can hold unsigned integers of as many as
| 8 bits.  The `flag' type must be able to hold either a 0 or 1.  For most
| implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed
| to the same as `int'.
*----------------------------------------------------------------------------*/
typedef uint8_t flag;
typedef uint8_t uint8;
typedef int8_t int8;
typedef int uint16;
typedef int int16;
typedef unsigned int uint32;
typedef signed int int32;
typedef uint64_t uint64;
typedef int64_t int64;

/*----------------------------------------------------------------------------
| Each of the following `typedef's defines a type that holds integers
| of _exactly_ the number of bits specified.  For instance, for most
| implementation of C, `bits16' and `sbits16' should be `typedef'ed to
| `unsigned short int' and `signed short int' (or `short int'), respectively.
*----------------------------------------------------------------------------*/
typedef uint8_t bits8;
typedef int8_t sbits8;
typedef uint16_t bits16;
typedef int16_t sbits16;
typedef uint32_t bits32;
typedef int32_t sbits32;
typedef uint64_t bits64;
typedef int64_t sbits64;

#define LIT64( a ) a##LL
#define INLINE static inline

/*----------------------------------------------------------------------------
| The macro `FLOATX80' must be defined to enable the extended double-precision
| floating-point format `floatx80'.  If this macro is not defined, the
| `floatx80' type will not be defined, and none of the functions that either
| input or output the `floatx80' type will be defined.  The same applies to
| the `FLOAT128' macro and the quadruple-precision format `float128'.
*----------------------------------------------------------------------------*/
#ifdef CONFIG_SOFTFLOAT
/* bit exact soft float support */
#define FLOATX80
#define FLOAT128
#else
/* native float support */
#if (defined(__i386__) || defined(__x86_64__)) && !defined(_BSD)
#define FLOATX80
#endif
#endif /* !CONFIG_SOFTFLOAT */

#define STATUS_PARAM , float_status *status
#define STATUS(field) status->field
#define STATUS_VAR , status

/*----------------------------------------------------------------------------
| Software IEC/IEEE floating-point ordering relations
*----------------------------------------------------------------------------*/
enum {
    float_relation_less      = -1,
    float_relation_equal     =  0,
    float_relation_greater   =  1,
    float_relation_unordered =  2
};

#ifdef CONFIG_SOFTFLOAT
/*----------------------------------------------------------------------------
| Software IEC/IEEE floating-point types.
*----------------------------------------------------------------------------*/
typedef uint32_t float32;
typedef uint64_t float64;
#ifdef FLOATX80
typedef struct {
    uint64_t low;
    uint16_t high;
} floatx80;
#endif
#ifdef FLOAT128
typedef struct {
#ifdef WORDS_BIGENDIAN
    uint64_t high, low;
#else
    uint64_t low, high;
#endif
} float128;
#endif

/*----------------------------------------------------------------------------
| Software IEC/IEEE floating-point underflow tininess-detection mode.
*----------------------------------------------------------------------------*/
enum {
    float_tininess_after_rounding  = 0,
    float_tininess_before_rounding = 1
};

/*----------------------------------------------------------------------------
| Software IEC/IEEE floating-point rounding mode.
*----------------------------------------------------------------------------*/
enum {
    float_round_nearest_even = 0,
    float_round_down         = 1,
    float_round_up           = 2,
    float_round_to_zero      = 3
};

/*----------------------------------------------------------------------------
| Software IEC/IEEE floating-point exception flags.
*----------------------------------------------------------------------------*/
enum {
    float_flag_invalid   =  1,
    float_flag_divbyzero =  4,
    float_flag_overflow  =  8,
    float_flag_underflow = 16,
    float_flag_inexact   = 32
};

typedef struct float_status {
    signed char float_detect_tininess;
    signed char float_rounding_mode;
    signed char float_exception_flags;
#ifdef FLOATX80
    signed char floatx80_rounding_precision;
#endif
} float_status;

void set_float_rounding_mode(int val STATUS_PARAM);
void set_float_exception_flags(int val STATUS_PARAM);
INLINE int get_float_exception_flags(float_status *status)
{
    return STATUS(float_exception_flags);
}
#ifdef FLOATX80
void set_floatx80_rounding_precision(int val STATUS_PARAM);
#endif

/*----------------------------------------------------------------------------
| Routine to raise any or all of the software IEC/IEEE floating-point
| exception flags.
*----------------------------------------------------------------------------*/
void float_raise( int8 flags STATUS_PARAM);

/*----------------------------------------------------------------------------
| Software IEC/IEEE integer-to-floating-point conversion routines.
*----------------------------------------------------------------------------*/
float32 int32_to_float32( int STATUS_PARAM );
float64 int32_to_float64( int STATUS_PARAM );
float32 uint32_to_float32( unsigned int STATUS_PARAM );
float64 uint32_to_float64( unsigned int STATUS_PARAM );
#ifdef FLOATX80
floatx80 int32_to_floatx80( int STATUS_PARAM );
#endif
#ifdef FLOAT128
float128 int32_to_float128( int STATUS_PARAM );
#endif
float32 int64_to_float32( int64_t STATUS_PARAM );
float32 uint64_to_float32( uint64_t STATUS_PARAM );
float64 int64_to_float64( int64_t STATUS_PARAM );
float64 uint64_to_float64( uint64_t STATUS_PARAM );
#ifdef FLOATX80
floatx80 int64_to_floatx80( int64_t STATUS_PARAM );
#endif
#ifdef FLOAT128
float128 int64_to_float128( int64_t STATUS_PARAM );
#endif

/*----------------------------------------------------------------------------
| Software IEC/IEEE single-precision conversion routines.
*----------------------------------------------------------------------------*/
int float32_to_int32( float32 STATUS_PARAM );
int float32_to_int32_round_to_zero( float32 STATUS_PARAM );
unsigned int float32_to_uint32( float32 STATUS_PARAM );
unsigned int float32_to_uint32_round_to_zero( float32 STATUS_PARAM );
int64_t float32_to_int64( float32 STATUS_PARAM );
int64_t float32_to_int64_round_to_zero( float32 STATUS_PARAM );
float64 float32_to_float64( float32 STATUS_PARAM );
#ifdef FLOATX80
floatx80 float32_to_floatx80( float32 STATUS_PARAM );
#endif
#ifdef FLOAT128
float128 float32_to_float128( float32 STATUS_PARAM );
#endif

/*----------------------------------------------------------------------------
| Software IEC/IEEE single-precision operations.
*----------------------------------------------------------------------------*/
float32 float32_round_to_int( float32 STATUS_PARAM );
float32 float32_add( float32, float32 STATUS_PARAM );
float32 float32_sub( float32, float32 STATUS_PARAM );
float32 float32_mul( float32, float32 STATUS_PARAM );
float32 float32_div( float32, float32 STATUS_PARAM );
float32 float32_rem( float32, float32 STATUS_PARAM );
float32 float32_sqrt( float32 STATUS_PARAM );
int float32_eq( float32, float32 STATUS_PARAM );
int float32_le( float32, float32 STATUS_PARAM );
int float32_lt( float32, float32 STATUS_PARAM );
int float32_eq_signaling( float32, float32 STATUS_PARAM );
int float32_le_quiet( float32, float32 STATUS_PARAM );
int float32_lt_quiet( float32, float32 STATUS_PARAM );
int float32_compare( float32, float32 STATUS_PARAM );
int float32_compare_quiet( float32, float32 STATUS_PARAM );
int float32_is_nan( float32 );
int float32_is_signaling_nan( float32 );
float32 float32_scalbn( float32, int STATUS_PARAM );

INLINE float32 float32_abs(float32 a)
{
    return a & 0x7fffffff;
}

INLINE float32 float32_chs(float32 a)
{
    return a ^ 0x80000000;
}

/*----------------------------------------------------------------------------
| Software IEC/IEEE double-precision conversion routines.
*----------------------------------------------------------------------------*/
int float64_to_int32( float64 STATUS_PARAM );
int float64_to_int32_round_to_zero( float64 STATUS_PARAM );
unsigned int float64_to_uint32( float64 STATUS_PARAM );
unsigned int float64_to_uint32_round_to_zero( float64 STATUS_PARAM );
int64_t float64_to_int64( float64 STATUS_PARAM );
int64_t float64_to_int64_round_to_zero( float64 STATUS_PARAM );
uint64_t float64_to_uint64 (float64 a STATUS_PARAM);
uint64_t float64_to_uint64_round_to_zero (float64 a STATUS_PARAM);
float32 float64_to_float32( float64 STATUS_PARAM );
#ifdef FLOATX80
floatx80 float64_to_floatx80( float64 STATUS_PARAM );
#endif
#ifdef FLOAT128
float128 float64_to_float128( float64 STATUS_PARAM );
#endif

/*----------------------------------------------------------------------------
| Software IEC/IEEE double-precision operations.
*----------------------------------------------------------------------------*/
float64 float64_round_to_int( float64 STATUS_PARAM );
float64 float64_trunc_to_int( float64 STATUS_PARAM );
float64 float64_add( float64, float64 STATUS_PARAM );
float64 float64_sub( float64, float64 STATUS_PARAM );
float64 float64_mul( float64, float64 STATUS_PARAM );
float64 float64_div( float64, float64 STATUS_PARAM );
float64 float64_rem( float64, float64 STATUS_PARAM );
float64 float64_sqrt( float64 STATUS_PARAM );
int float64_eq( float64, float64 STATUS_PARAM );
int float64_le( float64, float64 STATUS_PARAM );
int float64_lt( float64, float64 STATUS_PARAM );
int float64_eq_signaling( float64, float64 STATUS_PARAM );
int float64_le_quiet( float64, float64 STATUS_PARAM );
int float64_lt_quiet( float64, float64 STATUS_PARAM );
int float64_compare( float64, float64 STATUS_PARAM );
int float64_compare_quiet( float64, float64 STATUS_PARAM );
int float64_is_nan( float64 a );
int float64_is_signaling_nan( float64 );
float64 float64_scalbn( float64, int STATUS_PARAM );

INLINE float64 float64_abs(float64 a)
{
    return a & 0x7fffffffffffffffLL;
}

INLINE float64 float64_chs(float64 a)
{
    return a ^ 0x8000000000000000LL;
}

#ifdef FLOATX80

/*----------------------------------------------------------------------------
| Software IEC/IEEE extended double-precision conversion routines.
*----------------------------------------------------------------------------*/
int floatx80_to_int32( floatx80 STATUS_PARAM );
int floatx80_to_int32_round_to_zero( floatx80 STATUS_PARAM );
int64_t floatx80_to_int64( floatx80 STATUS_PARAM );
int64_t floatx80_to_int64_round_to_zero( floatx80 STATUS_PARAM );
float32 floatx80_to_float32( floatx80 STATUS_PARAM );
float64 floatx80_to_float64( floatx80 STATUS_PARAM );
#ifdef FLOAT128
float128 floatx80_to_float128( floatx80 STATUS_PARAM );
#endif

/*----------------------------------------------------------------------------
| Software IEC/IEEE extended double-precision operations.
*----------------------------------------------------------------------------*/
floatx80 floatx80_round_to_int( floatx80 STATUS_PARAM );
floatx80 floatx80_add( floatx80, floatx80 STATUS_PARAM );
floatx80 floatx80_sub( floatx80, floatx80 STATUS_PARAM );
floatx80 floatx80_mul( floatx80, floatx80 STATUS_PARAM );
floatx80 floatx80_div( floatx80, floatx80 STATUS_PARAM );
floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM );
floatx80 floatx80_sqrt( floatx80 STATUS_PARAM );
int floatx80_eq( floatx80, floatx80 STATUS_PARAM );
int floatx80_le( floatx80, floatx80 STATUS_PARAM );
int floatx80_lt( floatx80, floatx80 STATUS_PARAM );
int floatx80_eq_signaling( floatx80, floatx80 STATUS_PARAM );
int floatx80_le_quiet( floatx80, floatx80 STATUS_PARAM );
int floatx80_lt_quiet( floatx80, floatx80 STATUS_PARAM );
int floatx80_is_nan( floatx80 );
int floatx80_is_signaling_nan( floatx80 );
floatx80 floatx80_scalbn( floatx80, int STATUS_PARAM );

INLINE floatx80 floatx80_abs(floatx80 a)
{
    a.high &= 0x7fff;
    return a;
}

INLINE floatx80 floatx80_chs(floatx80 a)
{
    a.high ^= 0x8000;
    return a;
}

#endif

#ifdef FLOAT128

/*----------------------------------------------------------------------------
| Software IEC/IEEE quadruple-precision conversion routines.
*----------------------------------------------------------------------------*/
int float128_to_int32( float128 STATUS_PARAM );
int float128_to_int32_round_to_zero( float128 STATUS_PARAM );
int64_t float128_to_int64( float128 STATUS_PARAM );
int64_t float128_to_int64_round_to_zero( float128 STATUS_PARAM );
float32 float128_to_float32( float128 STATUS_PARAM );
float64 float128_to_float64( float128 STATUS_PARAM );
#ifdef FLOATX80
floatx80 float128_to_floatx80( float128 STATUS_PARAM );
#endif

/*----------------------------------------------------------------------------
| Software IEC/IEEE quadruple-precision operations.
*----------------------------------------------------------------------------*/
float128 float128_round_to_int( float128 STATUS_PARAM );
float128 float128_add( float128, float128 STATUS_PARAM );
float128 float128_sub( float128, float128 STATUS_PARAM );
float128 float128_mul( float128, float128 STATUS_PARAM );
float128 float128_div( float128, float128 STATUS_PARAM );
float128 float128_rem( float128, float128 STATUS_PARAM );
float128 float128_sqrt( float128 STATUS_PARAM );
int float128_eq( float128, float128 STATUS_PARAM );
int float128_le( float128, float128 STATUS_PARAM );
int float128_lt( float128, float128 STATUS_PARAM );
int float128_eq_signaling( float128, float128 STATUS_PARAM );
int float128_le_quiet( float128, float128 STATUS_PARAM );
int float128_lt_quiet( float128, float128 STATUS_PARAM );
int float128_is_nan( float128 );
int float128_is_signaling_nan( float128 );
float128 float128_scalbn( float128, int STATUS_PARAM );

INLINE float128 float128_abs(float128 a)
{
    a.high &= 0x7fffffffffffffffLL;
    return a;
}

INLINE float128 float128_chs(float128 a)
{
    a.high ^= 0x8000000000000000LL;
    return a;
}

#endif

#else /* CONFIG_SOFTFLOAT */

#include "softfloat-native.h"

#endif /* !CONFIG_SOFTFLOAT */

#endif /* !SOFTFLOAT_H */
Commit	Line	Data
158142c2 FB	1	/*============================================================================
	2
	3	This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic
	4	Package, Release 2b.
	5
	6	Written by John R. Hauser. This work was made possible in part by the
	7	International Computer Science Institute, located at Suite 600, 1947 Center
	8	Street, Berkeley, California 94704. Funding was partially provided by the
	9	National Science Foundation under grant MIP-9311980. The original version
	10	of this code was written as part of a project to build a fixed-point vector
	11	processor in collaboration with the University of California at Berkeley,
	12	overseen by Profs. Nelson Morgan and John Wawrzynek. More information
	13	is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
	14	arithmetic/SoftFloat.html'.
	15
	16	THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has
	17	been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
	18	RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
	19	AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
	20	COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
	21	EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
	22	INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
	23	OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
	24
	25	Derivative works are acceptable, even for commercial purposes, so long as
	26	(1) the source code for the derivative work includes prominent notice that
	27	the work is derivative, and (2) the source code includes prominent notice with
	28	these four paragraphs for those parts of this code that are retained.
	29
	30	=============================================================================*/
	31
	32	#ifndef SOFTFLOAT_H
	33	#define SOFTFLOAT_H
	34
0475a5ca TS	35	#if defined(HOST_SOLARIS) && defined(NEEDS_LIBSUNMATH)
	36	#include <sunmath.h>
	37	#endif
	38
158142c2 FB	39	#include <inttypes.h>
	40	#include "config.h"
	41
	42	/*----------------------------------------------------------------------------
	43	\| Each of the following `typedef's defines the most convenient type that holds
	44	\| integers of at least as many bits as specified. For example, `uint8' should
	45	\| be the most convenient type that can hold unsigned integers of as many as
	46	\| 8 bits. The `flag' type must be able to hold either a 0 or 1. For most
	47	\| implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed
	48	\| to the same as `int'.
	49	----------------------------------------------------------------------------/
750afe93	50	typedef uint8_t flag;
158142c2 FB	51	typedef uint8_t uint8;
	52	typedef int8_t int8;
	53	typedef int uint16;
	54	typedef int int16;
	55	typedef unsigned int uint32;
	56	typedef signed int int32;
	57	typedef uint64_t uint64;
	58	typedef int64_t int64;
	59
	60	/*----------------------------------------------------------------------------
	61	\| Each of the following `typedef's defines a type that holds integers
	62	\| of _exactly_ the number of bits specified. For instance, for most
	63	\| implementation of C, `bits16' and `sbits16' should be `typedef'ed to
	64	\| `unsigned short int' and `signed short int' (or `short int'), respectively.
	65	----------------------------------------------------------------------------/
	66	typedef uint8_t bits8;
	67	typedef int8_t sbits8;
	68	typedef uint16_t bits16;
	69	typedef int16_t sbits16;
	70	typedef uint32_t bits32;
	71	typedef int32_t sbits32;
	72	typedef uint64_t bits64;
	73	typedef int64_t sbits64;
	74
	75	#define LIT64( a ) a##LL
	76	#define INLINE static inline
	77
	78	/*----------------------------------------------------------------------------
	79	\| The macro `FLOATX80' must be defined to enable the extended double-precision
	80	\| floating-point format `floatx80'. If this macro is not defined, the
	81	\| `floatx80' type will not be defined, and none of the functions that either
	82	\| input or output the `floatx80' type will be defined. The same applies to
	83	\| the `FLOAT128' macro and the quadruple-precision format `float128'.
	84	----------------------------------------------------------------------------/
	85	#ifdef CONFIG_SOFTFLOAT
	86	/* bit exact soft float support */
	87	#define FLOATX80
	88	#define FLOAT128
	89	#else
	90	/* native float support */
	91	#if (defined(__i386__) \|\| defined(__x86_64__)) && !defined(_BSD)
	92	#define FLOATX80
	93	#endif
	94	#endif /* !CONFIG_SOFTFLOAT */
	95
	96	#define STATUS_PARAM , float_status *status
	97	#define STATUS(field) status->field
	98	#define STATUS_VAR , status
	99
1d6bda35 FB	100	/*----------------------------------------------------------------------------
	101	\| Software IEC/IEEE floating-point ordering relations
	102	----------------------------------------------------------------------------/
	103	enum {
	104	float_relation_less = -1,
	105	float_relation_equal = 0,
	106	float_relation_greater = 1,
	107	float_relation_unordered = 2
	108	};
	109
158142c2 FB	110	#ifdef CONFIG_SOFTFLOAT
	111	/*----------------------------------------------------------------------------
	112	\| Software IEC/IEEE floating-point types.
	113	----------------------------------------------------------------------------/
	114	typedef uint32_t float32;
	115	typedef uint64_t float64;
	116	#ifdef FLOATX80
	117	typedef struct {
	118	uint64_t low;
	119	uint16_t high;
	120	} floatx80;
	121	#endif
	122	#ifdef FLOAT128
	123	typedef struct {
	124	#ifdef WORDS_BIGENDIAN
	125	uint64_t high, low;
	126	#else
	127	uint64_t low, high;
	128	#endif
	129	} float128;
	130	#endif
	131
	132	/*----------------------------------------------------------------------------
	133	\| Software IEC/IEEE floating-point underflow tininess-detection mode.
	134	----------------------------------------------------------------------------/
	135	enum {
	136	float_tininess_after_rounding = 0,
	137	float_tininess_before_rounding = 1
	138	};
	139
	140	/*----------------------------------------------------------------------------
	141	\| Software IEC/IEEE floating-point rounding mode.
	142	----------------------------------------------------------------------------/
	143	enum {
	144	float_round_nearest_even = 0,
	145	float_round_down = 1,
	146	float_round_up = 2,
	147	float_round_to_zero = 3
	148	};
	149
	150	/*----------------------------------------------------------------------------
	151	\| Software IEC/IEEE floating-point exception flags.
	152	----------------------------------------------------------------------------/
	153	enum {
	154	float_flag_invalid = 1,
	155	float_flag_divbyzero = 4,
	156	float_flag_overflow = 8,
	157	float_flag_underflow = 16,
	158	float_flag_inexact = 32
	159	};
	160
	161	typedef struct float_status {
	162	signed char float_detect_tininess;
	163	signed char float_rounding_mode;
	164	signed char float_exception_flags;
	165	#ifdef FLOATX80
	166	signed char floatx80_rounding_precision;
	167	#endif
	168	} float_status;
	169
	170	void set_float_rounding_mode(int val STATUS_PARAM);
1d6bda35 FB	171	void set_float_exception_flags(int val STATUS_PARAM);
	172	INLINE int get_float_exception_flags(float_status *status)
	173	{
	174	return STATUS(float_exception_flags);
	175	}
158142c2 FB	176	#ifdef FLOATX80
	177	void set_floatx80_rounding_precision(int val STATUS_PARAM);
	178	#endif
	179
	180	/*----------------------------------------------------------------------------
	181	\| Routine to raise any or all of the software IEC/IEEE floating-point
	182	\| exception flags.
	183	----------------------------------------------------------------------------/
ec530c81	184	void float_raise( int8 flags STATUS_PARAM);
158142c2 FB	185
	186	/*----------------------------------------------------------------------------
	187	\| Software IEC/IEEE integer-to-floating-point conversion routines.
	188	----------------------------------------------------------------------------/
	189	float32 int32_to_float32( int STATUS_PARAM );
	190	float64 int32_to_float64( int STATUS_PARAM );
1d6bda35 FB	191	float32 uint32_to_float32( unsigned int STATUS_PARAM );
1d6bda35 FB	192	float64 uint32_to_float64( unsigned int STATUS_PARAM );
158142c2 FB	193	#ifdef FLOATX80
	194	floatx80 int32_to_floatx80( int STATUS_PARAM );
	195	#endif
	196	#ifdef FLOAT128
	197	float128 int32_to_float128( int STATUS_PARAM );
	198	#endif
	199	float32 int64_to_float32( int64_t STATUS_PARAM );
75d62a58	200	float32 uint64_to_float32( uint64_t STATUS_PARAM );
158142c2	201	float64 int64_to_float64( int64_t STATUS_PARAM );
75d62a58	202	float64 uint64_to_float64( uint64_t STATUS_PARAM );
158142c2 FB	203	#ifdef FLOATX80
	204	floatx80 int64_to_floatx80( int64_t STATUS_PARAM );
	205	#endif
	206	#ifdef FLOAT128
	207	float128 int64_to_float128( int64_t STATUS_PARAM );
	208	#endif
	209
	210	/*----------------------------------------------------------------------------
	211	\| Software IEC/IEEE single-precision conversion routines.
	212	----------------------------------------------------------------------------/
	213	int float32_to_int32( float32 STATUS_PARAM );
	214	int float32_to_int32_round_to_zero( float32 STATUS_PARAM );
1d6bda35 FB	215	unsigned int float32_to_uint32( float32 STATUS_PARAM );
1d6bda35 FB	216	unsigned int float32_to_uint32_round_to_zero( float32 STATUS_PARAM );
158142c2 FB	217	int64_t float32_to_int64( float32 STATUS_PARAM );
	218	int64_t float32_to_int64_round_to_zero( float32 STATUS_PARAM );
	219	float64 float32_to_float64( float32 STATUS_PARAM );
	220	#ifdef FLOATX80
	221	floatx80 float32_to_floatx80( float32 STATUS_PARAM );
	222	#endif
	223	#ifdef FLOAT128
	224	float128 float32_to_float128( float32 STATUS_PARAM );
	225	#endif
	226
	227	/*----------------------------------------------------------------------------
	228	\| Software IEC/IEEE single-precision operations.
	229	----------------------------------------------------------------------------/
	230	float32 float32_round_to_int( float32 STATUS_PARAM );
	231	float32 float32_add( float32, float32 STATUS_PARAM );
	232	float32 float32_sub( float32, float32 STATUS_PARAM );
	233	float32 float32_mul( float32, float32 STATUS_PARAM );
	234	float32 float32_div( float32, float32 STATUS_PARAM );
	235	float32 float32_rem( float32, float32 STATUS_PARAM );
	236	float32 float32_sqrt( float32 STATUS_PARAM );
750afe93 FB	237	int float32_eq( float32, float32 STATUS_PARAM );
	238	int float32_le( float32, float32 STATUS_PARAM );
	239	int float32_lt( float32, float32 STATUS_PARAM );
	240	int float32_eq_signaling( float32, float32 STATUS_PARAM );
	241	int float32_le_quiet( float32, float32 STATUS_PARAM );
	242	int float32_lt_quiet( float32, float32 STATUS_PARAM );
	243	int float32_compare( float32, float32 STATUS_PARAM );
	244	int float32_compare_quiet( float32, float32 STATUS_PARAM );
924b2c07	245	int float32_is_nan( float32 );
750afe93	246	int float32_is_signaling_nan( float32 );
9ee6e8bb	247	float32 float32_scalbn( float32, int STATUS_PARAM );
158142c2	248
1d6bda35 FB	249	INLINE float32 float32_abs(float32 a)
	250	{
	251	return a & 0x7fffffff;
	252	}
	253
	254	INLINE float32 float32_chs(float32 a)
	255	{
	256	return a ^ 0x80000000;
	257	}
	258
158142c2 FB	259	/*----------------------------------------------------------------------------
	260	\| Software IEC/IEEE double-precision conversion routines.
	261	----------------------------------------------------------------------------/
	262	int float64_to_int32( float64 STATUS_PARAM );
	263	int float64_to_int32_round_to_zero( float64 STATUS_PARAM );
1d6bda35 FB	264	unsigned int float64_to_uint32( float64 STATUS_PARAM );
1d6bda35 FB	265	unsigned int float64_to_uint32_round_to_zero( float64 STATUS_PARAM );
158142c2 FB	266	int64_t float64_to_int64( float64 STATUS_PARAM );
158142c2 FB	267	int64_t float64_to_int64_round_to_zero( float64 STATUS_PARAM );
75d62a58 JM	268	uint64_t float64_to_uint64 (float64 a STATUS_PARAM);
75d62a58 JM	269	uint64_t float64_to_uint64_round_to_zero (float64 a STATUS_PARAM);
158142c2 FB	270	float32 float64_to_float32( float64 STATUS_PARAM );
	271	#ifdef FLOATX80
	272	floatx80 float64_to_floatx80( float64 STATUS_PARAM );
	273	#endif
	274	#ifdef FLOAT128
	275	float128 float64_to_float128( float64 STATUS_PARAM );
	276	#endif
	277
	278	/*----------------------------------------------------------------------------
	279	\| Software IEC/IEEE double-precision operations.
	280	----------------------------------------------------------------------------/
	281	float64 float64_round_to_int( float64 STATUS_PARAM );
e6e5906b	282	float64 float64_trunc_to_int( float64 STATUS_PARAM );
158142c2 FB	283	float64 float64_add( float64, float64 STATUS_PARAM );
	284	float64 float64_sub( float64, float64 STATUS_PARAM );
	285	float64 float64_mul( float64, float64 STATUS_PARAM );
	286	float64 float64_div( float64, float64 STATUS_PARAM );
	287	float64 float64_rem( float64, float64 STATUS_PARAM );
	288	float64 float64_sqrt( float64 STATUS_PARAM );
750afe93 FB	289	int float64_eq( float64, float64 STATUS_PARAM );
	290	int float64_le( float64, float64 STATUS_PARAM );
	291	int float64_lt( float64, float64 STATUS_PARAM );
	292	int float64_eq_signaling( float64, float64 STATUS_PARAM );
	293	int float64_le_quiet( float64, float64 STATUS_PARAM );
	294	int float64_lt_quiet( float64, float64 STATUS_PARAM );
	295	int float64_compare( float64, float64 STATUS_PARAM );
	296	int float64_compare_quiet( float64, float64 STATUS_PARAM );
924b2c07	297	int float64_is_nan( float64 a );
750afe93	298	int float64_is_signaling_nan( float64 );
9ee6e8bb	299	float64 float64_scalbn( float64, int STATUS_PARAM );
158142c2	300
1d6bda35 FB	301	INLINE float64 float64_abs(float64 a)
	302	{
	303	return a & 0x7fffffffffffffffLL;
	304	}
	305
	306	INLINE float64 float64_chs(float64 a)
	307	{
	308	return a ^ 0x8000000000000000LL;
	309	}
	310
158142c2 FB	311	#ifdef FLOATX80
	312
	313	/*----------------------------------------------------------------------------
	314	\| Software IEC/IEEE extended double-precision conversion routines.
	315	----------------------------------------------------------------------------/
	316	int floatx80_to_int32( floatx80 STATUS_PARAM );
	317	int floatx80_to_int32_round_to_zero( floatx80 STATUS_PARAM );
	318	int64_t floatx80_to_int64( floatx80 STATUS_PARAM );
	319	int64_t floatx80_to_int64_round_to_zero( floatx80 STATUS_PARAM );
	320	float32 floatx80_to_float32( floatx80 STATUS_PARAM );
	321	float64 floatx80_to_float64( floatx80 STATUS_PARAM );
	322	#ifdef FLOAT128
	323	float128 floatx80_to_float128( floatx80 STATUS_PARAM );
	324	#endif
	325
	326	/*----------------------------------------------------------------------------
	327	\| Software IEC/IEEE extended double-precision operations.
	328	----------------------------------------------------------------------------/
	329	floatx80 floatx80_round_to_int( floatx80 STATUS_PARAM );
	330	floatx80 floatx80_add( floatx80, floatx80 STATUS_PARAM );
	331	floatx80 floatx80_sub( floatx80, floatx80 STATUS_PARAM );
	332	floatx80 floatx80_mul( floatx80, floatx80 STATUS_PARAM );
	333	floatx80 floatx80_div( floatx80, floatx80 STATUS_PARAM );
	334	floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM );
	335	floatx80 floatx80_sqrt( floatx80 STATUS_PARAM );
750afe93 FB	336	int floatx80_eq( floatx80, floatx80 STATUS_PARAM );
	337	int floatx80_le( floatx80, floatx80 STATUS_PARAM );
	338	int floatx80_lt( floatx80, floatx80 STATUS_PARAM );
	339	int floatx80_eq_signaling( floatx80, floatx80 STATUS_PARAM );
	340	int floatx80_le_quiet( floatx80, floatx80 STATUS_PARAM );
	341	int floatx80_lt_quiet( floatx80, floatx80 STATUS_PARAM );
924b2c07	342	int floatx80_is_nan( floatx80 );
750afe93	343	int floatx80_is_signaling_nan( floatx80 );
9ee6e8bb	344	floatx80 floatx80_scalbn( floatx80, int STATUS_PARAM );
158142c2	345
1d6bda35 FB	346	INLINE floatx80 floatx80_abs(floatx80 a)
	347	{
	348	a.high &= 0x7fff;
	349	return a;
	350	}
	351
	352	INLINE floatx80 floatx80_chs(floatx80 a)
	353	{
	354	a.high ^= 0x8000;
	355	return a;
	356	}
	357
158142c2 FB	358	#endif
	359
	360	#ifdef FLOAT128
	361
	362	/*----------------------------------------------------------------------------
	363	\| Software IEC/IEEE quadruple-precision conversion routines.
	364	----------------------------------------------------------------------------/
	365	int float128_to_int32( float128 STATUS_PARAM );
	366	int float128_to_int32_round_to_zero( float128 STATUS_PARAM );
	367	int64_t float128_to_int64( float128 STATUS_PARAM );
	368	int64_t float128_to_int64_round_to_zero( float128 STATUS_PARAM );
	369	float32 float128_to_float32( float128 STATUS_PARAM );
	370	float64 float128_to_float64( float128 STATUS_PARAM );
	371	#ifdef FLOATX80
	372	floatx80 float128_to_floatx80( float128 STATUS_PARAM );
	373	#endif
	374
	375	/*----------------------------------------------------------------------------
	376	\| Software IEC/IEEE quadruple-precision operations.
	377	----------------------------------------------------------------------------/
	378	float128 float128_round_to_int( float128 STATUS_PARAM );
	379	float128 float128_add( float128, float128 STATUS_PARAM );
	380	float128 float128_sub( float128, float128 STATUS_PARAM );
	381	float128 float128_mul( float128, float128 STATUS_PARAM );
	382	float128 float128_div( float128, float128 STATUS_PARAM );
	383	float128 float128_rem( float128, float128 STATUS_PARAM );
	384	float128 float128_sqrt( float128 STATUS_PARAM );
750afe93 FB	385	int float128_eq( float128, float128 STATUS_PARAM );
	386	int float128_le( float128, float128 STATUS_PARAM );
	387	int float128_lt( float128, float128 STATUS_PARAM );
	388	int float128_eq_signaling( float128, float128 STATUS_PARAM );
	389	int float128_le_quiet( float128, float128 STATUS_PARAM );
	390	int float128_lt_quiet( float128, float128 STATUS_PARAM );
924b2c07	391	int float128_is_nan( float128 );
750afe93	392	int float128_is_signaling_nan( float128 );
9ee6e8bb	393	float128 float128_scalbn( float128, int STATUS_PARAM );
158142c2	394
1d6bda35 FB	395	INLINE float128 float128_abs(float128 a)
	396	{
	397	a.high &= 0x7fffffffffffffffLL;
	398	return a;
	399	}
	400
	401	INLINE float128 float128_chs(float128 a)
	402	{
	403	a.high ^= 0x8000000000000000LL;
	404	return a;
	405	}
	406
158142c2 FB	407	#endif
	408
	409	#else /* CONFIG_SOFTFLOAT */
	410
	411	#include "softfloat-native.h"
	412
	413	#endif /* !CONFIG_SOFTFLOAT */
	414
	415	#endif /* !SOFTFLOAT_H */