mirror of
https://github.com/cc65/cc65.git
synced 2024-09-29 17:56:21 +00:00
softfloat compiles and produces a working binary
This commit is contained in:
parent
69d5d4dcdd
commit
3c01489940
@ -1,4 +1,6 @@
|
|||||||
|
|
||||||
|
#undef DOUBLES // implement double precision floats
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
| One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined.
|
| One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined.
|
||||||
*----------------------------------------------------------------------------*/
|
*----------------------------------------------------------------------------*/
|
||||||
|
@ -1,68 +0,0 @@
|
|||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define BIGENDIAN
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The macro `BITS64' can be defined to indicate that 64-bit integer types are
|
|
||||||
| supported by the compiler.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define BITS64
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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 int flag;
|
|
||||||
typedef int uint8;
|
|
||||||
typedef int int8;
|
|
||||||
typedef int uint16;
|
|
||||||
typedef int int16;
|
|
||||||
typedef unsigned int uint32;
|
|
||||||
typedef signed int int32;
|
|
||||||
#ifdef BITS64
|
|
||||||
typedef unsigned long long int uint64;
|
|
||||||
typedef signed long long int int64;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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 unsigned char bits8;
|
|
||||||
typedef signed char sbits8;
|
|
||||||
typedef unsigned short int bits16;
|
|
||||||
typedef signed short int sbits16;
|
|
||||||
typedef unsigned int bits32;
|
|
||||||
typedef signed int sbits32;
|
|
||||||
#ifdef BITS64
|
|
||||||
typedef unsigned long long int bits64;
|
|
||||||
typedef signed long long int sbits64;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef BITS64
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The `LIT64' macro takes as its argument a textual integer literal and
|
|
||||||
| if necessary ``marks'' the literal as having a 64-bit integer type.
|
|
||||||
| For 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
|
|
||||||
| name for the 64-bit integer type. Some compilers may allow `LIT64' to be
|
|
||||||
| defined as the identity macro: `#define LIT64( a ) a'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define LIT64( a ) a##LL
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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
|
|
||||||
| to be `static'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define INLINE extern inline
|
|
||||||
|
|
@ -2,11 +2,14 @@
|
|||||||
PROCESSOR_H = ../../../processors/6502-CC65.h
|
PROCESSOR_H = ../../../processors/6502-CC65.h
|
||||||
SOFTFLOAT_MACROS = ../softfloat-macros
|
SOFTFLOAT_MACROS = ../softfloat-macros
|
||||||
|
|
||||||
|
TARGET=-t sim6502
|
||||||
|
|
||||||
OBJ = .o
|
OBJ = .o
|
||||||
EXE =
|
EXE =
|
||||||
INCLUDES = -I. -I..
|
INCLUDES = -I. -I..
|
||||||
COMPILE_C = ../../../../../../bin/cl65 -c -o $@ $(INCLUDES) -I- -O
|
COMPILE_C = ../../../../../../bin/cl65 $(TARGET) -c -o $@ $(INCLUDES) -I- -O
|
||||||
LINK = ../../../../../../bin/cl6 -o $@
|
COMPILE_ONLY = ../../../../../../bin/cl65 $(TARGET) --add-source -S -o $@.s $(INCLUDES) -I- -O
|
||||||
|
LINK = ../../../../../../bin/cl65 $(TARGET) -o $@
|
||||||
|
|
||||||
#------------------------------------------------------------------------------
|
#------------------------------------------------------------------------------
|
||||||
# Probably okay below here.
|
# Probably okay below here.
|
||||||
@ -21,8 +24,11 @@ softfloat$(OBJ): milieu.h softfloat.h softfloat-specialize $(SOFTFLOAT_MACROS) .
|
|||||||
$(COMPILE_C) ../softfloat.c
|
$(COMPILE_C) ../softfloat.c
|
||||||
|
|
||||||
timesoftfloat$(OBJ): milieu.h softfloat.h ../timesoftfloat.c
|
timesoftfloat$(OBJ): milieu.h softfloat.h ../timesoftfloat.c
|
||||||
|
$(COMPILE_ONLY) ../timesoftfloat.c
|
||||||
$(COMPILE_C) ../timesoftfloat.c
|
$(COMPILE_C) ../timesoftfloat.c
|
||||||
|
|
||||||
timesoftfloat$(EXE): softfloat$(OBJ) timesoftfloat$(OBJ)
|
timesoftfloat$(EXE): softfloat$(OBJ) timesoftfloat$(OBJ)
|
||||||
$(LINK) softfloat$(OBJ) timesoftfloat$(OBJ)
|
$(LINK) softfloat$(OBJ) timesoftfloat$(OBJ)
|
||||||
|
|
||||||
|
clean:
|
||||||
|
$(RM) softfloat$(OBJ) timesoftfloat$(EXE) timesoftfloat$(OBJ) timesoftfloat$(OBJ).s
|
||||||
|
@ -88,16 +88,15 @@ flag float32_is_signaling_nan( float32 a )
|
|||||||
| exception is raised.
|
| exception is raised.
|
||||||
*----------------------------------------------------------------------------*/
|
*----------------------------------------------------------------------------*/
|
||||||
|
|
||||||
static commonNaNT float32ToCommonNaN( float32 a )
|
static commonNaNT *float32ToCommonNaN( float32 a )
|
||||||
{
|
{
|
||||||
commonNaNT z;
|
static commonNaNT z;
|
||||||
|
|
||||||
if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
|
if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
|
||||||
z.sign = a>>31;
|
z.sign = a>>31;
|
||||||
z.low = 0;
|
z.low = 0;
|
||||||
z.high = a<<9;
|
z.high = a<<9;
|
||||||
return z;
|
return &z;
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
@ -105,10 +104,10 @@ static commonNaNT float32ToCommonNaN( float32 a )
|
|||||||
| precision floating-point format.
|
| precision floating-point format.
|
||||||
*----------------------------------------------------------------------------*/
|
*----------------------------------------------------------------------------*/
|
||||||
|
|
||||||
static float32 commonNaNToFloat32( commonNaNT a )
|
static float32 commonNaNToFloat32( commonNaNT *a )
|
||||||
{
|
{
|
||||||
|
|
||||||
return ( ( (bits32) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>9 );
|
return ( ( (bits32) a->sign )<<31 ) | 0x7FC00000 | ( a->high>>9 );
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -138,6 +137,7 @@ static float32 propagateFloat32NaN( float32 a, float32 b )
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#ifdef DOUBLES
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
| The pattern for a default generated double-precision NaN. The `high' and
|
| The pattern for a default generated double-precision NaN. The `high' and
|
||||||
| `low' values hold the most- and least-significant bits, respectively.
|
| `low' values hold the most- and least-significant bits, respectively.
|
||||||
@ -233,3 +233,5 @@ static float64 propagateFloat64NaN( float64 a, float64 b )
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
@ -72,14 +72,14 @@ void float_raise( signed char );
|
|||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
| Software IEEE integer-to-floating-point conversion routines.
|
| Software IEEE integer-to-floating-point conversion routines.
|
||||||
*----------------------------------------------------------------------------*/
|
*----------------------------------------------------------------------------*/
|
||||||
float32 int32_to_float32( signed short );
|
float32 int32_to_float32( int32 );
|
||||||
float64 int32_to_float64( signed short );
|
float64 int32_to_float64( int32 );
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
| Software IEEE single-precision conversion routines.
|
| Software IEEE single-precision conversion routines.
|
||||||
*----------------------------------------------------------------------------*/
|
*----------------------------------------------------------------------------*/
|
||||||
signed short float32_to_int32( float32 );
|
int32 float32_to_int32( float32 );
|
||||||
signed short float32_to_int32_round_to_zero( float32 );
|
int32 float32_to_int32_round_to_zero( float32 );
|
||||||
float64 float32_to_float64( float32 );
|
float64 float32_to_float64( float32 );
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
|
@ -1,24 +0,0 @@
|
|||||||
|
|
||||||
PROCESSOR_H = ../../../processors/SPARC-GCC.h
|
|
||||||
SOFTFLOAT_MACROS = ../softfloat-macros
|
|
||||||
|
|
||||||
OBJ = .o
|
|
||||||
EXE =
|
|
||||||
INCLUDES = -I. -I..
|
|
||||||
COMPILE_C = gcc -c -o $@ $(INCLUDES) -I- -O2
|
|
||||||
LINK = gcc -o $@
|
|
||||||
|
|
||||||
ALL: softfloat$(OBJ) timesoftfloat$(EXE)
|
|
||||||
|
|
||||||
milieu.h: $(PROCESSOR_H)
|
|
||||||
touch milieu.h
|
|
||||||
|
|
||||||
softfloat$(OBJ): milieu.h softfloat.h softfloat-specialize $(SOFTFLOAT_MACROS) ../softfloat.c
|
|
||||||
$(COMPILE_C) ../softfloat.c
|
|
||||||
|
|
||||||
timesoftfloat$(OBJ): milieu.h softfloat.h ../timesoftfloat.c
|
|
||||||
$(COMPILE_C) ../timesoftfloat.c
|
|
||||||
|
|
||||||
timesoftfloat$(EXE): softfloat$(OBJ) timesoftfloat$(OBJ)
|
|
||||||
$(LINK) softfloat$(OBJ) timesoftfloat$(OBJ)
|
|
||||||
|
|
@ -1,38 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C header file is part of the Berkeley SoftFloat IEEE Floating-Point
|
|
||||||
Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Include common integer types and flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#include "../../../processors/SPARC-GCC.h"
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Symbolic Boolean literals.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
enum {
|
|
||||||
FALSE = 0,
|
|
||||||
TRUE = 1
|
|
||||||
};
|
|
||||||
|
|
@ -1,225 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C source fragment is part of the Berkeley SoftFloat IEEE Floating-Point
|
|
||||||
Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Underflow tininess-detection mode, statically initialized to default value.
|
|
||||||
| (The declaration in `softfloat.h' must match the `int8' type here.)
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int8 float_detect_tininess = float_tininess_before_rounding;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Raises the exceptions specified by `flags'. Floating-point traps can be
|
|
||||||
| defined here if desired. It is currently not possible for such a trap
|
|
||||||
| to substitute a result value. If traps are not implemented, this routine
|
|
||||||
| should be simply `float_exception_flags |= flags;'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
void float_raise( int8 flags )
|
|
||||||
{
|
|
||||||
|
|
||||||
float_exception_flags |= flags;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Internal canonical NaN format.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
typedef struct {
|
|
||||||
flag sign;
|
|
||||||
bits32 high, low;
|
|
||||||
} commonNaNT;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The pattern for a default generated single-precision NaN.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
enum {
|
|
||||||
float32_default_nan = 0x7FFFFFFF
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the single-precision floating-point value `a' is a NaN;
|
|
||||||
| otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float32_is_nan( float32 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( 0xFF000000 < (bits32) ( a<<1 ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the single-precision floating-point value `a' is a signaling
|
|
||||||
| NaN; otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float32_is_signaling_nan( float32 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the single-precision floating-point NaN
|
|
||||||
| `a' to the canonical NaN format. If `a' is a 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 )
|
|
||||||
{
|
|
||||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
|
||||||
|
|
||||||
aIsNaN = float32_is_nan( a );
|
|
||||||
aIsSignalingNaN = float32_is_signaling_nan( a );
|
|
||||||
bIsNaN = float32_is_nan( b );
|
|
||||||
bIsSignalingNaN = float32_is_signaling_nan( b );
|
|
||||||
a |= 0x00400000;
|
|
||||||
b |= 0x00400000;
|
|
||||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
|
||||||
return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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 = 0x7FFFFFFF,
|
|
||||||
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 );
|
|
||||||
return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,127 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C header file is part of the Berkeley SoftFloat IEEE Floating-Point
|
|
||||||
Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point types.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
typedef unsigned int float32;
|
|
||||||
typedef struct {
|
|
||||||
unsigned int high, low;
|
|
||||||
} float64;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point underflow tininess-detection mode.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern int float_detect_tininess;
|
|
||||||
enum {
|
|
||||||
float_tininess_after_rounding = 0,
|
|
||||||
float_tininess_before_rounding = 1
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point rounding mode.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern int float_rounding_mode;
|
|
||||||
enum {
|
|
||||||
float_round_nearest_even = 0,
|
|
||||||
float_round_to_zero = 1,
|
|
||||||
float_round_up = 2,
|
|
||||||
float_round_down = 3
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point exception flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern int float_exception_flags;
|
|
||||||
enum {
|
|
||||||
float_flag_inexact = 1,
|
|
||||||
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 IEEE floating-point exception
|
|
||||||
| flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
void float_raise( int );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE integer-to-floating-point conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
float32 int32_to_float32( int );
|
|
||||||
float64 int32_to_float64( int );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE single-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int float32_to_int32( float32 );
|
|
||||||
int float32_to_int32_round_to_zero( float32 );
|
|
||||||
float64 float32_to_float64( float32 );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE single-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
float32 float32_round_to_int( float32 );
|
|
||||||
float32 float32_add( float32, float32 );
|
|
||||||
float32 float32_sub( float32, float32 );
|
|
||||||
float32 float32_mul( float32, float32 );
|
|
||||||
float32 float32_div( float32, float32 );
|
|
||||||
float32 float32_rem( float32, float32 );
|
|
||||||
float32 float32_sqrt( float32 );
|
|
||||||
int float32_eq( float32, float32 );
|
|
||||||
int float32_le( float32, float32 );
|
|
||||||
int float32_lt( float32, float32 );
|
|
||||||
int float32_eq_signaling( float32, float32 );
|
|
||||||
int float32_le_quiet( float32, float32 );
|
|
||||||
int float32_lt_quiet( float32, float32 );
|
|
||||||
int float32_is_signaling_nan( float32 );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int float64_to_int32( float64 );
|
|
||||||
int float64_to_int32_round_to_zero( float64 );
|
|
||||||
float32 float64_to_float32( float64 );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
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 );
|
|
||||||
int float64_eq( float64, float64 );
|
|
||||||
int float64_le( float64, float64 );
|
|
||||||
int float64_lt( float64, float64 );
|
|
||||||
int float64_eq_signaling( float64, float64 );
|
|
||||||
int float64_le_quiet( float64, float64 );
|
|
||||||
int float64_lt_quiet( float64, float64 );
|
|
||||||
int float64_is_signaling_nan( float64 );
|
|
||||||
|
|
@ -211,6 +211,7 @@ static float32
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#ifdef DOUBLES
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
| Returns the least-significant 32 fraction bits of the double-precision
|
| Returns the least-significant 32 fraction bits of the double-precision
|
||||||
| floating-point value `a'.
|
| floating-point value `a'.
|
||||||
@ -256,6 +257,7 @@ INLINE flag extractFloat64Sign( float64 a )
|
|||||||
return a.high>>31;
|
return a.high>>31;
|
||||||
|
|
||||||
}
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
| Normalizes the subnormal double-precision floating-point value represented
|
| Normalizes the subnormal double-precision floating-point value represented
|
||||||
@ -267,6 +269,7 @@ INLINE flag extractFloat64Sign( float64 a )
|
|||||||
| by `zSig1Ptr'.
|
| by `zSig1Ptr'.
|
||||||
*----------------------------------------------------------------------------*/
|
*----------------------------------------------------------------------------*/
|
||||||
|
|
||||||
|
#ifdef DOUBLES
|
||||||
static void
|
static void
|
||||||
normalizeFloat64Subnormal(
|
normalizeFloat64Subnormal(
|
||||||
bits32 aSig0,
|
bits32 aSig0,
|
||||||
@ -451,6 +454,7 @@ static float64
|
|||||||
return roundAndPackFloat64( zSign, zExp, zSig0, zSig1, zSig2 );
|
return roundAndPackFloat64( zSign, zExp, zSig0, zSig1, zSig2 );
|
||||||
|
|
||||||
}
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
| Returns the result of converting the 32-bit two's complement integer `a'
|
| Returns the result of converting the 32-bit two's complement integer `a'
|
||||||
@ -469,6 +473,7 @@ float32 int32_to_float32( int32 a )
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#ifdef DOUBLES
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
| Returns the result of converting the 32-bit two's complement integer `a'
|
| Returns the result of converting the 32-bit two's complement integer `a'
|
||||||
| to the double-precision floating-point format. The conversion is performed
|
| to the double-precision floating-point format. The conversion is performed
|
||||||
@ -496,6 +501,7 @@ float64 int32_to_float64( int32 a )
|
|||||||
return packFloat64( zSign, 0x412 - shiftCount, zSig0, zSig1 );
|
return packFloat64( zSign, 0x412 - shiftCount, zSig0, zSig1 );
|
||||||
|
|
||||||
}
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
| Returns the result of converting the single-precision floating-point value
|
| Returns the result of converting the single-precision floating-point value
|
||||||
@ -607,6 +613,7 @@ int32 float32_to_int32_round_to_zero( float32 a )
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#ifdef DOUBLES
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
| Returns the result of converting the single-precision floating-point value
|
| Returns the result of converting the single-precision floating-point value
|
||||||
| `a' to the double-precision floating-point format. The conversion is
|
| `a' to the double-precision floating-point format. The conversion is
|
||||||
@ -635,6 +642,7 @@ float64 float32_to_float64( float32 a )
|
|||||||
return packFloat64( aSign, aExp + 0x380, zSig0, zSig1 );
|
return packFloat64( aSign, aExp + 0x380, zSig0, zSig1 );
|
||||||
|
|
||||||
}
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
| Rounds the single-precision floating-point value `a' to an integer,
|
| Rounds the single-precision floating-point value `a' to an integer,
|
||||||
@ -1290,6 +1298,7 @@ flag float32_lt_quiet( float32 a, float32 b )
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#ifdef DOUBLES
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
| Returns the result of converting the double-precision floating-point value
|
| Returns the result of converting the double-precision floating-point value
|
||||||
| `a' to the 32-bit two's complement integer format. The conversion is
|
| `a' to the 32-bit two's complement integer format. The conversion is
|
||||||
@ -2256,4 +2265,4 @@ flag float64_lt_quiet( float64 a, float64 b )
|
|||||||
: lt64( a.high, a.low, b.high, b.low );
|
: lt64( a.high, a.low, b.high, b.low );
|
||||||
|
|
||||||
}
|
}
|
||||||
|
#endif
|
||||||
|
@ -1,28 +0,0 @@
|
|||||||
|
|
||||||
PROCESSOR_H = ../../../processors/!!!processor.h
|
|
||||||
SOFTFLOAT_MACROS = ../softfloat-macros
|
|
||||||
|
|
||||||
OBJ = .o
|
|
||||||
EXE =
|
|
||||||
INCLUDES = -I. -I..
|
|
||||||
COMPILE_C = gcc -c -o $@ $(INCLUDES) -I- -O2
|
|
||||||
LINK = gcc -o $@
|
|
||||||
|
|
||||||
#------------------------------------------------------------------------------
|
|
||||||
# Probably okay below here.
|
|
||||||
#------------------------------------------------------------------------------
|
|
||||||
|
|
||||||
ALL: softfloat$(OBJ) timesoftfloat$(EXE)
|
|
||||||
|
|
||||||
milieu.h: $(PROCESSOR_H)
|
|
||||||
touch milieu.h
|
|
||||||
|
|
||||||
softfloat$(OBJ): milieu.h softfloat.h softfloat-specialize $(SOFTFLOAT_MACROS) ../softfloat.c
|
|
||||||
$(COMPILE_C) ../softfloat.c
|
|
||||||
|
|
||||||
timesoftfloat$(OBJ): milieu.h softfloat.h ../timesoftfloat.c
|
|
||||||
$(COMPILE_C) ../timesoftfloat.c
|
|
||||||
|
|
||||||
timesoftfloat$(EXE): softfloat$(OBJ) timesoftfloat$(OBJ)
|
|
||||||
$(LINK) softfloat$(OBJ) timesoftfloat$(OBJ)
|
|
||||||
|
|
@ -1,38 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C header file template is part of the Berkeley SoftFloat IEEE Floating-
|
|
||||||
Point Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Include common integer types and flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#include "../../../processors/!!!processor.h"
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Symbolic Boolean literals.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
enum {
|
|
||||||
FALSE = 0,
|
|
||||||
TRUE = 1
|
|
||||||
};
|
|
||||||
|
|
@ -1,235 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C source fragment is part of the Berkeley SoftFloat IEEE Floating-Point
|
|
||||||
Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Underflow tininess-detection mode, statically initialized to default value.
|
|
||||||
| (The declaration in `softfloat.h' must match the `int8' type here.)
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int8 float_detect_tininess = float_tininess_after_rounding;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Raises the exceptions specified by `flags'. Floating-point traps can be
|
|
||||||
| defined here if desired. It is currently not possible for such a trap
|
|
||||||
| to substitute a result value. If traps are not implemented, this routine
|
|
||||||
| should be simply `float_exception_flags |= flags;'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
void float_raise( int8 flags )
|
|
||||||
{
|
|
||||||
|
|
||||||
float_exception_flags |= flags;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Internal canonical NaN format.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
typedef struct {
|
|
||||||
flag sign;
|
|
||||||
bits32 high, low;
|
|
||||||
} commonNaNT;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The pattern for a default generated single-precision NaN.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
enum {
|
|
||||||
float32_default_nan = 0xFFFFFFFF
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the single-precision floating-point value `a' is a NaN;
|
|
||||||
| otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float32_is_nan( float32 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( 0xFF000000 < (bits32) ( a<<1 ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the single-precision floating-point value `a' is a signaling
|
|
||||||
| NaN; otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float32_is_signaling_nan( float32 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the single-precision floating-point NaN
|
|
||||||
| `a' to the canonical NaN format. If `a' is a 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 )
|
|
||||||
{
|
|
||||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
|
||||||
|
|
||||||
aIsNaN = float32_is_nan( a );
|
|
||||||
aIsSignalingNaN = float32_is_signaling_nan( a );
|
|
||||||
bIsNaN = float32_is_nan( b );
|
|
||||||
bIsSignalingNaN = float32_is_signaling_nan( b );
|
|
||||||
a |= 0x00400000;
|
|
||||||
b |= 0x00400000;
|
|
||||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
|
||||||
if ( aIsNaN ) {
|
|
||||||
return ( aIsSignalingNaN & bIsNaN ) ? b : a;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
return 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;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,127 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C header file template is part of the Berkeley SoftFloat IEEE Floating-
|
|
||||||
Point Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point types.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
typedef !!!bits32 float32;
|
|
||||||
typedef struct {
|
|
||||||
!!!bits32 high, low;
|
|
||||||
} float64;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point underflow tininess-detection mode.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern !!!int8 float_detect_tininess;
|
|
||||||
enum {
|
|
||||||
float_tininess_after_rounding = 0,
|
|
||||||
float_tininess_before_rounding = 1
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point rounding mode.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern !!!int8 float_rounding_mode;
|
|
||||||
enum {
|
|
||||||
float_round_nearest_even = 0,
|
|
||||||
float_round_to_zero = 1,
|
|
||||||
float_round_down = 2,
|
|
||||||
float_round_up = 3
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point exception flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern !!!int8 float_exception_flags;
|
|
||||||
enum {
|
|
||||||
float_flag_inexact = 1,
|
|
||||||
float_flag_underflow = 2,
|
|
||||||
float_flag_overflow = 4,
|
|
||||||
float_flag_divbyzero = 8,
|
|
||||||
float_flag_invalid = 16
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Routine to raise any or all of the software IEEE floating-point exception
|
|
||||||
| flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
void float_raise( !!!int8 );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE integer-to-floating-point conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
float32 int32_to_float32( !!!int32 );
|
|
||||||
float64 int32_to_float64( !!!int32 );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE single-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
!!!int32 float32_to_int32( float32 );
|
|
||||||
!!!int32 float32_to_int32_round_to_zero( float32 );
|
|
||||||
float64 float32_to_float64( float32 );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE single-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
float32 float32_round_to_int( float32 );
|
|
||||||
float32 float32_add( float32, float32 );
|
|
||||||
float32 float32_sub( float32, float32 );
|
|
||||||
float32 float32_mul( float32, float32 );
|
|
||||||
float32 float32_div( float32, float32 );
|
|
||||||
float32 float32_rem( float32, float32 );
|
|
||||||
float32 float32_sqrt( float32 );
|
|
||||||
!!!flag float32_eq( float32, float32 );
|
|
||||||
!!!flag float32_le( float32, float32 );
|
|
||||||
!!!flag float32_lt( float32, float32 );
|
|
||||||
!!!flag float32_eq_signaling( float32, float32 );
|
|
||||||
!!!flag float32_le_quiet( float32, float32 );
|
|
||||||
!!!flag float32_lt_quiet( float32, float32 );
|
|
||||||
!!!flag float32_is_signaling_nan( float32 );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
!!!int32 float64_to_int32( float64 );
|
|
||||||
!!!int32 float64_to_int32_round_to_zero( float64 );
|
|
||||||
float32 float64_to_float32( float64 );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
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 );
|
|
||||||
|
|
@ -31,6 +31,15 @@ code that are retained.
|
|||||||
#include "milieu.h"
|
#include "milieu.h"
|
||||||
#include "softfloat.h"
|
#include "softfloat.h"
|
||||||
|
|
||||||
|
#ifndef CLOCKS_PER_SEC
|
||||||
|
#define CLOCKS_PER_SEC 50
|
||||||
|
#warning "CLOCKS_PER_SEC not defined"
|
||||||
|
clock_t clock(void) {
|
||||||
|
static clock_t cnt;
|
||||||
|
++cnt;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
enum {
|
enum {
|
||||||
minIterations = 1000
|
minIterations = 1000
|
||||||
};
|
};
|
||||||
@ -52,12 +61,13 @@ static char *functionName, *roundingModeName, *tininessModeName;
|
|||||||
|
|
||||||
static void reportTime( int32 count, long clocks )
|
static void reportTime( int32 count, long clocks )
|
||||||
{
|
{
|
||||||
|
#if 0
|
||||||
printf(
|
printf(
|
||||||
"%8.1f kops/s: %s",
|
"%8.1f kops/s: %s",
|
||||||
( count / ( ( (float) clocks ) / CLOCKS_PER_SEC ) ) / 1000,
|
( count / ( ( (float) clocks ) / CLOCKS_PER_SEC ) ) / 1000,
|
||||||
functionName
|
functionName
|
||||||
);
|
);
|
||||||
|
#endif
|
||||||
if ( roundingModeName ) {
|
if ( roundingModeName ) {
|
||||||
fputs( ", rounding ", stdout );
|
fputs( ", rounding ", stdout );
|
||||||
fputs( roundingModeName, stdout );
|
fputs( roundingModeName, stdout );
|
||||||
@ -86,7 +96,8 @@ static const int32 inputs_int32[ numInputs_int32 ] = {
|
|||||||
0xBFFFFFF8, 0x0001BF56, 0x000017F6, 0x000A908A
|
0xBFFFFFF8, 0x0001BF56, 0x000017F6, 0x000A908A
|
||||||
};
|
};
|
||||||
|
|
||||||
static void time_a_int32_z_float32( float32 function( int32 ) )
|
//static void time_a_int32_z_float32( float32 function( int32 ) )
|
||||||
|
static void time_a_int32_z_float32( float32 (*function)( int32 ) )
|
||||||
{
|
{
|
||||||
clock_t startClock, endClock;
|
clock_t startClock, endClock;
|
||||||
int32 count, i;
|
int32 count, i;
|
||||||
@ -113,6 +124,7 @@ static void time_a_int32_z_float32( float32 function( int32 ) )
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#ifdef DOUBLES
|
||||||
static void time_a_int32_z_float64( float64 function( int32 ) )
|
static void time_a_int32_z_float64( float64 function( int32 ) )
|
||||||
{
|
{
|
||||||
clock_t startClock, endClock;
|
clock_t startClock, endClock;
|
||||||
@ -139,6 +151,7 @@ static void time_a_int32_z_float64( float64 function( int32 ) )
|
|||||||
reportTime( count, endClock - startClock );
|
reportTime( count, endClock - startClock );
|
||||||
|
|
||||||
}
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
enum {
|
enum {
|
||||||
numInputs_float32 = 32
|
numInputs_float32 = 32
|
||||||
@ -155,7 +168,8 @@ static const float32 inputs_float32[ numInputs_float32 ] = {
|
|||||||
0xDB428661, 0x33F89B1F, 0xA3BFEFFF, 0x537BFFBE
|
0xDB428661, 0x33F89B1F, 0xA3BFEFFF, 0x537BFFBE
|
||||||
};
|
};
|
||||||
|
|
||||||
static void time_a_float32_z_int32( int32 function( float32 ) )
|
//static void time_a_float32_z_int32( int32 function( float32 ) )
|
||||||
|
static void time_a_float32_z_int32( int32 (*function)( float32 ) )
|
||||||
{
|
{
|
||||||
clock_t startClock, endClock;
|
clock_t startClock, endClock;
|
||||||
int32 count, i;
|
int32 count, i;
|
||||||
@ -182,6 +196,7 @@ static void time_a_float32_z_int32( int32 function( float32 ) )
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#ifdef DOUBLES
|
||||||
static void time_a_float32_z_float64( float64 function( float32 ) )
|
static void time_a_float32_z_float64( float64 function( float32 ) )
|
||||||
{
|
{
|
||||||
clock_t startClock, endClock;
|
clock_t startClock, endClock;
|
||||||
@ -208,8 +223,10 @@ static void time_a_float32_z_float64( float64 function( float32 ) )
|
|||||||
reportTime( count, endClock - startClock );
|
reportTime( count, endClock - startClock );
|
||||||
|
|
||||||
}
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
static void time_az_float32( float32 function( float32 ) )
|
//static void time_az_float32( float32 function( float32 ) )
|
||||||
|
static void time_az_float32( float32 (*function)( float32 ) )
|
||||||
{
|
{
|
||||||
clock_t startClock, endClock;
|
clock_t startClock, endClock;
|
||||||
int32 count, i;
|
int32 count, i;
|
||||||
@ -236,7 +253,8 @@ static void time_az_float32( float32 function( float32 ) )
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static void time_ab_float32_z_flag( flag function( float32, float32 ) )
|
//static void time_ab_float32_z_flag( flag function( float32, float32 ) )
|
||||||
|
static void time_ab_float32_z_flag( flag (*function)( float32, float32 ) )
|
||||||
{
|
{
|
||||||
clock_t startClock, endClock;
|
clock_t startClock, endClock;
|
||||||
int32 count, i;
|
int32 count, i;
|
||||||
@ -271,7 +289,8 @@ static void time_ab_float32_z_flag( flag function( float32, float32 ) )
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static void time_abz_float32( float32 function( float32, float32 ) )
|
//static void time_abz_float32( float32 function( float32, float32 ) )
|
||||||
|
static void time_abz_float32( float32 (*function)( float32, float32 ) )
|
||||||
{
|
{
|
||||||
clock_t startClock, endClock;
|
clock_t startClock, endClock;
|
||||||
int32 count, i;
|
int32 count, i;
|
||||||
@ -317,7 +336,8 @@ static const float32 inputs_float32_pos[ numInputs_float32 ] = {
|
|||||||
0x5B428661, 0x33F89B1F, 0x23BFEFFF, 0x537BFFBE
|
0x5B428661, 0x33F89B1F, 0x23BFEFFF, 0x537BFFBE
|
||||||
};
|
};
|
||||||
|
|
||||||
static void time_az_float32_pos( float32 function( float32 ) )
|
//static void time_az_float32_pos( float32 function( float32 ) )
|
||||||
|
static void time_az_float32_pos( float32 (*function)( float32 ) )
|
||||||
{
|
{
|
||||||
clock_t startClock, endClock;
|
clock_t startClock, endClock;
|
||||||
int32 count, i;
|
int32 count, i;
|
||||||
@ -344,6 +364,7 @@ static void time_az_float32_pos( float32 function( float32 ) )
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#ifdef DOUBLES
|
||||||
enum {
|
enum {
|
||||||
numInputs_float64 = 32
|
numInputs_float64 = 32
|
||||||
};
|
};
|
||||||
@ -385,7 +406,8 @@ static const struct {
|
|||||||
{ 0xC237FFFF, 0xFFFFFDFE }
|
{ 0xC237FFFF, 0xFFFFFDFE }
|
||||||
};
|
};
|
||||||
|
|
||||||
static void time_a_float64_z_int32( int32 function( float64 ) )
|
//static void time_a_float64_z_int32( int32 function( float64 ) )
|
||||||
|
static void time_a_float64_z_int32( int32 (*function)( float64 ) )
|
||||||
{
|
{
|
||||||
clock_t startClock, endClock;
|
clock_t startClock, endClock;
|
||||||
int32 count, i;
|
int32 count, i;
|
||||||
@ -633,13 +655,18 @@ static void time_az_float64_pos( float64 function( float64 ) )
|
|||||||
reportTime( count, endClock - startClock );
|
reportTime( count, endClock - startClock );
|
||||||
|
|
||||||
}
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
enum {
|
enum {
|
||||||
INT32_TO_FLOAT32 = 1,
|
INT32_TO_FLOAT32 = 1,
|
||||||
|
#ifdef DOUBLES
|
||||||
INT32_TO_FLOAT64,
|
INT32_TO_FLOAT64,
|
||||||
|
#endif
|
||||||
FLOAT32_TO_INT32,
|
FLOAT32_TO_INT32,
|
||||||
FLOAT32_TO_INT32_ROUND_TO_ZERO,
|
FLOAT32_TO_INT32_ROUND_TO_ZERO,
|
||||||
|
#ifdef DOUBLES
|
||||||
FLOAT32_TO_FLOAT64,
|
FLOAT32_TO_FLOAT64,
|
||||||
|
#endif
|
||||||
FLOAT32_ROUND_TO_INT,
|
FLOAT32_ROUND_TO_INT,
|
||||||
FLOAT32_ADD,
|
FLOAT32_ADD,
|
||||||
FLOAT32_SUB,
|
FLOAT32_SUB,
|
||||||
@ -653,6 +680,7 @@ enum {
|
|||||||
FLOAT32_EQ_SIGNALING,
|
FLOAT32_EQ_SIGNALING,
|
||||||
FLOAT32_LE_QUIET,
|
FLOAT32_LE_QUIET,
|
||||||
FLOAT32_LT_QUIET,
|
FLOAT32_LT_QUIET,
|
||||||
|
#ifdef DOUBLES
|
||||||
FLOAT64_TO_INT32,
|
FLOAT64_TO_INT32,
|
||||||
FLOAT64_TO_INT32_ROUND_TO_ZERO,
|
FLOAT64_TO_INT32_ROUND_TO_ZERO,
|
||||||
FLOAT64_TO_FLOAT32,
|
FLOAT64_TO_FLOAT32,
|
||||||
@ -669,6 +697,7 @@ enum {
|
|||||||
FLOAT64_EQ_SIGNALING,
|
FLOAT64_EQ_SIGNALING,
|
||||||
FLOAT64_LE_QUIET,
|
FLOAT64_LE_QUIET,
|
||||||
FLOAT64_LT_QUIET,
|
FLOAT64_LT_QUIET,
|
||||||
|
#endif
|
||||||
NUM_FUNCTIONS
|
NUM_FUNCTIONS
|
||||||
};
|
};
|
||||||
|
|
||||||
@ -679,10 +708,14 @@ static struct {
|
|||||||
} functions[ NUM_FUNCTIONS ] = {
|
} functions[ NUM_FUNCTIONS ] = {
|
||||||
{ 0, 0, 0, 0 },
|
{ 0, 0, 0, 0 },
|
||||||
{ "int32_to_float32", 1, TRUE, FALSE },
|
{ "int32_to_float32", 1, TRUE, FALSE },
|
||||||
|
#ifdef DOUBLES
|
||||||
{ "int32_to_float64", 1, FALSE, FALSE },
|
{ "int32_to_float64", 1, FALSE, FALSE },
|
||||||
|
#endif
|
||||||
{ "float32_to_int32", 1, TRUE, FALSE },
|
{ "float32_to_int32", 1, TRUE, FALSE },
|
||||||
{ "float32_to_int32_round_to_zero", 1, FALSE, FALSE },
|
{ "float32_to_int32_round_to_zero", 1, FALSE, FALSE },
|
||||||
|
#ifdef DOUBLES
|
||||||
{ "float32_to_float64", 1, FALSE, FALSE },
|
{ "float32_to_float64", 1, FALSE, FALSE },
|
||||||
|
#endif
|
||||||
{ "float32_round_to_int", 1, TRUE, FALSE },
|
{ "float32_round_to_int", 1, TRUE, FALSE },
|
||||||
{ "float32_add", 2, TRUE, FALSE },
|
{ "float32_add", 2, TRUE, FALSE },
|
||||||
{ "float32_sub", 2, TRUE, FALSE },
|
{ "float32_sub", 2, TRUE, FALSE },
|
||||||
@ -696,6 +729,7 @@ static struct {
|
|||||||
{ "float32_eq_signaling", 2, FALSE, FALSE },
|
{ "float32_eq_signaling", 2, FALSE, FALSE },
|
||||||
{ "float32_le_quiet", 2, FALSE, FALSE },
|
{ "float32_le_quiet", 2, FALSE, FALSE },
|
||||||
{ "float32_lt_quiet", 2, FALSE, FALSE },
|
{ "float32_lt_quiet", 2, FALSE, FALSE },
|
||||||
|
#ifdef DOUBLES
|
||||||
{ "float64_to_int32", 1, TRUE, FALSE },
|
{ "float64_to_int32", 1, TRUE, FALSE },
|
||||||
{ "float64_to_int32_round_to_zero", 1, FALSE, FALSE },
|
{ "float64_to_int32_round_to_zero", 1, FALSE, FALSE },
|
||||||
{ "float64_to_float32", 1, TRUE, TRUE, },
|
{ "float64_to_float32", 1, TRUE, TRUE, },
|
||||||
@ -712,6 +746,7 @@ static struct {
|
|||||||
{ "float64_eq_signaling", 2, FALSE, FALSE },
|
{ "float64_eq_signaling", 2, FALSE, FALSE },
|
||||||
{ "float64_le_quiet", 2, FALSE, FALSE },
|
{ "float64_le_quiet", 2, FALSE, FALSE },
|
||||||
{ "float64_lt_quiet", 2, FALSE, FALSE }
|
{ "float64_lt_quiet", 2, FALSE, FALSE }
|
||||||
|
#endif
|
||||||
};
|
};
|
||||||
|
|
||||||
enum {
|
enum {
|
||||||
@ -777,18 +812,22 @@ static void
|
|||||||
case INT32_TO_FLOAT32:
|
case INT32_TO_FLOAT32:
|
||||||
time_a_int32_z_float32( int32_to_float32 );
|
time_a_int32_z_float32( int32_to_float32 );
|
||||||
break;
|
break;
|
||||||
|
#ifdef DOUBLES
|
||||||
case INT32_TO_FLOAT64:
|
case INT32_TO_FLOAT64:
|
||||||
time_a_int32_z_float64( int32_to_float64 );
|
time_a_int32_z_float64( int32_to_float64 );
|
||||||
break;
|
break;
|
||||||
|
#endif
|
||||||
case FLOAT32_TO_INT32:
|
case FLOAT32_TO_INT32:
|
||||||
time_a_float32_z_int32( float32_to_int32 );
|
time_a_float32_z_int32( float32_to_int32 );
|
||||||
break;
|
break;
|
||||||
case FLOAT32_TO_INT32_ROUND_TO_ZERO:
|
case FLOAT32_TO_INT32_ROUND_TO_ZERO:
|
||||||
time_a_float32_z_int32( float32_to_int32_round_to_zero );
|
time_a_float32_z_int32( float32_to_int32_round_to_zero );
|
||||||
break;
|
break;
|
||||||
|
#ifdef DOUBLES
|
||||||
case FLOAT32_TO_FLOAT64:
|
case FLOAT32_TO_FLOAT64:
|
||||||
time_a_float32_z_float64( float32_to_float64 );
|
time_a_float32_z_float64( float32_to_float64 );
|
||||||
break;
|
break;
|
||||||
|
#endif
|
||||||
case FLOAT32_ROUND_TO_INT:
|
case FLOAT32_ROUND_TO_INT:
|
||||||
time_az_float32( float32_round_to_int );
|
time_az_float32( float32_round_to_int );
|
||||||
break;
|
break;
|
||||||
@ -828,6 +867,7 @@ static void
|
|||||||
case FLOAT32_LT_QUIET:
|
case FLOAT32_LT_QUIET:
|
||||||
time_ab_float32_z_flag( float32_lt_quiet );
|
time_ab_float32_z_flag( float32_lt_quiet );
|
||||||
break;
|
break;
|
||||||
|
#ifdef DOUBLES
|
||||||
case FLOAT64_TO_INT32:
|
case FLOAT64_TO_INT32:
|
||||||
time_a_float64_z_int32( float64_to_int32 );
|
time_a_float64_z_int32( float64_to_int32 );
|
||||||
break;
|
break;
|
||||||
@ -876,6 +916,7 @@ static void
|
|||||||
case FLOAT64_LT_QUIET:
|
case FLOAT64_LT_QUIET:
|
||||||
time_ab_float64_z_flag( float64_lt_quiet );
|
time_ab_float64_z_flag( float64_lt_quiet );
|
||||||
break;
|
break;
|
||||||
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
|
@ -1,24 +0,0 @@
|
|||||||
|
|
||||||
PROCESSOR_H = ../../../processors/386-GCC.h
|
|
||||||
SOFTFLOAT_MACROS = ../softfloat-macros
|
|
||||||
|
|
||||||
OBJ = .o
|
|
||||||
EXE = .exe
|
|
||||||
INCLUDES = -I. -I..
|
|
||||||
COMPILE_C = gcc -c -o $@ $(INCLUDES) -I- -O2
|
|
||||||
LINK = gcc -o $@
|
|
||||||
|
|
||||||
ALL: softfloat$(OBJ) timesoftfloat$(EXE)
|
|
||||||
|
|
||||||
milieu.h: $(PROCESSOR_H)
|
|
||||||
touch milieu.h
|
|
||||||
|
|
||||||
softfloat$(OBJ): milieu.h softfloat.h softfloat-specialize $(SOFTFLOAT_MACROS) ../softfloat.c
|
|
||||||
$(COMPILE_C) ../softfloat.c
|
|
||||||
|
|
||||||
timesoftfloat$(OBJ): milieu.h softfloat.h ../timesoftfloat.c
|
|
||||||
$(COMPILE_C) ../timesoftfloat.c
|
|
||||||
|
|
||||||
timesoftfloat$(EXE): softfloat$(OBJ) timesoftfloat$(OBJ)
|
|
||||||
$(LINK) softfloat$(OBJ) timesoftfloat$(OBJ)
|
|
||||||
|
|
@ -1,38 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C header file is part of the Berkeley SoftFloat IEEE Floating-Point
|
|
||||||
Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Include common integer types and flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#include "../../../processors/386-GCC.h"
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Symbolic Boolean literals.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
enum {
|
|
||||||
FALSE = 0,
|
|
||||||
TRUE = 1
|
|
||||||
};
|
|
||||||
|
|
@ -1,457 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C source fragment is part of the Berkeley SoftFloat IEEE Floating-Point
|
|
||||||
Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Underflow tininess-detection mode, statically initialized to default value.
|
|
||||||
| (The declaration in `softfloat.h' must match the `int8' type here.)
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int8 float_detect_tininess = float_tininess_after_rounding;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Raises the exceptions specified by `flags'. Floating-point traps can be
|
|
||||||
| defined here if desired. It is currently not possible for such a trap
|
|
||||||
| to substitute a result value. If traps are not implemented, this routine
|
|
||||||
| should be simply `float_exception_flags |= flags;'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
void float_raise( int8 flags )
|
|
||||||
{
|
|
||||||
|
|
||||||
float_exception_flags |= flags;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Internal canonical NaN format.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
typedef struct {
|
|
||||||
flag sign;
|
|
||||||
bits64 high, low;
|
|
||||||
} commonNaNT;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The pattern for a default generated single-precision NaN.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define float32_default_nan 0xFFC00000
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the single-precision floating-point value `a' is a NaN;
|
|
||||||
| otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float32_is_nan( float32 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( 0xFF000000 < (bits32) ( a<<1 ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the single-precision floating-point value `a' is a signaling
|
|
||||||
| NaN; otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float32_is_signaling_nan( float32 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the single-precision floating-point NaN
|
|
||||||
| `a' to the canonical NaN format. If `a' is a 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 = ( (bits64) a )<<41;
|
|
||||||
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>>41 );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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 )
|
|
||||||
{
|
|
||||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
|
||||||
|
|
||||||
aIsNaN = float32_is_nan( a );
|
|
||||||
aIsSignalingNaN = float32_is_signaling_nan( a );
|
|
||||||
bIsNaN = float32_is_nan( b );
|
|
||||||
bIsSignalingNaN = float32_is_signaling_nan( b );
|
|
||||||
a |= 0x00400000;
|
|
||||||
b |= 0x00400000;
|
|
||||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
|
||||||
if ( aIsSignalingNaN ) {
|
|
||||||
if ( bIsSignalingNaN ) goto returnLargerSignificand;
|
|
||||||
return bIsNaN ? b : a;
|
|
||||||
}
|
|
||||||
else if ( aIsNaN ) {
|
|
||||||
if ( bIsSignalingNaN | ! bIsNaN ) return a;
|
|
||||||
returnLargerSignificand:
|
|
||||||
if ( (bits32) ( a<<1 ) < (bits32) ( b<<1 ) ) return b;
|
|
||||||
if ( (bits32) ( b<<1 ) < (bits32) ( a<<1 ) ) return a;
|
|
||||||
return ( a < b ) ? a : b;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
return b;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The pattern for a default generated double-precision NaN.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define float64_default_nan LIT64( 0xFFF8000000000000 )
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the double-precision floating-point value `a' is a NaN;
|
|
||||||
| otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float64_is_nan( float64 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( LIT64( 0xFFE0000000000000 ) < (bits64) ( a<<1 ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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>>51 ) & 0xFFF ) == 0xFFE )
|
|
||||||
&& ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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>>63;
|
|
||||||
z.low = 0;
|
|
||||||
z.high = a<<12;
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the canonical NaN `a' to the double-
|
|
||||||
| precision floating-point format.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static float64 commonNaNToFloat64( commonNaNT a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return
|
|
||||||
( ( (bits64) a.sign )<<63 )
|
|
||||||
| LIT64( 0x7FF8000000000000 )
|
|
||||||
| ( a.high>>12 );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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 |= LIT64( 0x0008000000000000 );
|
|
||||||
b |= LIT64( 0x0008000000000000 );
|
|
||||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
|
||||||
if ( aIsSignalingNaN ) {
|
|
||||||
if ( bIsSignalingNaN ) goto returnLargerSignificand;
|
|
||||||
return bIsNaN ? b : a;
|
|
||||||
}
|
|
||||||
else if ( aIsNaN ) {
|
|
||||||
if ( bIsSignalingNaN | ! bIsNaN ) return a;
|
|
||||||
returnLargerSignificand:
|
|
||||||
if ( (bits64) ( a<<1 ) < (bits64) ( b<<1 ) ) return b;
|
|
||||||
if ( (bits64) ( b<<1 ) < (bits64) ( a<<1 ) ) return a;
|
|
||||||
return ( a < b ) ? a : b;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
return b;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef FLOATX80
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The pattern for a default generated double-extended-precision NaN.
|
|
||||||
| The `high' and `low' values hold the most- and least-significant bits,
|
|
||||||
| respectively.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define floatx80_default_nan_high 0xFFFF
|
|
||||||
#define floatx80_default_nan_low LIT64( 0xC000000000000000 )
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the double-extended-precision floating-point value `a' is a
|
|
||||||
| NaN; otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag floatx80_is_nan( floatx80 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the double-extended-precision floating-point value `a' is a
|
|
||||||
| signaling NaN; otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag floatx80_is_signaling_nan( floatx80 a )
|
|
||||||
{
|
|
||||||
bits64 aLow;
|
|
||||||
|
|
||||||
aLow = a.low & ~ LIT64( 0x4000000000000000 );
|
|
||||||
return
|
|
||||||
( ( a.high & 0x7FFF ) == 0x7FFF )
|
|
||||||
&& (bits64) ( aLow<<1 )
|
|
||||||
&& ( a.low == aLow );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the double-extended-precision floating-
|
|
||||||
| point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the
|
|
||||||
| invalid exception is raised.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static commonNaNT floatx80ToCommonNaN( floatx80 a )
|
|
||||||
{
|
|
||||||
commonNaNT z;
|
|
||||||
|
|
||||||
if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
|
|
||||||
z.sign = a.high>>15;
|
|
||||||
z.low = 0;
|
|
||||||
z.high = a.low<<1;
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the canonical NaN `a' to the double-
|
|
||||||
| extended-precision floating-point format.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static floatx80 commonNaNToFloatx80( commonNaNT a )
|
|
||||||
{
|
|
||||||
floatx80 z;
|
|
||||||
|
|
||||||
z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 );
|
|
||||||
z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF;
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Takes two double-extended-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 floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b )
|
|
||||||
{
|
|
||||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
|
||||||
|
|
||||||
aIsNaN = floatx80_is_nan( a );
|
|
||||||
aIsSignalingNaN = floatx80_is_signaling_nan( a );
|
|
||||||
bIsNaN = floatx80_is_nan( b );
|
|
||||||
bIsSignalingNaN = floatx80_is_signaling_nan( b );
|
|
||||||
a.low |= LIT64( 0xC000000000000000 );
|
|
||||||
b.low |= LIT64( 0xC000000000000000 );
|
|
||||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
|
||||||
if ( aIsSignalingNaN ) {
|
|
||||||
if ( bIsSignalingNaN ) goto returnLargerSignificand;
|
|
||||||
return bIsNaN ? b : a;
|
|
||||||
}
|
|
||||||
else if ( aIsNaN ) {
|
|
||||||
if ( bIsSignalingNaN | ! bIsNaN ) return a;
|
|
||||||
returnLargerSignificand:
|
|
||||||
if ( a.low < b.low ) return b;
|
|
||||||
if ( b.low < a.low ) return a;
|
|
||||||
return ( a.high < b.high ) ? a : b;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
return b;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef FLOAT128
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The pattern for a default generated quadruple-precision NaN. The `high' and
|
|
||||||
| `low' values hold the most- and least-significant bits, respectively.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define float128_default_nan_high LIT64( 0xFFFF800000000000 )
|
|
||||||
#define float128_default_nan_low LIT64( 0x0000000000000000 )
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the quadruple-precision floating-point value `a' is a NaN;
|
|
||||||
| otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float128_is_nan( float128 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return
|
|
||||||
( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
|
|
||||||
&& ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the quadruple-precision floating-point value `a' is a
|
|
||||||
| signaling NaN; otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float128_is_signaling_nan( float128 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return
|
|
||||||
( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
|
|
||||||
&& ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the quadruple-precision floating-point NaN
|
|
||||||
| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
|
|
||||||
| exception is raised.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static commonNaNT float128ToCommonNaN( float128 a )
|
|
||||||
{
|
|
||||||
commonNaNT z;
|
|
||||||
|
|
||||||
if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
|
|
||||||
z.sign = a.high>>63;
|
|
||||||
shortShift128Left( a.high, a.low, 16, &z.high, &z.low );
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the canonical NaN `a' to the quadruple-
|
|
||||||
| precision floating-point format.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static float128 commonNaNToFloat128( commonNaNT a )
|
|
||||||
{
|
|
||||||
float128 z;
|
|
||||||
|
|
||||||
shift128Right( a.high, a.low, 16, &z.high, &z.low );
|
|
||||||
z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF800000000000 );
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Takes two quadruple-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 float128 propagateFloat128NaN( float128 a, float128 b )
|
|
||||||
{
|
|
||||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
|
||||||
|
|
||||||
aIsNaN = float128_is_nan( a );
|
|
||||||
aIsSignalingNaN = float128_is_signaling_nan( a );
|
|
||||||
bIsNaN = float128_is_nan( b );
|
|
||||||
bIsSignalingNaN = float128_is_signaling_nan( b );
|
|
||||||
a.high |= LIT64( 0x0000800000000000 );
|
|
||||||
b.high |= LIT64( 0x0000800000000000 );
|
|
||||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
|
||||||
if ( aIsSignalingNaN ) {
|
|
||||||
if ( bIsSignalingNaN ) goto returnLargerSignificand;
|
|
||||||
return bIsNaN ? b : a;
|
|
||||||
}
|
|
||||||
else if ( aIsNaN ) {
|
|
||||||
if ( bIsSignalingNaN | ! bIsNaN ) return a;
|
|
||||||
returnLargerSignificand:
|
|
||||||
if ( lt128( a.high<<1, a.low, b.high<<1, b.low ) ) return b;
|
|
||||||
if ( lt128( b.high<<1, b.low, a.high<<1, a.low ) ) return a;
|
|
||||||
return ( a.high < b.high ) ? a : b;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
return b;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,252 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C header file is part of the Berkeley SoftFloat IEEE Floating-Point
|
|
||||||
Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The macro `FLOATX80' must be defined to enable the double-extended-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'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define FLOATX80
|
|
||||||
#define FLOAT128
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point types.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
typedef unsigned int float32;
|
|
||||||
typedef unsigned long long float64;
|
|
||||||
#ifdef FLOATX80
|
|
||||||
typedef struct {
|
|
||||||
unsigned long long low;
|
|
||||||
unsigned short high;
|
|
||||||
} floatx80;
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
typedef struct {
|
|
||||||
unsigned long long low, high;
|
|
||||||
} float128;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point underflow tininess-detection mode.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern signed char float_detect_tininess;
|
|
||||||
enum {
|
|
||||||
float_tininess_after_rounding = 0,
|
|
||||||
float_tininess_before_rounding = 1
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point rounding mode.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern signed char float_rounding_mode;
|
|
||||||
enum {
|
|
||||||
float_round_nearest_even = 0,
|
|
||||||
float_round_down = 1,
|
|
||||||
float_round_up = 2,
|
|
||||||
float_round_to_zero = 3
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point exception flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern signed char float_exception_flags;
|
|
||||||
enum {
|
|
||||||
float_flag_invalid = 1,
|
|
||||||
float_flag_divbyzero = 4,
|
|
||||||
float_flag_overflow = 8,
|
|
||||||
float_flag_underflow = 16,
|
|
||||||
float_flag_inexact = 32
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Routine to raise any or all of the software IEEE floating-point exception
|
|
||||||
| flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
void float_raise( signed char );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE integer-to-floating-point conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
float32 int32_to_float32( int );
|
|
||||||
float64 int32_to_float64( int );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 int32_to_floatx80( int );
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 int32_to_float128( int );
|
|
||||||
#endif
|
|
||||||
float32 int64_to_float32( long long );
|
|
||||||
float64 int64_to_float64( long long );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 int64_to_floatx80( long long );
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 int64_to_float128( long long );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE single-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int float32_to_int32( float32 );
|
|
||||||
int float32_to_int32_round_to_zero( float32 );
|
|
||||||
long long float32_to_int64( float32 );
|
|
||||||
long long float32_to_int64_round_to_zero( float32 );
|
|
||||||
float64 float32_to_float64( float32 );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 float32_to_floatx80( float32 );
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 float32_to_float128( float32 );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE single-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
float32 float32_round_to_int( float32 );
|
|
||||||
float32 float32_add( float32, float32 );
|
|
||||||
float32 float32_sub( float32, float32 );
|
|
||||||
float32 float32_mul( float32, float32 );
|
|
||||||
float32 float32_div( float32, float32 );
|
|
||||||
float32 float32_rem( float32, float32 );
|
|
||||||
float32 float32_sqrt( float32 );
|
|
||||||
char float32_eq( float32, float32 );
|
|
||||||
char float32_le( float32, float32 );
|
|
||||||
char float32_lt( float32, float32 );
|
|
||||||
char float32_eq_signaling( float32, float32 );
|
|
||||||
char float32_le_quiet( float32, float32 );
|
|
||||||
char float32_lt_quiet( float32, float32 );
|
|
||||||
char float32_is_signaling_nan( float32 );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int float64_to_int32( float64 );
|
|
||||||
int float64_to_int32_round_to_zero( float64 );
|
|
||||||
long long float64_to_int64( float64 );
|
|
||||||
long long float64_to_int64_round_to_zero( float64 );
|
|
||||||
float32 float64_to_float32( float64 );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 float64_to_floatx80( float64 );
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 float64_to_float128( float64 );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
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 );
|
|
||||||
char float64_eq( float64, float64 );
|
|
||||||
char float64_le( float64, float64 );
|
|
||||||
char float64_lt( float64, float64 );
|
|
||||||
char float64_eq_signaling( float64, float64 );
|
|
||||||
char float64_le_quiet( float64, float64 );
|
|
||||||
char float64_lt_quiet( float64, float64 );
|
|
||||||
char float64_is_signaling_nan( float64 );
|
|
||||||
|
|
||||||
#ifdef FLOATX80
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-extended-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int floatx80_to_int32( floatx80 );
|
|
||||||
int floatx80_to_int32_round_to_zero( floatx80 );
|
|
||||||
long long floatx80_to_int64( floatx80 );
|
|
||||||
long long floatx80_to_int64_round_to_zero( floatx80 );
|
|
||||||
float32 floatx80_to_float32( floatx80 );
|
|
||||||
float64 floatx80_to_float64( floatx80 );
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 floatx80_to_float128( floatx80 );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-extended-precision rounding precision. Valid values
|
|
||||||
| are 32, 64, and 80.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern signed char floatx80_rounding_precision;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-extended-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
floatx80 floatx80_round_to_int( floatx80 );
|
|
||||||
floatx80 floatx80_add( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_sub( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_mul( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_div( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_rem( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_sqrt( floatx80 );
|
|
||||||
char floatx80_eq( floatx80, floatx80 );
|
|
||||||
char floatx80_le( floatx80, floatx80 );
|
|
||||||
char floatx80_lt( floatx80, floatx80 );
|
|
||||||
char floatx80_eq_signaling( floatx80, floatx80 );
|
|
||||||
char floatx80_le_quiet( floatx80, floatx80 );
|
|
||||||
char floatx80_lt_quiet( floatx80, floatx80 );
|
|
||||||
char floatx80_is_signaling_nan( floatx80 );
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef FLOAT128
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE quadruple-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int float128_to_int32( float128 );
|
|
||||||
int float128_to_int32_round_to_zero( float128 );
|
|
||||||
long long float128_to_int64( float128 );
|
|
||||||
long long float128_to_int64_round_to_zero( float128 );
|
|
||||||
float32 float128_to_float32( float128 );
|
|
||||||
float64 float128_to_float64( float128 );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 float128_to_floatx80( float128 );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE quadruple-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
float128 float128_round_to_int( float128 );
|
|
||||||
float128 float128_add( float128, float128 );
|
|
||||||
float128 float128_sub( float128, float128 );
|
|
||||||
float128 float128_mul( float128, float128 );
|
|
||||||
float128 float128_div( float128, float128 );
|
|
||||||
float128 float128_rem( float128, float128 );
|
|
||||||
float128 float128_sqrt( float128 );
|
|
||||||
char float128_eq( float128, float128 );
|
|
||||||
char float128_le( float128, float128 );
|
|
||||||
char float128_lt( float128, float128 );
|
|
||||||
char float128_eq_signaling( float128, float128 );
|
|
||||||
char float128_le_quiet( float128, float128 );
|
|
||||||
char float128_lt_quiet( float128, float128 );
|
|
||||||
char float128_is_signaling_nan( float128 );
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,24 +0,0 @@
|
|||||||
|
|
||||||
PROCESSOR_H = ../../../processors/SPARC-GCC.h
|
|
||||||
SOFTFLOAT_MACROS = ../softfloat-macros
|
|
||||||
|
|
||||||
OBJ = .o
|
|
||||||
EXE =
|
|
||||||
INCLUDES = -I. -I..
|
|
||||||
COMPILE_C = gcc -c -o $@ $(INCLUDES) -I- -O2
|
|
||||||
LINK = gcc -o $@
|
|
||||||
|
|
||||||
ALL: softfloat$(OBJ) timesoftfloat$(EXE)
|
|
||||||
|
|
||||||
milieu.h: $(PROCESSOR_H)
|
|
||||||
touch milieu.h
|
|
||||||
|
|
||||||
softfloat$(OBJ): milieu.h softfloat.h softfloat-specialize $(SOFTFLOAT_MACROS) ../softfloat.c
|
|
||||||
$(COMPILE_C) ../softfloat.c
|
|
||||||
|
|
||||||
timesoftfloat$(OBJ): milieu.h softfloat.h ../timesoftfloat.c
|
|
||||||
$(COMPILE_C) ../timesoftfloat.c
|
|
||||||
|
|
||||||
timesoftfloat$(EXE): softfloat$(OBJ) timesoftfloat$(OBJ)
|
|
||||||
$(LINK) softfloat$(OBJ) timesoftfloat$(OBJ)
|
|
||||||
|
|
@ -1,38 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C header file is part of the Berkeley SoftFloat IEEE Floating-Point
|
|
||||||
Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Include common integer types and flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#include "../../../processors/SPARC-GCC.h"
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Symbolic Boolean literals.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
enum {
|
|
||||||
FALSE = 0,
|
|
||||||
TRUE = 1
|
|
||||||
};
|
|
||||||
|
|
@ -1,405 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C source fragment is part of the Berkeley SoftFloat IEEE Floating-Point
|
|
||||||
Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Underflow tininess-detection mode, statically initialized to default value.
|
|
||||||
| (The declaration in `softfloat.h' must match the `int8' type here.)
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int8 float_detect_tininess = float_tininess_before_rounding;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Raises the exceptions specified by `flags'. Floating-point traps can be
|
|
||||||
| defined here if desired. It is currently not possible for such a trap
|
|
||||||
| to substitute a result value. If traps are not implemented, this routine
|
|
||||||
| should be simply `float_exception_flags |= flags;'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
void float_raise( int8 flags )
|
|
||||||
{
|
|
||||||
|
|
||||||
float_exception_flags |= flags;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Internal canonical NaN format.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
typedef struct {
|
|
||||||
flag sign;
|
|
||||||
bits64 high, low;
|
|
||||||
} commonNaNT;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The pattern for a default generated single-precision NaN.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define float32_default_nan 0x7FFFFFFF
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the single-precision floating-point value `a' is a NaN;
|
|
||||||
| otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float32_is_nan( float32 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( 0xFF000000 < (bits32) ( a<<1 ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the single-precision floating-point value `a' is a signaling
|
|
||||||
| NaN; otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float32_is_signaling_nan( float32 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the single-precision floating-point NaN
|
|
||||||
| `a' to the canonical NaN format. If `a' is a 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 = ( (bits64) a )<<41;
|
|
||||||
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>>41 );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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 )
|
|
||||||
{
|
|
||||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
|
||||||
|
|
||||||
aIsNaN = float32_is_nan( a );
|
|
||||||
aIsSignalingNaN = float32_is_signaling_nan( a );
|
|
||||||
bIsNaN = float32_is_nan( b );
|
|
||||||
bIsSignalingNaN = float32_is_signaling_nan( b );
|
|
||||||
a |= 0x00400000;
|
|
||||||
b |= 0x00400000;
|
|
||||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
|
||||||
return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The pattern for a default generated double-precision NaN.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define float64_default_nan LIT64( 0x7FFFFFFFFFFFFFFF )
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the double-precision floating-point value `a' is a NaN;
|
|
||||||
| otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float64_is_nan( float64 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( LIT64( 0xFFE0000000000000 ) < (bits64) ( a<<1 ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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>>51 ) & 0xFFF ) == 0xFFE )
|
|
||||||
&& ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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>>63;
|
|
||||||
z.low = 0;
|
|
||||||
z.high = a<<12;
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the canonical NaN `a' to the double-
|
|
||||||
| precision floating-point format.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static float64 commonNaNToFloat64( commonNaNT a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return
|
|
||||||
( ( (bits64) a.sign )<<63 )
|
|
||||||
| LIT64( 0x7FF8000000000000 )
|
|
||||||
| ( a.high>>12 );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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 |= LIT64( 0x0008000000000000 );
|
|
||||||
b |= LIT64( 0x0008000000000000 );
|
|
||||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
|
||||||
return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef FLOATX80
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The pattern for a default generated double-extended-precision NaN.
|
|
||||||
| The `high' and `low' values hold the most- and least-significant bits,
|
|
||||||
| respectively.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define floatx80_default_nan_high 0x7FFF
|
|
||||||
#define floatx80_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF )
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the double-extended-precision floating-point value `a' is a
|
|
||||||
| NaN; otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag floatx80_is_nan( floatx80 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the double-extended-precision floating-point value `a' is a
|
|
||||||
| signaling NaN; otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag floatx80_is_signaling_nan( floatx80 a )
|
|
||||||
{
|
|
||||||
bits64 aLow;
|
|
||||||
|
|
||||||
aLow = a.low & ~ LIT64( 0x4000000000000000 );
|
|
||||||
return
|
|
||||||
( ( a.high & 0x7FFF ) == 0x7FFF )
|
|
||||||
&& (bits64) ( aLow<<1 )
|
|
||||||
&& ( a.low == aLow );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the double-extended-precision floating-
|
|
||||||
| point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the
|
|
||||||
| invalid exception is raised.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static commonNaNT floatx80ToCommonNaN( floatx80 a )
|
|
||||||
{
|
|
||||||
commonNaNT z;
|
|
||||||
|
|
||||||
if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
|
|
||||||
z.sign = a.high>>15;
|
|
||||||
z.low = 0;
|
|
||||||
z.high = a.low<<1;
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the canonical NaN `a' to the double-
|
|
||||||
| extended-precision floating-point format.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static floatx80 commonNaNToFloatx80( commonNaNT a )
|
|
||||||
{
|
|
||||||
floatx80 z;
|
|
||||||
|
|
||||||
z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 );
|
|
||||||
z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF;
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Takes two double-extended-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 floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b )
|
|
||||||
{
|
|
||||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
|
||||||
|
|
||||||
aIsNaN = floatx80_is_nan( a );
|
|
||||||
aIsSignalingNaN = floatx80_is_signaling_nan( a );
|
|
||||||
bIsNaN = floatx80_is_nan( b );
|
|
||||||
bIsSignalingNaN = floatx80_is_signaling_nan( b );
|
|
||||||
a.low |= LIT64( 0xC000000000000000 );
|
|
||||||
b.low |= LIT64( 0xC000000000000000 );
|
|
||||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
|
||||||
return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef FLOAT128
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The pattern for a default generated quadruple-precision NaN. The `high' and
|
|
||||||
| `low' values hold the most- and least-significant bits, respectively.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define float128_default_nan_high LIT64( 0x7FFFFFFFFFFFFFFF )
|
|
||||||
#define float128_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF )
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the quadruple-precision floating-point value `a' is a NaN;
|
|
||||||
| otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float128_is_nan( float128 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return
|
|
||||||
( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
|
|
||||||
&& ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the quadruple-precision floating-point value `a' is a
|
|
||||||
| signaling NaN; otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float128_is_signaling_nan( float128 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return
|
|
||||||
( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
|
|
||||||
&& ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the quadruple-precision floating-point NaN
|
|
||||||
| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
|
|
||||||
| exception is raised.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static commonNaNT float128ToCommonNaN( float128 a )
|
|
||||||
{
|
|
||||||
commonNaNT z;
|
|
||||||
|
|
||||||
if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
|
|
||||||
z.sign = a.high>>63;
|
|
||||||
shortShift128Left( a.high, a.low, 16, &z.high, &z.low );
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the canonical NaN `a' to the quadruple-
|
|
||||||
| precision floating-point format.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static float128 commonNaNToFloat128( commonNaNT a )
|
|
||||||
{
|
|
||||||
float128 z;
|
|
||||||
|
|
||||||
shift128Right( a.high, a.low, 16, &z.high, &z.low );
|
|
||||||
z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF800000000000 );
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Takes two quadruple-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 float128 propagateFloat128NaN( float128 a, float128 b )
|
|
||||||
{
|
|
||||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
|
||||||
|
|
||||||
aIsNaN = float128_is_nan( a );
|
|
||||||
aIsSignalingNaN = float128_is_signaling_nan( a );
|
|
||||||
bIsNaN = float128_is_nan( b );
|
|
||||||
bIsSignalingNaN = float128_is_signaling_nan( b );
|
|
||||||
a.high |= LIT64( 0x0000800000000000 );
|
|
||||||
b.high |= LIT64( 0x0000800000000000 );
|
|
||||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
|
||||||
return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,252 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C header file is part of the Berkeley SoftFloat IEEE Floating-Point
|
|
||||||
Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The macro `FLOATX80' must be defined to enable the double-extended-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'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define FLOATX80
|
|
||||||
#define FLOAT128
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point types.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
typedef unsigned int float32;
|
|
||||||
typedef unsigned long long float64;
|
|
||||||
#ifdef FLOATX80
|
|
||||||
typedef struct {
|
|
||||||
unsigned short high;
|
|
||||||
unsigned long long low;
|
|
||||||
} floatx80;
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
typedef struct {
|
|
||||||
unsigned long long high, low;
|
|
||||||
} float128;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point underflow tininess-detection mode.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern int float_detect_tininess;
|
|
||||||
enum {
|
|
||||||
float_tininess_after_rounding = 0,
|
|
||||||
float_tininess_before_rounding = 1
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point rounding mode.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern int float_rounding_mode;
|
|
||||||
enum {
|
|
||||||
float_round_nearest_even = 0,
|
|
||||||
float_round_to_zero = 1,
|
|
||||||
float_round_up = 2,
|
|
||||||
float_round_down = 3
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point exception flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern int float_exception_flags;
|
|
||||||
enum {
|
|
||||||
float_flag_inexact = 1,
|
|
||||||
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 IEEE floating-point exception
|
|
||||||
| flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
void float_raise( int );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE integer-to-floating-point conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
float32 int32_to_float32( int );
|
|
||||||
float64 int32_to_float64( int );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 int32_to_floatx80( int );
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 int32_to_float128( int );
|
|
||||||
#endif
|
|
||||||
float32 int64_to_float32( long long );
|
|
||||||
float64 int64_to_float64( long long );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 int64_to_floatx80( long long );
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 int64_to_float128( long long );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE single-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int float32_to_int32( float32 );
|
|
||||||
int float32_to_int32_round_to_zero( float32 );
|
|
||||||
long long float32_to_int64( float32 );
|
|
||||||
long long float32_to_int64_round_to_zero( float32 );
|
|
||||||
float64 float32_to_float64( float32 );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 float32_to_floatx80( float32 );
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 float32_to_float128( float32 );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE single-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
float32 float32_round_to_int( float32 );
|
|
||||||
float32 float32_add( float32, float32 );
|
|
||||||
float32 float32_sub( float32, float32 );
|
|
||||||
float32 float32_mul( float32, float32 );
|
|
||||||
float32 float32_div( float32, float32 );
|
|
||||||
float32 float32_rem( float32, float32 );
|
|
||||||
float32 float32_sqrt( float32 );
|
|
||||||
int float32_eq( float32, float32 );
|
|
||||||
int float32_le( float32, float32 );
|
|
||||||
int float32_lt( float32, float32 );
|
|
||||||
int float32_eq_signaling( float32, float32 );
|
|
||||||
int float32_le_quiet( float32, float32 );
|
|
||||||
int float32_lt_quiet( float32, float32 );
|
|
||||||
int float32_is_signaling_nan( float32 );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int float64_to_int32( float64 );
|
|
||||||
int float64_to_int32_round_to_zero( float64 );
|
|
||||||
long long float64_to_int64( float64 );
|
|
||||||
long long float64_to_int64_round_to_zero( float64 );
|
|
||||||
float32 float64_to_float32( float64 );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 float64_to_floatx80( float64 );
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 float64_to_float128( float64 );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
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 );
|
|
||||||
int float64_eq( float64, float64 );
|
|
||||||
int float64_le( float64, float64 );
|
|
||||||
int float64_lt( float64, float64 );
|
|
||||||
int float64_eq_signaling( float64, float64 );
|
|
||||||
int float64_le_quiet( float64, float64 );
|
|
||||||
int float64_lt_quiet( float64, float64 );
|
|
||||||
int float64_is_signaling_nan( float64 );
|
|
||||||
|
|
||||||
#ifdef FLOATX80
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-extended-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int floatx80_to_int32( floatx80 );
|
|
||||||
int floatx80_to_int32_round_to_zero( floatx80 );
|
|
||||||
long long floatx80_to_int64( floatx80 );
|
|
||||||
long long floatx80_to_int64_round_to_zero( floatx80 );
|
|
||||||
float32 floatx80_to_float32( floatx80 );
|
|
||||||
float64 floatx80_to_float64( floatx80 );
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 floatx80_to_float128( floatx80 );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-extended-precision rounding precision. Valid values
|
|
||||||
| are 32, 64, and 80.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern int floatx80_rounding_precision;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-extended-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
floatx80 floatx80_round_to_int( floatx80 );
|
|
||||||
floatx80 floatx80_add( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_sub( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_mul( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_div( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_rem( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_sqrt( floatx80 );
|
|
||||||
int floatx80_eq( floatx80, floatx80 );
|
|
||||||
int floatx80_le( floatx80, floatx80 );
|
|
||||||
int floatx80_lt( floatx80, floatx80 );
|
|
||||||
int floatx80_eq_signaling( floatx80, floatx80 );
|
|
||||||
int floatx80_le_quiet( floatx80, floatx80 );
|
|
||||||
int floatx80_lt_quiet( floatx80, floatx80 );
|
|
||||||
int floatx80_is_signaling_nan( floatx80 );
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef FLOAT128
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE quadruple-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int float128_to_int32( float128 );
|
|
||||||
int float128_to_int32_round_to_zero( float128 );
|
|
||||||
long long float128_to_int64( float128 );
|
|
||||||
long long float128_to_int64_round_to_zero( float128 );
|
|
||||||
float32 float128_to_float32( float128 );
|
|
||||||
float64 float128_to_float64( float128 );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 float128_to_floatx80( float128 );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE quadruple-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
float128 float128_round_to_int( float128 );
|
|
||||||
float128 float128_add( float128, float128 );
|
|
||||||
float128 float128_sub( float128, float128 );
|
|
||||||
float128 float128_mul( float128, float128 );
|
|
||||||
float128 float128_div( float128, float128 );
|
|
||||||
float128 float128_rem( float128, float128 );
|
|
||||||
float128 float128_sqrt( float128 );
|
|
||||||
int float128_eq( float128, float128 );
|
|
||||||
int float128_le( float128, float128 );
|
|
||||||
int float128_lt( float128, float128 );
|
|
||||||
int float128_eq_signaling( float128, float128 );
|
|
||||||
int float128_le_quiet( float128, float128 );
|
|
||||||
int float128_lt_quiet( float128, float128 );
|
|
||||||
int float128_is_signaling_nan( float128 );
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,713 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C source fragment is part of the Berkeley SoftFloat IEEE Floating-Point
|
|
||||||
Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Shifts `a' right by the number of bits given in `count'. If any nonzero
|
|
||||||
| bits are shifted off, they are "jammed" into the least significant bit of
|
|
||||||
| the result by setting the least significant bit to 1. The value of `count'
|
|
||||||
| can be arbitrarily large; in particular, if `count' is greater than 32, the
|
|
||||||
| result will be either 0 or 1, depending on whether `a' is zero or nonzero.
|
|
||||||
| The result is stored in the location pointed to by `zPtr'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void shift32RightJamming( bits32 a, int16 count, bits32 *zPtr )
|
|
||||||
{
|
|
||||||
bits32 z;
|
|
||||||
|
|
||||||
if ( count == 0 ) {
|
|
||||||
z = a;
|
|
||||||
}
|
|
||||||
else if ( count < 32 ) {
|
|
||||||
z = ( a>>count ) | ( ( a<<( ( - count ) & 31 ) ) != 0 );
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
z = ( a != 0 );
|
|
||||||
}
|
|
||||||
*zPtr = z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Shifts `a' right by the number of bits given in `count'. If any nonzero
|
|
||||||
| bits are shifted off, they are "jammed" into the least significant bit of
|
|
||||||
| the result by setting the least significant bit to 1. The value of `count'
|
|
||||||
| can be arbitrarily large; in particular, if `count' is greater than 64, the
|
|
||||||
| result will be either 0 or 1, depending on whether `a' is zero or nonzero.
|
|
||||||
| The result is stored in the location pointed to by `zPtr'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void shift64RightJamming( bits64 a, int16 count, bits64 *zPtr )
|
|
||||||
{
|
|
||||||
bits64 z;
|
|
||||||
|
|
||||||
if ( count == 0 ) {
|
|
||||||
z = a;
|
|
||||||
}
|
|
||||||
else if ( count < 64 ) {
|
|
||||||
z = ( a>>count ) | ( ( a<<( ( - count ) & 63 ) ) != 0 );
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
z = ( a != 0 );
|
|
||||||
}
|
|
||||||
*zPtr = z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Shifts the 128-bit value formed by concatenating `a0' and `a1' right by 64
|
|
||||||
| _plus_ the number of bits given in `count'. The shifted result is at most
|
|
||||||
| 64 nonzero bits; this is stored at the location pointed to by `z0Ptr'. The
|
|
||||||
| bits shifted off form a second 64-bit result as follows: The _last_ bit
|
|
||||||
| shifted off is the most-significant bit of the extra result, and the other
|
|
||||||
| 63 bits of the extra result are all zero if and only if _all_but_the_last_
|
|
||||||
| bits shifted off were all zero. This extra result is stored in the location
|
|
||||||
| pointed to by `z1Ptr'. The value of `count' can be arbitrarily large.
|
|
||||||
| (This routine makes more sense if `a0' and `a1' are considered to form
|
|
||||||
| a fixed-point value with binary point between `a0' and `a1'. This fixed-
|
|
||||||
| point value is shifted right by the number of bits given in `count', and
|
|
||||||
| the integer part of the result is returned at the location pointed to by
|
|
||||||
| `z0Ptr'. The fractional part of the result may be slightly corrupted as
|
|
||||||
| described above, and is returned at the location pointed to by `z1Ptr'.)
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void
|
|
||||||
shift64ExtraRightJamming(
|
|
||||||
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr )
|
|
||||||
{
|
|
||||||
bits64 z0, z1;
|
|
||||||
int8 negCount = ( - count ) & 63;
|
|
||||||
|
|
||||||
if ( count == 0 ) {
|
|
||||||
z1 = a1;
|
|
||||||
z0 = a0;
|
|
||||||
}
|
|
||||||
else if ( count < 64 ) {
|
|
||||||
z1 = ( a0<<negCount ) | ( a1 != 0 );
|
|
||||||
z0 = a0>>count;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
if ( count == 64 ) {
|
|
||||||
z1 = a0 | ( a1 != 0 );
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
z1 = ( ( a0 | a1 ) != 0 );
|
|
||||||
}
|
|
||||||
z0 = 0;
|
|
||||||
}
|
|
||||||
*z1Ptr = z1;
|
|
||||||
*z0Ptr = z0;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the
|
|
||||||
| number of bits given in `count'. Any bits shifted off are lost. The value
|
|
||||||
| of `count' can be arbitrarily large; in particular, if `count' is greater
|
|
||||||
| than 128, the result will be 0. The result is broken into two 64-bit pieces
|
|
||||||
| which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void
|
|
||||||
shift128Right(
|
|
||||||
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr )
|
|
||||||
{
|
|
||||||
bits64 z0, z1;
|
|
||||||
int8 negCount = ( - count ) & 63;
|
|
||||||
|
|
||||||
if ( count == 0 ) {
|
|
||||||
z1 = a1;
|
|
||||||
z0 = a0;
|
|
||||||
}
|
|
||||||
else if ( count < 64 ) {
|
|
||||||
z1 = ( a0<<negCount ) | ( a1>>count );
|
|
||||||
z0 = a0>>count;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
z1 = ( count < 128 ) ? ( a0>>( count & 63 ) ) : 0;
|
|
||||||
z0 = 0;
|
|
||||||
}
|
|
||||||
*z1Ptr = z1;
|
|
||||||
*z0Ptr = z0;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the
|
|
||||||
| number of bits given in `count'. If any nonzero bits are shifted off, they
|
|
||||||
| are "jammed" into the least significant bit of the result by setting the
|
|
||||||
| least significant bit to 1. The value of `count' can be arbitrarily large;
|
|
||||||
| in particular, if `count' is greater than 128, the result will be either
|
|
||||||
| 0 or 1, depending on whether the concatenation of `a0' and `a1' is zero or
|
|
||||||
| nonzero. The result is broken into two 64-bit pieces which are stored at
|
|
||||||
| the locations pointed to by `z0Ptr' and `z1Ptr'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void
|
|
||||||
shift128RightJamming(
|
|
||||||
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr )
|
|
||||||
{
|
|
||||||
bits64 z0, z1;
|
|
||||||
int8 negCount = ( - count ) & 63;
|
|
||||||
|
|
||||||
if ( count == 0 ) {
|
|
||||||
z1 = a1;
|
|
||||||
z0 = a0;
|
|
||||||
}
|
|
||||||
else if ( count < 64 ) {
|
|
||||||
z1 = ( a0<<negCount ) | ( a1>>count ) | ( ( a1<<negCount ) != 0 );
|
|
||||||
z0 = a0>>count;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
if ( count == 64 ) {
|
|
||||||
z1 = a0 | ( a1 != 0 );
|
|
||||||
}
|
|
||||||
else if ( count < 128 ) {
|
|
||||||
z1 = ( a0>>( count & 63 ) ) | ( ( ( a0<<negCount ) | a1 ) != 0 );
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
z1 = ( ( a0 | a1 ) != 0 );
|
|
||||||
}
|
|
||||||
z0 = 0;
|
|
||||||
}
|
|
||||||
*z1Ptr = z1;
|
|
||||||
*z0Ptr = z0;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' right
|
|
||||||
| by 64 _plus_ the number of bits given in `count'. The shifted result is
|
|
||||||
| at most 128 nonzero bits; these are broken into two 64-bit pieces which are
|
|
||||||
| stored at the locations pointed to by `z0Ptr' and `z1Ptr'. The bits shifted
|
|
||||||
| off form a third 64-bit result as follows: The _last_ bit shifted off is
|
|
||||||
| the most-significant bit of the extra result, and the other 63 bits of the
|
|
||||||
| extra result are all zero if and only if _all_but_the_last_ bits shifted off
|
|
||||||
| were all zero. This extra result is stored in the location pointed to by
|
|
||||||
| `z2Ptr'. The value of `count' can be arbitrarily large.
|
|
||||||
| (This routine makes more sense if `a0', `a1', and `a2' are considered
|
|
||||||
| to form a fixed-point value with binary point between `a1' and `a2'. This
|
|
||||||
| fixed-point value is shifted right by the number of bits given in `count',
|
|
||||||
| and the integer part of the result is returned at the locations pointed to
|
|
||||||
| by `z0Ptr' and `z1Ptr'. The fractional part of the result may be slightly
|
|
||||||
| corrupted as described above, and is returned at the location pointed to by
|
|
||||||
| `z2Ptr'.)
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void
|
|
||||||
shift128ExtraRightJamming(
|
|
||||||
bits64 a0,
|
|
||||||
bits64 a1,
|
|
||||||
bits64 a2,
|
|
||||||
int16 count,
|
|
||||||
bits64 *z0Ptr,
|
|
||||||
bits64 *z1Ptr,
|
|
||||||
bits64 *z2Ptr
|
|
||||||
)
|
|
||||||
{
|
|
||||||
bits64 z0, z1, z2;
|
|
||||||
int8 negCount = ( - count ) & 63;
|
|
||||||
|
|
||||||
if ( count == 0 ) {
|
|
||||||
z2 = a2;
|
|
||||||
z1 = a1;
|
|
||||||
z0 = a0;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
if ( count < 64 ) {
|
|
||||||
z2 = a1<<negCount;
|
|
||||||
z1 = ( a0<<negCount ) | ( a1>>count );
|
|
||||||
z0 = a0>>count;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
if ( count == 64 ) {
|
|
||||||
z2 = a1;
|
|
||||||
z1 = a0;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
a2 |= a1;
|
|
||||||
if ( count < 128 ) {
|
|
||||||
z2 = a0<<negCount;
|
|
||||||
z1 = a0>>( count & 63 );
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
z2 = ( count == 128 ) ? a0 : ( a0 != 0 );
|
|
||||||
z1 = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
z0 = 0;
|
|
||||||
}
|
|
||||||
z2 |= ( a2 != 0 );
|
|
||||||
}
|
|
||||||
*z2Ptr = z2;
|
|
||||||
*z1Ptr = z1;
|
|
||||||
*z0Ptr = z0;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Shifts the 128-bit value formed by concatenating `a0' and `a1' left by the
|
|
||||||
| number of bits given in `count'. Any bits shifted off are lost. The value
|
|
||||||
| of `count' must be less than 64. The result is broken into two 64-bit
|
|
||||||
| pieces which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void
|
|
||||||
shortShift128Left(
|
|
||||||
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr )
|
|
||||||
{
|
|
||||||
|
|
||||||
*z1Ptr = a1<<count;
|
|
||||||
*z0Ptr =
|
|
||||||
( count == 0 ) ? a0 : ( a0<<count ) | ( a1>>( ( - count ) & 63 ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' left
|
|
||||||
| by the number of bits given in `count'. Any bits shifted off are lost.
|
|
||||||
| The value of `count' must be less than 64. The result is broken into three
|
|
||||||
| 64-bit pieces which are stored at the locations pointed to by `z0Ptr',
|
|
||||||
| `z1Ptr', and `z2Ptr'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void
|
|
||||||
shortShift192Left(
|
|
||||||
bits64 a0,
|
|
||||||
bits64 a1,
|
|
||||||
bits64 a2,
|
|
||||||
int16 count,
|
|
||||||
bits64 *z0Ptr,
|
|
||||||
bits64 *z1Ptr,
|
|
||||||
bits64 *z2Ptr
|
|
||||||
)
|
|
||||||
{
|
|
||||||
bits64 z0, z1, z2;
|
|
||||||
int8 negCount;
|
|
||||||
|
|
||||||
z2 = a2<<count;
|
|
||||||
z1 = a1<<count;
|
|
||||||
z0 = a0<<count;
|
|
||||||
if ( 0 < count ) {
|
|
||||||
negCount = ( ( - count ) & 63 );
|
|
||||||
z1 |= a2>>negCount;
|
|
||||||
z0 |= a1>>negCount;
|
|
||||||
}
|
|
||||||
*z2Ptr = z2;
|
|
||||||
*z1Ptr = z1;
|
|
||||||
*z0Ptr = z0;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Adds the 128-bit value formed by concatenating `a0' and `a1' to the 128-bit
|
|
||||||
| value formed by concatenating `b0' and `b1'. Addition is modulo 2^128, so
|
|
||||||
| any carry out is lost. The result is broken into two 64-bit pieces which
|
|
||||||
| are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void
|
|
||||||
add128(
|
|
||||||
bits64 a0, bits64 a1, bits64 b0, bits64 b1, bits64 *z0Ptr, bits64 *z1Ptr )
|
|
||||||
{
|
|
||||||
bits64 z1;
|
|
||||||
|
|
||||||
z1 = a1 + b1;
|
|
||||||
*z1Ptr = z1;
|
|
||||||
*z0Ptr = a0 + b0 + ( z1 < a1 );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Adds the 192-bit value formed by concatenating `a0', `a1', and `a2' to the
|
|
||||||
| 192-bit value formed by concatenating `b0', `b1', and `b2'. Addition is
|
|
||||||
| modulo 2^192, so any carry out is lost. The result is broken into three
|
|
||||||
| 64-bit pieces which are stored at the locations pointed to by `z0Ptr',
|
|
||||||
| `z1Ptr', and `z2Ptr'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void
|
|
||||||
add192(
|
|
||||||
bits64 a0,
|
|
||||||
bits64 a1,
|
|
||||||
bits64 a2,
|
|
||||||
bits64 b0,
|
|
||||||
bits64 b1,
|
|
||||||
bits64 b2,
|
|
||||||
bits64 *z0Ptr,
|
|
||||||
bits64 *z1Ptr,
|
|
||||||
bits64 *z2Ptr
|
|
||||||
)
|
|
||||||
{
|
|
||||||
bits64 z0, z1, z2;
|
|
||||||
int8 carry0, carry1;
|
|
||||||
|
|
||||||
z2 = a2 + b2;
|
|
||||||
carry1 = ( z2 < a2 );
|
|
||||||
z1 = a1 + b1;
|
|
||||||
carry0 = ( z1 < a1 );
|
|
||||||
z0 = a0 + b0;
|
|
||||||
z1 += carry1;
|
|
||||||
z0 += ( z1 < carry1 );
|
|
||||||
z0 += carry0;
|
|
||||||
*z2Ptr = z2;
|
|
||||||
*z1Ptr = z1;
|
|
||||||
*z0Ptr = z0;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Subtracts the 128-bit value formed by concatenating `b0' and `b1' from the
|
|
||||||
| 128-bit value formed by concatenating `a0' and `a1'. Subtraction is modulo
|
|
||||||
| 2^128, so any borrow out (carry out) is lost. The result is broken into two
|
|
||||||
| 64-bit pieces which are stored at the locations pointed to by `z0Ptr' and
|
|
||||||
| `z1Ptr'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void
|
|
||||||
sub128(
|
|
||||||
bits64 a0, bits64 a1, bits64 b0, bits64 b1, bits64 *z0Ptr, bits64 *z1Ptr )
|
|
||||||
{
|
|
||||||
|
|
||||||
*z1Ptr = a1 - b1;
|
|
||||||
*z0Ptr = a0 - b0 - ( a1 < b1 );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Subtracts the 192-bit value formed by concatenating `b0', `b1', and `b2'
|
|
||||||
| from the 192-bit value formed by concatenating `a0', `a1', and `a2'.
|
|
||||||
| Subtraction is modulo 2^192, so any borrow out (carry out) is lost. The
|
|
||||||
| result is broken into three 64-bit pieces which are stored at the locations
|
|
||||||
| pointed to by `z0Ptr', `z1Ptr', and `z2Ptr'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void
|
|
||||||
sub192(
|
|
||||||
bits64 a0,
|
|
||||||
bits64 a1,
|
|
||||||
bits64 a2,
|
|
||||||
bits64 b0,
|
|
||||||
bits64 b1,
|
|
||||||
bits64 b2,
|
|
||||||
bits64 *z0Ptr,
|
|
||||||
bits64 *z1Ptr,
|
|
||||||
bits64 *z2Ptr
|
|
||||||
)
|
|
||||||
{
|
|
||||||
bits64 z0, z1, z2;
|
|
||||||
int8 borrow0, borrow1;
|
|
||||||
|
|
||||||
z2 = a2 - b2;
|
|
||||||
borrow1 = ( a2 < b2 );
|
|
||||||
z1 = a1 - b1;
|
|
||||||
borrow0 = ( a1 < b1 );
|
|
||||||
z0 = a0 - b0;
|
|
||||||
z0 -= ( z1 < borrow1 );
|
|
||||||
z1 -= borrow1;
|
|
||||||
z0 -= borrow0;
|
|
||||||
*z2Ptr = z2;
|
|
||||||
*z1Ptr = z1;
|
|
||||||
*z0Ptr = z0;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Multiplies `a' by `b' to obtain a 128-bit product. The product is broken
|
|
||||||
| into two 64-bit pieces which are stored at the locations pointed to by
|
|
||||||
| `z0Ptr' and `z1Ptr'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void mul64To128( bits64 a, bits64 b, bits64 *z0Ptr, bits64 *z1Ptr )
|
|
||||||
{
|
|
||||||
bits32 aHigh, aLow, bHigh, bLow;
|
|
||||||
bits64 z0, zMiddleA, zMiddleB, z1;
|
|
||||||
|
|
||||||
aLow = a;
|
|
||||||
aHigh = a>>32;
|
|
||||||
bLow = b;
|
|
||||||
bHigh = b>>32;
|
|
||||||
z1 = ( (bits64) aLow ) * bLow;
|
|
||||||
zMiddleA = ( (bits64) aLow ) * bHigh;
|
|
||||||
zMiddleB = ( (bits64) aHigh ) * bLow;
|
|
||||||
z0 = ( (bits64) aHigh ) * bHigh;
|
|
||||||
zMiddleA += zMiddleB;
|
|
||||||
z0 += ( ( (bits64) ( zMiddleA < zMiddleB ) )<<32 ) + ( zMiddleA>>32 );
|
|
||||||
zMiddleA <<= 32;
|
|
||||||
z1 += zMiddleA;
|
|
||||||
z0 += ( z1 < zMiddleA );
|
|
||||||
*z1Ptr = z1;
|
|
||||||
*z0Ptr = z0;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Multiplies the 128-bit value formed by concatenating `a0' and `a1' by
|
|
||||||
| `b' to obtain a 192-bit product. The product is broken into three 64-bit
|
|
||||||
| pieces which are stored at the locations pointed to by `z0Ptr', `z1Ptr', and
|
|
||||||
| `z2Ptr'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void
|
|
||||||
mul128By64To192(
|
|
||||||
bits64 a0,
|
|
||||||
bits64 a1,
|
|
||||||
bits64 b,
|
|
||||||
bits64 *z0Ptr,
|
|
||||||
bits64 *z1Ptr,
|
|
||||||
bits64 *z2Ptr
|
|
||||||
)
|
|
||||||
{
|
|
||||||
bits64 z0, z1, z2, more1;
|
|
||||||
|
|
||||||
mul64To128( a1, b, &z1, &z2 );
|
|
||||||
mul64To128( a0, b, &z0, &more1 );
|
|
||||||
add128( z0, more1, 0, z1, &z0, &z1 );
|
|
||||||
*z2Ptr = z2;
|
|
||||||
*z1Ptr = z1;
|
|
||||||
*z0Ptr = z0;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Multiplies the 128-bit value formed by concatenating `a0' and `a1' to the
|
|
||||||
| 128-bit value formed by concatenating `b0' and `b1' to obtain a 256-bit
|
|
||||||
| product. The product is broken into four 64-bit pieces which are stored at
|
|
||||||
| the locations pointed to by `z0Ptr', `z1Ptr', `z2Ptr', and `z3Ptr'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE void
|
|
||||||
mul128To256(
|
|
||||||
bits64 a0,
|
|
||||||
bits64 a1,
|
|
||||||
bits64 b0,
|
|
||||||
bits64 b1,
|
|
||||||
bits64 *z0Ptr,
|
|
||||||
bits64 *z1Ptr,
|
|
||||||
bits64 *z2Ptr,
|
|
||||||
bits64 *z3Ptr
|
|
||||||
)
|
|
||||||
{
|
|
||||||
bits64 z0, z1, z2, z3;
|
|
||||||
bits64 more1, more2;
|
|
||||||
|
|
||||||
mul64To128( a1, b1, &z2, &z3 );
|
|
||||||
mul64To128( a1, b0, &z1, &more2 );
|
|
||||||
add128( z1, more2, 0, z2, &z1, &z2 );
|
|
||||||
mul64To128( a0, b0, &z0, &more1 );
|
|
||||||
add128( z0, more1, 0, z1, &z0, &z1 );
|
|
||||||
mul64To128( a0, b1, &more1, &more2 );
|
|
||||||
add128( more1, more2, 0, z2, &more1, &z2 );
|
|
||||||
add128( z0, z1, 0, more1, &z0, &z1 );
|
|
||||||
*z3Ptr = z3;
|
|
||||||
*z2Ptr = z2;
|
|
||||||
*z1Ptr = z1;
|
|
||||||
*z0Ptr = z0;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns an approximation to the 64-bit integer quotient obtained by dividing
|
|
||||||
| `b' into the 128-bit value formed by concatenating `a0' and `a1'. The
|
|
||||||
| divisor `b' must be at least 2^63. If q is the exact quotient truncated
|
|
||||||
| toward zero, the approximation returned lies between q and q + 2 inclusive.
|
|
||||||
| If the exact quotient q is larger than 64 bits, the maximum positive 64-bit
|
|
||||||
| unsigned integer is returned.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static bits64 estimateDiv128To64( bits64 a0, bits64 a1, bits64 b )
|
|
||||||
{
|
|
||||||
bits64 b0, b1;
|
|
||||||
bits64 rem0, rem1, term0, term1;
|
|
||||||
bits64 z;
|
|
||||||
|
|
||||||
if ( b <= a0 ) return LIT64( 0xFFFFFFFFFFFFFFFF );
|
|
||||||
b0 = b>>32;
|
|
||||||
z = ( b0<<32 <= a0 ) ? LIT64( 0xFFFFFFFF00000000 ) : ( a0 / b0 )<<32;
|
|
||||||
mul64To128( b, z, &term0, &term1 );
|
|
||||||
sub128( a0, a1, term0, term1, &rem0, &rem1 );
|
|
||||||
while ( ( (sbits64) rem0 ) < 0 ) {
|
|
||||||
z -= LIT64( 0x100000000 );
|
|
||||||
b1 = b<<32;
|
|
||||||
add128( rem0, rem1, b0, b1, &rem0, &rem1 );
|
|
||||||
}
|
|
||||||
rem0 = ( rem0<<32 ) | ( rem1>>32 );
|
|
||||||
z |= ( b0<<32 <= rem0 ) ? 0xFFFFFFFF : rem0 / b0;
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns an approximation to the square root of the 32-bit significand given
|
|
||||||
| by `a'. Considered as an integer, `a' must be at least 2^31. If bit 0 of
|
|
||||||
| `aExp' (the least significant bit) is 1, the integer returned approximates
|
|
||||||
| 2^31*sqrt(`a'/2^31), where `a' is considered an integer. If bit 0 of `aExp'
|
|
||||||
| is 0, the integer returned approximates 2^31*sqrt(`a'/2^30). In either
|
|
||||||
| case, the approximation returned lies strictly within +/-2 of the exact
|
|
||||||
| value.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static bits32 estimateSqrt32( int16 aExp, bits32 a )
|
|
||||||
{
|
|
||||||
static const bits16 sqrtOddAdjustments[] = {
|
|
||||||
0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,
|
|
||||||
0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67
|
|
||||||
};
|
|
||||||
static const bits16 sqrtEvenAdjustments[] = {
|
|
||||||
0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E,
|
|
||||||
0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002
|
|
||||||
};
|
|
||||||
int8 index;
|
|
||||||
bits32 z;
|
|
||||||
|
|
||||||
index = ( a>>27 ) & 15;
|
|
||||||
if ( aExp & 1 ) {
|
|
||||||
z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ index ];
|
|
||||||
z = ( ( a / z )<<14 ) + ( z<<15 );
|
|
||||||
a >>= 1;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ index ];
|
|
||||||
z = a / z + z;
|
|
||||||
z = ( 0x20000 <= z ) ? 0xFFFF8000 : ( z<<15 );
|
|
||||||
if ( z <= a ) return (bits32) ( ( (sbits32) a )>>1 );
|
|
||||||
}
|
|
||||||
return ( (bits32) ( ( ( (bits64) a )<<31 ) / z ) ) + ( z>>1 );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the number of leading 0 bits before the most-significant 1 bit of
|
|
||||||
| `a'. If `a' is zero, 32 is returned.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static int8 countLeadingZeros32( bits32 a )
|
|
||||||
{
|
|
||||||
static const int8 countLeadingZerosHigh[] = {
|
|
||||||
8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
|
|
||||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
||||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
||||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
||||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
||||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
||||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
||||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
||||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
||||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
||||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
||||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
||||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
||||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
||||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
||||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
|
||||||
};
|
|
||||||
int8 shiftCount;
|
|
||||||
|
|
||||||
shiftCount = 0;
|
|
||||||
if ( a < 0x10000 ) {
|
|
||||||
shiftCount += 16;
|
|
||||||
a <<= 16;
|
|
||||||
}
|
|
||||||
if ( a < 0x1000000 ) {
|
|
||||||
shiftCount += 8;
|
|
||||||
a <<= 8;
|
|
||||||
}
|
|
||||||
shiftCount += countLeadingZerosHigh[ a>>24 ];
|
|
||||||
return shiftCount;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the number of leading 0 bits before the most-significant 1 bit of
|
|
||||||
| `a'. If `a' is zero, 64 is returned.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static int8 countLeadingZeros64( bits64 a )
|
|
||||||
{
|
|
||||||
int8 shiftCount;
|
|
||||||
|
|
||||||
shiftCount = 0;
|
|
||||||
if ( a < ( (bits64) 1 )<<32 ) {
|
|
||||||
shiftCount += 32;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
a >>= 32;
|
|
||||||
}
|
|
||||||
shiftCount += countLeadingZeros32( a );
|
|
||||||
return shiftCount;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the 128-bit value formed by concatenating `a0' and `a1'
|
|
||||||
| is equal to the 128-bit value formed by concatenating `b0' and `b1'.
|
|
||||||
| Otherwise, returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE flag eq128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( a0 == b0 ) && ( a1 == b1 );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less
|
|
||||||
| than or equal to the 128-bit value formed by concatenating `b0' and `b1'.
|
|
||||||
| Otherwise, returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE flag le128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 <= b1 ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less
|
|
||||||
| than the 128-bit value formed by concatenating `b0' and `b1'. Otherwise,
|
|
||||||
| returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE flag lt128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is
|
|
||||||
| not equal to the 128-bit value formed by concatenating `b0' and `b1'.
|
|
||||||
| Otherwise, returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
INLINE flag ne128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( a0 != b0 ) || ( a1 != b1 );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
File diff suppressed because it is too large
Load Diff
@ -1,28 +0,0 @@
|
|||||||
|
|
||||||
PROCESSOR_H = ../../../processors/!!!processor.h
|
|
||||||
SOFTFLOAT_MACROS = ../softfloat-macros
|
|
||||||
|
|
||||||
OBJ = .o
|
|
||||||
EXE =
|
|
||||||
INCLUDES = -I. -I..
|
|
||||||
COMPILE_C = gcc -c -o $@ $(INCLUDES) -I- -O2
|
|
||||||
LINK = gcc -o $@
|
|
||||||
|
|
||||||
#-----------------------------------------------------------------------------
|
|
||||||
# Probably okay below here.
|
|
||||||
#-----------------------------------------------------------------------------
|
|
||||||
|
|
||||||
ALL: softfloat$(OBJ) timesoftfloat$(EXE)
|
|
||||||
|
|
||||||
milieu.h: $(PROCESSOR_H)
|
|
||||||
touch milieu.h
|
|
||||||
|
|
||||||
softfloat$(OBJ): milieu.h softfloat.h softfloat-specialize $(SOFTFLOAT_MACROS) ../softfloat.c
|
|
||||||
$(COMPILE_C) ../softfloat.c
|
|
||||||
|
|
||||||
timesoftfloat$(OBJ): milieu.h softfloat.h ../timesoftfloat.c
|
|
||||||
$(COMPILE_C) ../timesoftfloat.c
|
|
||||||
|
|
||||||
timesoftfloat$(EXE): softfloat$(OBJ) timesoftfloat$(OBJ)
|
|
||||||
$(LINK) softfloat$(OBJ) timesoftfloat$(OBJ)
|
|
||||||
|
|
@ -1,38 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C header file template is part of the Berkeley SoftFloat IEEE Floating-
|
|
||||||
Point Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Include common integer types and flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#include "../../../processors/!!!processor.h"
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Symbolic Boolean literals.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
enum {
|
|
||||||
FALSE = 0,
|
|
||||||
TRUE = 1
|
|
||||||
};
|
|
||||||
|
|
@ -1,425 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C source fragment is part of the Berkeley SoftFloat IEEE Floating-Point
|
|
||||||
Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Underflow tininess-detection mode, statically initialized to default value.
|
|
||||||
| (The declaration in `softfloat.h' must match the `int8' type here.)
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int8 float_detect_tininess = float_tininess_after_rounding;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Raises the exceptions specified by `flags'. Floating-point traps can be
|
|
||||||
| defined here if desired. It is currently not possible for such a trap to
|
|
||||||
| substitute a result value. If traps are not implemented, this routine
|
|
||||||
| should be simply `float_exception_flags |= flags;'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
void float_raise( int8 flags )
|
|
||||||
{
|
|
||||||
|
|
||||||
float_exception_flags |= flags;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Internal canonical NaN format.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
typedef struct {
|
|
||||||
flag sign;
|
|
||||||
bits64 high, low;
|
|
||||||
} commonNaNT;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The pattern for a default generated single-precision NaN.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define float32_default_nan 0xFFFFFFFF
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the single-precision floating-point value `a' is a NaN;
|
|
||||||
| otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float32_is_nan( float32 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( 0xFF000000 < (bits32) ( a<<1 ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the single-precision floating-point value `a' is a signaling
|
|
||||||
| NaN; otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float32_is_signaling_nan( float32 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the single-precision floating-point NaN
|
|
||||||
| `a' to the canonical NaN format. If `a' is a 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 = ( (bits64) a )<<41;
|
|
||||||
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>>41 );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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 )
|
|
||||||
{
|
|
||||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
|
||||||
|
|
||||||
aIsNaN = float32_is_nan( a );
|
|
||||||
aIsSignalingNaN = float32_is_signaling_nan( a );
|
|
||||||
bIsNaN = float32_is_nan( b );
|
|
||||||
bIsSignalingNaN = float32_is_signaling_nan( b );
|
|
||||||
a |= 0x00400000;
|
|
||||||
b |= 0x00400000;
|
|
||||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
|
||||||
if ( aIsNaN ) {
|
|
||||||
return ( aIsSignalingNaN & bIsNaN ) ? b : a;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
return b;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The pattern for a default generated double-precision NaN.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define float64_default_nan LIT64( 0xFFFFFFFFFFFFFFFF )
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the double-precision floating-point value `a' is a NaN;
|
|
||||||
| otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float64_is_nan( float64 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( LIT64( 0xFFE0000000000000 ) < (bits64) ( a<<1 ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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>>51 ) & 0xFFF ) == 0xFFE )
|
|
||||||
&& ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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>>63;
|
|
||||||
z.low = 0;
|
|
||||||
z.high = a<<12;
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the canonical NaN `a' to the double-
|
|
||||||
| precision floating-point format.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static float64 commonNaNToFloat64( commonNaNT a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return
|
|
||||||
( ( (bits64) a.sign )<<63 )
|
|
||||||
| LIT64( 0x7FF8000000000000 )
|
|
||||||
| ( a.high>>12 );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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 |= LIT64( 0x0008000000000000 );
|
|
||||||
b |= LIT64( 0x0008000000000000 );
|
|
||||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
|
||||||
if ( aIsNaN ) {
|
|
||||||
return ( aIsSignalingNaN & bIsNaN ) ? b : a;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
return b;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef FLOATX80
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The pattern for a default generated double-extended-precision NaN.
|
|
||||||
| The `high' and `low' values hold the most- and least-significant bits,
|
|
||||||
| respectively.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define floatx80_default_nan_high 0xFFFF
|
|
||||||
#define floatx80_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF )
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the double-extended-precision floating-point value `a' is a
|
|
||||||
| NaN; otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag floatx80_is_nan( floatx80 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the double-extended-precision floating-point value `a' is a
|
|
||||||
| signaling NaN; otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag floatx80_is_signaling_nan( floatx80 a )
|
|
||||||
{
|
|
||||||
bits64 aLow;
|
|
||||||
|
|
||||||
aLow = a.low & ~ LIT64( 0x4000000000000000 );
|
|
||||||
return
|
|
||||||
( ( a.high & 0x7FFF ) == 0x7FFF )
|
|
||||||
&& (bits64) ( aLow<<1 )
|
|
||||||
&& ( a.low == aLow );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the double-extended-precision floating-
|
|
||||||
| point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the
|
|
||||||
| invalid exception is raised.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static commonNaNT floatx80ToCommonNaN( floatx80 a )
|
|
||||||
{
|
|
||||||
commonNaNT z;
|
|
||||||
|
|
||||||
if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
|
|
||||||
z.sign = a.high>>15;
|
|
||||||
z.low = 0;
|
|
||||||
z.high = a.low<<1;
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the canonical NaN `a' to the double-
|
|
||||||
| extended-precision floating-point format.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static floatx80 commonNaNToFloatx80( commonNaNT a )
|
|
||||||
{
|
|
||||||
floatx80 z;
|
|
||||||
|
|
||||||
z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 );
|
|
||||||
z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF;
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Takes two double-extended-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 floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b )
|
|
||||||
{
|
|
||||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
|
||||||
|
|
||||||
aIsNaN = floatx80_is_nan( a );
|
|
||||||
aIsSignalingNaN = floatx80_is_signaling_nan( a );
|
|
||||||
bIsNaN = floatx80_is_nan( b );
|
|
||||||
bIsSignalingNaN = floatx80_is_signaling_nan( b );
|
|
||||||
a.low |= LIT64( 0xC000000000000000 );
|
|
||||||
b.low |= LIT64( 0xC000000000000000 );
|
|
||||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
|
||||||
if ( aIsNaN ) {
|
|
||||||
return ( aIsSignalingNaN & bIsNaN ) ? b : a;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
return b;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef FLOAT128
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The pattern for a default generated quadruple-precision NaN. The `high' and
|
|
||||||
| `low' values hold the most- and least-significant bits, respectively.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define float128_default_nan_high LIT64( 0xFFFFFFFFFFFFFFFF )
|
|
||||||
#define float128_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF )
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the quadruple-precision floating-point value `a' is a NaN;
|
|
||||||
| otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float128_is_nan( float128 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return
|
|
||||||
( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
|
|
||||||
&& ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the quadruple-precision floating-point value `a' is a
|
|
||||||
| signaling NaN; otherwise returns 0.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
flag float128_is_signaling_nan( float128 a )
|
|
||||||
{
|
|
||||||
|
|
||||||
return
|
|
||||||
( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
|
|
||||||
&& ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the quadruple-precision floating-point NaN
|
|
||||||
| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
|
|
||||||
| exception is raised.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static commonNaNT float128ToCommonNaN( float128 a )
|
|
||||||
{
|
|
||||||
commonNaNT z;
|
|
||||||
|
|
||||||
if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
|
|
||||||
z.sign = a.high>>63;
|
|
||||||
shortShift128Left( a.high, a.low, 16, &z.high, &z.low );
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns the result of converting the canonical NaN `a' to the quadruple-
|
|
||||||
| precision floating-point format.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
static float128 commonNaNToFloat128( commonNaNT a )
|
|
||||||
{
|
|
||||||
float128 z;
|
|
||||||
|
|
||||||
shift128Right( a.high, a.low, 16, &z.high, &z.low );
|
|
||||||
z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF800000000000 );
|
|
||||||
return z;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Takes two quadruple-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 float128 propagateFloat128NaN( float128 a, float128 b )
|
|
||||||
{
|
|
||||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
|
||||||
|
|
||||||
aIsNaN = float128_is_nan( a );
|
|
||||||
aIsSignalingNaN = float128_is_signaling_nan( a );
|
|
||||||
bIsNaN = float128_is_nan( b );
|
|
||||||
bIsSignalingNaN = float128_is_signaling_nan( b );
|
|
||||||
a.high |= LIT64( 0x0000800000000000 );
|
|
||||||
b.high |= LIT64( 0x0000800000000000 );
|
|
||||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
|
||||||
if ( aIsNaN ) {
|
|
||||||
return ( aIsSignalingNaN & bIsNaN ) ? b : a;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
return b;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,252 +0,0 @@
|
|||||||
|
|
||||||
/*============================================================================
|
|
||||||
|
|
||||||
This C header file template is part of the Berkeley SoftFloat IEEE Floating-
|
|
||||||
Point Arithmetic Package, Release 2c, by John R. Hauser.
|
|
||||||
|
|
||||||
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 TOLERATE ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS THEY INCUR DUE TO THE SOFTWARE WITHOUT RECOMPENSE FROM JOHN HAUSER OR
|
|
||||||
THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE, AND WHO FURTHERMORE EFFECTIVELY
|
|
||||||
INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE INSTITUTE
|
|
||||||
(possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR OTHER
|
|
||||||
PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE, OR
|
|
||||||
INCURRED BY ANYONE DUE TO A DERIVATIVE WORK THEY CREATE USING ANY PART OF THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
Derivative works require also that (1) the source code for the derivative work
|
|
||||||
includes prominent notice that the work is derivative, and (2) the source code
|
|
||||||
includes prominent notice of these three paragraphs for those parts of this
|
|
||||||
code that are retained.
|
|
||||||
|
|
||||||
=============================================================================*/
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| The macro `FLOATX80' must be defined to enable the double-extended-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'.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
#define FLOATX80
|
|
||||||
#define FLOAT128
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point types.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
typedef !!!bits32 float32;
|
|
||||||
typedef !!!bits64 float64;
|
|
||||||
#ifdef FLOATX80
|
|
||||||
typedef struct {
|
|
||||||
!!!bits16 high;
|
|
||||||
!!!bits64 low;
|
|
||||||
} floatx80;
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
typedef struct {
|
|
||||||
!!!bits64 high, low;
|
|
||||||
} float128;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point underflow tininess-detection mode.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern !!!int8 float_detect_tininess;
|
|
||||||
enum {
|
|
||||||
float_tininess_after_rounding = 0,
|
|
||||||
float_tininess_before_rounding = 1
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point rounding mode.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern !!!int8 float_rounding_mode;
|
|
||||||
enum {
|
|
||||||
float_round_nearest_even = 0,
|
|
||||||
float_round_to_zero = 1,
|
|
||||||
float_round_down = 2,
|
|
||||||
float_round_up = 3
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE floating-point exception flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern !!!int8 float_exception_flags;
|
|
||||||
enum {
|
|
||||||
float_flag_inexact = 1,
|
|
||||||
float_flag_underflow = 2,
|
|
||||||
float_flag_overflow = 4,
|
|
||||||
float_flag_divbyzero = 8,
|
|
||||||
float_flag_invalid = 16
|
|
||||||
};
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Routine to raise any or all of the software IEEE floating-point exception
|
|
||||||
| flags.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
void float_raise( !!!int8 );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE integer-to-floating-point conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
float32 int32_to_float32( !!!int32 );
|
|
||||||
float64 int32_to_float64( !!!int32 );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 int32_to_floatx80( !!!int32 );
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 int32_to_float128( !!!int32 );
|
|
||||||
#endif
|
|
||||||
float32 int64_to_float32( !!!int64 );
|
|
||||||
float64 int64_to_float64( !!!int64 );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 int64_to_floatx80( !!!int64 );
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 int64_to_float128( !!!int64 );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE single-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
!!!int32 float32_to_int32( float32 );
|
|
||||||
!!!int32 float32_to_int32_round_to_zero( float32 );
|
|
||||||
!!!int64 float32_to_int64( float32 );
|
|
||||||
!!!int64 float32_to_int64_round_to_zero( float32 );
|
|
||||||
float64 float32_to_float64( float32 );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 float32_to_floatx80( float32 );
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 float32_to_float128( float32 );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE single-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
float32 float32_round_to_int( float32 );
|
|
||||||
float32 float32_add( float32, float32 );
|
|
||||||
float32 float32_sub( float32, float32 );
|
|
||||||
float32 float32_mul( float32, float32 );
|
|
||||||
float32 float32_div( float32, float32 );
|
|
||||||
float32 float32_rem( float32, float32 );
|
|
||||||
float32 float32_sqrt( float32 );
|
|
||||||
!!!flag float32_eq( float32, float32 );
|
|
||||||
!!!flag float32_le( float32, float32 );
|
|
||||||
!!!flag float32_lt( float32, float32 );
|
|
||||||
!!!flag float32_eq_signaling( float32, float32 );
|
|
||||||
!!!flag float32_le_quiet( float32, float32 );
|
|
||||||
!!!flag float32_lt_quiet( float32, float32 );
|
|
||||||
!!!flag float32_is_signaling_nan( float32 );
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
!!!int32 float64_to_int32( float64 );
|
|
||||||
!!!int32 float64_to_int32_round_to_zero( float64 );
|
|
||||||
!!!int64 float64_to_int64( float64 );
|
|
||||||
!!!int64 float64_to_int64_round_to_zero( float64 );
|
|
||||||
float32 float64_to_float32( float64 );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 float64_to_floatx80( float64 );
|
|
||||||
#endif
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 float64_to_float128( float64 );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
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 );
|
|
||||||
|
|
||||||
#ifdef FLOATX80
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-extended-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
!!!int32 floatx80_to_int32( floatx80 );
|
|
||||||
!!!int32 floatx80_to_int32_round_to_zero( floatx80 );
|
|
||||||
!!!int64 floatx80_to_int64( floatx80 );
|
|
||||||
!!!int64 floatx80_to_int64_round_to_zero( floatx80 );
|
|
||||||
float32 floatx80_to_float32( floatx80 );
|
|
||||||
float64 floatx80_to_float64( floatx80 );
|
|
||||||
#ifdef FLOAT128
|
|
||||||
float128 floatx80_to_float128( floatx80 );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-extended-precision rounding precision. Valid values
|
|
||||||
| are 32, 64, and 80.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
extern !!!int8 floatx80_rounding_precision;
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE double-extended-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
floatx80 floatx80_round_to_int( floatx80 );
|
|
||||||
floatx80 floatx80_add( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_sub( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_mul( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_div( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_rem( floatx80, floatx80 );
|
|
||||||
floatx80 floatx80_sqrt( floatx80 );
|
|
||||||
!!!flag floatx80_eq( floatx80, floatx80 );
|
|
||||||
!!!flag floatx80_le( floatx80, floatx80 );
|
|
||||||
!!!flag floatx80_lt( floatx80, floatx80 );
|
|
||||||
!!!flag floatx80_eq_signaling( floatx80, floatx80 );
|
|
||||||
!!!flag floatx80_le_quiet( floatx80, floatx80 );
|
|
||||||
!!!flag floatx80_lt_quiet( floatx80, floatx80 );
|
|
||||||
!!!flag floatx80_is_signaling_nan( floatx80 );
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef FLOAT128
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE quadruple-precision conversion routines.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
!!!int32 float128_to_int32( float128 );
|
|
||||||
!!!int32 float128_to_int32_round_to_zero( float128 );
|
|
||||||
!!!int64 float128_to_int64( float128 );
|
|
||||||
!!!int64 float128_to_int64_round_to_zero( float128 );
|
|
||||||
float32 float128_to_float32( float128 );
|
|
||||||
float64 float128_to_float64( float128 );
|
|
||||||
#ifdef FLOATX80
|
|
||||||
floatx80 float128_to_floatx80( float128 );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Software IEEE quadruple-precision operations.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
float128 float128_round_to_int( float128 );
|
|
||||||
float128 float128_add( float128, float128 );
|
|
||||||
float128 float128_sub( float128, float128 );
|
|
||||||
float128 float128_mul( float128, float128 );
|
|
||||||
float128 float128_div( float128, float128 );
|
|
||||||
float128 float128_rem( float128, float128 );
|
|
||||||
float128 float128_sqrt( float128 );
|
|
||||||
!!!flag float128_eq( float128, float128 );
|
|
||||||
!!!flag float128_le( float128, float128 );
|
|
||||||
!!!flag float128_lt( float128, float128 );
|
|
||||||
!!!flag float128_eq_signaling( float128, float128 );
|
|
||||||
!!!flag float128_le_quiet( float128, float128 );
|
|
||||||
!!!flag float128_lt_quiet( float128, float128 );
|
|
||||||
!!!flag float128_is_signaling_nan( float128 );
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user