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