1/* $NetBSD: softfloat-specialize,v 1.4 2004/09/26 21:13:27 jmmv Exp $ */ 2 3/* This is a derivative work. */ 4 5/* 6=============================================================================== 7 8This C source fragment is part of the SoftFloat IEC/IEEE Floating-point 9Arithmetic Package, Release 2a. 10 11Written by John R. Hauser. This work was made possible in part by the 12International Computer Science Institute, located at Suite 600, 1947 Center 13Street, Berkeley, California 94704. Funding was partially provided by the 14National Science Foundation under grant MIP-9311980. The original version 15of this code was written as part of a project to build a fixed-point vector 16processor in collaboration with the University of California at Berkeley, 17overseen by Profs. Nelson Morgan and John Wawrzynek. More information 18is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/ 19arithmetic/SoftFloat.html'. 20 21THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort 22has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT 23TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO 24PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY 25AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. 26 27Derivative works are acceptable, even for commercial purposes, so long as 28(1) they include prominent notice that the work is derivative, and (2) they 29include prominent notice akin to these four paragraphs for those parts of 30this code that are retained. 31 32=============================================================================== 33*/ 34 35#include <signal.h> 36 37/* 38------------------------------------------------------------------------------- 39Underflow tininess-detection mode, statically initialized to default value. 40(The declaration in `softfloat.h' must match the `int8' type here.) 41------------------------------------------------------------------------------- 42*/ 43#ifdef SOFTFLOAT_FOR_GCC 44static 45#endif 46int8 float_detect_tininess = float_tininess_after_rounding; 47 48/* 49------------------------------------------------------------------------------- 50Raises the exceptions specified by `flags'. Floating-point traps can be 51defined here if desired. It is currently not possible for such a trap to 52substitute a result value. If traps are not implemented, this routine 53should be simply `float_exception_flags |= flags;'. 54------------------------------------------------------------------------------- 55*/ 56fp_except float_exception_mask = 0; 57void float_raise( fp_except flags ) 58{ 59 60 float_exception_flags |= flags; 61 62 if ( flags & float_exception_mask ) { 63 raise( SIGFPE ); 64 } 65} 66 67/* 68------------------------------------------------------------------------------- 69Internal canonical NaN format. 70------------------------------------------------------------------------------- 71*/ 72typedef struct { 73 flag sign; 74 bits64 high, low; 75} commonNaNT; 76 77/* 78------------------------------------------------------------------------------- 79The pattern for a default generated single-precision NaN. 80------------------------------------------------------------------------------- 81*/ 82#define float32_default_nan 0xFFFFFFFF 83 84/* 85------------------------------------------------------------------------------- 86Returns 1 if the single-precision floating-point value `a' is a NaN; 87otherwise returns 0. 88------------------------------------------------------------------------------- 89*/ 90#ifdef SOFTFLOAT_FOR_GCC 91static 92#endif 93flag float32_is_nan( float32 a ) 94{ 95 96 return ( 0xFF000000 < (bits32) ( a<<1 ) ); 97 98} 99 100/* 101------------------------------------------------------------------------------- 102Returns 1 if the single-precision floating-point value `a' is a signaling 103NaN; otherwise returns 0. 104------------------------------------------------------------------------------- 105*/ 106#if defined(SOFTFLOAT_FOR_GCC) && !defined(SOFTFLOATSPARC64_FOR_GCC) && \ 107 !defined(SOFTFLOAT_M68K_FOR_GCC) 108static 109#endif 110flag float32_is_signaling_nan( float32 a ) 111{ 112 113 return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF ); 114 115} 116 117/* 118------------------------------------------------------------------------------- 119Returns the result of converting the single-precision floating-point NaN 120`a' to the canonical NaN format. If `a' is a signaling NaN, the invalid 121exception is raised. 122------------------------------------------------------------------------------- 123*/ 124static commonNaNT float32ToCommonNaN( float32 a ) 125{ 126 commonNaNT z; 127 128 if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); 129 z.sign = a>>31; 130 z.low = 0; 131 z.high = ( (bits64) a )<<41; 132 return z; 133 134} 135 136/* 137------------------------------------------------------------------------------- 138Returns the result of converting the canonical NaN `a' to the single- 139precision floating-point format. 140------------------------------------------------------------------------------- 141*/ 142static float32 commonNaNToFloat32( commonNaNT a ) 143{ 144 145 return ( ( (bits32) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>41 ); 146 147} 148 149/* 150------------------------------------------------------------------------------- 151Takes two single-precision floating-point values `a' and `b', one of which 152is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a 153signaling NaN, the invalid exception is raised. 154------------------------------------------------------------------------------- 155*/ 156static float32 propagateFloat32NaN( float32 a, float32 b ) 157{ 158 flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; 159 160 aIsNaN = float32_is_nan( a ); 161 aIsSignalingNaN = float32_is_signaling_nan( a ); 162 bIsNaN = float32_is_nan( b ); 163 bIsSignalingNaN = float32_is_signaling_nan( b ); 164 a |= 0x00400000; 165 b |= 0x00400000; 166 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); 167 if ( aIsNaN ) { 168 return ( aIsSignalingNaN & bIsNaN ) ? b : a; 169 } 170 else { 171 return b; 172 } 173 174} 175 176/* 177------------------------------------------------------------------------------- 178The pattern for a default generated double-precision NaN. 179------------------------------------------------------------------------------- 180*/ 181#define float64_default_nan LIT64( 0xFFFFFFFFFFFFFFFF ) 182 183/* 184------------------------------------------------------------------------------- 185Returns 1 if the double-precision floating-point value `a' is a NaN; 186otherwise returns 0. 187------------------------------------------------------------------------------- 188*/ 189#ifdef SOFTFLOAT_FOR_GCC 190static 191#endif 192flag float64_is_nan( float64 a ) 193{ 194 195 return ( LIT64( 0xFFE0000000000000 ) < 196 (bits64) ( FLOAT64_DEMANGLE(a)<<1 ) ); 197 198} 199 200/* 201------------------------------------------------------------------------------- 202Returns 1 if the double-precision floating-point value `a' is a signaling 203NaN; otherwise returns 0. 204------------------------------------------------------------------------------- 205*/ 206#if defined(SOFTFLOAT_FOR_GCC) && !defined(SOFTFLOATSPARC64_FOR_GCC) && \ 207 !defined(SOFTFLOATM68K_FOR_GCC) 208static 209#endif 210flag float64_is_signaling_nan( float64 a ) 211{ 212 213 return 214 ( ( ( FLOAT64_DEMANGLE(a)>>51 ) & 0xFFF ) == 0xFFE ) 215 && ( FLOAT64_DEMANGLE(a) & LIT64( 0x0007FFFFFFFFFFFF ) ); 216 217} 218 219/* 220------------------------------------------------------------------------------- 221Returns the result of converting the double-precision floating-point NaN 222`a' to the canonical NaN format. If `a' is a signaling NaN, the invalid 223exception is raised. 224------------------------------------------------------------------------------- 225*/ 226static commonNaNT float64ToCommonNaN( float64 a ) 227{ 228 commonNaNT z; 229 230 if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); 231 z.sign = FLOAT64_DEMANGLE(a)>>63; 232 z.low = 0; 233 z.high = FLOAT64_DEMANGLE(a)<<12; 234 return z; 235 236} 237 238/* 239------------------------------------------------------------------------------- 240Returns the result of converting the canonical NaN `a' to the double- 241precision floating-point format. 242------------------------------------------------------------------------------- 243*/ 244static float64 commonNaNToFloat64( commonNaNT a ) 245{ 246 247 return FLOAT64_MANGLE( 248 ( ( (bits64) a.sign )<<63 ) 249 | LIT64( 0x7FF8000000000000 ) 250 | ( a.high>>12 ) ); 251 252} 253 254/* 255------------------------------------------------------------------------------- 256Takes two double-precision floating-point values `a' and `b', one of which 257is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a 258signaling NaN, the invalid exception is raised. 259------------------------------------------------------------------------------- 260*/ 261static float64 propagateFloat64NaN( float64 a, float64 b ) 262{ 263 flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; 264 265 aIsNaN = float64_is_nan( a ); 266 aIsSignalingNaN = float64_is_signaling_nan( a ); 267 bIsNaN = float64_is_nan( b ); 268 bIsSignalingNaN = float64_is_signaling_nan( b ); 269 a |= FLOAT64_MANGLE(LIT64( 0x0008000000000000 )); 270 b |= FLOAT64_MANGLE(LIT64( 0x0008000000000000 )); 271 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); 272 if ( aIsNaN ) { 273 return ( aIsSignalingNaN & bIsNaN ) ? b : a; 274 } 275 else { 276 return b; 277 } 278 279} 280 281#ifdef FLOATX80 282 283/* 284------------------------------------------------------------------------------- 285The pattern for a default generated extended double-precision NaN. The 286`high' and `low' values hold the most- and least-significant bits, 287respectively. 288------------------------------------------------------------------------------- 289*/ 290#define floatx80_default_nan_high 0xFFFF 291#define floatx80_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF ) 292 293/* 294------------------------------------------------------------------------------- 295Returns 1 if the extended double-precision floating-point value `a' is a 296NaN; otherwise returns 0. 297------------------------------------------------------------------------------- 298*/ 299flag floatx80_is_nan( floatx80 a ) 300{ 301 302 return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 ); 303 304} 305 306/* 307------------------------------------------------------------------------------- 308Returns 1 if the extended double-precision floating-point value `a' is a 309signaling NaN; otherwise returns 0. 310------------------------------------------------------------------------------- 311*/ 312flag floatx80_is_signaling_nan( floatx80 a ) 313{ 314 bits64 aLow; 315 316 aLow = a.low & ~ LIT64( 0x4000000000000000 ); 317 return 318 ( ( a.high & 0x7FFF ) == 0x7FFF ) 319 && (bits64) ( aLow<<1 ) 320 && ( a.low == aLow ); 321 322} 323 324/* 325------------------------------------------------------------------------------- 326Returns the result of converting the extended double-precision floating- 327point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the 328invalid exception is raised. 329------------------------------------------------------------------------------- 330*/ 331static commonNaNT floatx80ToCommonNaN( floatx80 a ) 332{ 333 commonNaNT z; 334 335 if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); 336 z.sign = a.high>>15; 337 z.low = 0; 338 z.high = a.low<<1; 339 return z; 340 341} 342 343/* 344------------------------------------------------------------------------------- 345Returns the result of converting the canonical NaN `a' to the extended 346double-precision floating-point format. 347------------------------------------------------------------------------------- 348*/ 349static floatx80 commonNaNToFloatx80( commonNaNT a ) 350{ 351 floatx80 z; 352 353 z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 ); 354 z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF; 355 return z; 356 357} 358 359/* 360------------------------------------------------------------------------------- 361Takes two extended double-precision floating-point values `a' and `b', one 362of which is a NaN, and returns the appropriate NaN result. If either `a' or 363`b' is a signaling NaN, the invalid exception is raised. 364------------------------------------------------------------------------------- 365*/ 366static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b ) 367{ 368 flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; 369 370 aIsNaN = floatx80_is_nan( a ); 371 aIsSignalingNaN = floatx80_is_signaling_nan( a ); 372 bIsNaN = floatx80_is_nan( b ); 373 bIsSignalingNaN = floatx80_is_signaling_nan( b ); 374 a.low |= LIT64( 0xC000000000000000 ); 375 b.low |= LIT64( 0xC000000000000000 ); 376 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); 377 if ( aIsNaN ) { 378 return ( aIsSignalingNaN & bIsNaN ) ? b : a; 379 } 380 else { 381 return b; 382 } 383 384} 385 386#endif 387 388#ifdef FLOAT128 389 390/* 391------------------------------------------------------------------------------- 392The pattern for a default generated quadruple-precision NaN. The `high' and 393`low' values hold the most- and least-significant bits, respectively. 394------------------------------------------------------------------------------- 395*/ 396#define float128_default_nan_high LIT64( 0xFFFFFFFFFFFFFFFF ) 397#define float128_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF ) 398 399/* 400------------------------------------------------------------------------------- 401Returns 1 if the quadruple-precision floating-point value `a' is a NaN; 402otherwise returns 0. 403------------------------------------------------------------------------------- 404*/ 405flag float128_is_nan( float128 a ) 406{ 407 408 return 409 ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) ) 410 && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) ); 411 412} 413 414/* 415------------------------------------------------------------------------------- 416Returns 1 if the quadruple-precision floating-point value `a' is a 417signaling NaN; otherwise returns 0. 418------------------------------------------------------------------------------- 419*/ 420flag float128_is_signaling_nan( float128 a ) 421{ 422 423 return 424 ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE ) 425 && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) ); 426 427} 428 429/* 430------------------------------------------------------------------------------- 431Returns the result of converting the quadruple-precision floating-point NaN 432`a' to the canonical NaN format. If `a' is a signaling NaN, the invalid 433exception is raised. 434------------------------------------------------------------------------------- 435*/ 436static commonNaNT float128ToCommonNaN( float128 a ) 437{ 438 commonNaNT z; 439 440 if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); 441 z.sign = a.high>>63; 442 shortShift128Left( a.high, a.low, 16, &z.high, &z.low ); 443 return z; 444 445} 446 447/* 448------------------------------------------------------------------------------- 449Returns the result of converting the canonical NaN `a' to the quadruple- 450precision floating-point format. 451------------------------------------------------------------------------------- 452*/ 453static float128 commonNaNToFloat128( commonNaNT a ) 454{ 455 float128 z; 456 457 shift128Right( a.high, a.low, 16, &z.high, &z.low ); 458 z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF800000000000 ); 459 return z; 460 461} 462 463/* 464------------------------------------------------------------------------------- 465Takes two quadruple-precision floating-point values `a' and `b', one of 466which is a NaN, and returns the appropriate NaN result. If either `a' or 467`b' is a signaling NaN, the invalid exception is raised. 468------------------------------------------------------------------------------- 469*/ 470static float128 propagateFloat128NaN( float128 a, float128 b ) 471{ 472 flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; 473 474 aIsNaN = float128_is_nan( a ); 475 aIsSignalingNaN = float128_is_signaling_nan( a ); 476 bIsNaN = float128_is_nan( b ); 477 bIsSignalingNaN = float128_is_signaling_nan( b ); 478 a.high |= LIT64( 0x0000800000000000 ); 479 b.high |= LIT64( 0x0000800000000000 ); 480 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); 481 if ( aIsNaN ) { 482 return ( aIsSignalingNaN & bIsNaN ) ? b : a; 483 } 484 else { 485 return b; 486 } 487 488} 489 490#endif 491 492