Hardware/litex
1
0
Fork 0
mirror of https://github.com/enjoy-digital/litex.git synced 2025-01-04 09:52:26 -05:00
Code Issues Projects Releases Packages Wiki Activity

software/libbase: upgrade softfloat to version 2b + add support for more precision

Browse source
This commit is contained in:
Sebastien Bourdeauducq 2012-05-24 23:21:18 +02:00
parent 22f7d1716e
commit 97b77945e5
5 changed files with 3268 additions and 1930 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

138
software/libbase/milieu.h
View file

@ -1,9 +1,8 @@
/* /*============================================================================
===============================================================================
This C header file is part of the SoftFloat IEC/IEEE Floating-point This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic
Arithmetic Package, Release 2. Package, Release 2b.
Written by John R. Hauser. This work was made possible in part by the Written by John R. Hauser. This work was made possible in part by the
International Computer Science Institute, located at Suite 600, 1947 Center International Computer Science Institute, located at Suite 600, 1947 Center
@ -12,54 +11,48 @@ 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 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, processor in collaboration with the University of California at Berkeley,
overseen by Profs. Nelson Morgan and John Wawrzynek. More information overseen by Profs. Nelson Morgan and John Wawrzynek. More information
is available through the Web page `http://http.cs.berkeley.edu/~jhauser/ is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
arithmetic/softfloat.html'. arithmetic/SoftFloat.html'.
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. 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 Derivative works are acceptable, even for commercial purposes, so long as
(1) they include prominent notice that the work is derivative, and (2) they (1) the source code for the derivative work includes prominent notice that
include prominent notice akin to these three paragraphs for those parts of the work is derivative, and (2) the source code includes prominent notice with
this code that are retained. these four paragraphs for those parts of this code that are retained.
=============================================================================== =============================================================================*/
*/
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | Include common integer types and flags.
Common integer types and flags. *----------------------------------------------------------------------------*/
-------------------------------------------------------------------------------
*/
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined.
One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined. *----------------------------------------------------------------------------*/
-------------------------------------------------------------------------------
*/
#define BIGENDIAN #define BIGENDIAN
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | The macro `BITS64' can be defined to indicate that 64-bit integer types are
The macro `BITS64' can be defined to indicate that 64-bit integer types are | supported by the compiler.
supported by the compiler. *----------------------------------------------------------------------------*/
-------------------------------------------------------------------------------
*/
//#define BITS64 //#define BITS64
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | Each of the following `typedef's defines the most convenient type that holds
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
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
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
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
implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed | to the same as `int'.
to the same as `int'. *----------------------------------------------------------------------------*/
-------------------------------------------------------------------------------
*/
typedef int flag; typedef int flag;
typedef int uint8; typedef int uint8;
typedef int int8; typedef int int8;
@ -68,18 +61,16 @@ typedef int int16;
typedef unsigned int uint32; typedef unsigned int uint32;
typedef signed int int32; typedef signed int int32;
#ifdef BITS64 #ifdef BITS64
typedef unsigned long long int bits64; typedef unsigned long long int uint64;
typedef signed long long int sbits64; typedef signed long long int int64;
#endif #endif
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | Each of the following `typedef's defines a type that holds integers
Each of the following `typedef's defines a type that holds integers | of _exactly_ the number of bits specified. For instance, for most
of _exactly_ the number of bits specified. For instance, for most | implementation of C, `bits16' and `sbits16' should be `typedef'ed to
implementation of C, `bits16' and `sbits16' should be `typedef'ed to | `unsigned short int' and `signed short int' (or `short int'), respectively.
`unsigned short int' and `signed short int' (or `short int'), respectively. *----------------------------------------------------------------------------*/
-------------------------------------------------------------------------------
*/
typedef unsigned char bits8; typedef unsigned char bits8;
typedef signed char sbits8; typedef signed char sbits8;
typedef unsigned short int bits16; typedef unsigned short int bits16;
@ -87,38 +78,33 @@ typedef signed short int sbits16;
typedef unsigned int bits32; typedef unsigned int bits32;
typedef signed int sbits32; typedef signed int sbits32;
#ifdef BITS64 #ifdef BITS64
typedef unsigned long long int uint64; typedef unsigned long long int bits64;
typedef signed long long int int64; typedef signed long long int sbits64;
#endif #endif
#ifdef BITS64 #ifdef BITS64
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | The `LIT64' macro takes as its argument a textual integer literal and
The `LIT64' macro takes as its argument a textual integer literal and if | if necessary ``marks'' the literal as having a 64-bit integer type.
necessary ``marks'' the literal as having a 64-bit integer type. For | For example, the GNU C Compiler (`gcc') requires that 64-bit literals be
example, the Gnu C Compiler (`gcc') requires that 64-bit literals be | appended with the letters `LL' standing for `long long', which is `gcc's
appended with the letters `LL' standing for `long long', which is `gcc's | name for the 64-bit integer type. Some compilers may allow `LIT64' to be
name for the 64-bit integer type. Some compilers may allow `LIT64' to be | defined as the identity macro: `#define LIT64( a ) a'.
defined as the identity macro: `#define LIT64( a ) a'. *----------------------------------------------------------------------------*/
-------------------------------------------------------------------------------
*/
#define LIT64( a ) a##LL #define LIT64( a ) a##LL
#endif #endif
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | The macro `INLINE' can be used before functions that should be inlined. If
The macro `INLINE' can be used before functions that should be inlined. If | a compiler does not support explicit inlining, this macro should be defined
a compiler does not support explicit inlining, this macro should be defined | to be `static'.
to be `static'. *----------------------------------------------------------------------------*/
-------------------------------------------------------------------------------
*/
#define INLINE extern inline #define INLINE extern inline
/*
------------------------------------------------------------------------------- /*----------------------------------------------------------------------------
Symbolic Boolean literals. | Symbolic Boolean literals.
------------------------------------------------------------------------------- *----------------------------------------------------------------------------*/
*/
enum { enum {
FALSE = 0, FALSE = 0,
TRUE = 1 TRUE = 1

1273
software/libbase/softfloat-macros.h
View file

File diff suppressed because it is too large Load diff

233
software/libbase/softfloat-specialize.h
View file

@ -1,9 +1,8 @@
/* /*============================================================================
===============================================================================
This C source fragment is part of the SoftFloat IEC/IEEE Floating-point This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
Arithmetic Package, Release 2. Arithmetic Package, Release 2b.
Written by John R. Hauser. This work was made possible in part by the Written by John R. Hauser. This work was made possible in part by the
International Computer Science Institute, located at Suite 600, 1947 Center International Computer Science Institute, located at Suite 600, 1947 Center
@ -12,39 +11,38 @@ 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 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, processor in collaboration with the University of California at Berkeley,
overseen by Profs. Nelson Morgan and John Wawrzynek. More information overseen by Profs. Nelson Morgan and John Wawrzynek. More information
is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/ is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
arithmetic/softfloat.html'. arithmetic/SoftFloat.html'.
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. 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 Derivative works are acceptable, even for commercial purposes, so long as
(1) they include prominent notice that the work is derivative, and (2) they (1) the source code for the derivative work includes prominent notice that
include prominent notice akin to these three paragraphs for those parts of the work is derivative, and (2) the source code includes prominent notice with
this code that are retained. these four paragraphs for those parts of this code that are retained.
=============================================================================== =============================================================================*/
*/
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | Underflow tininess-detection mode, statically initialized to default value.
Underflow tininess-detection mode, statically initialized to default value. | (The declaration in `softfloat.h' must match the `int8' type here.)
(The declaration in `softfloat.h' must match the `int8' type here.) *----------------------------------------------------------------------------*/
-------------------------------------------------------------------------------
*/
int8 float_detect_tininess = float_tininess_after_rounding; int8 float_detect_tininess = float_tininess_after_rounding;
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | Raises the exceptions specified by `flags'. Floating-point traps can be
Raises the exceptions specified by `flags'. Floating-point traps can be | defined here if desired. It is currently not possible for such a trap
defined here if desired. It is currently not possible for such a trap to | to substitute a result value. If traps are not implemented, this routine
substitute a result value. If traps are not implemented, this routine | should be simply `float_exception_flags |= flags;'.
should be simply `float_exception_flags |= flags;'. *----------------------------------------------------------------------------*/
-------------------------------------------------------------------------------
*/
void float_raise( int8 flags ) void float_raise( int8 flags )
{ {
@ -52,31 +50,26 @@ void float_raise( int8 flags )
} }
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | Internal canonical NaN format.
Internal canonical NaN format. *----------------------------------------------------------------------------*/
-------------------------------------------------------------------------------
*/
typedef struct { typedef struct {
flag sign; flag sign;
bits32 high, low; bits32 high, low;
} commonNaNT; } commonNaNT;
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | The pattern for a default generated single-precision NaN.
The pattern for a default generated single-precision NaN. *----------------------------------------------------------------------------*/
-------------------------------------------------------------------------------
*/
enum { enum {
float32_default_nan = 0xFFFFFFFF float32_default_nan = 0xFFFFFFFF
}; };
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | Returns 1 if the single-precision floating-point value `a' is a NaN;
Returns 1 if the single-precision floating-point value `a' is a NaN; | otherwise returns 0.
otherwise returns 0. *----------------------------------------------------------------------------*/
-------------------------------------------------------------------------------
*/
flag float32_is_nan( float32 a ) flag float32_is_nan( float32 a )
{ {
@ -84,12 +77,11 @@ flag float32_is_nan( float32 a )
} }
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | Returns 1 if the single-precision floating-point value `a' is a signaling
Returns 1 if the single-precision floating-point value `a' is a signaling | NaN; otherwise returns 0.
NaN; otherwise returns 0. *----------------------------------------------------------------------------*/
-------------------------------------------------------------------------------
*/
flag float32_is_signaling_nan( float32 a ) flag float32_is_signaling_nan( float32 a )
{ {
@ -97,13 +89,42 @@ flag float32_is_signaling_nan( float32 a )
} }
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | Returns the result of converting the single-precision floating-point NaN
Takes two single-precision floating-point values `a' and `b', one of which | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a | exception is raised.
signaling NaN, the invalid exception is raised. *----------------------------------------------------------------------------*/
-------------------------------------------------------------------------------
*/ static commonNaNT float32ToCommonNaN( float32 a )
{
commonNaNT z;
if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
z.sign = a>>31;
z.low = 0;
z.high = a<<9;
return z;
}
/*----------------------------------------------------------------------------
| Returns the result of converting the canonical NaN `a' to the single-
| precision floating-point format.
*----------------------------------------------------------------------------*/
static float32 commonNaNToFloat32( commonNaNT a )
{
return ( ( (bits32) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>9 );
}
/*----------------------------------------------------------------------------
| Takes two single-precision floating-point values `a' and `b', one of which
| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
| signaling NaN, the invalid exception is raised.
*----------------------------------------------------------------------------*/
static float32 propagateFloat32NaN( float32 a, float32 b ) static float32 propagateFloat32NaN( float32 a, float32 b )
{ {
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
@ -123,3 +144,99 @@ static float32 propagateFloat32NaN( float32 a, float32 b )
} }
} }
/*----------------------------------------------------------------------------
| The pattern for a default generated double-precision NaN. The `high' and
| `low' values hold the most- and least-significant bits, respectively.
*----------------------------------------------------------------------------*/
enum {
float64_default_nan_high = 0xFFFFFFFF,
float64_default_nan_low = 0xFFFFFFFF
};
/*----------------------------------------------------------------------------
| Returns 1 if the double-precision floating-point value `a' is a NaN;
| otherwise returns 0.
*----------------------------------------------------------------------------*/
flag float64_is_nan( float64 a )
{
return
( 0xFFE00000 <= (bits32) ( a.high<<1 ) )
&& ( a.low || ( a.high & 0x000FFFFF ) );
}
/*----------------------------------------------------------------------------
| Returns 1 if the double-precision floating-point value `a' is a signaling
| NaN; otherwise returns 0.
*----------------------------------------------------------------------------*/
flag float64_is_signaling_nan( float64 a )
{
return
( ( ( a.high>>19 ) & 0xFFF ) == 0xFFE )
&& ( a.low || ( a.high & 0x0007FFFF ) );
}
/*----------------------------------------------------------------------------
| Returns the result of converting the double-precision floating-point NaN
| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
| exception is raised.
*----------------------------------------------------------------------------*/
static commonNaNT float64ToCommonNaN( float64 a )
{
commonNaNT z;
if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
z.sign = a.high>>31;
shortShift64Left( a.high, a.low, 12, &z.high, &z.low );
return z;
}
/*----------------------------------------------------------------------------
| Returns the result of converting the canonical NaN `a' to the double-
| precision floating-point format.
*----------------------------------------------------------------------------*/
static float64 commonNaNToFloat64( commonNaNT a )
{
float64 z;
shift64Right( a.high, a.low, 12, &z.high, &z.low );
z.high |= ( ( (bits32) a.sign )<<31 ) | 0x7FF80000;
return z;
}
/*----------------------------------------------------------------------------
| Takes two double-precision floating-point values `a' and `b', one of which
| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
| signaling NaN, the invalid exception is raised.
*----------------------------------------------------------------------------*/
static float64 propagateFloat64NaN( float64 a, float64 b )
{
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
aIsNaN = float64_is_nan( a );
aIsSignalingNaN = float64_is_signaling_nan( a );
bIsNaN = float64_is_nan( b );
bIsSignalingNaN = float64_is_signaling_nan( b );
a.high |= 0x00080000;
b.high |= 0x00080000;
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
if ( aIsNaN ) {
return ( aIsSignalingNaN & bIsNaN ) ? b : a;
}
else {
return b;
}
}

3300
software/libbase/softfloat.c
View file

File diff suppressed because it is too large Load diff

254
software/libbase/softfloat.h
View file

@ -1,120 +1,134 @@
/* /*============================================================================
===============================================================================
This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic
This C header file is part of the SoftFloat IEC/IEEE Floating-point Package, Release 2b.
Arithmetic Package, Release 2.
Written by John R. Hauser. This work was made possible in part by the
Written by John R. Hauser. This work was made possible in part by the International Computer Science Institute, located at Suite 600, 1947 Center
International Computer Science Institute, located at Suite 600, 1947 Center Street, Berkeley, California 94704. Funding was partially provided by the
Street, Berkeley, California 94704. Funding was partially provided by the National Science Foundation under grant MIP-9311980. The original version
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
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,
processor in collaboration with the University of California at Berkeley, overseen by Profs. Nelson Morgan and John Wawrzynek. More information
overseen by Profs. Nelson Morgan and John Wawrzynek. More information is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/ arithmetic/SoftFloat.html'.
arithmetic/softfloat.html'.
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
Derivative works are acceptable, even for commercial purposes, so long as OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
(1) they include prominent notice that the work is derivative, and (2) they
include prominent notice akin to these three paragraphs for those parts of Derivative works are acceptable, even for commercial purposes, so long as
this code that are retained. (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.
*/
=============================================================================*/
/*
------------------------------------------------------------------------------- /*----------------------------------------------------------------------------
Software IEC/IEEE floating-point types. | Software IEC/IEEE floating-point types.
------------------------------------------------------------------------------- *----------------------------------------------------------------------------*/
*/ typedef bits32 float32;
typedef unsigned int float32; typedef struct {
bits32 high, low;
/* } float64;
-------------------------------------------------------------------------------
Software IEC/IEEE floating-point underflow tininess-detection mode. /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | Software IEC/IEEE floating-point underflow tininess-detection mode.
*/ *----------------------------------------------------------------------------*/
extern int float_detect_tininess; extern int8 float_detect_tininess;
enum { enum {
float_tininess_after_rounding = 0, float_tininess_after_rounding = 0,
float_tininess_before_rounding = 1 float_tininess_before_rounding = 1
}; };
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | Software IEC/IEEE floating-point rounding mode.
Software IEC/IEEE floating-point rounding mode. *----------------------------------------------------------------------------*/
------------------------------------------------------------------------------- extern int8 float_rounding_mode;
*/ enum {
extern int float_rounding_mode; float_round_nearest_even = 0,
enum { float_round_to_zero = 1,
float_round_nearest_even = 0, float_round_down = 2,
float_round_to_zero = 1, float_round_up = 3
float_round_up = 2, };
float_round_down = 3
}; /*----------------------------------------------------------------------------
| Software IEC/IEEE floating-point exception flags.
/* *----------------------------------------------------------------------------*/
------------------------------------------------------------------------------- extern int8 float_exception_flags;
Software IEC/IEEE floating-point exception flags. enum {
------------------------------------------------------------------------------- float_flag_inexact = 1,
*/ float_flag_underflow = 2,
extern int float_exception_flags; float_flag_overflow = 4,
enum { float_flag_divbyzero = 8,
float_flag_inexact = 1, float_flag_invalid = 16
float_flag_divbyzero = 2, };
float_flag_underflow = 4,
float_flag_overflow = 8, /*----------------------------------------------------------------------------
float_flag_invalid = 16 | Routine to raise any or all of the software IEC/IEEE floating-point
}; | exception flags.
*----------------------------------------------------------------------------*/
/* void float_raise( int8 );
-------------------------------------------------------------------------------
Routine to raise any or all of the software IEC/IEEE floating-point /*----------------------------------------------------------------------------
exception flags. | Software IEC/IEEE integer-to-floating-point conversion routines.
------------------------------------------------------------------------------- *----------------------------------------------------------------------------*/
*/ float32 int32_to_float32( int32 );
void float_raise( int ); float64 int32_to_float64( int32 );
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | Software IEC/IEEE single-precision conversion routines.
Software IEC/IEEE integer-to-floating-point conversion routines. *----------------------------------------------------------------------------*/
------------------------------------------------------------------------------- int32 float32_to_int32( float32 );
*/ int32 float32_to_int32_round_to_zero( float32 );
float32 int32_to_float32( int ); float64 float32_to_float64( float32 );
/* /*----------------------------------------------------------------------------
------------------------------------------------------------------------------- | Software IEC/IEEE single-precision operations.
Software IEC/IEEE single-precision conversion routines. *----------------------------------------------------------------------------*/
------------------------------------------------------------------------------- float32 float32_round_to_int( float32 );
*/ float32 float32_add( float32, float32 );
int float32_to_int32( float32 ); float32 float32_sub( float32, float32 );
int float32_to_int32_round_to_zero( float32 ); float32 float32_mul( float32, float32 );
float32 float32_div( float32, float32 );
/* float32 float32_rem( float32, float32 );
------------------------------------------------------------------------------- float32 float32_sqrt( float32 );
Software IEC/IEEE single-precision operations. flag float32_eq( float32, float32 );
------------------------------------------------------------------------------- flag float32_le( float32, float32 );
*/ flag float32_lt( float32, float32 );
float32 float32_round_to_int( float32 ); flag float32_eq_signaling( float32, float32 );
float32 float32_add( float32, float32 ); flag float32_le_quiet( float32, float32 );
float32 float32_sub( float32, float32 ); flag float32_lt_quiet( float32, float32 );
float32 float32_mul( float32, float32 ); flag float32_is_signaling_nan( float32 );
float32 float32_div( float32, float32 );
float32 float32_rem( float32, float32 ); /*----------------------------------------------------------------------------
float32 float32_sqrt( float32 ); | Software IEC/IEEE double-precision conversion routines.
flag float32_eq( float32, float32 ); *----------------------------------------------------------------------------*/
flag float32_le( float32, float32 ); int32 float64_to_int32( float64 );
flag float32_lt( float32, float32 ); int32 float64_to_int32_round_to_zero( float64 );
flag float32_eq_signaling( float32, float32 ); float32 float64_to_float32( float64 );
flag float32_le_quiet( float32, float32 );
flag float32_lt_quiet( float32, float32 ); /*----------------------------------------------------------------------------
flag float32_is_nan( float32 a ); | Software IEC/IEEE double-precision operations.
flag float32_is_signaling_nan( float32 ); *----------------------------------------------------------------------------*/
float64 float64_round_to_int( float64 );
float64 float64_add( float64, float64 );
float64 float64_sub( float64, float64 );
float64 float64_mul( float64, float64 );
float64 float64_div( float64, float64 );
float64 float64_rem( float64, float64 );
float64 float64_sqrt( float64 );
flag float64_eq( float64, float64 );
flag float64_le( float64, float64 );
flag float64_lt( float64, float64 );
flag float64_eq_signaling( float64, float64 );
flag float64_le_quiet( float64, float64 );
flag float64_lt_quiet( float64, float64 );
flag float64_is_signaling_nan( float64 );