1 /* 2 * QEMU float support 3 * 4 * The code in this source file is derived from release 2a of the SoftFloat 5 * IEC/IEEE Floating-point Arithmetic Package. Those parts of the code (and 6 * some later contributions) are provided under that license, as detailed below. 7 * It has subsequently been modified by contributors to the QEMU Project, 8 * so some portions are provided under: 9 * the SoftFloat-2a license 10 * the BSD license 11 * GPL-v2-or-later 12 * 13 * Any future contributions to this file after December 1st 2014 will be 14 * taken to be licensed under the Softfloat-2a license unless specifically 15 * indicated otherwise. 16 */ 17 18 /* 19 =============================================================================== 20 This C header file is part of the SoftFloat IEC/IEEE Floating-point 21 Arithmetic Package, Release 2a. 22 23 Written by John R. Hauser. This work was made possible in part by the 24 International Computer Science Institute, located at Suite 600, 1947 Center 25 Street, Berkeley, California 94704. Funding was partially provided by the 26 National Science Foundation under grant MIP-9311980. The original version 27 of this code was written as part of a project to build a fixed-point vector 28 processor in collaboration with the University of California at Berkeley, 29 overseen by Profs. Nelson Morgan and John Wawrzynek. More information 30 is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/ 31 arithmetic/SoftFloat.html'. 32 33 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort 34 has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT 35 TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO 36 PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY 37 AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. 38 39 Derivative works are acceptable, even for commercial purposes, so long as 40 (1) they include prominent notice that the work is derivative, and (2) they 41 include prominent notice akin to these four paragraphs for those parts of 42 this code that are retained. 43 44 =============================================================================== 45 */ 46 47 /* BSD licensing: 48 * Copyright (c) 2006, Fabrice Bellard 49 * All rights reserved. 50 * 51 * Redistribution and use in source and binary forms, with or without 52 * modification, are permitted provided that the following conditions are met: 53 * 54 * 1. Redistributions of source code must retain the above copyright notice, 55 * this list of conditions and the following disclaimer. 56 * 57 * 2. Redistributions in binary form must reproduce the above copyright notice, 58 * this list of conditions and the following disclaimer in the documentation 59 * and/or other materials provided with the distribution. 60 * 61 * 3. Neither the name of the copyright holder nor the names of its contributors 62 * may be used to endorse or promote products derived from this software without 63 * specific prior written permission. 64 * 65 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 66 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 67 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 68 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 69 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 70 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 71 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 72 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 73 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 74 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 75 * THE POSSIBILITY OF SUCH DAMAGE. 76 */ 77 78 /* Portions of this work are licensed under the terms of the GNU GPL, 79 * version 2 or later. See the COPYING file in the top-level directory. 80 */ 81 82 #ifndef SOFTFLOAT_H 83 #define SOFTFLOAT_H 84 85 /* This 'flag' type must be able to hold at least 0 and 1. It should 86 * probably be replaced with 'bool' but the uses would need to be audited 87 * to check that they weren't accidentally relying on it being a larger type. 88 */ 89 typedef uint8_t flag; 90 91 #define LIT64( a ) a##LL 92 93 /*---------------------------------------------------------------------------- 94 | Software IEC/IEEE floating-point ordering relations 95 *----------------------------------------------------------------------------*/ 96 enum { 97 float_relation_less = -1, 98 float_relation_equal = 0, 99 float_relation_greater = 1, 100 float_relation_unordered = 2 101 }; 102 103 /*---------------------------------------------------------------------------- 104 | Software IEC/IEEE floating-point types. 105 *----------------------------------------------------------------------------*/ 106 /* Use structures for soft-float types. This prevents accidentally mixing 107 them with native int/float types. A sufficiently clever compiler and 108 sane ABI should be able to see though these structs. However 109 x86/gcc 3.x seems to struggle a bit, so leave them disabled by default. */ 110 //#define USE_SOFTFLOAT_STRUCT_TYPES 111 #ifdef USE_SOFTFLOAT_STRUCT_TYPES 112 typedef struct { 113 uint16_t v; 114 } float16; 115 #define float16_val(x) (((float16)(x)).v) 116 #define make_float16(x) __extension__ ({ float16 f16_val = {x}; f16_val; }) 117 #define const_float16(x) { x } 118 typedef struct { 119 uint32_t v; 120 } float32; 121 /* The cast ensures an error if the wrong type is passed. */ 122 #define float32_val(x) (((float32)(x)).v) 123 #define make_float32(x) __extension__ ({ float32 f32_val = {x}; f32_val; }) 124 #define const_float32(x) { x } 125 typedef struct { 126 uint64_t v; 127 } float64; 128 #define float64_val(x) (((float64)(x)).v) 129 #define make_float64(x) __extension__ ({ float64 f64_val = {x}; f64_val; }) 130 #define const_float64(x) { x } 131 #else 132 typedef uint16_t float16; 133 typedef uint32_t float32; 134 typedef uint64_t float64; 135 #define float16_val(x) (x) 136 #define float32_val(x) (x) 137 #define float64_val(x) (x) 138 #define make_float16(x) (x) 139 #define make_float32(x) (x) 140 #define make_float64(x) (x) 141 #define const_float16(x) (x) 142 #define const_float32(x) (x) 143 #define const_float64(x) (x) 144 #endif 145 typedef struct { 146 uint64_t low; 147 uint16_t high; 148 } floatx80; 149 #define make_floatx80(exp, mant) ((floatx80) { mant, exp }) 150 #define make_floatx80_init(exp, mant) { .low = mant, .high = exp } 151 typedef struct { 152 #ifdef HOST_WORDS_BIGENDIAN 153 uint64_t high, low; 154 #else 155 uint64_t low, high; 156 #endif 157 } float128; 158 #define make_float128(high_, low_) ((float128) { .high = high_, .low = low_ }) 159 #define make_float128_init(high_, low_) { .high = high_, .low = low_ } 160 161 /*---------------------------------------------------------------------------- 162 | Software IEC/IEEE floating-point underflow tininess-detection mode. 163 *----------------------------------------------------------------------------*/ 164 enum { 165 float_tininess_after_rounding = 0, 166 float_tininess_before_rounding = 1 167 }; 168 169 /*---------------------------------------------------------------------------- 170 | Software IEC/IEEE floating-point rounding mode. 171 *----------------------------------------------------------------------------*/ 172 enum { 173 float_round_nearest_even = 0, 174 float_round_down = 1, 175 float_round_up = 2, 176 float_round_to_zero = 3, 177 float_round_ties_away = 4, 178 /* Not an IEEE rounding mode: round to the closest odd mantissa value */ 179 float_round_to_odd = 5, 180 }; 181 182 /*---------------------------------------------------------------------------- 183 | Software IEC/IEEE floating-point exception flags. 184 *----------------------------------------------------------------------------*/ 185 enum { 186 float_flag_invalid = 1, 187 float_flag_divbyzero = 4, 188 float_flag_overflow = 8, 189 float_flag_underflow = 16, 190 float_flag_inexact = 32, 191 float_flag_input_denormal = 64, 192 float_flag_output_denormal = 128 193 }; 194 195 typedef struct float_status { 196 signed char float_detect_tininess; 197 signed char float_rounding_mode; 198 uint8_t float_exception_flags; 199 signed char floatx80_rounding_precision; 200 /* should denormalised results go to zero and set the inexact flag? */ 201 flag flush_to_zero; 202 /* should denormalised inputs go to zero and set the input_denormal flag? */ 203 flag flush_inputs_to_zero; 204 flag default_nan_mode; 205 flag snan_bit_is_one; 206 } float_status; 207 208 static inline void set_float_detect_tininess(int val, float_status *status) 209 { 210 status->float_detect_tininess = val; 211 } 212 static inline void set_float_rounding_mode(int val, float_status *status) 213 { 214 status->float_rounding_mode = val; 215 } 216 static inline void set_float_exception_flags(int val, float_status *status) 217 { 218 status->float_exception_flags = val; 219 } 220 static inline void set_floatx80_rounding_precision(int val, 221 float_status *status) 222 { 223 status->floatx80_rounding_precision = val; 224 } 225 static inline void set_flush_to_zero(flag val, float_status *status) 226 { 227 status->flush_to_zero = val; 228 } 229 static inline void set_flush_inputs_to_zero(flag val, float_status *status) 230 { 231 status->flush_inputs_to_zero = val; 232 } 233 static inline void set_default_nan_mode(flag val, float_status *status) 234 { 235 status->default_nan_mode = val; 236 } 237 static inline void set_snan_bit_is_one(flag val, float_status *status) 238 { 239 status->snan_bit_is_one = val; 240 } 241 static inline int get_float_detect_tininess(float_status *status) 242 { 243 return status->float_detect_tininess; 244 } 245 static inline int get_float_rounding_mode(float_status *status) 246 { 247 return status->float_rounding_mode; 248 } 249 static inline int get_float_exception_flags(float_status *status) 250 { 251 return status->float_exception_flags; 252 } 253 static inline int get_floatx80_rounding_precision(float_status *status) 254 { 255 return status->floatx80_rounding_precision; 256 } 257 static inline flag get_flush_to_zero(float_status *status) 258 { 259 return status->flush_to_zero; 260 } 261 static inline flag get_flush_inputs_to_zero(float_status *status) 262 { 263 return status->flush_inputs_to_zero; 264 } 265 static inline flag get_default_nan_mode(float_status *status) 266 { 267 return status->default_nan_mode; 268 } 269 270 /*---------------------------------------------------------------------------- 271 | Routine to raise any or all of the software IEC/IEEE floating-point 272 | exception flags. 273 *----------------------------------------------------------------------------*/ 274 void float_raise(uint8_t flags, float_status *status); 275 276 /*---------------------------------------------------------------------------- 277 | If `a' is denormal and we are in flush-to-zero mode then set the 278 | input-denormal exception and return zero. Otherwise just return the value. 279 *----------------------------------------------------------------------------*/ 280 float32 float32_squash_input_denormal(float32 a, float_status *status); 281 float64 float64_squash_input_denormal(float64 a, float_status *status); 282 283 /*---------------------------------------------------------------------------- 284 | Options to indicate which negations to perform in float*_muladd() 285 | Using these differs from negating an input or output before calling 286 | the muladd function in that this means that a NaN doesn't have its 287 | sign bit inverted before it is propagated. 288 | We also support halving the result before rounding, as a special 289 | case to support the ARM fused-sqrt-step instruction FRSQRTS. 290 *----------------------------------------------------------------------------*/ 291 enum { 292 float_muladd_negate_c = 1, 293 float_muladd_negate_product = 2, 294 float_muladd_negate_result = 4, 295 float_muladd_halve_result = 8, 296 }; 297 298 /*---------------------------------------------------------------------------- 299 | Software IEC/IEEE integer-to-floating-point conversion routines. 300 *----------------------------------------------------------------------------*/ 301 float32 int32_to_float32(int32_t, float_status *status); 302 float64 int32_to_float64(int32_t, float_status *status); 303 float32 uint32_to_float32(uint32_t, float_status *status); 304 float64 uint32_to_float64(uint32_t, float_status *status); 305 floatx80 int32_to_floatx80(int32_t, float_status *status); 306 float128 int32_to_float128(int32_t, float_status *status); 307 float32 int64_to_float32(int64_t, float_status *status); 308 float64 int64_to_float64(int64_t, float_status *status); 309 floatx80 int64_to_floatx80(int64_t, float_status *status); 310 float128 int64_to_float128(int64_t, float_status *status); 311 float32 uint64_to_float32(uint64_t, float_status *status); 312 float64 uint64_to_float64(uint64_t, float_status *status); 313 float128 uint64_to_float128(uint64_t, float_status *status); 314 315 /* We provide the int16 versions for symmetry of API with float-to-int */ 316 static inline float32 int16_to_float32(int16_t v, float_status *status) 317 { 318 return int32_to_float32(v, status); 319 } 320 321 static inline float32 uint16_to_float32(uint16_t v, float_status *status) 322 { 323 return uint32_to_float32(v, status); 324 } 325 326 static inline float64 int16_to_float64(int16_t v, float_status *status) 327 { 328 return int32_to_float64(v, status); 329 } 330 331 static inline float64 uint16_to_float64(uint16_t v, float_status *status) 332 { 333 return uint32_to_float64(v, status); 334 } 335 336 /*---------------------------------------------------------------------------- 337 | Software half-precision conversion routines. 338 *----------------------------------------------------------------------------*/ 339 float16 float32_to_float16(float32, flag, float_status *status); 340 float32 float16_to_float32(float16, flag, float_status *status); 341 float16 float64_to_float16(float64 a, flag ieee, float_status *status); 342 float64 float16_to_float64(float16 a, flag ieee, float_status *status); 343 344 /*---------------------------------------------------------------------------- 345 | Software half-precision operations. 346 *----------------------------------------------------------------------------*/ 347 int float16_is_quiet_nan(float16, float_status *status); 348 int float16_is_signaling_nan(float16, float_status *status); 349 float16 float16_maybe_silence_nan(float16, float_status *status); 350 351 static inline int float16_is_any_nan(float16 a) 352 { 353 return ((float16_val(a) & ~0x8000) > 0x7c00); 354 } 355 356 static inline int float16_is_neg(float16 a) 357 { 358 return float16_val(a) >> 15; 359 } 360 361 static inline int float16_is_infinity(float16 a) 362 { 363 return (float16_val(a) & 0x7fff) == 0x7c00; 364 } 365 366 static inline int float16_is_zero(float16 a) 367 { 368 return (float16_val(a) & 0x7fff) == 0; 369 } 370 371 static inline int float16_is_zero_or_denormal(float16 a) 372 { 373 return (float16_val(a) & 0x7c00) == 0; 374 } 375 376 /*---------------------------------------------------------------------------- 377 | The pattern for a default generated half-precision NaN. 378 *----------------------------------------------------------------------------*/ 379 float16 float16_default_nan(float_status *status); 380 381 /*---------------------------------------------------------------------------- 382 | Software IEC/IEEE single-precision conversion routines. 383 *----------------------------------------------------------------------------*/ 384 int16_t float32_to_int16(float32, float_status *status); 385 uint16_t float32_to_uint16(float32, float_status *status); 386 int16_t float32_to_int16_round_to_zero(float32, float_status *status); 387 uint16_t float32_to_uint16_round_to_zero(float32, float_status *status); 388 int32_t float32_to_int32(float32, float_status *status); 389 int32_t float32_to_int32_round_to_zero(float32, float_status *status); 390 uint32_t float32_to_uint32(float32, float_status *status); 391 uint32_t float32_to_uint32_round_to_zero(float32, float_status *status); 392 int64_t float32_to_int64(float32, float_status *status); 393 uint64_t float32_to_uint64(float32, float_status *status); 394 uint64_t float32_to_uint64_round_to_zero(float32, float_status *status); 395 int64_t float32_to_int64_round_to_zero(float32, float_status *status); 396 float64 float32_to_float64(float32, float_status *status); 397 floatx80 float32_to_floatx80(float32, float_status *status); 398 float128 float32_to_float128(float32, float_status *status); 399 400 /*---------------------------------------------------------------------------- 401 | Software IEC/IEEE single-precision operations. 402 *----------------------------------------------------------------------------*/ 403 float32 float32_round_to_int(float32, float_status *status); 404 float32 float32_add(float32, float32, float_status *status); 405 float32 float32_sub(float32, float32, float_status *status); 406 float32 float32_mul(float32, float32, float_status *status); 407 float32 float32_div(float32, float32, float_status *status); 408 float32 float32_rem(float32, float32, float_status *status); 409 float32 float32_muladd(float32, float32, float32, int, float_status *status); 410 float32 float32_sqrt(float32, float_status *status); 411 float32 float32_exp2(float32, float_status *status); 412 float32 float32_log2(float32, float_status *status); 413 int float32_eq(float32, float32, float_status *status); 414 int float32_le(float32, float32, float_status *status); 415 int float32_lt(float32, float32, float_status *status); 416 int float32_unordered(float32, float32, float_status *status); 417 int float32_eq_quiet(float32, float32, float_status *status); 418 int float32_le_quiet(float32, float32, float_status *status); 419 int float32_lt_quiet(float32, float32, float_status *status); 420 int float32_unordered_quiet(float32, float32, float_status *status); 421 int float32_compare(float32, float32, float_status *status); 422 int float32_compare_quiet(float32, float32, float_status *status); 423 float32 float32_min(float32, float32, float_status *status); 424 float32 float32_max(float32, float32, float_status *status); 425 float32 float32_minnum(float32, float32, float_status *status); 426 float32 float32_maxnum(float32, float32, float_status *status); 427 float32 float32_minnummag(float32, float32, float_status *status); 428 float32 float32_maxnummag(float32, float32, float_status *status); 429 int float32_is_quiet_nan(float32, float_status *status); 430 int float32_is_signaling_nan(float32, float_status *status); 431 float32 float32_maybe_silence_nan(float32, float_status *status); 432 float32 float32_scalbn(float32, int, float_status *status); 433 434 static inline float32 float32_abs(float32 a) 435 { 436 /* Note that abs does *not* handle NaN specially, nor does 437 * it flush denormal inputs to zero. 438 */ 439 return make_float32(float32_val(a) & 0x7fffffff); 440 } 441 442 static inline float32 float32_chs(float32 a) 443 { 444 /* Note that chs does *not* handle NaN specially, nor does 445 * it flush denormal inputs to zero. 446 */ 447 return make_float32(float32_val(a) ^ 0x80000000); 448 } 449 450 static inline int float32_is_infinity(float32 a) 451 { 452 return (float32_val(a) & 0x7fffffff) == 0x7f800000; 453 } 454 455 static inline int float32_is_neg(float32 a) 456 { 457 return float32_val(a) >> 31; 458 } 459 460 static inline int float32_is_zero(float32 a) 461 { 462 return (float32_val(a) & 0x7fffffff) == 0; 463 } 464 465 static inline int float32_is_any_nan(float32 a) 466 { 467 return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL); 468 } 469 470 static inline int float32_is_zero_or_denormal(float32 a) 471 { 472 return (float32_val(a) & 0x7f800000) == 0; 473 } 474 475 static inline float32 float32_set_sign(float32 a, int sign) 476 { 477 return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31)); 478 } 479 480 #define float32_zero make_float32(0) 481 #define float32_one make_float32(0x3f800000) 482 #define float32_ln2 make_float32(0x3f317218) 483 #define float32_pi make_float32(0x40490fdb) 484 #define float32_half make_float32(0x3f000000) 485 #define float32_infinity make_float32(0x7f800000) 486 487 488 /*---------------------------------------------------------------------------- 489 | The pattern for a default generated single-precision NaN. 490 *----------------------------------------------------------------------------*/ 491 float32 float32_default_nan(float_status *status); 492 493 /*---------------------------------------------------------------------------- 494 | Software IEC/IEEE double-precision conversion routines. 495 *----------------------------------------------------------------------------*/ 496 int16_t float64_to_int16(float64, float_status *status); 497 uint16_t float64_to_uint16(float64, float_status *status); 498 int16_t float64_to_int16_round_to_zero(float64, float_status *status); 499 uint16_t float64_to_uint16_round_to_zero(float64, float_status *status); 500 int32_t float64_to_int32(float64, float_status *status); 501 int32_t float64_to_int32_round_to_zero(float64, float_status *status); 502 uint32_t float64_to_uint32(float64, float_status *status); 503 uint32_t float64_to_uint32_round_to_zero(float64, float_status *status); 504 int64_t float64_to_int64(float64, float_status *status); 505 int64_t float64_to_int64_round_to_zero(float64, float_status *status); 506 uint64_t float64_to_uint64(float64 a, float_status *status); 507 uint64_t float64_to_uint64_round_to_zero(float64 a, float_status *status); 508 float32 float64_to_float32(float64, float_status *status); 509 floatx80 float64_to_floatx80(float64, float_status *status); 510 float128 float64_to_float128(float64, float_status *status); 511 512 /*---------------------------------------------------------------------------- 513 | Software IEC/IEEE double-precision operations. 514 *----------------------------------------------------------------------------*/ 515 float64 float64_round_to_int(float64, float_status *status); 516 float64 float64_trunc_to_int(float64, float_status *status); 517 float64 float64_add(float64, float64, float_status *status); 518 float64 float64_sub(float64, float64, float_status *status); 519 float64 float64_mul(float64, float64, float_status *status); 520 float64 float64_div(float64, float64, float_status *status); 521 float64 float64_rem(float64, float64, float_status *status); 522 float64 float64_muladd(float64, float64, float64, int, float_status *status); 523 float64 float64_sqrt(float64, float_status *status); 524 float64 float64_log2(float64, float_status *status); 525 int float64_eq(float64, float64, float_status *status); 526 int float64_le(float64, float64, float_status *status); 527 int float64_lt(float64, float64, float_status *status); 528 int float64_unordered(float64, float64, float_status *status); 529 int float64_eq_quiet(float64, float64, float_status *status); 530 int float64_le_quiet(float64, float64, float_status *status); 531 int float64_lt_quiet(float64, float64, float_status *status); 532 int float64_unordered_quiet(float64, float64, float_status *status); 533 int float64_compare(float64, float64, float_status *status); 534 int float64_compare_quiet(float64, float64, float_status *status); 535 float64 float64_min(float64, float64, float_status *status); 536 float64 float64_max(float64, float64, float_status *status); 537 float64 float64_minnum(float64, float64, float_status *status); 538 float64 float64_maxnum(float64, float64, float_status *status); 539 float64 float64_minnummag(float64, float64, float_status *status); 540 float64 float64_maxnummag(float64, float64, float_status *status); 541 int float64_is_quiet_nan(float64 a, float_status *status); 542 int float64_is_signaling_nan(float64, float_status *status); 543 float64 float64_maybe_silence_nan(float64, float_status *status); 544 float64 float64_scalbn(float64, int, float_status *status); 545 546 static inline float64 float64_abs(float64 a) 547 { 548 /* Note that abs does *not* handle NaN specially, nor does 549 * it flush denormal inputs to zero. 550 */ 551 return make_float64(float64_val(a) & 0x7fffffffffffffffLL); 552 } 553 554 static inline float64 float64_chs(float64 a) 555 { 556 /* Note that chs does *not* handle NaN specially, nor does 557 * it flush denormal inputs to zero. 558 */ 559 return make_float64(float64_val(a) ^ 0x8000000000000000LL); 560 } 561 562 static inline int float64_is_infinity(float64 a) 563 { 564 return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL; 565 } 566 567 static inline int float64_is_neg(float64 a) 568 { 569 return float64_val(a) >> 63; 570 } 571 572 static inline int float64_is_zero(float64 a) 573 { 574 return (float64_val(a) & 0x7fffffffffffffffLL) == 0; 575 } 576 577 static inline int float64_is_any_nan(float64 a) 578 { 579 return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL); 580 } 581 582 static inline int float64_is_zero_or_denormal(float64 a) 583 { 584 return (float64_val(a) & 0x7ff0000000000000LL) == 0; 585 } 586 587 static inline float64 float64_set_sign(float64 a, int sign) 588 { 589 return make_float64((float64_val(a) & 0x7fffffffffffffffULL) 590 | ((int64_t)sign << 63)); 591 } 592 593 #define float64_zero make_float64(0) 594 #define float64_one make_float64(0x3ff0000000000000LL) 595 #define float64_ln2 make_float64(0x3fe62e42fefa39efLL) 596 #define float64_pi make_float64(0x400921fb54442d18LL) 597 #define float64_half make_float64(0x3fe0000000000000LL) 598 #define float64_infinity make_float64(0x7ff0000000000000LL) 599 600 /*---------------------------------------------------------------------------- 601 | The pattern for a default generated double-precision NaN. 602 *----------------------------------------------------------------------------*/ 603 float64 float64_default_nan(float_status *status); 604 605 /*---------------------------------------------------------------------------- 606 | Software IEC/IEEE extended double-precision conversion routines. 607 *----------------------------------------------------------------------------*/ 608 int32_t floatx80_to_int32(floatx80, float_status *status); 609 int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status); 610 int64_t floatx80_to_int64(floatx80, float_status *status); 611 int64_t floatx80_to_int64_round_to_zero(floatx80, float_status *status); 612 float32 floatx80_to_float32(floatx80, float_status *status); 613 float64 floatx80_to_float64(floatx80, float_status *status); 614 float128 floatx80_to_float128(floatx80, float_status *status); 615 616 /*---------------------------------------------------------------------------- 617 | Software IEC/IEEE extended double-precision operations. 618 *----------------------------------------------------------------------------*/ 619 floatx80 floatx80_round(floatx80 a, float_status *status); 620 floatx80 floatx80_round_to_int(floatx80, float_status *status); 621 floatx80 floatx80_add(floatx80, floatx80, float_status *status); 622 floatx80 floatx80_sub(floatx80, floatx80, float_status *status); 623 floatx80 floatx80_mul(floatx80, floatx80, float_status *status); 624 floatx80 floatx80_div(floatx80, floatx80, float_status *status); 625 floatx80 floatx80_rem(floatx80, floatx80, float_status *status); 626 floatx80 floatx80_sqrt(floatx80, float_status *status); 627 int floatx80_eq(floatx80, floatx80, float_status *status); 628 int floatx80_le(floatx80, floatx80, float_status *status); 629 int floatx80_lt(floatx80, floatx80, float_status *status); 630 int floatx80_unordered(floatx80, floatx80, float_status *status); 631 int floatx80_eq_quiet(floatx80, floatx80, float_status *status); 632 int floatx80_le_quiet(floatx80, floatx80, float_status *status); 633 int floatx80_lt_quiet(floatx80, floatx80, float_status *status); 634 int floatx80_unordered_quiet(floatx80, floatx80, float_status *status); 635 int floatx80_compare(floatx80, floatx80, float_status *status); 636 int floatx80_compare_quiet(floatx80, floatx80, float_status *status); 637 int floatx80_is_quiet_nan(floatx80, float_status *status); 638 int floatx80_is_signaling_nan(floatx80, float_status *status); 639 floatx80 floatx80_maybe_silence_nan(floatx80, float_status *status); 640 floatx80 floatx80_scalbn(floatx80, int, float_status *status); 641 642 static inline floatx80 floatx80_abs(floatx80 a) 643 { 644 a.high &= 0x7fff; 645 return a; 646 } 647 648 static inline floatx80 floatx80_chs(floatx80 a) 649 { 650 a.high ^= 0x8000; 651 return a; 652 } 653 654 static inline int floatx80_is_infinity(floatx80 a) 655 { 656 return (a.high & 0x7fff) == 0x7fff && a.low == 0x8000000000000000LL; 657 } 658 659 static inline int floatx80_is_neg(floatx80 a) 660 { 661 return a.high >> 15; 662 } 663 664 static inline int floatx80_is_zero(floatx80 a) 665 { 666 return (a.high & 0x7fff) == 0 && a.low == 0; 667 } 668 669 static inline int floatx80_is_zero_or_denormal(floatx80 a) 670 { 671 return (a.high & 0x7fff) == 0; 672 } 673 674 static inline int floatx80_is_any_nan(floatx80 a) 675 { 676 return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1); 677 } 678 679 /*---------------------------------------------------------------------------- 680 | Return whether the given value is an invalid floatx80 encoding. 681 | Invalid floatx80 encodings arise when the integer bit is not set, but 682 | the exponent is not zero. The only times the integer bit is permitted to 683 | be zero is in subnormal numbers and the value zero. 684 | This includes what the Intel software developer's manual calls pseudo-NaNs, 685 | pseudo-infinities and un-normal numbers. It does not include 686 | pseudo-denormals, which must still be correctly handled as inputs even 687 | if they are never generated as outputs. 688 *----------------------------------------------------------------------------*/ 689 static inline bool floatx80_invalid_encoding(floatx80 a) 690 { 691 return (a.low & (1ULL << 63)) == 0 && (a.high & 0x7FFF) != 0; 692 } 693 694 #define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL) 695 #define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL) 696 #define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL) 697 #define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL) 698 #define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL) 699 #define floatx80_infinity make_floatx80(0x7fff, 0x8000000000000000LL) 700 701 /*---------------------------------------------------------------------------- 702 | The pattern for a default generated extended double-precision NaN. 703 *----------------------------------------------------------------------------*/ 704 floatx80 floatx80_default_nan(float_status *status); 705 706 /*---------------------------------------------------------------------------- 707 | Software IEC/IEEE quadruple-precision conversion routines. 708 *----------------------------------------------------------------------------*/ 709 int32_t float128_to_int32(float128, float_status *status); 710 int32_t float128_to_int32_round_to_zero(float128, float_status *status); 711 int64_t float128_to_int64(float128, float_status *status); 712 int64_t float128_to_int64_round_to_zero(float128, float_status *status); 713 uint64_t float128_to_uint64(float128, float_status *status); 714 uint64_t float128_to_uint64_round_to_zero(float128, float_status *status); 715 uint32_t float128_to_uint32_round_to_zero(float128, float_status *status); 716 float32 float128_to_float32(float128, float_status *status); 717 float64 float128_to_float64(float128, float_status *status); 718 floatx80 float128_to_floatx80(float128, float_status *status); 719 720 /*---------------------------------------------------------------------------- 721 | Software IEC/IEEE quadruple-precision operations. 722 *----------------------------------------------------------------------------*/ 723 float128 float128_round_to_int(float128, float_status *status); 724 float128 float128_add(float128, float128, float_status *status); 725 float128 float128_sub(float128, float128, float_status *status); 726 float128 float128_mul(float128, float128, float_status *status); 727 float128 float128_div(float128, float128, float_status *status); 728 float128 float128_rem(float128, float128, float_status *status); 729 float128 float128_sqrt(float128, float_status *status); 730 int float128_eq(float128, float128, float_status *status); 731 int float128_le(float128, float128, float_status *status); 732 int float128_lt(float128, float128, float_status *status); 733 int float128_unordered(float128, float128, float_status *status); 734 int float128_eq_quiet(float128, float128, float_status *status); 735 int float128_le_quiet(float128, float128, float_status *status); 736 int float128_lt_quiet(float128, float128, float_status *status); 737 int float128_unordered_quiet(float128, float128, float_status *status); 738 int float128_compare(float128, float128, float_status *status); 739 int float128_compare_quiet(float128, float128, float_status *status); 740 int float128_is_quiet_nan(float128, float_status *status); 741 int float128_is_signaling_nan(float128, float_status *status); 742 float128 float128_maybe_silence_nan(float128, float_status *status); 743 float128 float128_scalbn(float128, int, float_status *status); 744 745 static inline float128 float128_abs(float128 a) 746 { 747 a.high &= 0x7fffffffffffffffLL; 748 return a; 749 } 750 751 static inline float128 float128_chs(float128 a) 752 { 753 a.high ^= 0x8000000000000000LL; 754 return a; 755 } 756 757 static inline int float128_is_infinity(float128 a) 758 { 759 return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0; 760 } 761 762 static inline int float128_is_neg(float128 a) 763 { 764 return a.high >> 63; 765 } 766 767 static inline int float128_is_zero(float128 a) 768 { 769 return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0; 770 } 771 772 static inline int float128_is_zero_or_denormal(float128 a) 773 { 774 return (a.high & 0x7fff000000000000LL) == 0; 775 } 776 777 static inline int float128_is_any_nan(float128 a) 778 { 779 return ((a.high >> 48) & 0x7fff) == 0x7fff && 780 ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0)); 781 } 782 783 #define float128_zero make_float128(0, 0) 784 785 /*---------------------------------------------------------------------------- 786 | The pattern for a default generated quadruple-precision NaN. 787 *----------------------------------------------------------------------------*/ 788 float128 float128_default_nan(float_status *status); 789 790 #endif /* SOFTFLOAT_H */ 791