![[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 [HATARI the Atari ST Emulator] / hatari / src / cpu / softfloat|
Return to softfloat.h CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src / cpu / softfloat |
1.1 ! root 1: #define SOFTFLOAT_68K ! 2: ! 3: /* ! 4: * QEMU float support ! 5: * ! 6: * The code in this source file is derived from release 2a of the SoftFloat ! 7: * IEC/IEEE Floating-point Arithmetic Package. Those parts of the code (and ! 8: * some later contributions) are provided under that license, as detailed below. ! 9: * It has subsequently been modified by contributors to the QEMU Project, ! 10: * so some portions are provided under: ! 11: * the SoftFloat-2a license ! 12: * the BSD license ! 13: * GPL-v2-or-later ! 14: * ! 15: * Any future contributions to this file after December 1st 2014 will be ! 16: * taken to be licensed under the Softfloat-2a license unless specifically ! 17: * indicated otherwise. ! 18: */ ! 19: ! 20: /* ! 21: =============================================================================== ! 22: This C header file is part of the SoftFloat IEC/IEEE Floating-point ! 23: Arithmetic Package, Release 2a. ! 24: ! 25: Written by John R. Hauser. This work was made possible in part by the ! 26: International Computer Science Institute, located at Suite 600, 1947 Center ! 27: Street, Berkeley, California 94704. Funding was partially provided by the ! 28: National Science Foundation under grant MIP-9311980. The original version ! 29: of this code was written as part of a project to build a fixed-point vector ! 30: processor in collaboration with the University of California at Berkeley, ! 31: overseen by Profs. Nelson Morgan and John Wawrzynek. More information ! 32: is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/ ! 33: arithmetic/SoftFloat.html'. ! 34: ! 35: THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort ! 36: has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT ! 37: TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO ! 38: PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY ! 39: AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. ! 40: ! 41: Derivative works are acceptable, even for commercial purposes, so long as ! 42: (1) they include prominent notice that the work is derivative, and (2) they ! 43: include prominent notice akin to these four paragraphs for those parts of ! 44: this code that are retained. ! 45: ! 46: =============================================================================== ! 47: */ ! 48: ! 49: /* BSD licensing: ! 50: * Copyright (c) 2006, Fabrice Bellard ! 51: * All rights reserved. ! 52: * ! 53: * Redistribution and use in source and binary forms, with or without ! 54: * modification, are permitted provided that the following conditions are met: ! 55: * ! 56: * 1. Redistributions of source code must retain the above copyright notice, ! 57: * this list of conditions and the following disclaimer. ! 58: * ! 59: * 2. Redistributions in binary form must reproduce the above copyright notice, ! 60: * this list of conditions and the following disclaimer in the documentation ! 61: * and/or other materials provided with the distribution. ! 62: * ! 63: * 3. Neither the name of the copyright holder nor the names of its contributors ! 64: * may be used to endorse or promote products derived from this software without ! 65: * specific prior written permission. ! 66: * ! 67: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ! 68: * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 69: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 70: * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ! 71: * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ! 72: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ! 73: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ! 74: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ! 75: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ! 76: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF ! 77: * THE POSSIBILITY OF SUCH DAMAGE. ! 78: */ ! 79: ! 80: /* Portions of this work are licensed under the terms of the GNU GPL, ! 81: * version 2 or later. See the COPYING file in the top-level directory. ! 82: */ ! 83: ! 84: #ifndef SOFTFLOAT_H ! 85: #define SOFTFLOAT_H ! 86: ! 87: #include <stdbool.h> ! 88: ! 89: #if defined(CONFIG_SOLARIS) && defined(CONFIG_NEEDS_LIBSUNMATH) ! 90: #include <sunmath.h> ! 91: #endif ! 92: ! 93: ! 94: /* This 'flag' type must be able to hold at least 0 and 1. It should ! 95: * probably be replaced with 'bool' but the uses would need to be audited ! 96: * to check that they weren't accidentally relying on it being a larger type. ! 97: */ ! 98: typedef uint8_t flag; ! 99: ! 100: #define LIT64( a ) a##ULL ! 101: ! 102: /*---------------------------------------------------------------------------- ! 103: | Software IEC/IEEE floating-point ordering relations ! 104: *----------------------------------------------------------------------------*/ ! 105: enum { ! 106: float_relation_less = -1, ! 107: float_relation_equal = 0, ! 108: float_relation_greater = 1, ! 109: float_relation_unordered = 2 ! 110: }; ! 111: ! 112: /*---------------------------------------------------------------------------- ! 113: | Software IEC/IEEE floating-point types. ! 114: *----------------------------------------------------------------------------*/ ! 115: /* Use structures for soft-float types. This prevents accidentally mixing ! 116: them with native int/float types. A sufficiently clever compiler and ! 117: sane ABI should be able to see though these structs. However ! 118: x86/gcc 3.x seems to struggle a bit, so leave them disabled by default. */ ! 119: //#define USE_SOFTFLOAT_STRUCT_TYPES ! 120: #ifdef USE_SOFTFLOAT_STRUCT_TYPES ! 121: typedef struct { ! 122: uint16_t v; ! 123: } float16; ! 124: #define float16_val(x) (((float16)(x)).v) ! 125: #define make_float16(x) __extension__ ({ float16 f16_val = {x}; f16_val; }) ! 126: #define const_float16(x) { x } ! 127: typedef struct { ! 128: uint32_t v; ! 129: } float32; ! 130: /* The cast ensures an error if the wrong type is passed. */ ! 131: #define float32_val(x) (((float32)(x)).v) ! 132: #define make_float32(x) __extension__ ({ float32 f32_val = {x}; f32_val; }) ! 133: #define const_float32(x) { x } ! 134: typedef struct { ! 135: uint64_t v; ! 136: } float64; ! 137: #define float64_val(x) (((float64)(x)).v) ! 138: #define make_float64(x) __extension__ ({ float64 f64_val = {x}; f64_val; }) ! 139: #define const_float64(x) { x } ! 140: #else ! 141: typedef uint16_t float16; ! 142: typedef uint32_t float32; ! 143: typedef uint64_t float64; ! 144: #define float16_val(x) (x) ! 145: #define float32_val(x) (x) ! 146: #define float64_val(x) (x) ! 147: #define make_float16(x) (x) ! 148: #define make_float32(x) (x) ! 149: #define make_float64(x) (x) ! 150: #define const_float16(x) (x) ! 151: #define const_float32(x) (x) ! 152: #define const_float64(x) (x) ! 153: #endif ! 154: typedef struct { ! 155: uint16_t high; ! 156: uint64_t low; ! 157: } floatx80; ! 158: typedef struct { ! 159: #ifdef HOST_WORDS_BIGENDIAN ! 160: uint64_t high, low; ! 161: #else ! 162: uint64_t low, high; ! 163: #endif ! 164: } float128; ! 165: ! 166: /*---------------------------------------------------------------------------- ! 167: | Software IEC/IEEE floating-point underflow tininess-detection mode. ! 168: *----------------------------------------------------------------------------*/ ! 169: enum { ! 170: float_tininess_after_rounding = 0, ! 171: float_tininess_before_rounding = 1 ! 172: }; ! 173: ! 174: /*---------------------------------------------------------------------------- ! 175: | Software IEC/IEEE floating-point rounding mode. ! 176: *----------------------------------------------------------------------------*/ ! 177: enum { ! 178: float_round_nearest_even = 0, ! 179: float_round_down = 1, ! 180: float_round_up = 2, ! 181: float_round_to_zero = 3, ! 182: float_round_ties_away = 4, ! 183: }; ! 184: ! 185: /*---------------------------------------------------------------------------- ! 186: | Software IEC/IEEE floating-point exception flags. ! 187: *----------------------------------------------------------------------------*/ ! 188: enum { ! 189: float_flag_invalid = 0x01, ! 190: float_flag_denormal = 0x02, ! 191: float_flag_divbyzero = 0x04, ! 192: float_flag_overflow = 0x08, ! 193: float_flag_underflow = 0x10, ! 194: float_flag_inexact = 0x20, ! 195: float_flag_signaling = 0x40, ! 196: float_flag_decimal = 0x80 ! 197: }; ! 198: ! 199: /*---------------------------------------------------------------------------- ! 200: | Variables for storing sign, exponent and significand of overflowed or ! 201: | underflowed extended double-precision floating-point value. ! 202: | Variables for storing sign, exponent and significand of internal extended ! 203: | double-precision floating-point value for external use. ! 204: *----------------------------------------------------------------------------*/ ! 205: ! 206: extern flag floatx80_internal_sign; ! 207: extern int32_t floatx80_internal_exp; ! 208: extern uint64_t floatx80_internal_sig; ! 209: extern int32_t floatx80_internal_exp0; ! 210: extern uint64_t floatx80_internal_sig0; ! 211: extern uint64_t floatx80_internal_sig1; ! 212: extern int8_t floatx80_internal_precision; ! 213: extern int8_t floatx80_internal_mode; ! 214: ! 215: typedef struct float_status { ! 216: signed char float_detect_tininess; ! 217: signed char float_rounding_mode; ! 218: uint8_t float_exception_flags; ! 219: signed char floatx80_rounding_precision; ! 220: /* should denormalised results go to zero and set the inexact flag? */ ! 221: flag flush_to_zero; ! 222: /* should denormalised inputs go to zero and set the input_denormal flag? */ ! 223: flag flush_inputs_to_zero; ! 224: flag default_nan_mode; ! 225: flag snan_bit_is_one; ! 226: } float_status; ! 227: ! 228: /*---------------------------------------------------------------------------- ! 229: | Function for getting sign, exponent and significand of extended ! 230: | double-precision floating-point intermediate result for external use. ! 231: *----------------------------------------------------------------------------*/ ! 232: floatx80 getFloatInternalOverflow( void ); ! 233: floatx80 getFloatInternalUnderflow( void ); ! 234: floatx80 getFloatInternalRoundedAll( void ); ! 235: floatx80 getFloatInternalRoundedSome( void ); ! 236: floatx80 getFloatInternalUnrounded( void ); ! 237: floatx80 getFloatInternalFloatx80( void ); ! 238: uint64_t getFloatInternalGRS( void ); ! 239: ! 240: static inline void set_float_detect_tininess(int val, float_status *status) ! 241: { ! 242: status->float_detect_tininess = val; ! 243: } ! 244: static inline void set_float_rounding_mode(int val, float_status *status) ! 245: { ! 246: status->float_rounding_mode = val; ! 247: } ! 248: static inline void set_float_exception_flags(int val, float_status *status) ! 249: { ! 250: status->float_exception_flags = val; ! 251: } ! 252: static inline void set_floatx80_rounding_precision(int val, ! 253: float_status *status) ! 254: { ! 255: status->floatx80_rounding_precision = val; ! 256: } ! 257: static inline void set_flush_to_zero(flag val, float_status *status) ! 258: { ! 259: status->flush_to_zero = val; ! 260: } ! 261: static inline void set_flush_inputs_to_zero(flag val, float_status *status) ! 262: { ! 263: status->flush_inputs_to_zero = val; ! 264: } ! 265: static inline void set_default_nan_mode(flag val, float_status *status) ! 266: { ! 267: status->default_nan_mode = val; ! 268: } ! 269: static inline void set_snan_bit_is_one(flag val, float_status *status) ! 270: { ! 271: status->snan_bit_is_one = val; ! 272: } ! 273: static inline int get_float_detect_tininess(float_status *status) ! 274: { ! 275: return status->float_detect_tininess; ! 276: } ! 277: static inline int get_float_rounding_mode(float_status *status) ! 278: { ! 279: return status->float_rounding_mode; ! 280: } ! 281: static inline int get_float_exception_flags(float_status *status) ! 282: { ! 283: return status->float_exception_flags; ! 284: } ! 285: static inline int get_floatx80_rounding_precision(float_status *status) ! 286: { ! 287: return status->floatx80_rounding_precision; ! 288: } ! 289: static inline flag get_flush_to_zero(float_status *status) ! 290: { ! 291: return status->flush_to_zero; ! 292: } ! 293: static inline flag get_flush_inputs_to_zero(float_status *status) ! 294: { ! 295: return status->flush_inputs_to_zero; ! 296: } ! 297: static inline flag get_default_nan_mode(float_status *status) ! 298: { ! 299: return status->default_nan_mode; ! 300: } ! 301: ! 302: /*---------------------------------------------------------------------------- ! 303: | Routine to raise any or all of the software IEC/IEEE floating-point ! 304: | exception flags. ! 305: *----------------------------------------------------------------------------*/ ! 306: //void float_raise(uint8_t flags, float_status *status); ! 307: ! 308: ! 309: /*---------------------------------------------------------------------------- ! 310: | The pattern for a default generated single-precision NaN. ! 311: *----------------------------------------------------------------------------*/ ! 312: #define float32_default_nan 0x7FFFFFFF ! 313: ! 314: /*---------------------------------------------------------------------------- ! 315: | The pattern for a default generated double-precision NaN. ! 316: *----------------------------------------------------------------------------*/ ! 317: #define float64_default_nan LIT64( 0x7FFFFFFFFFFFFFFF ) ! 318: ! 319: /*---------------------------------------------------------------------------- ! 320: | The pattern for a default generated extended double-precision NaN. The ! 321: | `high' and `low' values hold the most- and least-significant bits, ! 322: | respectively. ! 323: *----------------------------------------------------------------------------*/ ! 324: #define floatx80_default_nan_high 0x7FFF ! 325: #define floatx80_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF ) ! 326: ! 327: /*---------------------------------------------------------------------------- ! 328: | The pattern for a default generated extended double-precision infinity. ! 329: *----------------------------------------------------------------------------*/ ! 330: #define floatx80_default_infinity_low LIT64( 0x0000000000000000 ) ! 331: ! 332: /*---------------------------------------------------------------------------- ! 333: | If `a' is denormal and we are in flush-to-zero mode then set the ! 334: | input-denormal exception and return zero. Otherwise just return the value. ! 335: *----------------------------------------------------------------------------*/ ! 336: float64 float64_squash_input_denormal(float64 a, float_status *status); ! 337: ! 338: /*---------------------------------------------------------------------------- ! 339: | Options to indicate which negations to perform in float*_muladd() ! 340: | Using these differs from negating an input or output before calling ! 341: | the muladd function in that this means that a NaN doesn't have its ! 342: | sign bit inverted before it is propagated. ! 343: | We also support halving the result before rounding, as a special ! 344: | case to support the ARM fused-sqrt-step instruction FRSQRTS. ! 345: *----------------------------------------------------------------------------*/ ! 346: enum { ! 347: float_muladd_negate_c = 1, ! 348: float_muladd_negate_product = 2, ! 349: float_muladd_negate_result = 4, ! 350: float_muladd_halve_result = 8, ! 351: }; ! 352: ! 353: /*---------------------------------------------------------------------------- ! 354: | Software IEC/IEEE integer-to-floating-point conversion routines. ! 355: *----------------------------------------------------------------------------*/ ! 356: ! 357: floatx80 int32_to_floatx80(int32_t); ! 358: floatx80 int64_to_floatx80(int64_t); ! 359: ! 360: /*---------------------------------------------------------------------------- ! 361: | Software IEC/IEEE single-precision conversion routines. ! 362: *----------------------------------------------------------------------------*/ ! 363: floatx80 float32_to_floatx80(float32, float_status *status); ! 364: floatx80 float32_to_floatx80_allowunnormal(float32, float_status *status); ! 365: ! 366: /*---------------------------------------------------------------------------- ! 367: | Software IEC/IEEE double-precision conversion routines. ! 368: *----------------------------------------------------------------------------*/ ! 369: floatx80 float64_to_floatx80(float64, float_status *status); ! 370: ! 371: floatx80 float64_to_floatx80_allowunnormal( float64 a, float_status *status ); ! 372: ! 373: /*---------------------------------------------------------------------------- ! 374: | Software IEC/IEEE extended double-precision conversion routines. ! 375: *----------------------------------------------------------------------------*/ ! 376: int32_t floatx80_to_int32(floatx80, float_status *status); ! 377: #ifdef SOFTFLOAT_68K ! 378: int16_t floatx80_to_int16(floatx80, float_status *status); ! 379: int8_t floatx80_to_int8(floatx80, float_status *status); ! 380: #endif ! 381: int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status); ! 382: int64_t floatx80_to_int64(floatx80, float_status *status); ! 383: float32 floatx80_to_float32(floatx80, float_status *status); ! 384: float64 floatx80_to_float64(floatx80, float_status *status); ! 385: #ifdef SOFTFLOAT_68K ! 386: floatx80 floatx80_to_floatx80( floatx80, float_status *status); ! 387: floatx80 floatdecimal_to_floatx80(floatx80, float_status *status); ! 388: floatx80 floatx80_to_floatdecimal(floatx80, int32_t*, float_status *status); ! 389: #endif ! 390: ! 391: uint64_t extractFloatx80Frac( floatx80 a ); ! 392: int32_t extractFloatx80Exp( floatx80 a ); ! 393: flag extractFloatx80Sign( floatx80 a ); ! 394: ! 395: floatx80 floatx80_round_to_int_toward_zero( floatx80 a, float_status *status); ! 396: floatx80 floatx80_round_to_float32( floatx80, float_status *status ); ! 397: floatx80 floatx80_round_to_float64( floatx80, float_status *status ); ! 398: floatx80 floatx80_round32( floatx80, float_status *status); ! 399: floatx80 floatx80_round64( floatx80, float_status *status); ! 400: ! 401: flag floatx80_eq( floatx80, floatx80, float_status *status); ! 402: flag floatx80_le( floatx80, floatx80, float_status *status); ! 403: flag floatx80_lt( floatx80, floatx80, float_status *status); ! 404: ! 405: #ifdef SOFTFLOAT_68K ! 406: // functions are in softfloat.c ! 407: floatx80 roundSaveFloatx80Internal( int8_t roundingPrecision, flag zSign, int32_t zExp, uint64_t zSig0, uint64_t zSig1, float_status *status ); ! 408: void getRoundedFloatInternal( int8_t roundingPrecision, flag *pzSign, int32_t *pzExp, uint64_t *pzSig ); ! 409: floatx80 roundSigAndPackFloatx80( int8_t roundingPrecision, flag zSign, int32_t zExp, uint64_t zSig0, uint64_t zSig1, float_status *status ); ! 410: floatx80 floatx80_move( floatx80 a, float_status *status ); ! 411: floatx80 floatx80_abs( floatx80 a, float_status *status ); ! 412: floatx80 floatx80_neg( floatx80 a, float_status *status ); ! 413: floatx80 floatx80_getexp( floatx80 a, float_status *status ); ! 414: floatx80 floatx80_getman( floatx80 a, float_status *status ); ! 415: floatx80 floatx80_scale(floatx80 a, floatx80 b, float_status *status ); ! 416: floatx80 floatx80_rem( floatx80 a, floatx80 b, uint64_t *q, flag *s, float_status *status ); ! 417: floatx80 floatx80_mod( floatx80 a, floatx80 b, uint64_t *q, flag *s, float_status *status ); ! 418: floatx80 floatx80_sglmul( floatx80 a, floatx80 b, float_status *status ); ! 419: floatx80 floatx80_sgldiv( floatx80 a, floatx80 b, float_status *status ); ! 420: floatx80 floatx80_cmp( floatx80 a, floatx80 b, float_status *status ); ! 421: floatx80 floatx80_tst( floatx80 a, float_status *status ); ! 422: ! 423: // functions are in softfloat_fpsp.c ! 424: floatx80 floatx80_acos(floatx80 a, float_status *status); ! 425: floatx80 floatx80_asin(floatx80 a, float_status *status); ! 426: floatx80 floatx80_atan(floatx80 a, float_status *status); ! 427: floatx80 floatx80_atanh(floatx80 a, float_status *status); ! 428: floatx80 floatx80_cos(floatx80 a, float_status *status); ! 429: floatx80 floatx80_cosh(floatx80 a, float_status *status); ! 430: floatx80 floatx80_etox(floatx80 a, float_status *status); ! 431: floatx80 floatx80_etoxm1(floatx80 a, float_status *status); ! 432: floatx80 floatx80_log10(floatx80 a, float_status *status); ! 433: floatx80 floatx80_log2(floatx80 a, float_status *status); ! 434: floatx80 floatx80_logn(floatx80 a, float_status *status); ! 435: floatx80 floatx80_lognp1(floatx80 a, float_status *status); ! 436: floatx80 floatx80_sin(floatx80 a, float_status *status); ! 437: floatx80 floatx80_sinh(floatx80 a, float_status *status); ! 438: floatx80 floatx80_tan(floatx80 a, float_status *status); ! 439: floatx80 floatx80_tanh(floatx80 a, float_status *status); ! 440: floatx80 floatx80_tentox(floatx80 a, float_status *status); ! 441: floatx80 floatx80_twotox(floatx80 a, float_status *status); ! 442: #endif ! 443: ! 444: // functions originally internal to softfloat.c ! 445: void normalizeFloatx80Subnormal( uint64_t aSig, int32_t *zExpPtr, uint64_t *zSigPtr ); ! 446: floatx80 packFloatx80( flag zSign, int32_t zExp, uint64_t zSig ); ! 447: floatx80 roundAndPackFloatx80(int8_t roundingPrecision, flag zSign, int32_t zExp, uint64_t zSig0, uint64_t zSig1, float_status *status); ! 448: ! 449: /*---------------------------------------------------------------------------- ! 450: | Software IEC/IEEE extended double-precision operations. ! 451: *----------------------------------------------------------------------------*/ ! 452: floatx80 floatx80_round_to_int(floatx80, float_status *status); ! 453: floatx80 floatx80_add(floatx80, floatx80, float_status *status); ! 454: floatx80 floatx80_sub(floatx80, floatx80, float_status *status); ! 455: floatx80 floatx80_mul(floatx80, floatx80, float_status *status); ! 456: floatx80 floatx80_div(floatx80, floatx80, float_status *status); ! 457: floatx80 floatx80_sqrt(floatx80, float_status *status); ! 458: floatx80 floatx80_normalize(floatx80); ! 459: floatx80 floatx80_denormalize(floatx80, flag); ! 460: ! 461: static inline int floatx80_is_zero_or_denormal(floatx80 a) ! 462: { ! 463: return (a.high & 0x7fff) == 0; ! 464: } ! 465: ! 466: static inline int floatx80_is_any_nan(floatx80 a) ! 467: { ! 468: return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1); ! 469: } ! 470: ! 471: /*---------------------------------------------------------------------------- ! 472: | Return whether the given value is an invalid floatx80 encoding. ! 473: | Invalid floatx80 encodings arise when the integer bit is not set, but ! 474: | the exponent is not zero. The only times the integer bit is permitted to ! 475: | be zero is in subnormal numbers and the value zero. ! 476: | This includes what the Intel software developer's manual calls pseudo-NaNs, ! 477: | pseudo-infinities and un-normal numbers. It does not include ! 478: | pseudo-denormals, which must still be correctly handled as inputs even ! 479: | if they are never generated as outputs. ! 480: *----------------------------------------------------------------------------*/ ! 481: static inline bool floatx80_invalid_encoding(floatx80 a) ! 482: { ! 483: return (a.low & (1ULL << 63)) == 0 && (a.high & 0x7FFF) != 0 && (a.high & 0x7FFF) != 0x7FFF; ! 484: } ! 485: ! 486: #define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL) ! 487: #define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL) ! 488: #define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL) ! 489: #define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL) ! 490: #define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL) ! 491: #define floatx80_infinity make_floatx80(0x7fff, 0x8000000000000000LL) ! 492: ! 493: #endif /* SOFTFLOAT_H */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.