Annotation of sys/lib/libkern/softfloat-specialize.h, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: softfloat-specialize.h,v 1.1 2002/04/28 20:55:14 pvalchev Exp $ */
! 2: /* $NetBSD: softfloat-specialize.h,v 1.1 2001/04/26 03:10:47 ross Exp $ */
! 3:
! 4: /* This is a derivative work. */
! 5:
! 6: /*-
! 7: * Copyright (c) 2001 The NetBSD Foundation, Inc.
! 8: * All rights reserved.
! 9: *
! 10: * This code is derived from software contributed to The NetBSD Foundation
! 11: * by Ross Harvey.
! 12: *
! 13: * Redistribution and use in source and binary forms, with or without
! 14: * modification, are permitted provided that the following conditions
! 15: * are met:
! 16: * 1. Redistributions of source code must retain the above copyright
! 17: * notice, this list of conditions and the following disclaimer.
! 18: * 2. Redistributions in binary form must reproduce the above copyright
! 19: * notice, this list of conditions and the following disclaimer in the
! 20: * documentation and/or other materials provided with the distribution.
! 21: * 3. All advertising materials mentioning features or use of this software
! 22: * must display the following acknowledgement:
! 23: * This product includes software developed by the NetBSD
! 24: * Foundation, Inc. and its contributors.
! 25: * 4. Neither the name of The NetBSD Foundation nor the names of its
! 26: * contributors may be used to endorse or promote products derived
! 27: * from this software without specific prior written permission.
! 28: *
! 29: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
! 30: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 31: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 32: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 33: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 34: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 35: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 36: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 37: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 38: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 39: * POSSIBILITY OF SUCH DAMAGE.
! 40: */
! 41:
! 42: /*
! 43: ===============================================================================
! 44:
! 45: This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
! 46: Arithmetic Package, Release 2a.
! 47:
! 48: Written by John R. Hauser. This work was made possible in part by the
! 49: International Computer Science Institute, located at Suite 600, 1947 Center
! 50: Street, Berkeley, California 94704. Funding was partially provided by the
! 51: National Science Foundation under grant MIP-9311980. The original version
! 52: of this code was written as part of a project to build a fixed-point vector
! 53: processor in collaboration with the University of California at Berkeley,
! 54: overseen by Profs. Nelson Morgan and John Wawrzynek. More information
! 55: is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
! 56: arithmetic/SoftFloat.html'.
! 57:
! 58: THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable
! 59: effort has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT
! 60: WILL AT TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS
! 61: RESTRICTED TO PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL
! 62: RESPONSIBILITY FOR ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM
! 63: THEIR OWN USE OF THE SOFTWARE, AND WHO ALSO EFFECTIVELY INDEMNIFY
! 64: (possibly via similar legal warning) JOHN HAUSER AND THE INTERNATIONAL
! 65: COMPUTER SCIENCE INSTITUTE AGAINST ALL LOSSES, COSTS, OR OTHER PROBLEMS
! 66: ARISING FROM THE USE OF THE SOFTWARE BY THEIR CUSTOMERS AND CLIENTS.
! 67:
! 68: Derivative works are acceptable, even for commercial purposes, so long as
! 69: (1) they include prominent notice that the work is derivative, and (2) they
! 70: include prominent notice akin to these four paragraphs for those parts of
! 71: this code that are retained.
! 72:
! 73: ===============================================================================
! 74: */
! 75:
! 76: /*
! 77: -------------------------------------------------------------------------------
! 78: Underflow tininess-detection mode, statically initialized to default value.
! 79: -------------------------------------------------------------------------------
! 80: */
! 81:
! 82: #ifndef NO_IEEE
! 83:
! 84: /* [ MP safe, does not change dynamically ] */
! 85: int float_detect_tininess = float_tininess_after_rounding;
! 86:
! 87: /*
! 88: -------------------------------------------------------------------------------
! 89: Internal canonical NaN format.
! 90: -------------------------------------------------------------------------------
! 91: */
! 92: typedef struct {
! 93: flag sign;
! 94: bits64 high, low;
! 95: } commonNaNT;
! 96:
! 97: /*
! 98: -------------------------------------------------------------------------------
! 99: The pattern for a default generated single-precision NaN.
! 100: -------------------------------------------------------------------------------
! 101: */
! 102: #define float32_default_nan 0xFFC00000
! 103:
! 104: /*
! 105: -------------------------------------------------------------------------------
! 106: Returns 1 if the single-precision floating-point value `a' is a NaN;
! 107: otherwise returns 0.
! 108: -------------------------------------------------------------------------------
! 109: */
! 110: static flag float32_is_nan( float32 a )
! 111: {
! 112:
! 113: return ( 0xFF000000 < (bits32) ( a<<1 ) );
! 114:
! 115: }
! 116:
! 117: /*
! 118: -------------------------------------------------------------------------------
! 119: Returns 1 if the single-precision floating-point value `a' is a signaling
! 120: NaN; otherwise returns 0.
! 121: -------------------------------------------------------------------------------
! 122: */
! 123: flag float32_is_signaling_nan( float32 a )
! 124: {
! 125:
! 126: return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
! 127:
! 128: }
! 129:
! 130: /*
! 131: -------------------------------------------------------------------------------
! 132: Returns the result of converting the single-precision floating-point NaN
! 133: `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
! 134: exception is raised.
! 135: -------------------------------------------------------------------------------
! 136: */
! 137: static commonNaNT float32ToCommonNaN( float32 a )
! 138: {
! 139: commonNaNT z;
! 140:
! 141: if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
! 142: z.sign = a>>31;
! 143: z.low = 0;
! 144: z.high = ( (bits64) a )<<41;
! 145: return z;
! 146:
! 147: }
! 148:
! 149: /*
! 150: -------------------------------------------------------------------------------
! 151: Returns the result of converting the canonical NaN `a' to the single-
! 152: precision floating-point format.
! 153: -------------------------------------------------------------------------------
! 154: */
! 155: static float32 commonNaNToFloat32( commonNaNT a )
! 156: {
! 157:
! 158: return ( ( (bits32) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>41 );
! 159:
! 160: }
! 161:
! 162: /*
! 163: -------------------------------------------------------------------------------
! 164: Takes two single-precision floating-point values `a' and `b', one of which
! 165: is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
! 166: signaling NaN, the invalid exception is raised.
! 167: -------------------------------------------------------------------------------
! 168: */
! 169: static float32 propagateFloat32NaN( float32 a, float32 b )
! 170: {
! 171: flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
! 172:
! 173: aIsNaN = float32_is_nan( a );
! 174: aIsSignalingNaN = float32_is_signaling_nan( a );
! 175: bIsNaN = float32_is_nan( b );
! 176: bIsSignalingNaN = float32_is_signaling_nan( b );
! 177: a |= 0x00400000;
! 178: b |= 0x00400000;
! 179: if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
! 180: if ( aIsSignalingNaN ) {
! 181: if ( bIsSignalingNaN ) goto returnLargerSignificand;
! 182: return bIsNaN ? b : a;
! 183: }
! 184: else if ( aIsNaN ) {
! 185: if ( bIsSignalingNaN | ! bIsNaN ) return a;
! 186: returnLargerSignificand:
! 187: if ( (bits32) ( a<<1 ) < (bits32) ( b<<1 ) ) return b;
! 188: if ( (bits32) ( b<<1 ) < (bits32) ( a<<1 ) ) return a;
! 189: return ( a < b ) ? a : b;
! 190: }
! 191: else {
! 192: return b;
! 193: }
! 194:
! 195: }
! 196:
! 197:
! 198: /*
! 199: -------------------------------------------------------------------------------
! 200: Returns the result of converting the double-precision floating-point NaN
! 201: `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
! 202: exception is raised.
! 203: -------------------------------------------------------------------------------
! 204: */
! 205: static commonNaNT float64ToCommonNaN( float64 a )
! 206: {
! 207: commonNaNT z;
! 208:
! 209: if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
! 210: z.sign = a>>63;
! 211: z.low = 0;
! 212: z.high = a<<12;
! 213: return z;
! 214:
! 215: }
! 216:
! 217: /*
! 218: -------------------------------------------------------------------------------
! 219: Returns the result of converting the canonical NaN `a' to the double-
! 220: precision floating-point format.
! 221: -------------------------------------------------------------------------------
! 222: */
! 223: static float64 commonNaNToFloat64( commonNaNT a )
! 224: {
! 225:
! 226: return
! 227: ( ( (bits64) a.sign )<<63 )
! 228: | LIT64( 0x7FF8000000000000 )
! 229: | ( a.high>>12 );
! 230:
! 231: }
! 232:
! 233: /*
! 234: -------------------------------------------------------------------------------
! 235: Takes two double-precision floating-point values `a' and `b', one of which
! 236: is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
! 237: signaling NaN, the invalid exception is raised.
! 238: -------------------------------------------------------------------------------
! 239: */
! 240: static float64 propagateFloat64NaN( float64 a, float64 b )
! 241: {
! 242: flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
! 243:
! 244: aIsNaN = float64_is_nan( a );
! 245: aIsSignalingNaN = float64_is_signaling_nan( a );
! 246: bIsNaN = float64_is_nan( b );
! 247: bIsSignalingNaN = float64_is_signaling_nan( b );
! 248: a |= LIT64( 0x0008000000000000 );
! 249: b |= LIT64( 0x0008000000000000 );
! 250: if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
! 251: if ( aIsSignalingNaN ) {
! 252: if ( bIsSignalingNaN ) goto returnLargerSignificand;
! 253: return bIsNaN ? b : a;
! 254: }
! 255: else if ( aIsNaN ) {
! 256: if ( bIsSignalingNaN | ! bIsNaN ) return a;
! 257: returnLargerSignificand:
! 258: if ( (bits64) ( a<<1 ) < (bits64) ( b<<1 ) ) return b;
! 259: if ( (bits64) ( b<<1 ) < (bits64) ( a<<1 ) ) return a;
! 260: return ( a < b ) ? a : b;
! 261: }
! 262: else {
! 263: return b;
! 264: }
! 265:
! 266: }
! 267:
! 268: #ifdef FLOATX80
! 269:
! 270: /*
! 271: -------------------------------------------------------------------------------
! 272: The pattern for a default generated extended double-precision NaN. The
! 273: `high' and `low' values hold the most- and least-significant bits,
! 274: respectively.
! 275: -------------------------------------------------------------------------------
! 276: */
! 277: #define floatx80_default_nan_high 0xFFFF
! 278: #define floatx80_default_nan_low LIT64( 0xC000000000000000 )
! 279:
! 280: /*
! 281: -------------------------------------------------------------------------------
! 282: Returns 1 if the extended double-precision floating-point value `a' is a
! 283: NaN; otherwise returns 0.
! 284: -------------------------------------------------------------------------------
! 285: */
! 286: static flag floatx80_is_nan( floatx80 a )
! 287: {
! 288:
! 289: return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );
! 290:
! 291: }
! 292:
! 293: /*
! 294: -------------------------------------------------------------------------------
! 295: Returns 1 if the extended double-precision floating-point value `a' is a
! 296: signaling NaN; otherwise returns 0.
! 297: -------------------------------------------------------------------------------
! 298: */
! 299: flag floatx80_is_signaling_nan( floatx80 a )
! 300: {
! 301: bits64 aLow;
! 302:
! 303: aLow = a.low & ~ LIT64( 0x4000000000000000 );
! 304: return
! 305: ( ( a.high & 0x7FFF ) == 0x7FFF )
! 306: && (bits64) ( aLow<<1 )
! 307: && ( a.low == aLow );
! 308:
! 309: }
! 310:
! 311: /*
! 312: -------------------------------------------------------------------------------
! 313: Returns the result of converting the extended double-precision floating-
! 314: point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the
! 315: invalid exception is raised.
! 316: -------------------------------------------------------------------------------
! 317: */
! 318: static commonNaNT floatx80ToCommonNaN( floatx80 a )
! 319: {
! 320: commonNaNT z;
! 321:
! 322: if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
! 323: z.sign = a.high>>15;
! 324: z.low = 0;
! 325: z.high = a.low<<1;
! 326: return z;
! 327:
! 328: }
! 329:
! 330: /*
! 331: -------------------------------------------------------------------------------
! 332: Returns the result of converting the canonical NaN `a' to the extended
! 333: double-precision floating-point format.
! 334: -------------------------------------------------------------------------------
! 335: */
! 336: static floatx80 commonNaNToFloatx80( commonNaNT a )
! 337: {
! 338: floatx80 z;
! 339:
! 340: z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 );
! 341: z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF;
! 342: return z;
! 343:
! 344: }
! 345:
! 346: /*
! 347: -------------------------------------------------------------------------------
! 348: Takes two extended double-precision floating-point values `a' and `b', one
! 349: of which is a NaN, and returns the appropriate NaN result. If either `a' or
! 350: `b' is a signaling NaN, the invalid exception is raised.
! 351: -------------------------------------------------------------------------------
! 352: */
! 353: static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b )
! 354: {
! 355: flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
! 356:
! 357: aIsNaN = floatx80_is_nan( a );
! 358: aIsSignalingNaN = floatx80_is_signaling_nan( a );
! 359: bIsNaN = floatx80_is_nan( b );
! 360: bIsSignalingNaN = floatx80_is_signaling_nan( b );
! 361: a.low |= LIT64( 0xC000000000000000 );
! 362: b.low |= LIT64( 0xC000000000000000 );
! 363: if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
! 364: if ( aIsSignalingNaN ) {
! 365: if ( bIsSignalingNaN ) goto returnLargerSignificand;
! 366: return bIsNaN ? b : a;
! 367: }
! 368: else if ( aIsNaN ) {
! 369: if ( bIsSignalingNaN | ! bIsNaN ) return a;
! 370: returnLargerSignificand:
! 371: if ( a.low < b.low ) return b;
! 372: if ( b.low < a.low ) return a;
! 373: return ( a.high < b.high ) ? a : b;
! 374: }
! 375: else {
! 376: return b;
! 377: }
! 378:
! 379: }
! 380:
! 381: #endif
! 382:
! 383: #ifdef FLOAT128
! 384:
! 385: /*
! 386: -------------------------------------------------------------------------------
! 387: The pattern for a default generated quadruple-precision NaN. The `high' and
! 388: `low' values hold the most- and least-significant bits, respectively.
! 389: -------------------------------------------------------------------------------
! 390: */
! 391: #define float128_default_nan_high LIT64( 0xFFFF800000000000 )
! 392: #define float128_default_nan_low LIT64( 0x0000000000000000 )
! 393:
! 394: /*
! 395: -------------------------------------------------------------------------------
! 396: Returns 1 if the quadruple-precision floating-point value `a' is a NaN;
! 397: otherwise returns 0.
! 398: -------------------------------------------------------------------------------
! 399: */
! 400: flag float128_is_nan( float128 a )
! 401: {
! 402:
! 403: return
! 404: ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
! 405: && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
! 406:
! 407: }
! 408:
! 409: /*
! 410: -------------------------------------------------------------------------------
! 411: Returns 1 if the quadruple-precision floating-point value `a' is a
! 412: signaling NaN; otherwise returns 0.
! 413: -------------------------------------------------------------------------------
! 414: */
! 415: flag float128_is_signaling_nan( float128 a )
! 416: {
! 417:
! 418: return
! 419: ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
! 420: && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
! 421:
! 422: }
! 423:
! 424: /*
! 425: -------------------------------------------------------------------------------
! 426: Returns the result of converting the quadruple-precision floating-point NaN
! 427: `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
! 428: exception is raised.
! 429: -------------------------------------------------------------------------------
! 430: */
! 431: static commonNaNT float128ToCommonNaN( float128 a )
! 432: {
! 433: commonNaNT z;
! 434:
! 435: if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
! 436: z.sign = a.high>>63;
! 437: shortShift128Left( a.high, a.low, 16, &z.high, &z.low );
! 438: return z;
! 439:
! 440: }
! 441:
! 442: /*
! 443: -------------------------------------------------------------------------------
! 444: Returns the result of converting the canonical NaN `a' to the quadruple-
! 445: precision floating-point format.
! 446: -------------------------------------------------------------------------------
! 447: */
! 448: static float128 commonNaNToFloat128( commonNaNT a )
! 449: {
! 450: float128 z;
! 451:
! 452: shift128Right( a.high, a.low, 16, &z.high, &z.low );
! 453: z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF800000000000 );
! 454: return z;
! 455:
! 456: }
! 457:
! 458: /*
! 459: -------------------------------------------------------------------------------
! 460: Takes two quadruple-precision floating-point values `a' and `b', one of
! 461: which is a NaN, and returns the appropriate NaN result. If either `a' or
! 462: `b' is a signaling NaN, the invalid exception is raised.
! 463: -------------------------------------------------------------------------------
! 464: */
! 465: static float128 propagateFloat128NaN( float128 a, float128 b )
! 466: {
! 467: flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
! 468:
! 469: aIsNaN = float128_is_nan( a );
! 470: aIsSignalingNaN = float128_is_signaling_nan( a );
! 471: bIsNaN = float128_is_nan( b );
! 472: bIsSignalingNaN = float128_is_signaling_nan( b );
! 473: a.high |= LIT64( 0x0000800000000000 );
! 474: b.high |= LIT64( 0x0000800000000000 );
! 475: if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
! 476: if ( aIsSignalingNaN ) {
! 477: if ( bIsSignalingNaN ) goto returnLargerSignificand;
! 478: return bIsNaN ? b : a;
! 479: }
! 480: else if ( aIsNaN ) {
! 481: if ( bIsSignalingNaN | ! bIsNaN ) return a;
! 482: returnLargerSignificand:
! 483: if ( lt128( a.high<<1, a.low, b.high<<1, b.low ) ) return b;
! 484: if ( lt128( b.high<<1, b.low, a.high<<1, a.low ) ) return a;
! 485: return ( a.high < b.high ) ? a : b;
! 486: }
! 487: else {
! 488: return b;
! 489: }
! 490:
! 491: }
! 492:
! 493: #endif
! 494:
! 495: #endif /* !NO_IEEE */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to softfloat-specialize.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / lib / libkern