+++ /dev/null
-\r
-/*============================================================================\r
-\r
-*** FIX.\r
-\r
-This C source fragment is part of the SoftFloat IEC/IEEE Floating-point\r
-Arithmetic Package, Release 2b.\r
-\r
-Written by John R. Hauser. This work was made possible in part by the\r
-International Computer Science Institute, located at Suite 600, 1947 Center\r
-Street, Berkeley, California 94704. Funding was partially provided by the\r
-National Science Foundation under grant MIP-9311980. The original version\r
-of this code was written as part of a project to build a fixed-point vector\r
-processor in collaboration with the University of California at Berkeley,\r
-overseen by Profs. Nelson Morgan and John Wawrzynek. More information\r
-is available through the Web page `http://www.cs.berkeley.edu/~jhauser/\r
-arithmetic/SoftFloat.html'.\r
-\r
-THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has\r
-been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES\r
-RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS\r
-AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,\r
-COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE\r
-EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE\r
-INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR\r
-OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.\r
-\r
-Derivative works are acceptable, even for commercial purposes, so long as\r
-(1) the source code for the derivative work includes prominent notice that\r
-the work is derivative, and (2) the source code includes prominent notice with\r
-these four paragraphs for those parts of this code that are retained.\r
-\r
-=============================================================================*/\r
-\r
-/*----------------------------------------------------------------------------\r
-| Internal canonical NaN format.\r
-*----------------------------------------------------------------------------*/\r
-*** COMMON\r
-typedef struct {\r
- flag sign;\r
- uint128_t bits;\r
-} commonNaNT;\r
-\r
-/*----------------------------------------------------------------------------\r
-| The pattern for a default generated single-precision NaN.\r
-*----------------------------------------------------------------------------*/\r
-#define float32Bits_defaultNaN 0xFFC00000\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns 1 if the single-precision floating-point value `a' is a NaN;\r
-| otherwise, returns 0.\r
-*----------------------------------------------------------------------------*/\r
-*** COMMON\r
-#define softfloat_isNaNFloat32Bits( a ) ( 0xFF000000 < (uint32_t) ( a )<<1 )\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns 1 if the single-precision floating-point value `a' is a signaling\r
-| NaN; otherwise, returns 0.\r
-*----------------------------------------------------------------------------*/\r
-inline bool softfloat_isSigNaNFloat32Bits( uint32_t a )\r
- { return ( ( a>>22 & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF ); }\r
-\r
-/*----------------------------------------------------------------------------\r
-*----------------------------------------------------------------------------*/\r
-commonNaNT softfloat_NaNFromFloat32Bits( uint32_t );\r
-uint32_t softfloat_float32BitsFromNaN( commonNaNT );\r
-uint32_t softfloat_propNaNFloat32Bits( uint32_t, uint32_t );\r
-\r
-/*----------------------------------------------------------------------------\r
-| The pattern for a default generated double-precision NaN.\r
-*----------------------------------------------------------------------------*/\r
-#define float64Bits_defaultNaN 0xFFF8000000000000\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns 1 if the double-precision floating-point value `a' is a NaN;\r
-| otherwise, returns 0.\r
-*----------------------------------------------------------------------------*/\r
-*** COMMON\r
-#define softfloat_isNaNFloat64Bits( a ) ( 0xFFE0000000000000 < (uint64_t) ( a )<<1 )\r
-\r
-\r
-\r
-\r
-\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns 1 if the double-precision floating-point value `a' is a signaling\r
-| NaN; otherwise, returns 0.\r
-*----------------------------------------------------------------------------*/\r
-\r
-flag float64_is_signaling_nan( float64 a )\r
-{\r
-\r
- return\r
- ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )\r
- && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );\r
-\r
-}\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns the result of converting the double-precision floating-point NaN\r
-| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid\r
-| exception is raised.\r
-*----------------------------------------------------------------------------*/\r
-\r
-static commonNaNT float64ToCommonNaN( float64 a )\r
-{\r
- commonNaNT z;\r
-\r
- if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid );\r
- z.sign = a>>63;\r
- z.low = 0;\r
- z.high = a<<12;\r
- return z;\r
-\r
-}\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns the result of converting the canonical NaN `a' to the double-\r
-| precision floating-point format.\r
-*----------------------------------------------------------------------------*/\r
-\r
-static float64 commonNaNToFloat64( commonNaNT a )\r
-{\r
-\r
- return\r
- ( ( (bits64) a.sign )<<63 )\r
- | LIT64( 0x7FF8000000000000 )\r
- | ( a.high>>12 );\r
-\r
-}\r
-\r
-/*----------------------------------------------------------------------------\r
-| Takes two double-precision floating-point values `a' and `b', one of which\r
-| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a\r
-| signaling NaN, the invalid exception is raised.\r
-*----------------------------------------------------------------------------*/\r
-\r
-static float64 propagateFloat64NaN( float64 a, float64 b )\r
-{\r
- flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;\r
-\r
- aIsNaN = float64_is_nan( a );\r
- aIsSignalingNaN = float64_is_signaling_nan( a );\r
- bIsNaN = float64_is_nan( b );\r
- bIsSignalingNaN = float64_is_signaling_nan( b );\r
- a |= LIT64( 0x0008000000000000 );\r
- b |= LIT64( 0x0008000000000000 );\r
- if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );\r
- if ( aIsSignalingNaN ) {\r
- if ( bIsSignalingNaN ) goto returnLargerSignificand;\r
- return bIsNaN ? b : a;\r
- }\r
- else if ( aIsNaN ) {\r
- if ( bIsSignalingNaN | ! bIsNaN ) return a;\r
- returnLargerSignificand:\r
- if ( (bits64) ( a<<1 ) < (bits64) ( b<<1 ) ) return b;\r
- if ( (bits64) ( b<<1 ) < (bits64) ( a<<1 ) ) return a;\r
- return ( a < b ) ? a : b;\r
- }\r
- else {\r
- return b;\r
- }\r
-\r
-}\r
-\r
-#ifdef FLOATX80\r
-\r
-/*----------------------------------------------------------------------------\r
-| The pattern for a default generated extended double-precision NaN. The\r
-| `high' and `low' values hold the most- and least-significant bits,\r
-| respectively.\r
-*----------------------------------------------------------------------------*/\r
-#define floatx80_default_nan_high 0xFFFF\r
-#define floatx80_default_nan_low LIT64( 0xC000000000000000 )\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns 1 if the extended double-precision floating-point value `a' is a\r
-| NaN; otherwise, returns 0.\r
-*----------------------------------------------------------------------------*/\r
-\r
-flag floatx80_is_nan( floatx80 a )\r
-{\r
-\r
- return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );\r
-\r
-}\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns 1 if the extended double-precision floating-point value `a' is a\r
-| signaling NaN; otherwise, returns 0.\r
-*----------------------------------------------------------------------------*/\r
-\r
-flag floatx80_is_signaling_nan( floatx80 a )\r
-{\r
- bits64 aLow;\r
-\r
- aLow = a.low & ~ LIT64( 0x4000000000000000 );\r
- return\r
- ( ( a.high & 0x7FFF ) == 0x7FFF )\r
- && (bits64) ( aLow<<1 )\r
- && ( a.low == aLow );\r
-\r
-}\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns the result of converting the extended double-precision floating-\r
-| point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the\r
-| invalid exception is raised.\r
-*----------------------------------------------------------------------------*/\r
-\r
-static commonNaNT floatx80ToCommonNaN( floatx80 a )\r
-{\r
- commonNaNT z;\r
-\r
- if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid );\r
- z.sign = a.high>>15;\r
- z.low = 0;\r
- z.high = a.low<<1;\r
- return z;\r
-\r
-}\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns the result of converting the canonical NaN `a' to the extended\r
-| double-precision floating-point format.\r
-*----------------------------------------------------------------------------*/\r
-\r
-static floatx80 commonNaNToFloatx80( commonNaNT a )\r
-{\r
- floatx80 z;\r
-\r
- z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 );\r
- z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF;\r
- return z;\r
-\r
-}\r
-\r
-/*----------------------------------------------------------------------------\r
-| Takes two extended double-precision floating-point values `a' and `b', one\r
-| of which is a NaN, and returns the appropriate NaN result. If either `a' or\r
-| `b' is a signaling NaN, the invalid exception is raised.\r
-*----------------------------------------------------------------------------*/\r
-\r
-static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b )\r
-{\r
- flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;\r
-\r
- aIsNaN = floatx80_is_nan( a );\r
- aIsSignalingNaN = floatx80_is_signaling_nan( a );\r
- bIsNaN = floatx80_is_nan( b );\r
- bIsSignalingNaN = floatx80_is_signaling_nan( b );\r
- a.low |= LIT64( 0xC000000000000000 );\r
- b.low |= LIT64( 0xC000000000000000 );\r
- if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );\r
- if ( aIsSignalingNaN ) {\r
- if ( bIsSignalingNaN ) goto returnLargerSignificand;\r
- return bIsNaN ? b : a;\r
- }\r
- else if ( aIsNaN ) {\r
- if ( bIsSignalingNaN | ! bIsNaN ) return a;\r
- returnLargerSignificand:\r
- if ( a.low < b.low ) return b;\r
- if ( b.low < a.low ) return a;\r
- return ( a.high < b.high ) ? a : b;\r
- }\r
- else {\r
- return b;\r
- }\r
-\r
-}\r
-\r
-#endif\r
-\r
-#ifdef FLOAT128\r
-\r
-/*----------------------------------------------------------------------------\r
-| The pattern for a default generated quadruple-precision NaN. The `high' and\r
-| `low' values hold the most- and least-significant bits, respectively.\r
-*----------------------------------------------------------------------------*/\r
-#define float128_default_nan_high LIT64( 0xFFFF800000000000 )\r
-#define float128_default_nan_low LIT64( 0x0000000000000000 )\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns 1 if the quadruple-precision floating-point value `a' is a NaN;\r
-| otherwise, returns 0.\r
-*----------------------------------------------------------------------------*/\r
-\r
-flag float128_is_nan( float128 a )\r
-{\r
-\r
- return\r
- ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )\r
- && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );\r
-\r
-}\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns 1 if the quadruple-precision floating-point value `a' is a\r
-| signaling NaN; otherwise, returns 0.\r
-*----------------------------------------------------------------------------*/\r
-\r
-flag float128_is_signaling_nan( float128 a )\r
-{\r
-\r
- return\r
- ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )\r
- && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );\r
-\r
-}\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns the result of converting the quadruple-precision floating-point NaN\r
-| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid\r
-| exception is raised.\r
-*----------------------------------------------------------------------------*/\r
-\r
-static commonNaNT float128ToCommonNaN( float128 a )\r
-{\r
- commonNaNT z;\r
-\r
- if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid );\r
- z.sign = a.high>>63;\r
- shortShift128Left( a.high, a.low, 16, &z.high, &z.low );\r
- return z;\r
-\r
-}\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns the result of converting the canonical NaN `a' to the quadruple-\r
-| precision floating-point format.\r
-*----------------------------------------------------------------------------*/\r
-\r
-static float128 commonNaNToFloat128( commonNaNT a )\r
-{\r
- float128 z;\r
-\r
- shift128Right( a.high, a.low, 16, &z.high, &z.low );\r
- z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF800000000000 );\r
- return z;\r
-\r
-}\r
-\r
-/*----------------------------------------------------------------------------\r
-| Takes two quadruple-precision floating-point values `a' and `b', one of\r
-| which is a NaN, and returns the appropriate NaN result. If either `a' or\r
-| `b' is a signaling NaN, the invalid exception is raised.\r
-*----------------------------------------------------------------------------*/\r
-\r
-static float128 propagateFloat128NaN( float128 a, float128 b )\r
-{\r
- flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;\r
-\r
- aIsNaN = float128_is_nan( a );\r
- aIsSignalingNaN = float128_is_signaling_nan( a );\r
- bIsNaN = float128_is_nan( b );\r
- bIsSignalingNaN = float128_is_signaling_nan( b );\r
- a.high |= LIT64( 0x0000800000000000 );\r
- b.high |= LIT64( 0x0000800000000000 );\r
- if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );\r
- if ( aIsSignalingNaN ) {\r
- if ( bIsSignalingNaN ) goto returnLargerSignificand;\r
- return bIsNaN ? b : a;\r
- }\r
- else if ( aIsNaN ) {\r
- if ( bIsSignalingNaN | ! bIsNaN ) return a;\r
- returnLargerSignificand:\r
- if ( lt128( a.high<<1, a.low, b.high<<1, b.low ) ) return b;\r
- if ( lt128( b.high<<1, b.low, a.high<<1, a.low ) ) return a;\r
- return ( a.high < b.high ) ? a : b;\r
- }\r
- else {\r
- return b;\r
- }\r
-\r
-}\r
-\r
-#endif\r
-\r
projects / riscv-isa-sim.git / blobdiff