![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to softfloat.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / fpu|
Return to softfloat.h CVS log | Up to [Qemu by Fabrice Bellard] / qemu / fpu |
1.1.1.10! root 1: /* ! 2: * QEMU float support ! 3: * ! 4: * Derived from SoftFloat. ! 5: */ ! 6: 1.1 root 7: /*============================================================================ 8: 9: This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic 10: Package, Release 2b. 11: 12: Written by John R. Hauser. This work was made possible in part by the 13: International Computer Science Institute, located at Suite 600, 1947 Center 14: Street, Berkeley, California 94704. Funding was partially provided by the 15: National Science Foundation under grant MIP-9311980. The original version 16: of this code was written as part of a project to build a fixed-point vector 17: processor in collaboration with the University of California at Berkeley, 18: overseen by Profs. Nelson Morgan and John Wawrzynek. More information 19: is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ 20: arithmetic/SoftFloat.html'. 21: 22: THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has 23: been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES 24: RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS 25: AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, 26: COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE 27: EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE 28: INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR 29: OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. 30: 31: Derivative works are acceptable, even for commercial purposes, so long as 32: (1) the source code for the derivative work includes prominent notice that 33: the work is derivative, and (2) the source code includes prominent notice with 34: these four paragraphs for those parts of this code that are retained. 35: 36: =============================================================================*/ 37: 38: #ifndef SOFTFLOAT_H 39: #define SOFTFLOAT_H 40: 1.1.1.7 root 41: #if defined(CONFIG_SOLARIS) && defined(CONFIG_NEEDS_LIBSUNMATH) 1.1.1.4 root 42: #include <sunmath.h> 43: #endif 44: 1.1 root 45: #include <inttypes.h> 46: #include "config.h" 47: 48: /*---------------------------------------------------------------------------- 49: | Each of the following `typedef's defines the most convenient type that holds 50: | integers of at least as many bits as specified. For example, `uint8' should 51: | be the most convenient type that can hold unsigned integers of as many as 52: | 8 bits. The `flag' type must be able to hold either a 0 or 1. For most 53: | implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed 54: | to the same as `int'. 55: *----------------------------------------------------------------------------*/ 1.1.1.3 root 56: typedef uint8_t flag; 1.1 root 57: typedef uint8_t uint8; 58: typedef int8_t int8; 1.1.1.5 root 59: #ifndef _AIX 1.1 root 60: typedef int uint16; 61: typedef int int16; 1.1.1.5 root 62: #endif 1.1 root 63: typedef unsigned int uint32; 64: typedef signed int int32; 65: typedef uint64_t uint64; 66: typedef int64_t int64; 67: 68: #define LIT64( a ) a##LL 69: #define INLINE static inline 70: 1.1.1.10! root 71: #if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32) ! 72: #define SNAN_BIT_IS_ONE 1 1.1 root 73: #else 1.1.1.10! root 74: #define SNAN_BIT_IS_ONE 0 1.1 root 75: #endif 76: 77: #define STATUS_PARAM , float_status *status 78: #define STATUS(field) status->field 79: #define STATUS_VAR , status 80: 81: /*---------------------------------------------------------------------------- 82: | Software IEC/IEEE floating-point ordering relations 83: *----------------------------------------------------------------------------*/ 84: enum { 85: float_relation_less = -1, 86: float_relation_equal = 0, 87: float_relation_greater = 1, 88: float_relation_unordered = 2 89: }; 90: 91: /*---------------------------------------------------------------------------- 92: | Software IEC/IEEE floating-point types. 93: *----------------------------------------------------------------------------*/ 1.1.1.4 root 94: /* Use structures for soft-float types. This prevents accidentally mixing 95: them with native int/float types. A sufficiently clever compiler and 96: sane ABI should be able to see though these structs. However 97: x86/gcc 3.x seems to struggle a bit, so leave them disabled by default. */ 98: //#define USE_SOFTFLOAT_STRUCT_TYPES 99: #ifdef USE_SOFTFLOAT_STRUCT_TYPES 100: typedef struct { 1.1.1.10! root 101: uint16_t v; ! 102: } float16; ! 103: #define float16_val(x) (((float16)(x)).v) ! 104: #define make_float16(x) __extension__ ({ float16 f16_val = {x}; f16_val; }) ! 105: #define const_float16(x) { x } ! 106: typedef struct { 1.1.1.4 root 107: uint32_t v; 108: } float32; 109: /* The cast ensures an error if the wrong type is passed. */ 110: #define float32_val(x) (((float32)(x)).v) 111: #define make_float32(x) __extension__ ({ float32 f32_val = {x}; f32_val; }) 1.1.1.10! root 112: #define const_float32(x) { x } 1.1.1.4 root 113: typedef struct { 114: uint64_t v; 115: } float64; 116: #define float64_val(x) (((float64)(x)).v) 117: #define make_float64(x) __extension__ ({ float64 f64_val = {x}; f64_val; }) 1.1.1.10! root 118: #define const_float64(x) { x } 1.1.1.4 root 119: #else 1.1.1.10! root 120: typedef uint16_t float16; 1.1 root 121: typedef uint32_t float32; 122: typedef uint64_t float64; 1.1.1.10! root 123: #define float16_val(x) (x) 1.1.1.4 root 124: #define float32_val(x) (x) 125: #define float64_val(x) (x) 1.1.1.10! root 126: #define make_float16(x) (x) 1.1.1.4 root 127: #define make_float32(x) (x) 128: #define make_float64(x) (x) 1.1.1.10! root 129: #define const_float16(x) (x) ! 130: #define const_float32(x) (x) ! 131: #define const_float64(x) (x) 1.1.1.4 root 132: #endif 1.1 root 133: typedef struct { 134: uint64_t low; 135: uint16_t high; 136: } floatx80; 1.1.1.10! root 137: #define make_floatx80(exp, mant) ((floatx80) { mant, exp }) 1.1 root 138: typedef struct { 1.1.1.7 root 139: #ifdef HOST_WORDS_BIGENDIAN 1.1 root 140: uint64_t high, low; 141: #else 142: uint64_t low, high; 143: #endif 144: } float128; 145: 146: /*---------------------------------------------------------------------------- 147: | Software IEC/IEEE floating-point underflow tininess-detection mode. 148: *----------------------------------------------------------------------------*/ 149: enum { 150: float_tininess_after_rounding = 0, 151: float_tininess_before_rounding = 1 152: }; 153: 154: /*---------------------------------------------------------------------------- 155: | Software IEC/IEEE floating-point rounding mode. 156: *----------------------------------------------------------------------------*/ 157: enum { 158: float_round_nearest_even = 0, 159: float_round_down = 1, 160: float_round_up = 2, 161: float_round_to_zero = 3 162: }; 163: 164: /*---------------------------------------------------------------------------- 165: | Software IEC/IEEE floating-point exception flags. 166: *----------------------------------------------------------------------------*/ 167: enum { 168: float_flag_invalid = 1, 169: float_flag_divbyzero = 4, 170: float_flag_overflow = 8, 171: float_flag_underflow = 16, 1.1.1.9 root 172: float_flag_inexact = 32, 1.1.1.10! root 173: float_flag_input_denormal = 64, ! 174: float_flag_output_denormal = 128 1.1 root 175: }; 176: 177: typedef struct float_status { 178: signed char float_detect_tininess; 179: signed char float_rounding_mode; 180: signed char float_exception_flags; 181: signed char floatx80_rounding_precision; 1.1.1.9 root 182: /* should denormalised results go to zero and set the inexact flag? */ 1.1.1.5 root 183: flag flush_to_zero; 1.1.1.9 root 184: /* should denormalised inputs go to zero and set the input_denormal flag? */ 185: flag flush_inputs_to_zero; 1.1.1.5 root 186: flag default_nan_mode; 1.1 root 187: } float_status; 188: 189: void set_float_rounding_mode(int val STATUS_PARAM); 190: void set_float_exception_flags(int val STATUS_PARAM); 1.1.1.10! root 191: INLINE void set_float_detect_tininess(int val STATUS_PARAM) ! 192: { ! 193: STATUS(float_detect_tininess) = val; ! 194: } 1.1.1.5 root 195: INLINE void set_flush_to_zero(flag val STATUS_PARAM) 196: { 197: STATUS(flush_to_zero) = val; 198: } 1.1.1.9 root 199: INLINE void set_flush_inputs_to_zero(flag val STATUS_PARAM) 200: { 201: STATUS(flush_inputs_to_zero) = val; 202: } 1.1.1.5 root 203: INLINE void set_default_nan_mode(flag val STATUS_PARAM) 204: { 205: STATUS(default_nan_mode) = val; 206: } 1.1 root 207: INLINE int get_float_exception_flags(float_status *status) 208: { 209: return STATUS(float_exception_flags); 210: } 211: void set_floatx80_rounding_precision(int val STATUS_PARAM); 212: 213: /*---------------------------------------------------------------------------- 214: | Routine to raise any or all of the software IEC/IEEE floating-point 215: | exception flags. 216: *----------------------------------------------------------------------------*/ 1.1.1.2 root 217: void float_raise( int8 flags STATUS_PARAM); 1.1 root 218: 219: /*---------------------------------------------------------------------------- 220: | Software IEC/IEEE integer-to-floating-point conversion routines. 221: *----------------------------------------------------------------------------*/ 1.1.1.10! root 222: float32 int32_to_float32( int32 STATUS_PARAM ); ! 223: float64 int32_to_float64( int32 STATUS_PARAM ); 1.1 root 224: float32 uint32_to_float32( unsigned int STATUS_PARAM ); 225: float64 uint32_to_float64( unsigned int STATUS_PARAM ); 1.1.1.10! root 226: floatx80 int32_to_floatx80( int32 STATUS_PARAM ); ! 227: float128 int32_to_float128( int32 STATUS_PARAM ); ! 228: float32 int64_to_float32( int64 STATUS_PARAM ); ! 229: float32 uint64_to_float32( uint64 STATUS_PARAM ); ! 230: float64 int64_to_float64( int64 STATUS_PARAM ); ! 231: float64 uint64_to_float64( uint64 STATUS_PARAM ); ! 232: floatx80 int64_to_floatx80( int64 STATUS_PARAM ); ! 233: float128 int64_to_float128( int64 STATUS_PARAM ); 1.1 root 234: 235: /*---------------------------------------------------------------------------- 1.1.1.7 root 236: | Software half-precision conversion routines. 237: *----------------------------------------------------------------------------*/ 1.1.1.10! root 238: float16 float32_to_float16( float32, flag STATUS_PARAM ); ! 239: float32 float16_to_float32( float16, flag STATUS_PARAM ); ! 240: ! 241: /*---------------------------------------------------------------------------- ! 242: | Software half-precision operations. ! 243: *----------------------------------------------------------------------------*/ ! 244: int float16_is_quiet_nan( float16 ); ! 245: int float16_is_signaling_nan( float16 ); ! 246: float16 float16_maybe_silence_nan( float16 ); ! 247: ! 248: /*---------------------------------------------------------------------------- ! 249: | The pattern for a default generated half-precision NaN. ! 250: *----------------------------------------------------------------------------*/ ! 251: #if defined(TARGET_ARM) ! 252: #define float16_default_nan make_float16(0x7E00) ! 253: #elif SNAN_BIT_IS_ONE ! 254: #define float16_default_nan make_float16(0x7DFF) ! 255: #else ! 256: #define float16_default_nan make_float16(0xFE00) ! 257: #endif 1.1.1.7 root 258: 259: /*---------------------------------------------------------------------------- 1.1 root 260: | Software IEC/IEEE single-precision conversion routines. 261: *----------------------------------------------------------------------------*/ 1.1.1.10! root 262: int16 float32_to_int16_round_to_zero( float32 STATUS_PARAM ); 1.1.1.9 root 263: unsigned int float32_to_uint16_round_to_zero( float32 STATUS_PARAM ); 1.1.1.10! root 264: int32 float32_to_int32( float32 STATUS_PARAM ); ! 265: int32 float32_to_int32_round_to_zero( float32 STATUS_PARAM ); ! 266: uint32 float32_to_uint32( float32 STATUS_PARAM ); ! 267: uint32 float32_to_uint32_round_to_zero( float32 STATUS_PARAM ); ! 268: int64 float32_to_int64( float32 STATUS_PARAM ); ! 269: int64 float32_to_int64_round_to_zero( float32 STATUS_PARAM ); 1.1 root 270: float64 float32_to_float64( float32 STATUS_PARAM ); 271: floatx80 float32_to_floatx80( float32 STATUS_PARAM ); 272: float128 float32_to_float128( float32 STATUS_PARAM ); 273: 274: /*---------------------------------------------------------------------------- 275: | Software IEC/IEEE single-precision operations. 276: *----------------------------------------------------------------------------*/ 277: float32 float32_round_to_int( float32 STATUS_PARAM ); 278: float32 float32_add( float32, float32 STATUS_PARAM ); 279: float32 float32_sub( float32, float32 STATUS_PARAM ); 280: float32 float32_mul( float32, float32 STATUS_PARAM ); 281: float32 float32_div( float32, float32 STATUS_PARAM ); 282: float32 float32_rem( float32, float32 STATUS_PARAM ); 283: float32 float32_sqrt( float32 STATUS_PARAM ); 1.1.1.8 root 284: float32 float32_exp2( float32 STATUS_PARAM ); 1.1.1.5 root 285: float32 float32_log2( float32 STATUS_PARAM ); 1.1.1.3 root 286: int float32_eq( float32, float32 STATUS_PARAM ); 287: int float32_le( float32, float32 STATUS_PARAM ); 288: int float32_lt( float32, float32 STATUS_PARAM ); 1.1.1.10! root 289: int float32_unordered( float32, float32 STATUS_PARAM ); ! 290: int float32_eq_quiet( float32, float32 STATUS_PARAM ); 1.1.1.3 root 291: int float32_le_quiet( float32, float32 STATUS_PARAM ); 292: int float32_lt_quiet( float32, float32 STATUS_PARAM ); 1.1.1.10! root 293: int float32_unordered_quiet( float32, float32 STATUS_PARAM ); 1.1.1.3 root 294: int float32_compare( float32, float32 STATUS_PARAM ); 295: int float32_compare_quiet( float32, float32 STATUS_PARAM ); 1.1.1.10! root 296: float32 float32_min(float32, float32 STATUS_PARAM); ! 297: float32 float32_max(float32, float32 STATUS_PARAM); 1.1.1.9 root 298: int float32_is_quiet_nan( float32 ); 1.1.1.3 root 299: int float32_is_signaling_nan( float32 ); 1.1.1.9 root 300: float32 float32_maybe_silence_nan( float32 ); 1.1.1.4 root 301: float32 float32_scalbn( float32, int STATUS_PARAM ); 1.1 root 302: 303: INLINE float32 float32_abs(float32 a) 304: { 1.1.1.9 root 305: /* Note that abs does *not* handle NaN specially, nor does 306: * it flush denormal inputs to zero. 307: */ 1.1.1.4 root 308: return make_float32(float32_val(a) & 0x7fffffff); 1.1 root 309: } 310: 311: INLINE float32 float32_chs(float32 a) 312: { 1.1.1.9 root 313: /* Note that chs does *not* handle NaN specially, nor does 314: * it flush denormal inputs to zero. 315: */ 1.1.1.4 root 316: return make_float32(float32_val(a) ^ 0x80000000); 1.1 root 317: } 318: 1.1.1.5 root 319: INLINE int float32_is_infinity(float32 a) 320: { 321: return (float32_val(a) & 0x7fffffff) == 0x7f800000; 322: } 323: 324: INLINE int float32_is_neg(float32 a) 325: { 326: return float32_val(a) >> 31; 327: } 328: 329: INLINE int float32_is_zero(float32 a) 330: { 331: return (float32_val(a) & 0x7fffffff) == 0; 332: } 333: 1.1.1.9 root 334: INLINE int float32_is_any_nan(float32 a) 335: { 336: return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL); 337: } 338: 339: INLINE int float32_is_zero_or_denormal(float32 a) 340: { 341: return (float32_val(a) & 0x7f800000) == 0; 342: } 343: 1.1.1.10! root 344: INLINE float32 float32_set_sign(float32 a, int sign) ! 345: { ! 346: return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31)); ! 347: } ! 348: 1.1.1.4 root 349: #define float32_zero make_float32(0) 1.1.1.5 root 350: #define float32_one make_float32(0x3f800000) 1.1.1.8 root 351: #define float32_ln2 make_float32(0x3f317218) 1.1.1.10! root 352: #define float32_pi make_float32(0x40490fdb) ! 353: #define float32_half make_float32(0x3f000000) ! 354: #define float32_infinity make_float32(0x7f800000) ! 355: ! 356: ! 357: /*---------------------------------------------------------------------------- ! 358: | The pattern for a default generated single-precision NaN. ! 359: *----------------------------------------------------------------------------*/ ! 360: #if defined(TARGET_SPARC) ! 361: #define float32_default_nan make_float32(0x7FFFFFFF) ! 362: #elif defined(TARGET_PPC) || defined(TARGET_ARM) || defined(TARGET_ALPHA) ! 363: #define float32_default_nan make_float32(0x7FC00000) ! 364: #elif SNAN_BIT_IS_ONE ! 365: #define float32_default_nan make_float32(0x7FBFFFFF) ! 366: #else ! 367: #define float32_default_nan make_float32(0xFFC00000) ! 368: #endif 1.1.1.4 root 369: 1.1 root 370: /*---------------------------------------------------------------------------- 371: | Software IEC/IEEE double-precision conversion routines. 372: *----------------------------------------------------------------------------*/ 1.1.1.10! root 373: int16 float64_to_int16_round_to_zero( float64 STATUS_PARAM ); 1.1.1.9 root 374: unsigned int float64_to_uint16_round_to_zero( float64 STATUS_PARAM ); 1.1.1.10! root 375: int32 float64_to_int32( float64 STATUS_PARAM ); ! 376: int32 float64_to_int32_round_to_zero( float64 STATUS_PARAM ); ! 377: uint32 float64_to_uint32( float64 STATUS_PARAM ); ! 378: uint32 float64_to_uint32_round_to_zero( float64 STATUS_PARAM ); ! 379: int64 float64_to_int64( float64 STATUS_PARAM ); ! 380: int64 float64_to_int64_round_to_zero( float64 STATUS_PARAM ); ! 381: uint64 float64_to_uint64 (float64 a STATUS_PARAM); ! 382: uint64 float64_to_uint64_round_to_zero (float64 a STATUS_PARAM); 1.1 root 383: float32 float64_to_float32( float64 STATUS_PARAM ); 384: floatx80 float64_to_floatx80( float64 STATUS_PARAM ); 385: float128 float64_to_float128( float64 STATUS_PARAM ); 386: 387: /*---------------------------------------------------------------------------- 388: | Software IEC/IEEE double-precision operations. 389: *----------------------------------------------------------------------------*/ 390: float64 float64_round_to_int( float64 STATUS_PARAM ); 1.1.1.3 root 391: float64 float64_trunc_to_int( float64 STATUS_PARAM ); 1.1 root 392: float64 float64_add( float64, float64 STATUS_PARAM ); 393: float64 float64_sub( float64, float64 STATUS_PARAM ); 394: float64 float64_mul( float64, float64 STATUS_PARAM ); 395: float64 float64_div( float64, float64 STATUS_PARAM ); 396: float64 float64_rem( float64, float64 STATUS_PARAM ); 397: float64 float64_sqrt( float64 STATUS_PARAM ); 1.1.1.5 root 398: float64 float64_log2( float64 STATUS_PARAM ); 1.1.1.3 root 399: int float64_eq( float64, float64 STATUS_PARAM ); 400: int float64_le( float64, float64 STATUS_PARAM ); 401: int float64_lt( float64, float64 STATUS_PARAM ); 1.1.1.10! root 402: int float64_unordered( float64, float64 STATUS_PARAM ); ! 403: int float64_eq_quiet( float64, float64 STATUS_PARAM ); 1.1.1.3 root 404: int float64_le_quiet( float64, float64 STATUS_PARAM ); 405: int float64_lt_quiet( float64, float64 STATUS_PARAM ); 1.1.1.10! root 406: int float64_unordered_quiet( float64, float64 STATUS_PARAM ); 1.1.1.3 root 407: int float64_compare( float64, float64 STATUS_PARAM ); 408: int float64_compare_quiet( float64, float64 STATUS_PARAM ); 1.1.1.10! root 409: float64 float64_min(float64, float64 STATUS_PARAM); ! 410: float64 float64_max(float64, float64 STATUS_PARAM); 1.1.1.9 root 411: int float64_is_quiet_nan( float64 a ); 1.1.1.3 root 412: int float64_is_signaling_nan( float64 ); 1.1.1.9 root 413: float64 float64_maybe_silence_nan( float64 ); 1.1.1.4 root 414: float64 float64_scalbn( float64, int STATUS_PARAM ); 1.1 root 415: 416: INLINE float64 float64_abs(float64 a) 417: { 1.1.1.9 root 418: /* Note that abs does *not* handle NaN specially, nor does 419: * it flush denormal inputs to zero. 420: */ 1.1.1.4 root 421: return make_float64(float64_val(a) & 0x7fffffffffffffffLL); 1.1 root 422: } 423: 424: INLINE float64 float64_chs(float64 a) 425: { 1.1.1.9 root 426: /* Note that chs does *not* handle NaN specially, nor does 427: * it flush denormal inputs to zero. 428: */ 1.1.1.4 root 429: return make_float64(float64_val(a) ^ 0x8000000000000000LL); 1.1 root 430: } 431: 1.1.1.5 root 432: INLINE int float64_is_infinity(float64 a) 433: { 434: return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL; 435: } 436: 437: INLINE int float64_is_neg(float64 a) 438: { 439: return float64_val(a) >> 63; 440: } 441: 442: INLINE int float64_is_zero(float64 a) 443: { 444: return (float64_val(a) & 0x7fffffffffffffffLL) == 0; 445: } 446: 1.1.1.9 root 447: INLINE int float64_is_any_nan(float64 a) 448: { 449: return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL); 450: } 451: 1.1.1.10! root 452: INLINE int float64_is_zero_or_denormal(float64 a) ! 453: { ! 454: return (float64_val(a) & 0x7ff0000000000000LL) == 0; ! 455: } ! 456: ! 457: INLINE float64 float64_set_sign(float64 a, int sign) ! 458: { ! 459: return make_float64((float64_val(a) & 0x7fffffffffffffffULL) ! 460: | ((int64_t)sign << 63)); ! 461: } ! 462: 1.1.1.4 root 463: #define float64_zero make_float64(0) 1.1.1.5 root 464: #define float64_one make_float64(0x3ff0000000000000LL) 1.1.1.8 root 465: #define float64_ln2 make_float64(0x3fe62e42fefa39efLL) 1.1.1.10! root 466: #define float64_pi make_float64(0x400921fb54442d18LL) ! 467: #define float64_half make_float64(0x3fe0000000000000LL) ! 468: #define float64_infinity make_float64(0x7ff0000000000000LL) 1.1.1.4 root 469: 1.1.1.10! root 470: /*---------------------------------------------------------------------------- ! 471: | The pattern for a default generated double-precision NaN. ! 472: *----------------------------------------------------------------------------*/ ! 473: #if defined(TARGET_SPARC) ! 474: #define float64_default_nan make_float64(LIT64( 0x7FFFFFFFFFFFFFFF )) ! 475: #elif defined(TARGET_PPC) || defined(TARGET_ARM) || defined(TARGET_ALPHA) ! 476: #define float64_default_nan make_float64(LIT64( 0x7FF8000000000000 )) ! 477: #elif SNAN_BIT_IS_ONE ! 478: #define float64_default_nan make_float64(LIT64( 0x7FF7FFFFFFFFFFFF )) ! 479: #else ! 480: #define float64_default_nan make_float64(LIT64( 0xFFF8000000000000 )) ! 481: #endif 1.1 root 482: 483: /*---------------------------------------------------------------------------- 484: | Software IEC/IEEE extended double-precision conversion routines. 485: *----------------------------------------------------------------------------*/ 1.1.1.10! root 486: int32 floatx80_to_int32( floatx80 STATUS_PARAM ); ! 487: int32 floatx80_to_int32_round_to_zero( floatx80 STATUS_PARAM ); ! 488: int64 floatx80_to_int64( floatx80 STATUS_PARAM ); ! 489: int64 floatx80_to_int64_round_to_zero( floatx80 STATUS_PARAM ); 1.1 root 490: float32 floatx80_to_float32( floatx80 STATUS_PARAM ); 491: float64 floatx80_to_float64( floatx80 STATUS_PARAM ); 492: float128 floatx80_to_float128( floatx80 STATUS_PARAM ); 493: 494: /*---------------------------------------------------------------------------- 495: | Software IEC/IEEE extended double-precision operations. 496: *----------------------------------------------------------------------------*/ 497: floatx80 floatx80_round_to_int( floatx80 STATUS_PARAM ); 498: floatx80 floatx80_add( floatx80, floatx80 STATUS_PARAM ); 499: floatx80 floatx80_sub( floatx80, floatx80 STATUS_PARAM ); 500: floatx80 floatx80_mul( floatx80, floatx80 STATUS_PARAM ); 501: floatx80 floatx80_div( floatx80, floatx80 STATUS_PARAM ); 502: floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM ); 503: floatx80 floatx80_sqrt( floatx80 STATUS_PARAM ); 1.1.1.3 root 504: int floatx80_eq( floatx80, floatx80 STATUS_PARAM ); 505: int floatx80_le( floatx80, floatx80 STATUS_PARAM ); 506: int floatx80_lt( floatx80, floatx80 STATUS_PARAM ); 1.1.1.10! root 507: int floatx80_unordered( floatx80, floatx80 STATUS_PARAM ); ! 508: int floatx80_eq_quiet( floatx80, floatx80 STATUS_PARAM ); 1.1.1.3 root 509: int floatx80_le_quiet( floatx80, floatx80 STATUS_PARAM ); 510: int floatx80_lt_quiet( floatx80, floatx80 STATUS_PARAM ); 1.1.1.10! root 511: int floatx80_unordered_quiet( floatx80, floatx80 STATUS_PARAM ); ! 512: int floatx80_compare( floatx80, floatx80 STATUS_PARAM ); ! 513: int floatx80_compare_quiet( floatx80, floatx80 STATUS_PARAM ); 1.1.1.9 root 514: int floatx80_is_quiet_nan( floatx80 ); 1.1.1.3 root 515: int floatx80_is_signaling_nan( floatx80 ); 1.1.1.9 root 516: floatx80 floatx80_maybe_silence_nan( floatx80 ); 1.1.1.4 root 517: floatx80 floatx80_scalbn( floatx80, int STATUS_PARAM ); 1.1 root 518: 519: INLINE floatx80 floatx80_abs(floatx80 a) 520: { 521: a.high &= 0x7fff; 522: return a; 523: } 524: 525: INLINE floatx80 floatx80_chs(floatx80 a) 526: { 527: a.high ^= 0x8000; 528: return a; 529: } 530: 1.1.1.5 root 531: INLINE int floatx80_is_infinity(floatx80 a) 532: { 1.1.1.10! root 533: return (a.high & 0x7fff) == 0x7fff && a.low == 0x8000000000000000LL; 1.1.1.5 root 534: } 535: 536: INLINE int floatx80_is_neg(floatx80 a) 537: { 538: return a.high >> 15; 539: } 540: 541: INLINE int floatx80_is_zero(floatx80 a) 542: { 543: return (a.high & 0x7fff) == 0 && a.low == 0; 544: } 545: 1.1.1.10! root 546: INLINE int floatx80_is_zero_or_denormal(floatx80 a) ! 547: { ! 548: return (a.high & 0x7fff) == 0; ! 549: } ! 550: 1.1.1.9 root 551: INLINE int floatx80_is_any_nan(floatx80 a) 552: { 553: return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1); 554: } 555: 1.1.1.10! root 556: #define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL) ! 557: #define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL) ! 558: #define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL) ! 559: #define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL) ! 560: #define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL) ! 561: #define floatx80_infinity make_floatx80(0x7fff, 0x8000000000000000LL) 1.1 root 562: 1.1.1.10! root 563: /*---------------------------------------------------------------------------- ! 564: | The pattern for a default generated extended double-precision NaN. The ! 565: | `high' and `low' values hold the most- and least-significant bits, ! 566: | respectively. ! 567: *----------------------------------------------------------------------------*/ ! 568: #if SNAN_BIT_IS_ONE ! 569: #define floatx80_default_nan_high 0x7FFF ! 570: #define floatx80_default_nan_low LIT64( 0xBFFFFFFFFFFFFFFF ) ! 571: #else ! 572: #define floatx80_default_nan_high 0xFFFF ! 573: #define floatx80_default_nan_low LIT64( 0xC000000000000000 ) ! 574: #endif 1.1 root 575: 576: /*---------------------------------------------------------------------------- 577: | Software IEC/IEEE quadruple-precision conversion routines. 578: *----------------------------------------------------------------------------*/ 1.1.1.10! root 579: int32 float128_to_int32( float128 STATUS_PARAM ); ! 580: int32 float128_to_int32_round_to_zero( float128 STATUS_PARAM ); ! 581: int64 float128_to_int64( float128 STATUS_PARAM ); ! 582: int64 float128_to_int64_round_to_zero( float128 STATUS_PARAM ); 1.1 root 583: float32 float128_to_float32( float128 STATUS_PARAM ); 584: float64 float128_to_float64( float128 STATUS_PARAM ); 585: floatx80 float128_to_floatx80( float128 STATUS_PARAM ); 586: 587: /*---------------------------------------------------------------------------- 588: | Software IEC/IEEE quadruple-precision operations. 589: *----------------------------------------------------------------------------*/ 590: float128 float128_round_to_int( float128 STATUS_PARAM ); 591: float128 float128_add( float128, float128 STATUS_PARAM ); 592: float128 float128_sub( float128, float128 STATUS_PARAM ); 593: float128 float128_mul( float128, float128 STATUS_PARAM ); 594: float128 float128_div( float128, float128 STATUS_PARAM ); 595: float128 float128_rem( float128, float128 STATUS_PARAM ); 596: float128 float128_sqrt( float128 STATUS_PARAM ); 1.1.1.3 root 597: int float128_eq( float128, float128 STATUS_PARAM ); 598: int float128_le( float128, float128 STATUS_PARAM ); 599: int float128_lt( float128, float128 STATUS_PARAM ); 1.1.1.10! root 600: int float128_unordered( float128, float128 STATUS_PARAM ); ! 601: int float128_eq_quiet( float128, float128 STATUS_PARAM ); 1.1.1.3 root 602: int float128_le_quiet( float128, float128 STATUS_PARAM ); 603: int float128_lt_quiet( float128, float128 STATUS_PARAM ); 1.1.1.10! root 604: int float128_unordered_quiet( float128, float128 STATUS_PARAM ); 1.1.1.4 root 605: int float128_compare( float128, float128 STATUS_PARAM ); 606: int float128_compare_quiet( float128, float128 STATUS_PARAM ); 1.1.1.9 root 607: int float128_is_quiet_nan( float128 ); 1.1.1.3 root 608: int float128_is_signaling_nan( float128 ); 1.1.1.9 root 609: float128 float128_maybe_silence_nan( float128 ); 1.1.1.4 root 610: float128 float128_scalbn( float128, int STATUS_PARAM ); 1.1 root 611: 612: INLINE float128 float128_abs(float128 a) 613: { 614: a.high &= 0x7fffffffffffffffLL; 615: return a; 616: } 617: 618: INLINE float128 float128_chs(float128 a) 619: { 620: a.high ^= 0x8000000000000000LL; 621: return a; 622: } 623: 1.1.1.5 root 624: INLINE int float128_is_infinity(float128 a) 625: { 626: return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0; 627: } 628: 629: INLINE int float128_is_neg(float128 a) 630: { 631: return a.high >> 63; 632: } 633: 634: INLINE int float128_is_zero(float128 a) 635: { 636: return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0; 637: } 638: 1.1.1.10! root 639: INLINE int float128_is_zero_or_denormal(float128 a) ! 640: { ! 641: return (a.high & 0x7fff000000000000LL) == 0; ! 642: } ! 643: 1.1.1.9 root 644: INLINE int float128_is_any_nan(float128 a) 645: { 646: return ((a.high >> 48) & 0x7fff) == 0x7fff && 647: ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0)); 648: } 649: 1.1.1.10! root 650: /*---------------------------------------------------------------------------- ! 651: | The pattern for a default generated quadruple-precision NaN. The `high' and ! 652: | `low' values hold the most- and least-significant bits, respectively. ! 653: *----------------------------------------------------------------------------*/ ! 654: #if SNAN_BIT_IS_ONE ! 655: #define float128_default_nan_high LIT64( 0x7FFF7FFFFFFFFFFF ) ! 656: #define float128_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF ) ! 657: #else ! 658: #define float128_default_nan_high LIT64( 0xFFFF800000000000 ) ! 659: #define float128_default_nan_low LIT64( 0x0000000000000000 ) 1.1 root 660: #endif 661: 662: #endif /* !SOFTFLOAT_H */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.