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 #if defined(CONFIG_SOLARIS) && defined(CONFIG_NEEDS_LIBSUNMATH) 86 #include <sunmath.h> 87 #endif 88 89 90 /* This 'flag' type must be able to hold at least 0 and 1. It should 91 * probably be replaced with 'bool' but the uses would need to be audited 92 * to check that they weren't accidentally relying on it being a larger type. 93 */ 94 typedef uint8_t flag; 95 96 #define LIT64( a ) a##LL 97 98 /*---------------------------------------------------------------------------- 99 | Software IEC/IEEE floating-point ordering relations 100 *----------------------------------------------------------------------------*/ 101 enum { 102 float_relation_less = -1, 103 float_relation_equal = 0, 104 float_relation_greater = 1, 105 float_relation_unordered = 2 106 }; 107 108 /*---------------------------------------------------------------------------- 109 | Software IEC/IEEE floating-point types. 110 *----------------------------------------------------------------------------*/ 111 /* Use structures for soft-float types. This prevents accidentally mixing 112 them with native int/float types. A sufficiently clever compiler and 113 sane ABI should be able to see though these structs. However 114 x86/gcc 3.x seems to struggle a bit, so leave them disabled by default. */ 115 //#define USE_SOFTFLOAT_STRUCT_TYPES 116 #ifdef USE_SOFTFLOAT_STRUCT_TYPES 117 typedef struct { 118 uint16_t v; 119 } float16; 120 #define float16_val(x) (((float16)(x)).v) 121 #define make_float16(x) __extension__ ({ float16 f16_val = {x}; f16_val; }) 122 #define const_float16(x) { x } 123 typedef struct { 124 uint32_t v; 125 } float32; 126 /* The cast ensures an error if the wrong type is passed. */ 127 #define float32_val(x) (((float32)(x)).v) 128 #define make_float32(x) __extension__ ({ float32 f32_val = {x}; f32_val; }) 129 #define const_float32(x) { x } 130 typedef struct { 131 uint64_t v; 132 } float64; 133 #define float64_val(x) (((float64)(x)).v) 134 #define make_float64(x) __extension__ ({ float64 f64_val = {x}; f64_val; }) 135 #define const_float64(x) { x } 136 #else 137 typedef uint16_t float16; 138 typedef uint32_t float32; 139 typedef uint64_t float64; 140 #define float16_val(x) (x) 141 #define float32_val(x) (x) 142 #define float64_val(x) (x) 143 #define make_float16(x) (x) 144 #define make_float32(x) (x) 145 #define make_float64(x) (x) 146 #define const_float16(x) (x) 147 #define const_float32(x) (x) 148 #define const_float64(x) (x) 149 #endif 150 typedef struct { 151 uint64_t low; 152 uint16_t high; 153 } floatx80; 154 #define make_floatx80(exp, mant) ((floatx80) { mant, exp }) 155 #define make_floatx80_init(exp, mant) { .low = mant, .high = exp } 156 typedef struct { 157 #ifdef HOST_WORDS_BIGENDIAN 158 uint64_t high, low; 159 #else 160 uint64_t low, high; 161 #endif 162 } float128; 163 #define make_float128(high_, low_) ((float128) { .high = high_, .low = low_ }) 164 #define make_float128_init(high_, low_) { .high = high_, .low = low_ } 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 /* Not an IEEE rounding mode: round to the closest odd mantissa value */ 184 float_round_to_odd = 5, 185 }; 186 187 /*---------------------------------------------------------------------------- 188 | Software IEC/IEEE floating-point exception flags. 189 *----------------------------------------------------------------------------*/ 190 enum { 191 float_flag_invalid = 1, 192 float_flag_divbyzero = 4, 193 float_flag_overflow = 8, 194 float_flag_underflow = 16, 195 float_flag_inexact = 32, 196 float_flag_input_denormal = 64, 197 float_flag_output_denormal = 128 198 }; 199 200 typedef struct float_status { 201 signed char float_detect_tininess; 202 signed char float_rounding_mode; 203 uint8_t float_exception_flags; 204 signed char floatx80_rounding_precision; 205 /* should denormalised results go to zero and set the inexact flag? */ 206 flag flush_to_zero; 207 /* should denormalised inputs go to zero and set the input_denormal flag? */ 208 flag flush_inputs_to_zero; 209 flag default_nan_mode; 210 flag snan_bit_is_one; 211 } float_status; 212 213 static inline void set_float_detect_tininess(int val, float_status *status) 214 { 215 status->float_detect_tininess = val; 216 } 217 static inline void set_float_rounding_mode(int val, float_status *status) 218 { 219 status->float_rounding_mode = val; 220 } 221 static inline void set_float_exception_flags(int val, float_status *status) 222 { 223 status->float_exception_flags = val; 224 } 225 static inline void set_floatx80_rounding_precision(int val, 226 float_status *status) 227 { 228 status->floatx80_rounding_precision = val; 229 } 230 static inline void set_flush_to_zero(flag val, float_status *status) 231 { 232 status->flush_to_zero = val; 233 } 234 static inline void set_flush_inputs_to_zero(flag val, float_status *status) 235 { 236 status->flush_inputs_to_zero = val; 237 } 238 static inline void set_default_nan_mode(flag val, float_status *status) 239 { 240 status->default_nan_mode = val; 241 } 242 static inline void set_snan_bit_is_one(flag val, float_status *status) 243 { 244 status->snan_bit_is_one = val; 245 } 246 static inline int get_float_detect_tininess(float_status *status) 247 { 248 return status->float_detect_tininess; 249 } 250 static inline int get_float_rounding_mode(float_status *status) 251 { 252 return status->float_rounding_mode; 253 } 254 static inline int get_float_exception_flags(float_status *status) 255 { 256 return status->float_exception_flags; 257 } 258 static inline int get_floatx80_rounding_precision(float_status *status) 259 { 260 return status->floatx80_rounding_precision; 261 } 262 static inline flag get_flush_to_zero(float_status *status) 263 { 264 return status->flush_to_zero; 265 } 266 static inline flag get_flush_inputs_to_zero(float_status *status) 267 { 268 return status->flush_inputs_to_zero; 269 } 270 static inline flag get_default_nan_mode(float_status *status) 271 { 272 return status->default_nan_mode; 273 } 274 275 /*---------------------------------------------------------------------------- 276 | Routine to raise any or all of the software IEC/IEEE floating-point 277 | exception flags. 278 *----------------------------------------------------------------------------*/ 279 void float_raise(uint8_t flags, float_status *status); 280 281 /*---------------------------------------------------------------------------- 282 | If `a' is denormal and we are in flush-to-zero mode then set the 283 | input-denormal exception and return zero. Otherwise just return the value. 284 *----------------------------------------------------------------------------*/ 285 float32 float32_squash_input_denormal(float32 a, float_status *status); 286 float64 float64_squash_input_denormal(float64 a, float_status *status); 287 288 /*---------------------------------------------------------------------------- 289 | Options to indicate which negations to perform in float*_muladd() 290 | Using these differs from negating an input or output before calling 291 | the muladd function in that this means that a NaN doesn't have its 292 | sign bit inverted before it is propagated. 293 | We also support halving the result before rounding, as a special 294 | case to support the ARM fused-sqrt-step instruction FRSQRTS. 295 *----------------------------------------------------------------------------*/ 296 enum { 297 float_muladd_negate_c = 1, 298 float_muladd_negate_product = 2, 299 float_muladd_negate_result = 4, 300 float_muladd_halve_result = 8, 301 }; 302 303 /*---------------------------------------------------------------------------- 304 | Software IEC/IEEE integer-to-floating-point conversion routines. 305 *----------------------------------------------------------------------------*/ 306 float32 int32_to_float32(int32_t, float_status *status); 307 float64 int32_to_float64(int32_t, float_status *status); 308 float32 uint32_to_float32(uint32_t, float_status *status); 309 float64 uint32_to_float64(uint32_t, float_status *status); 310 floatx80 int32_to_floatx80(int32_t, float_status *status); 311 float128 int32_to_float128(int32_t, float_status *status); 312 float32 int64_to_float32(int64_t, float_status *status); 313 float64 int64_to_float64(int64_t, float_status *status); 314 floatx80 int64_to_floatx80(int64_t, float_status *status); 315 float128 int64_to_float128(int64_t, float_status *status); 316 float32 uint64_to_float32(uint64_t, float_status *status); 317 float64 uint64_to_float64(uint64_t, float_status *status); 318 float128 uint64_to_float128(uint64_t, float_status *status); 319 320 /* We provide the int16 versions for symmetry of API with float-to-int */ 321 static inline float32 int16_to_float32(int16_t v, float_status *status) 322 { 323 return int32_to_float32(v, status); 324 } 325 326 static inline float32 uint16_to_float32(uint16_t v, float_status *status) 327 { 328 return uint32_to_float32(v, status); 329 } 330 331 static inline float64 int16_to_float64(int16_t v, float_status *status) 332 { 333 return int32_to_float64(v, status); 334 } 335 336 static inline float64 uint16_to_float64(uint16_t v, float_status *status) 337 { 338 return uint32_to_float64(v, status); 339 } 340 341 /*---------------------------------------------------------------------------- 342 | Software half-precision conversion routines. 343 *----------------------------------------------------------------------------*/ 344 float16 float32_to_float16(float32, flag, float_status *status); 345 float32 float16_to_float32(float16, flag, float_status *status); 346 float16 float64_to_float16(float64 a, flag ieee, float_status *status); 347 float64 float16_to_float64(float16 a, flag ieee, float_status *status); 348 349 /*---------------------------------------------------------------------------- 350 | Software half-precision operations. 351 *----------------------------------------------------------------------------*/ 352 int float16_is_quiet_nan(float16, float_status *status); 353 int float16_is_signaling_nan(float16, float_status *status); 354 float16 float16_maybe_silence_nan(float16, float_status *status); 355 356 static inline int float16_is_any_nan(float16 a) 357 { 358 return ((float16_val(a) & ~0x8000) > 0x7c00); 359 } 360 361 static inline int float16_is_neg(float16 a) 362 { 363 return float16_val(a) >> 15; 364 } 365 366 static inline int float16_is_infinity(float16 a) 367 { 368 return (float16_val(a) & 0x7fff) == 0x7c00; 369 } 370 371 static inline int float16_is_zero(float16 a) 372 { 373 return (float16_val(a) & 0x7fff) == 0; 374 } 375 376 static inline int float16_is_zero_or_denormal(float16 a) 377 { 378 return (float16_val(a) & 0x7c00) == 0; 379 } 380 381 /*---------------------------------------------------------------------------- 382 | The pattern for a default generated half-precision NaN. 383 *----------------------------------------------------------------------------*/ 384 float16 float16_default_nan(float_status *status); 385 386 /*---------------------------------------------------------------------------- 387 | Software IEC/IEEE single-precision conversion routines. 388 *----------------------------------------------------------------------------*/ 389 int16_t float32_to_int16(float32, float_status *status); 390 uint16_t float32_to_uint16(float32, float_status *status); 391 int16_t float32_to_int16_round_to_zero(float32, float_status *status); 392 uint16_t float32_to_uint16_round_to_zero(float32, float_status *status); 393 int32_t float32_to_int32(float32, float_status *status); 394 int32_t float32_to_int32_round_to_zero(float32, float_status *status); 395 uint32_t float32_to_uint32(float32, float_status *status); 396 uint32_t float32_to_uint32_round_to_zero(float32, float_status *status); 397 int64_t float32_to_int64(float32, float_status *status); 398 uint64_t float32_to_uint64(float32, float_status *status); 399 uint64_t float32_to_uint64_round_to_zero(float32, float_status *status); 400 int64_t float32_to_int64_round_to_zero(float32, float_status *status); 401 float64 float32_to_float64(float32, float_status *status); 402 floatx80 float32_to_floatx80(float32, float_status *status); 403 float128 float32_to_float128(float32, float_status *status); 404 405 /*---------------------------------------------------------------------------- 406 | Software IEC/IEEE single-precision operations. 407 *----------------------------------------------------------------------------*/ 408 float32 float32_round_to_int(float32, float_status *status); 409 float32 float32_add(float32, float32, float_status *status); 410 float32 float32_sub(float32, float32, float_status *status); 411 float32 float32_mul(float32, float32, float_status *status); 412 float32 float32_div(float32, float32, float_status *status); 413 float32 float32_rem(float32, float32, float_status *status); 414 float32 float32_muladd(float32, float32, float32, int, float_status *status); 415 float32 float32_sqrt(float32, float_status *status); 416 float32 float32_exp2(float32, float_status *status); 417 float32 float32_log2(float32, float_status *status); 418 int float32_eq(float32, float32, float_status *status); 419 int float32_le(float32, float32, float_status *status); 420 int float32_lt(float32, float32, float_status *status); 421 int float32_unordered(float32, float32, float_status *status); 422 int float32_eq_quiet(float32, float32, float_status *status); 423 int float32_le_quiet(float32, float32, float_status *status); 424 int float32_lt_quiet(float32, float32, float_status *status); 425 int float32_unordered_quiet(float32, float32, float_status *status); 426 int float32_compare(float32, float32, float_status *status); 427 int float32_compare_quiet(float32, float32, float_status *status); 428 float32 float32_min(float32, float32, float_status *status); 429 float32 float32_max(float32, float32, float_status *status); 430 float32 float32_minnum(float32, float32, float_status *status); 431 float32 float32_maxnum(float32, float32, float_status *status); 432 float32 float32_minnummag(float32, float32, float_status *status); 433 float32 float32_maxnummag(float32, float32, float_status *status); 434 int float32_is_quiet_nan(float32, float_status *status); 435 int float32_is_signaling_nan(float32, float_status *status); 436 float32 float32_maybe_silence_nan(float32, float_status *status); 437 float32 float32_scalbn(float32, int, float_status *status); 438 439 static inline float32 float32_abs(float32 a) 440 { 441 /* Note that abs does *not* handle NaN specially, nor does 442 * it flush denormal inputs to zero. 443 */ 444 return make_float32(float32_val(a) & 0x7fffffff); 445 } 446 447 static inline float32 float32_chs(float32 a) 448 { 449 /* Note that chs does *not* handle NaN specially, nor does 450 * it flush denormal inputs to zero. 451 */ 452 return make_float32(float32_val(a) ^ 0x80000000); 453 } 454 455 static inline int float32_is_infinity(float32 a) 456 { 457 return (float32_val(a) & 0x7fffffff) == 0x7f800000; 458 } 459 460 static inline int float32_is_neg(float32 a) 461 { 462 return float32_val(a) >> 31; 463 } 464 465 static inline int float32_is_zero(float32 a) 466 { 467 return (float32_val(a) & 0x7fffffff) == 0; 468 } 469 470 static inline int float32_is_any_nan(float32 a) 471 { 472 return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL); 473 } 474 475 static inline int float32_is_zero_or_denormal(float32 a) 476 { 477 return (float32_val(a) & 0x7f800000) == 0; 478 } 479 480 static inline float32 float32_set_sign(float32 a, int sign) 481 { 482 return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31)); 483 } 484 485 #define float32_zero make_float32(0) 486 #define float32_one make_float32(0x3f800000) 487 #define float32_ln2 make_float32(0x3f317218) 488 #define float32_pi make_float32(0x40490fdb) 489 #define float32_half make_float32(0x3f000000) 490 #define float32_infinity make_float32(0x7f800000) 491 492 493 /*---------------------------------------------------------------------------- 494 | The pattern for a default generated single-precision NaN. 495 *----------------------------------------------------------------------------*/ 496 float32 float32_default_nan(float_status *status); 497 498 /*---------------------------------------------------------------------------- 499 | Software IEC/IEEE double-precision conversion routines. 500 *----------------------------------------------------------------------------*/ 501 int16_t float64_to_int16(float64, float_status *status); 502 uint16_t float64_to_uint16(float64, float_status *status); 503 int16_t float64_to_int16_round_to_zero(float64, float_status *status); 504 uint16_t float64_to_uint16_round_to_zero(float64, float_status *status); 505 int32_t float64_to_int32(float64, float_status *status); 506 int32_t float64_to_int32_round_to_zero(float64, float_status *status); 507 uint32_t float64_to_uint32(float64, float_status *status); 508 uint32_t float64_to_uint32_round_to_zero(float64, float_status *status); 509 int64_t float64_to_int64(float64, float_status *status); 510 int64_t float64_to_int64_round_to_zero(float64, float_status *status); 511 uint64_t float64_to_uint64(float64 a, float_status *status); 512 uint64_t float64_to_uint64_round_to_zero(float64 a, float_status *status); 513 float32 float64_to_float32(float64, float_status *status); 514 floatx80 float64_to_floatx80(float64, float_status *status); 515 float128 float64_to_float128(float64, float_status *status); 516 517 /*---------------------------------------------------------------------------- 518 | Software IEC/IEEE double-precision operations. 519 *----------------------------------------------------------------------------*/ 520 float64 float64_round_to_int(float64, float_status *status); 521 float64 float64_trunc_to_int(float64, float_status *status); 522 float64 float64_add(float64, float64, float_status *status); 523 float64 float64_sub(float64, float64, float_status *status); 524 float64 float64_mul(float64, float64, float_status *status); 525 float64 float64_div(float64, float64, float_status *status); 526 float64 float64_rem(float64, float64, float_status *status); 527 float64 float64_muladd(float64, float64, float64, int, float_status *status); 528 float64 float64_sqrt(float64, float_status *status); 529 float64 float64_log2(float64, float_status *status); 530 int float64_eq(float64, float64, float_status *status); 531 int float64_le(float64, float64, float_status *status); 532 int float64_lt(float64, float64, float_status *status); 533 int float64_unordered(float64, float64, float_status *status); 534 int float64_eq_quiet(float64, float64, float_status *status); 535 int float64_le_quiet(float64, float64, float_status *status); 536 int float64_lt_quiet(float64, float64, float_status *status); 537 int float64_unordered_quiet(float64, float64, float_status *status); 538 int float64_compare(float64, float64, float_status *status); 539 int float64_compare_quiet(float64, float64, float_status *status); 540 float64 float64_min(float64, float64, float_status *status); 541 float64 float64_max(float64, float64, float_status *status); 542 float64 float64_minnum(float64, float64, float_status *status); 543 float64 float64_maxnum(float64, float64, float_status *status); 544 float64 float64_minnummag(float64, float64, float_status *status); 545 float64 float64_maxnummag(float64, float64, float_status *status); 546 int float64_is_quiet_nan(float64 a, float_status *status); 547 int float64_is_signaling_nan(float64, float_status *status); 548 float64 float64_maybe_silence_nan(float64, float_status *status); 549 float64 float64_scalbn(float64, int, float_status *status); 550 551 static inline float64 float64_abs(float64 a) 552 { 553 /* Note that abs does *not* handle NaN specially, nor does 554 * it flush denormal inputs to zero. 555 */ 556 return make_float64(float64_val(a) & 0x7fffffffffffffffLL); 557 } 558 559 static inline float64 float64_chs(float64 a) 560 { 561 /* Note that chs does *not* handle NaN specially, nor does 562 * it flush denormal inputs to zero. 563 */ 564 return make_float64(float64_val(a) ^ 0x8000000000000000LL); 565 } 566 567 static inline int float64_is_infinity(float64 a) 568 { 569 return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL; 570 } 571 572 static inline int float64_is_neg(float64 a) 573 { 574 return float64_val(a) >> 63; 575 } 576 577 static inline int float64_is_zero(float64 a) 578 { 579 return (float64_val(a) & 0x7fffffffffffffffLL) == 0; 580 } 581 582 static inline int float64_is_any_nan(float64 a) 583 { 584 return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL); 585 } 586 587 static inline int float64_is_zero_or_denormal(float64 a) 588 { 589 return (float64_val(a) & 0x7ff0000000000000LL) == 0; 590 } 591 592 static inline float64 float64_set_sign(float64 a, int sign) 593 { 594 return make_float64((float64_val(a) & 0x7fffffffffffffffULL) 595 | ((int64_t)sign << 63)); 596 } 597 598 #define float64_zero make_float64(0) 599 #define float64_one make_float64(0x3ff0000000000000LL) 600 #define float64_ln2 make_float64(0x3fe62e42fefa39efLL) 601 #define float64_pi make_float64(0x400921fb54442d18LL) 602 #define float64_half make_float64(0x3fe0000000000000LL) 603 #define float64_infinity make_float64(0x7ff0000000000000LL) 604 605 /*---------------------------------------------------------------------------- 606 | The pattern for a default generated double-precision NaN. 607 *----------------------------------------------------------------------------*/ 608 float64 float64_default_nan(float_status *status); 609 610 /*---------------------------------------------------------------------------- 611 | Software IEC/IEEE extended double-precision conversion routines. 612 *----------------------------------------------------------------------------*/ 613 int32_t floatx80_to_int32(floatx80, float_status *status); 614 int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status); 615 int64_t floatx80_to_int64(floatx80, float_status *status); 616 int64_t floatx80_to_int64_round_to_zero(floatx80, float_status *status); 617 float32 floatx80_to_float32(floatx80, float_status *status); 618 float64 floatx80_to_float64(floatx80, float_status *status); 619 float128 floatx80_to_float128(floatx80, float_status *status); 620 621 /*---------------------------------------------------------------------------- 622 | Software IEC/IEEE extended double-precision operations. 623 *----------------------------------------------------------------------------*/ 624 floatx80 floatx80_round_to_int(floatx80, float_status *status); 625 floatx80 floatx80_add(floatx80, floatx80, float_status *status); 626 floatx80 floatx80_sub(floatx80, floatx80, float_status *status); 627 floatx80 floatx80_mul(floatx80, floatx80, float_status *status); 628 floatx80 floatx80_div(floatx80, floatx80, float_status *status); 629 floatx80 floatx80_rem(floatx80, floatx80, float_status *status); 630 floatx80 floatx80_sqrt(floatx80, float_status *status); 631 int floatx80_eq(floatx80, floatx80, float_status *status); 632 int floatx80_le(floatx80, floatx80, float_status *status); 633 int floatx80_lt(floatx80, floatx80, float_status *status); 634 int floatx80_unordered(floatx80, floatx80, float_status *status); 635 int floatx80_eq_quiet(floatx80, floatx80, float_status *status); 636 int floatx80_le_quiet(floatx80, floatx80, float_status *status); 637 int floatx80_lt_quiet(floatx80, floatx80, float_status *status); 638 int floatx80_unordered_quiet(floatx80, floatx80, float_status *status); 639 int floatx80_compare(floatx80, floatx80, float_status *status); 640 int floatx80_compare_quiet(floatx80, floatx80, float_status *status); 641 int floatx80_is_quiet_nan(floatx80, float_status *status); 642 int floatx80_is_signaling_nan(floatx80, float_status *status); 643 floatx80 floatx80_maybe_silence_nan(floatx80, float_status *status); 644 floatx80 floatx80_scalbn(floatx80, int, float_status *status); 645 646 static inline floatx80 floatx80_abs(floatx80 a) 647 { 648 a.high &= 0x7fff; 649 return a; 650 } 651 652 static inline floatx80 floatx80_chs(floatx80 a) 653 { 654 a.high ^= 0x8000; 655 return a; 656 } 657 658 static inline int floatx80_is_infinity(floatx80 a) 659 { 660 return (a.high & 0x7fff) == 0x7fff && a.low == 0x8000000000000000LL; 661 } 662 663 static inline int floatx80_is_neg(floatx80 a) 664 { 665 return a.high >> 15; 666 } 667 668 static inline int floatx80_is_zero(floatx80 a) 669 { 670 return (a.high & 0x7fff) == 0 && a.low == 0; 671 } 672 673 static inline int floatx80_is_zero_or_denormal(floatx80 a) 674 { 675 return (a.high & 0x7fff) == 0; 676 } 677 678 static inline int floatx80_is_any_nan(floatx80 a) 679 { 680 return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1); 681 } 682 683 /*---------------------------------------------------------------------------- 684 | Return whether the given value is an invalid floatx80 encoding. 685 | Invalid floatx80 encodings arise when the integer bit is not set, but 686 | the exponent is not zero. The only times the integer bit is permitted to 687 | be zero is in subnormal numbers and the value zero. 688 | This includes what the Intel software developer's manual calls pseudo-NaNs, 689 | pseudo-infinities and un-normal numbers. It does not include 690 | pseudo-denormals, which must still be correctly handled as inputs even 691 | if they are never generated as outputs. 692 *----------------------------------------------------------------------------*/ 693 static inline bool floatx80_invalid_encoding(floatx80 a) 694 { 695 return (a.low & (1ULL << 63)) == 0 && (a.high & 0x7FFF) != 0; 696 } 697 698 #define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL) 699 #define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL) 700 #define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL) 701 #define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL) 702 #define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL) 703 #define floatx80_infinity make_floatx80(0x7fff, 0x8000000000000000LL) 704 705 /*---------------------------------------------------------------------------- 706 | The pattern for a default generated extended double-precision NaN. 707 *----------------------------------------------------------------------------*/ 708 floatx80 floatx80_default_nan(float_status *status); 709 710 /*---------------------------------------------------------------------------- 711 | Software IEC/IEEE quadruple-precision conversion routines. 712 *----------------------------------------------------------------------------*/ 713 int32_t float128_to_int32(float128, float_status *status); 714 int32_t float128_to_int32_round_to_zero(float128, float_status *status); 715 int64_t float128_to_int64(float128, float_status *status); 716 int64_t float128_to_int64_round_to_zero(float128, float_status *status); 717 uint64_t float128_to_uint64(float128, float_status *status); 718 uint64_t float128_to_uint64_round_to_zero(float128, float_status *status); 719 uint32_t float128_to_uint32_round_to_zero(float128, float_status *status); 720 float32 float128_to_float32(float128, float_status *status); 721 float64 float128_to_float64(float128, float_status *status); 722 floatx80 float128_to_floatx80(float128, float_status *status); 723 724 /*---------------------------------------------------------------------------- 725 | Software IEC/IEEE quadruple-precision operations. 726 *----------------------------------------------------------------------------*/ 727 float128 float128_round_to_int(float128, float_status *status); 728 float128 float128_add(float128, float128, float_status *status); 729 float128 float128_sub(float128, float128, float_status *status); 730 float128 float128_mul(float128, float128, float_status *status); 731 float128 float128_div(float128, float128, float_status *status); 732 float128 float128_rem(float128, float128, float_status *status); 733 float128 float128_sqrt(float128, float_status *status); 734 int float128_eq(float128, float128, float_status *status); 735 int float128_le(float128, float128, float_status *status); 736 int float128_lt(float128, float128, float_status *status); 737 int float128_unordered(float128, float128, float_status *status); 738 int float128_eq_quiet(float128, float128, float_status *status); 739 int float128_le_quiet(float128, float128, float_status *status); 740 int float128_lt_quiet(float128, float128, float_status *status); 741 int float128_unordered_quiet(float128, float128, float_status *status); 742 int float128_compare(float128, float128, float_status *status); 743 int float128_compare_quiet(float128, float128, float_status *status); 744 int float128_is_quiet_nan(float128, float_status *status); 745 int float128_is_signaling_nan(float128, float_status *status); 746 float128 float128_maybe_silence_nan(float128, float_status *status); 747 float128 float128_scalbn(float128, int, float_status *status); 748 749 static inline float128 float128_abs(float128 a) 750 { 751 a.high &= 0x7fffffffffffffffLL; 752 return a; 753 } 754 755 static inline float128 float128_chs(float128 a) 756 { 757 a.high ^= 0x8000000000000000LL; 758 return a; 759 } 760 761 static inline int float128_is_infinity(float128 a) 762 { 763 return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0; 764 } 765 766 static inline int float128_is_neg(float128 a) 767 { 768 return a.high >> 63; 769 } 770 771 static inline int float128_is_zero(float128 a) 772 { 773 return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0; 774 } 775 776 static inline int float128_is_zero_or_denormal(float128 a) 777 { 778 return (a.high & 0x7fff000000000000LL) == 0; 779 } 780 781 static inline int float128_is_any_nan(float128 a) 782 { 783 return ((a.high >> 48) & 0x7fff) == 0x7fff && 784 ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0)); 785 } 786 787 #define float128_zero make_float128(0, 0) 788 789 /*---------------------------------------------------------------------------- 790 | The pattern for a default generated quadruple-precision NaN. 791 *----------------------------------------------------------------------------*/ 792 float128 float128_default_nan(float_status *status); 793 794 #endif /* SOFTFLOAT_H */ 795