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 /*---------------------------------------------------------------------------- 86 | Software IEC/IEEE floating-point ordering relations 87 *----------------------------------------------------------------------------*/ 88 89 typedef enum { 90 float_relation_less = -1, 91 float_relation_equal = 0, 92 float_relation_greater = 1, 93 float_relation_unordered = 2 94 } FloatRelation; 95 96 #include "fpu/softfloat-types.h" 97 #include "fpu/softfloat-helpers.h" 98 #include "qemu/int128.h" 99 100 /*---------------------------------------------------------------------------- 101 | Routine to raise any or all of the software IEC/IEEE floating-point 102 | exception flags. 103 *----------------------------------------------------------------------------*/ 104 static inline void float_raise(uint16_t flags, float_status *status) 105 { 106 status->float_exception_flags |= flags; 107 } 108 109 /*---------------------------------------------------------------------------- 110 | If `a' is denormal and we are in flush-to-zero mode then set the 111 | input-denormal exception and return zero. Otherwise just return the value. 112 *----------------------------------------------------------------------------*/ 113 float16 float16_squash_input_denormal(float16 a, float_status *status); 114 float32 float32_squash_input_denormal(float32 a, float_status *status); 115 float64 float64_squash_input_denormal(float64 a, float_status *status); 116 bfloat16 bfloat16_squash_input_denormal(bfloat16 a, float_status *status); 117 118 /*---------------------------------------------------------------------------- 119 | Options to indicate which negations to perform in float*_muladd() 120 | Using these differs from negating an input or output before calling 121 | the muladd function in that this means that a NaN doesn't have its 122 | sign bit inverted before it is propagated. 123 | We also support halving the result before rounding, as a special 124 | case to support the ARM fused-sqrt-step instruction FRSQRTS. 125 *----------------------------------------------------------------------------*/ 126 enum { 127 float_muladd_negate_c = 1, 128 float_muladd_negate_product = 2, 129 float_muladd_negate_result = 4, 130 float_muladd_halve_result = 8, 131 }; 132 133 /*---------------------------------------------------------------------------- 134 | Software IEC/IEEE integer-to-floating-point conversion routines. 135 *----------------------------------------------------------------------------*/ 136 137 float16 int16_to_float16_scalbn(int16_t a, int, float_status *status); 138 float16 int32_to_float16_scalbn(int32_t a, int, float_status *status); 139 float16 int64_to_float16_scalbn(int64_t a, int, float_status *status); 140 float16 uint16_to_float16_scalbn(uint16_t a, int, float_status *status); 141 float16 uint32_to_float16_scalbn(uint32_t a, int, float_status *status); 142 float16 uint64_to_float16_scalbn(uint64_t a, int, float_status *status); 143 144 float16 int8_to_float16(int8_t a, float_status *status); 145 float16 int16_to_float16(int16_t a, float_status *status); 146 float16 int32_to_float16(int32_t a, float_status *status); 147 float16 int64_to_float16(int64_t a, float_status *status); 148 float16 uint8_to_float16(uint8_t a, float_status *status); 149 float16 uint16_to_float16(uint16_t a, float_status *status); 150 float16 uint32_to_float16(uint32_t a, float_status *status); 151 float16 uint64_to_float16(uint64_t a, float_status *status); 152 153 float32 int16_to_float32_scalbn(int16_t, int, float_status *status); 154 float32 int32_to_float32_scalbn(int32_t, int, float_status *status); 155 float32 int64_to_float32_scalbn(int64_t, int, float_status *status); 156 float32 uint16_to_float32_scalbn(uint16_t, int, float_status *status); 157 float32 uint32_to_float32_scalbn(uint32_t, int, float_status *status); 158 float32 uint64_to_float32_scalbn(uint64_t, int, float_status *status); 159 160 float32 int16_to_float32(int16_t, float_status *status); 161 float32 int32_to_float32(int32_t, float_status *status); 162 float32 int64_to_float32(int64_t, float_status *status); 163 float32 uint16_to_float32(uint16_t, float_status *status); 164 float32 uint32_to_float32(uint32_t, float_status *status); 165 float32 uint64_to_float32(uint64_t, float_status *status); 166 167 float64 int16_to_float64_scalbn(int16_t, int, float_status *status); 168 float64 int32_to_float64_scalbn(int32_t, int, float_status *status); 169 float64 int64_to_float64_scalbn(int64_t, int, float_status *status); 170 float64 uint16_to_float64_scalbn(uint16_t, int, float_status *status); 171 float64 uint32_to_float64_scalbn(uint32_t, int, float_status *status); 172 float64 uint64_to_float64_scalbn(uint64_t, int, float_status *status); 173 174 float64 int16_to_float64(int16_t, float_status *status); 175 float64 int32_to_float64(int32_t, float_status *status); 176 float64 int64_to_float64(int64_t, float_status *status); 177 float64 uint16_to_float64(uint16_t, float_status *status); 178 float64 uint32_to_float64(uint32_t, float_status *status); 179 float64 uint64_to_float64(uint64_t, float_status *status); 180 181 floatx80 int32_to_floatx80(int32_t, float_status *status); 182 floatx80 int64_to_floatx80(int64_t, float_status *status); 183 184 float128 int32_to_float128(int32_t, float_status *status); 185 float128 int64_to_float128(int64_t, float_status *status); 186 float128 int128_to_float128(Int128, float_status *status); 187 float128 uint64_to_float128(uint64_t, float_status *status); 188 float128 uint128_to_float128(Int128, float_status *status); 189 190 /*---------------------------------------------------------------------------- 191 | Software half-precision conversion routines. 192 *----------------------------------------------------------------------------*/ 193 194 float16 float32_to_float16(float32, bool ieee, float_status *status); 195 float32 float16_to_float32(float16, bool ieee, float_status *status); 196 float16 float64_to_float16(float64 a, bool ieee, float_status *status); 197 float64 float16_to_float64(float16 a, bool ieee, float_status *status); 198 199 int8_t float16_to_int8_scalbn(float16, FloatRoundMode, int, 200 float_status *status); 201 int16_t float16_to_int16_scalbn(float16, FloatRoundMode, int, float_status *); 202 int32_t float16_to_int32_scalbn(float16, FloatRoundMode, int, float_status *); 203 int64_t float16_to_int64_scalbn(float16, FloatRoundMode, int, float_status *); 204 205 int8_t float16_to_int8(float16, float_status *status); 206 int16_t float16_to_int16(float16, float_status *status); 207 int32_t float16_to_int32(float16, float_status *status); 208 int64_t float16_to_int64(float16, float_status *status); 209 210 int16_t float16_to_int16_round_to_zero(float16, float_status *status); 211 int32_t float16_to_int32_round_to_zero(float16, float_status *status); 212 int64_t float16_to_int64_round_to_zero(float16, float_status *status); 213 214 uint8_t float16_to_uint8_scalbn(float16 a, FloatRoundMode, 215 int, float_status *status); 216 uint16_t float16_to_uint16_scalbn(float16 a, FloatRoundMode, 217 int, float_status *status); 218 uint32_t float16_to_uint32_scalbn(float16 a, FloatRoundMode, 219 int, float_status *status); 220 uint64_t float16_to_uint64_scalbn(float16 a, FloatRoundMode, 221 int, float_status *status); 222 223 uint8_t float16_to_uint8(float16 a, float_status *status); 224 uint16_t float16_to_uint16(float16 a, float_status *status); 225 uint32_t float16_to_uint32(float16 a, float_status *status); 226 uint64_t float16_to_uint64(float16 a, float_status *status); 227 228 uint16_t float16_to_uint16_round_to_zero(float16 a, float_status *status); 229 uint32_t float16_to_uint32_round_to_zero(float16 a, float_status *status); 230 uint64_t float16_to_uint64_round_to_zero(float16 a, float_status *status); 231 232 /*---------------------------------------------------------------------------- 233 | Software half-precision operations. 234 *----------------------------------------------------------------------------*/ 235 236 float16 float16_round_to_int(float16, float_status *status); 237 float16 float16_add(float16, float16, float_status *status); 238 float16 float16_sub(float16, float16, float_status *status); 239 float16 float16_mul(float16, float16, float_status *status); 240 float16 float16_muladd(float16, float16, float16, int, float_status *status); 241 float16 float16_div(float16, float16, float_status *status); 242 float16 float16_scalbn(float16, int, float_status *status); 243 float16 float16_min(float16, float16, float_status *status); 244 float16 float16_max(float16, float16, float_status *status); 245 float16 float16_minnum(float16, float16, float_status *status); 246 float16 float16_maxnum(float16, float16, float_status *status); 247 float16 float16_minnummag(float16, float16, float_status *status); 248 float16 float16_maxnummag(float16, float16, float_status *status); 249 float16 float16_minimum_number(float16, float16, float_status *status); 250 float16 float16_maximum_number(float16, float16, float_status *status); 251 float16 float16_sqrt(float16, float_status *status); 252 FloatRelation float16_compare(float16, float16, float_status *status); 253 FloatRelation float16_compare_quiet(float16, float16, float_status *status); 254 255 bool float16_is_quiet_nan(float16, float_status *status); 256 bool float16_is_signaling_nan(float16, float_status *status); 257 float16 float16_silence_nan(float16, float_status *status); 258 259 static inline bool float16_is_any_nan(float16 a) 260 { 261 return ((float16_val(a) & ~0x8000) > 0x7c00); 262 } 263 264 static inline bool float16_is_neg(float16 a) 265 { 266 return float16_val(a) >> 15; 267 } 268 269 static inline bool float16_is_infinity(float16 a) 270 { 271 return (float16_val(a) & 0x7fff) == 0x7c00; 272 } 273 274 static inline bool float16_is_zero(float16 a) 275 { 276 return (float16_val(a) & 0x7fff) == 0; 277 } 278 279 static inline bool float16_is_zero_or_denormal(float16 a) 280 { 281 return (float16_val(a) & 0x7c00) == 0; 282 } 283 284 static inline bool float16_is_normal(float16 a) 285 { 286 return (((float16_val(a) >> 10) + 1) & 0x1f) >= 2; 287 } 288 289 static inline float16 float16_abs(float16 a) 290 { 291 /* Note that abs does *not* handle NaN specially, nor does 292 * it flush denormal inputs to zero. 293 */ 294 return make_float16(float16_val(a) & 0x7fff); 295 } 296 297 static inline float16 float16_chs(float16 a) 298 { 299 /* Note that chs does *not* handle NaN specially, nor does 300 * it flush denormal inputs to zero. 301 */ 302 return make_float16(float16_val(a) ^ 0x8000); 303 } 304 305 static inline float16 float16_set_sign(float16 a, int sign) 306 { 307 return make_float16((float16_val(a) & 0x7fff) | (sign << 15)); 308 } 309 310 static inline bool float16_eq(float16 a, float16 b, float_status *s) 311 { 312 return float16_compare(a, b, s) == float_relation_equal; 313 } 314 315 static inline bool float16_le(float16 a, float16 b, float_status *s) 316 { 317 return float16_compare(a, b, s) <= float_relation_equal; 318 } 319 320 static inline bool float16_lt(float16 a, float16 b, float_status *s) 321 { 322 return float16_compare(a, b, s) < float_relation_equal; 323 } 324 325 static inline bool float16_unordered(float16 a, float16 b, float_status *s) 326 { 327 return float16_compare(a, b, s) == float_relation_unordered; 328 } 329 330 static inline bool float16_eq_quiet(float16 a, float16 b, float_status *s) 331 { 332 return float16_compare_quiet(a, b, s) == float_relation_equal; 333 } 334 335 static inline bool float16_le_quiet(float16 a, float16 b, float_status *s) 336 { 337 return float16_compare_quiet(a, b, s) <= float_relation_equal; 338 } 339 340 static inline bool float16_lt_quiet(float16 a, float16 b, float_status *s) 341 { 342 return float16_compare_quiet(a, b, s) < float_relation_equal; 343 } 344 345 static inline bool float16_unordered_quiet(float16 a, float16 b, 346 float_status *s) 347 { 348 return float16_compare_quiet(a, b, s) == float_relation_unordered; 349 } 350 351 #define float16_zero make_float16(0) 352 #define float16_half make_float16(0x3800) 353 #define float16_one make_float16(0x3c00) 354 #define float16_one_point_five make_float16(0x3e00) 355 #define float16_two make_float16(0x4000) 356 #define float16_three make_float16(0x4200) 357 #define float16_infinity make_float16(0x7c00) 358 359 /*---------------------------------------------------------------------------- 360 | Software bfloat16 conversion routines. 361 *----------------------------------------------------------------------------*/ 362 363 bfloat16 bfloat16_round_to_int(bfloat16, float_status *status); 364 bfloat16 float32_to_bfloat16(float32, float_status *status); 365 float32 bfloat16_to_float32(bfloat16, float_status *status); 366 bfloat16 float64_to_bfloat16(float64 a, float_status *status); 367 float64 bfloat16_to_float64(bfloat16 a, float_status *status); 368 369 int16_t bfloat16_to_int16_scalbn(bfloat16, FloatRoundMode, 370 int, float_status *status); 371 int32_t bfloat16_to_int32_scalbn(bfloat16, FloatRoundMode, 372 int, float_status *status); 373 int64_t bfloat16_to_int64_scalbn(bfloat16, FloatRoundMode, 374 int, float_status *status); 375 376 int16_t bfloat16_to_int16(bfloat16, float_status *status); 377 int32_t bfloat16_to_int32(bfloat16, float_status *status); 378 int64_t bfloat16_to_int64(bfloat16, float_status *status); 379 380 int16_t bfloat16_to_int16_round_to_zero(bfloat16, float_status *status); 381 int32_t bfloat16_to_int32_round_to_zero(bfloat16, float_status *status); 382 int64_t bfloat16_to_int64_round_to_zero(bfloat16, float_status *status); 383 384 uint16_t bfloat16_to_uint16_scalbn(bfloat16 a, FloatRoundMode, 385 int, float_status *status); 386 uint32_t bfloat16_to_uint32_scalbn(bfloat16 a, FloatRoundMode, 387 int, float_status *status); 388 uint64_t bfloat16_to_uint64_scalbn(bfloat16 a, FloatRoundMode, 389 int, float_status *status); 390 391 uint16_t bfloat16_to_uint16(bfloat16 a, float_status *status); 392 uint32_t bfloat16_to_uint32(bfloat16 a, float_status *status); 393 uint64_t bfloat16_to_uint64(bfloat16 a, float_status *status); 394 395 uint16_t bfloat16_to_uint16_round_to_zero(bfloat16 a, float_status *status); 396 uint32_t bfloat16_to_uint32_round_to_zero(bfloat16 a, float_status *status); 397 uint64_t bfloat16_to_uint64_round_to_zero(bfloat16 a, float_status *status); 398 399 bfloat16 int16_to_bfloat16_scalbn(int16_t a, int, float_status *status); 400 bfloat16 int32_to_bfloat16_scalbn(int32_t a, int, float_status *status); 401 bfloat16 int64_to_bfloat16_scalbn(int64_t a, int, float_status *status); 402 bfloat16 uint16_to_bfloat16_scalbn(uint16_t a, int, float_status *status); 403 bfloat16 uint32_to_bfloat16_scalbn(uint32_t a, int, float_status *status); 404 bfloat16 uint64_to_bfloat16_scalbn(uint64_t a, int, float_status *status); 405 406 bfloat16 int16_to_bfloat16(int16_t a, float_status *status); 407 bfloat16 int32_to_bfloat16(int32_t a, float_status *status); 408 bfloat16 int64_to_bfloat16(int64_t a, float_status *status); 409 bfloat16 uint16_to_bfloat16(uint16_t a, float_status *status); 410 bfloat16 uint32_to_bfloat16(uint32_t a, float_status *status); 411 bfloat16 uint64_to_bfloat16(uint64_t a, float_status *status); 412 413 /*---------------------------------------------------------------------------- 414 | Software bfloat16 operations. 415 *----------------------------------------------------------------------------*/ 416 417 bfloat16 bfloat16_add(bfloat16, bfloat16, float_status *status); 418 bfloat16 bfloat16_sub(bfloat16, bfloat16, float_status *status); 419 bfloat16 bfloat16_mul(bfloat16, bfloat16, float_status *status); 420 bfloat16 bfloat16_div(bfloat16, bfloat16, float_status *status); 421 bfloat16 bfloat16_muladd(bfloat16, bfloat16, bfloat16, int, 422 float_status *status); 423 float16 bfloat16_scalbn(bfloat16, int, float_status *status); 424 bfloat16 bfloat16_min(bfloat16, bfloat16, float_status *status); 425 bfloat16 bfloat16_max(bfloat16, bfloat16, float_status *status); 426 bfloat16 bfloat16_minnum(bfloat16, bfloat16, float_status *status); 427 bfloat16 bfloat16_maxnum(bfloat16, bfloat16, float_status *status); 428 bfloat16 bfloat16_minnummag(bfloat16, bfloat16, float_status *status); 429 bfloat16 bfloat16_maxnummag(bfloat16, bfloat16, float_status *status); 430 bfloat16 bfloat16_minimum_number(bfloat16, bfloat16, float_status *status); 431 bfloat16 bfloat16_maximum_number(bfloat16, bfloat16, float_status *status); 432 bfloat16 bfloat16_sqrt(bfloat16, float_status *status); 433 FloatRelation bfloat16_compare(bfloat16, bfloat16, float_status *status); 434 FloatRelation bfloat16_compare_quiet(bfloat16, bfloat16, float_status *status); 435 436 bool bfloat16_is_quiet_nan(bfloat16, float_status *status); 437 bool bfloat16_is_signaling_nan(bfloat16, float_status *status); 438 bfloat16 bfloat16_silence_nan(bfloat16, float_status *status); 439 bfloat16 bfloat16_default_nan(float_status *status); 440 441 static inline bool bfloat16_is_any_nan(bfloat16 a) 442 { 443 return ((a & ~0x8000) > 0x7F80); 444 } 445 446 static inline bool bfloat16_is_neg(bfloat16 a) 447 { 448 return a >> 15; 449 } 450 451 static inline bool bfloat16_is_infinity(bfloat16 a) 452 { 453 return (a & 0x7fff) == 0x7F80; 454 } 455 456 static inline bool bfloat16_is_zero(bfloat16 a) 457 { 458 return (a & 0x7fff) == 0; 459 } 460 461 static inline bool bfloat16_is_zero_or_denormal(bfloat16 a) 462 { 463 return (a & 0x7F80) == 0; 464 } 465 466 static inline bool bfloat16_is_normal(bfloat16 a) 467 { 468 return (((a >> 7) + 1) & 0xff) >= 2; 469 } 470 471 static inline bfloat16 bfloat16_abs(bfloat16 a) 472 { 473 /* Note that abs does *not* handle NaN specially, nor does 474 * it flush denormal inputs to zero. 475 */ 476 return a & 0x7fff; 477 } 478 479 static inline bfloat16 bfloat16_chs(bfloat16 a) 480 { 481 /* Note that chs does *not* handle NaN specially, nor does 482 * it flush denormal inputs to zero. 483 */ 484 return a ^ 0x8000; 485 } 486 487 static inline bfloat16 bfloat16_set_sign(bfloat16 a, int sign) 488 { 489 return (a & 0x7fff) | (sign << 15); 490 } 491 492 static inline bool bfloat16_eq(bfloat16 a, bfloat16 b, float_status *s) 493 { 494 return bfloat16_compare(a, b, s) == float_relation_equal; 495 } 496 497 static inline bool bfloat16_le(bfloat16 a, bfloat16 b, float_status *s) 498 { 499 return bfloat16_compare(a, b, s) <= float_relation_equal; 500 } 501 502 static inline bool bfloat16_lt(bfloat16 a, bfloat16 b, float_status *s) 503 { 504 return bfloat16_compare(a, b, s) < float_relation_equal; 505 } 506 507 static inline bool bfloat16_unordered(bfloat16 a, bfloat16 b, float_status *s) 508 { 509 return bfloat16_compare(a, b, s) == float_relation_unordered; 510 } 511 512 static inline bool bfloat16_eq_quiet(bfloat16 a, bfloat16 b, float_status *s) 513 { 514 return bfloat16_compare_quiet(a, b, s) == float_relation_equal; 515 } 516 517 static inline bool bfloat16_le_quiet(bfloat16 a, bfloat16 b, float_status *s) 518 { 519 return bfloat16_compare_quiet(a, b, s) <= float_relation_equal; 520 } 521 522 static inline bool bfloat16_lt_quiet(bfloat16 a, bfloat16 b, float_status *s) 523 { 524 return bfloat16_compare_quiet(a, b, s) < float_relation_equal; 525 } 526 527 static inline bool bfloat16_unordered_quiet(bfloat16 a, bfloat16 b, 528 float_status *s) 529 { 530 return bfloat16_compare_quiet(a, b, s) == float_relation_unordered; 531 } 532 533 #define bfloat16_zero 0 534 #define bfloat16_half 0x3f00 535 #define bfloat16_one 0x3f80 536 #define bfloat16_one_point_five 0x3fc0 537 #define bfloat16_two 0x4000 538 #define bfloat16_three 0x4040 539 #define bfloat16_infinity 0x7f80 540 541 /*---------------------------------------------------------------------------- 542 | The pattern for a default generated half-precision NaN. 543 *----------------------------------------------------------------------------*/ 544 float16 float16_default_nan(float_status *status); 545 546 /*---------------------------------------------------------------------------- 547 | Software IEC/IEEE single-precision conversion routines. 548 *----------------------------------------------------------------------------*/ 549 550 int16_t float32_to_int16_scalbn(float32, FloatRoundMode, int, float_status *); 551 int32_t float32_to_int32_scalbn(float32, FloatRoundMode, int, float_status *); 552 int64_t float32_to_int64_scalbn(float32, FloatRoundMode, int, float_status *); 553 554 int16_t float32_to_int16(float32, float_status *status); 555 int32_t float32_to_int32(float32, float_status *status); 556 int64_t float32_to_int64(float32, float_status *status); 557 558 int16_t float32_to_int16_round_to_zero(float32, float_status *status); 559 int32_t float32_to_int32_round_to_zero(float32, float_status *status); 560 int64_t float32_to_int64_round_to_zero(float32, float_status *status); 561 562 uint16_t float32_to_uint16_scalbn(float32, FloatRoundMode, int, float_status *); 563 uint32_t float32_to_uint32_scalbn(float32, FloatRoundMode, int, float_status *); 564 uint64_t float32_to_uint64_scalbn(float32, FloatRoundMode, int, float_status *); 565 566 uint16_t float32_to_uint16(float32, float_status *status); 567 uint32_t float32_to_uint32(float32, float_status *status); 568 uint64_t float32_to_uint64(float32, float_status *status); 569 570 uint16_t float32_to_uint16_round_to_zero(float32, float_status *status); 571 uint32_t float32_to_uint32_round_to_zero(float32, float_status *status); 572 uint64_t float32_to_uint64_round_to_zero(float32, float_status *status); 573 574 float64 float32_to_float64(float32, float_status *status); 575 floatx80 float32_to_floatx80(float32, float_status *status); 576 float128 float32_to_float128(float32, float_status *status); 577 578 /*---------------------------------------------------------------------------- 579 | Software IEC/IEEE single-precision operations. 580 *----------------------------------------------------------------------------*/ 581 float32 float32_round_to_int(float32, float_status *status); 582 float32 float32_add(float32, float32, float_status *status); 583 float32 float32_sub(float32, float32, float_status *status); 584 float32 float32_mul(float32, float32, float_status *status); 585 float32 float32_div(float32, float32, float_status *status); 586 float32 float32_rem(float32, float32, float_status *status); 587 float32 float32_muladd(float32, float32, float32, int, float_status *status); 588 float32 float32_sqrt(float32, float_status *status); 589 float32 float32_exp2(float32, float_status *status); 590 float32 float32_log2(float32, float_status *status); 591 FloatRelation float32_compare(float32, float32, float_status *status); 592 FloatRelation float32_compare_quiet(float32, float32, float_status *status); 593 float32 float32_min(float32, float32, float_status *status); 594 float32 float32_max(float32, float32, float_status *status); 595 float32 float32_minnum(float32, float32, float_status *status); 596 float32 float32_maxnum(float32, float32, float_status *status); 597 float32 float32_minnummag(float32, float32, float_status *status); 598 float32 float32_maxnummag(float32, float32, float_status *status); 599 float32 float32_minimum_number(float32, float32, float_status *status); 600 float32 float32_maximum_number(float32, float32, float_status *status); 601 bool float32_is_quiet_nan(float32, float_status *status); 602 bool float32_is_signaling_nan(float32, float_status *status); 603 float32 float32_silence_nan(float32, float_status *status); 604 float32 float32_scalbn(float32, int, float_status *status); 605 606 static inline float32 float32_abs(float32 a) 607 { 608 /* Note that abs does *not* handle NaN specially, nor does 609 * it flush denormal inputs to zero. 610 */ 611 return make_float32(float32_val(a) & 0x7fffffff); 612 } 613 614 static inline float32 float32_chs(float32 a) 615 { 616 /* Note that chs does *not* handle NaN specially, nor does 617 * it flush denormal inputs to zero. 618 */ 619 return make_float32(float32_val(a) ^ 0x80000000); 620 } 621 622 static inline bool float32_is_infinity(float32 a) 623 { 624 return (float32_val(a) & 0x7fffffff) == 0x7f800000; 625 } 626 627 static inline bool float32_is_neg(float32 a) 628 { 629 return float32_val(a) >> 31; 630 } 631 632 static inline bool float32_is_zero(float32 a) 633 { 634 return (float32_val(a) & 0x7fffffff) == 0; 635 } 636 637 static inline bool float32_is_any_nan(float32 a) 638 { 639 return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL); 640 } 641 642 static inline bool float32_is_zero_or_denormal(float32 a) 643 { 644 return (float32_val(a) & 0x7f800000) == 0; 645 } 646 647 static inline bool float32_is_normal(float32 a) 648 { 649 return (((float32_val(a) >> 23) + 1) & 0xff) >= 2; 650 } 651 652 static inline bool float32_is_denormal(float32 a) 653 { 654 return float32_is_zero_or_denormal(a) && !float32_is_zero(a); 655 } 656 657 static inline bool float32_is_zero_or_normal(float32 a) 658 { 659 return float32_is_normal(a) || float32_is_zero(a); 660 } 661 662 static inline float32 float32_set_sign(float32 a, int sign) 663 { 664 return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31)); 665 } 666 667 static inline bool float32_eq(float32 a, float32 b, float_status *s) 668 { 669 return float32_compare(a, b, s) == float_relation_equal; 670 } 671 672 static inline bool float32_le(float32 a, float32 b, float_status *s) 673 { 674 return float32_compare(a, b, s) <= float_relation_equal; 675 } 676 677 static inline bool float32_lt(float32 a, float32 b, float_status *s) 678 { 679 return float32_compare(a, b, s) < float_relation_equal; 680 } 681 682 static inline bool float32_unordered(float32 a, float32 b, float_status *s) 683 { 684 return float32_compare(a, b, s) == float_relation_unordered; 685 } 686 687 static inline bool float32_eq_quiet(float32 a, float32 b, float_status *s) 688 { 689 return float32_compare_quiet(a, b, s) == float_relation_equal; 690 } 691 692 static inline bool float32_le_quiet(float32 a, float32 b, float_status *s) 693 { 694 return float32_compare_quiet(a, b, s) <= float_relation_equal; 695 } 696 697 static inline bool float32_lt_quiet(float32 a, float32 b, float_status *s) 698 { 699 return float32_compare_quiet(a, b, s) < float_relation_equal; 700 } 701 702 static inline bool float32_unordered_quiet(float32 a, float32 b, 703 float_status *s) 704 { 705 return float32_compare_quiet(a, b, s) == float_relation_unordered; 706 } 707 708 #define float32_zero make_float32(0) 709 #define float32_half make_float32(0x3f000000) 710 #define float32_one make_float32(0x3f800000) 711 #define float32_one_point_five make_float32(0x3fc00000) 712 #define float32_two make_float32(0x40000000) 713 #define float32_three make_float32(0x40400000) 714 #define float32_infinity make_float32(0x7f800000) 715 716 /*---------------------------------------------------------------------------- 717 | Packs the sign `zSign', exponent `zExp', and significand `zSig' into a 718 | single-precision floating-point value, returning the result. After being 719 | shifted into the proper positions, the three fields are simply added 720 | together to form the result. This means that any integer portion of `zSig' 721 | will be added into the exponent. Since a properly normalized significand 722 | will have an integer portion equal to 1, the `zExp' input should be 1 less 723 | than the desired result exponent whenever `zSig' is a complete, normalized 724 | significand. 725 *----------------------------------------------------------------------------*/ 726 727 static inline float32 packFloat32(bool zSign, int zExp, uint32_t zSig) 728 { 729 return make_float32( 730 (((uint32_t)zSign) << 31) + (((uint32_t)zExp) << 23) + zSig); 731 } 732 733 /*---------------------------------------------------------------------------- 734 | The pattern for a default generated single-precision NaN. 735 *----------------------------------------------------------------------------*/ 736 float32 float32_default_nan(float_status *status); 737 738 /*---------------------------------------------------------------------------- 739 | Software IEC/IEEE double-precision conversion routines. 740 *----------------------------------------------------------------------------*/ 741 742 int16_t float64_to_int16_scalbn(float64, FloatRoundMode, int, float_status *); 743 int32_t float64_to_int32_scalbn(float64, FloatRoundMode, int, float_status *); 744 int64_t float64_to_int64_scalbn(float64, FloatRoundMode, int, float_status *); 745 746 int16_t float64_to_int16(float64, float_status *status); 747 int32_t float64_to_int32(float64, float_status *status); 748 int64_t float64_to_int64(float64, float_status *status); 749 750 int16_t float64_to_int16_round_to_zero(float64, float_status *status); 751 int32_t float64_to_int32_round_to_zero(float64, float_status *status); 752 int64_t float64_to_int64_round_to_zero(float64, float_status *status); 753 754 int32_t float64_to_int32_modulo(float64, FloatRoundMode, float_status *status); 755 int64_t float64_to_int64_modulo(float64, FloatRoundMode, float_status *status); 756 757 uint16_t float64_to_uint16_scalbn(float64, FloatRoundMode, int, float_status *); 758 uint32_t float64_to_uint32_scalbn(float64, FloatRoundMode, int, float_status *); 759 uint64_t float64_to_uint64_scalbn(float64, FloatRoundMode, int, float_status *); 760 761 uint16_t float64_to_uint16(float64, float_status *status); 762 uint32_t float64_to_uint32(float64, float_status *status); 763 uint64_t float64_to_uint64(float64, float_status *status); 764 765 uint16_t float64_to_uint16_round_to_zero(float64, float_status *status); 766 uint32_t float64_to_uint32_round_to_zero(float64, float_status *status); 767 uint64_t float64_to_uint64_round_to_zero(float64, float_status *status); 768 769 float32 float64_to_float32(float64, float_status *status); 770 floatx80 float64_to_floatx80(float64, float_status *status); 771 float128 float64_to_float128(float64, float_status *status); 772 773 /*---------------------------------------------------------------------------- 774 | Software IEC/IEEE double-precision operations. 775 *----------------------------------------------------------------------------*/ 776 float64 float64_round_to_int(float64, float_status *status); 777 float64 float64_add(float64, float64, float_status *status); 778 float64 float64_sub(float64, float64, float_status *status); 779 float64 float64_mul(float64, float64, float_status *status); 780 float64 float64_div(float64, float64, float_status *status); 781 float64 float64_rem(float64, float64, float_status *status); 782 float64 float64_muladd(float64, float64, float64, int, float_status *status); 783 float64 float64_sqrt(float64, float_status *status); 784 float64 float64_log2(float64, float_status *status); 785 FloatRelation float64_compare(float64, float64, float_status *status); 786 FloatRelation float64_compare_quiet(float64, float64, float_status *status); 787 float64 float64_min(float64, float64, float_status *status); 788 float64 float64_max(float64, float64, float_status *status); 789 float64 float64_minnum(float64, float64, float_status *status); 790 float64 float64_maxnum(float64, float64, float_status *status); 791 float64 float64_minnummag(float64, float64, float_status *status); 792 float64 float64_maxnummag(float64, float64, float_status *status); 793 float64 float64_minimum_number(float64, float64, float_status *status); 794 float64 float64_maximum_number(float64, float64, float_status *status); 795 bool float64_is_quiet_nan(float64 a, float_status *status); 796 bool float64_is_signaling_nan(float64, float_status *status); 797 float64 float64_silence_nan(float64, float_status *status); 798 float64 float64_scalbn(float64, int, float_status *status); 799 800 static inline float64 float64_abs(float64 a) 801 { 802 /* Note that abs does *not* handle NaN specially, nor does 803 * it flush denormal inputs to zero. 804 */ 805 return make_float64(float64_val(a) & 0x7fffffffffffffffLL); 806 } 807 808 static inline float64 float64_chs(float64 a) 809 { 810 /* Note that chs does *not* handle NaN specially, nor does 811 * it flush denormal inputs to zero. 812 */ 813 return make_float64(float64_val(a) ^ 0x8000000000000000LL); 814 } 815 816 static inline bool float64_is_infinity(float64 a) 817 { 818 return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL; 819 } 820 821 static inline bool float64_is_neg(float64 a) 822 { 823 return float64_val(a) >> 63; 824 } 825 826 static inline bool float64_is_zero(float64 a) 827 { 828 return (float64_val(a) & 0x7fffffffffffffffLL) == 0; 829 } 830 831 static inline bool float64_is_any_nan(float64 a) 832 { 833 return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL); 834 } 835 836 static inline bool float64_is_zero_or_denormal(float64 a) 837 { 838 return (float64_val(a) & 0x7ff0000000000000LL) == 0; 839 } 840 841 static inline bool float64_is_normal(float64 a) 842 { 843 return (((float64_val(a) >> 52) + 1) & 0x7ff) >= 2; 844 } 845 846 static inline bool float64_is_denormal(float64 a) 847 { 848 return float64_is_zero_or_denormal(a) && !float64_is_zero(a); 849 } 850 851 static inline bool float64_is_zero_or_normal(float64 a) 852 { 853 return float64_is_normal(a) || float64_is_zero(a); 854 } 855 856 static inline float64 float64_set_sign(float64 a, int sign) 857 { 858 return make_float64((float64_val(a) & 0x7fffffffffffffffULL) 859 | ((int64_t)sign << 63)); 860 } 861 862 static inline bool float64_eq(float64 a, float64 b, float_status *s) 863 { 864 return float64_compare(a, b, s) == float_relation_equal; 865 } 866 867 static inline bool float64_le(float64 a, float64 b, float_status *s) 868 { 869 return float64_compare(a, b, s) <= float_relation_equal; 870 } 871 872 static inline bool float64_lt(float64 a, float64 b, float_status *s) 873 { 874 return float64_compare(a, b, s) < float_relation_equal; 875 } 876 877 static inline bool float64_unordered(float64 a, float64 b, float_status *s) 878 { 879 return float64_compare(a, b, s) == float_relation_unordered; 880 } 881 882 static inline bool float64_eq_quiet(float64 a, float64 b, float_status *s) 883 { 884 return float64_compare_quiet(a, b, s) == float_relation_equal; 885 } 886 887 static inline bool float64_le_quiet(float64 a, float64 b, float_status *s) 888 { 889 return float64_compare_quiet(a, b, s) <= float_relation_equal; 890 } 891 892 static inline bool float64_lt_quiet(float64 a, float64 b, float_status *s) 893 { 894 return float64_compare_quiet(a, b, s) < float_relation_equal; 895 } 896 897 static inline bool float64_unordered_quiet(float64 a, float64 b, 898 float_status *s) 899 { 900 return float64_compare_quiet(a, b, s) == float_relation_unordered; 901 } 902 903 #define float64_zero make_float64(0) 904 #define float64_half make_float64(0x3fe0000000000000LL) 905 #define float64_one make_float64(0x3ff0000000000000LL) 906 #define float64_one_point_five make_float64(0x3FF8000000000000ULL) 907 #define float64_two make_float64(0x4000000000000000ULL) 908 #define float64_three make_float64(0x4008000000000000ULL) 909 #define float64_ln2 make_float64(0x3fe62e42fefa39efLL) 910 #define float64_infinity make_float64(0x7ff0000000000000LL) 911 912 /*---------------------------------------------------------------------------- 913 | The pattern for a default generated double-precision NaN. 914 *----------------------------------------------------------------------------*/ 915 float64 float64_default_nan(float_status *status); 916 917 /*---------------------------------------------------------------------------- 918 | Software IEC/IEEE double-precision operations, rounding to single precision, 919 | returning a result in double precision, with only one rounding step. 920 *----------------------------------------------------------------------------*/ 921 922 float64 float64r32_add(float64, float64, float_status *status); 923 float64 float64r32_sub(float64, float64, float_status *status); 924 float64 float64r32_mul(float64, float64, float_status *status); 925 float64 float64r32_div(float64, float64, float_status *status); 926 float64 float64r32_muladd(float64, float64, float64, int, float_status *status); 927 float64 float64r32_sqrt(float64, float_status *status); 928 929 /*---------------------------------------------------------------------------- 930 | Software IEC/IEEE extended double-precision conversion routines. 931 *----------------------------------------------------------------------------*/ 932 int32_t floatx80_to_int32(floatx80, float_status *status); 933 int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status); 934 int64_t floatx80_to_int64(floatx80, float_status *status); 935 int64_t floatx80_to_int64_round_to_zero(floatx80, float_status *status); 936 float32 floatx80_to_float32(floatx80, float_status *status); 937 float64 floatx80_to_float64(floatx80, float_status *status); 938 float128 floatx80_to_float128(floatx80, float_status *status); 939 940 /*---------------------------------------------------------------------------- 941 | The pattern for an extended double-precision inf. 942 *----------------------------------------------------------------------------*/ 943 extern const floatx80 floatx80_infinity; 944 945 /*---------------------------------------------------------------------------- 946 | Software IEC/IEEE extended double-precision operations. 947 *----------------------------------------------------------------------------*/ 948 floatx80 floatx80_round(floatx80 a, float_status *status); 949 floatx80 floatx80_round_to_int(floatx80, float_status *status); 950 floatx80 floatx80_add(floatx80, floatx80, float_status *status); 951 floatx80 floatx80_sub(floatx80, floatx80, float_status *status); 952 floatx80 floatx80_mul(floatx80, floatx80, float_status *status); 953 floatx80 floatx80_div(floatx80, floatx80, float_status *status); 954 floatx80 floatx80_modrem(floatx80, floatx80, bool, uint64_t *, 955 float_status *status); 956 floatx80 floatx80_mod(floatx80, floatx80, float_status *status); 957 floatx80 floatx80_rem(floatx80, floatx80, float_status *status); 958 floatx80 floatx80_sqrt(floatx80, float_status *status); 959 FloatRelation floatx80_compare(floatx80, floatx80, float_status *status); 960 FloatRelation floatx80_compare_quiet(floatx80, floatx80, float_status *status); 961 int floatx80_is_quiet_nan(floatx80, float_status *status); 962 int floatx80_is_signaling_nan(floatx80, float_status *status); 963 floatx80 floatx80_silence_nan(floatx80, float_status *status); 964 floatx80 floatx80_scalbn(floatx80, int, float_status *status); 965 966 static inline floatx80 floatx80_abs(floatx80 a) 967 { 968 a.high &= 0x7fff; 969 return a; 970 } 971 972 static inline floatx80 floatx80_chs(floatx80 a) 973 { 974 a.high ^= 0x8000; 975 return a; 976 } 977 978 static inline bool floatx80_is_infinity(floatx80 a) 979 { 980 #if defined(TARGET_M68K) 981 return (a.high & 0x7fff) == floatx80_infinity.high && !(a.low << 1); 982 #else 983 return (a.high & 0x7fff) == floatx80_infinity.high && 984 a.low == floatx80_infinity.low; 985 #endif 986 } 987 988 static inline bool floatx80_is_neg(floatx80 a) 989 { 990 return a.high >> 15; 991 } 992 993 static inline bool floatx80_is_zero(floatx80 a) 994 { 995 return (a.high & 0x7fff) == 0 && a.low == 0; 996 } 997 998 static inline bool floatx80_is_zero_or_denormal(floatx80 a) 999 { 1000 return (a.high & 0x7fff) == 0; 1001 } 1002 1003 static inline bool floatx80_is_any_nan(floatx80 a) 1004 { 1005 return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1); 1006 } 1007 1008 static inline bool floatx80_eq(floatx80 a, floatx80 b, float_status *s) 1009 { 1010 return floatx80_compare(a, b, s) == float_relation_equal; 1011 } 1012 1013 static inline bool floatx80_le(floatx80 a, floatx80 b, float_status *s) 1014 { 1015 return floatx80_compare(a, b, s) <= float_relation_equal; 1016 } 1017 1018 static inline bool floatx80_lt(floatx80 a, floatx80 b, float_status *s) 1019 { 1020 return floatx80_compare(a, b, s) < float_relation_equal; 1021 } 1022 1023 static inline bool floatx80_unordered(floatx80 a, floatx80 b, float_status *s) 1024 { 1025 return floatx80_compare(a, b, s) == float_relation_unordered; 1026 } 1027 1028 static inline bool floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *s) 1029 { 1030 return floatx80_compare_quiet(a, b, s) == float_relation_equal; 1031 } 1032 1033 static inline bool floatx80_le_quiet(floatx80 a, floatx80 b, float_status *s) 1034 { 1035 return floatx80_compare_quiet(a, b, s) <= float_relation_equal; 1036 } 1037 1038 static inline bool floatx80_lt_quiet(floatx80 a, floatx80 b, float_status *s) 1039 { 1040 return floatx80_compare_quiet(a, b, s) < float_relation_equal; 1041 } 1042 1043 static inline bool floatx80_unordered_quiet(floatx80 a, floatx80 b, 1044 float_status *s) 1045 { 1046 return floatx80_compare_quiet(a, b, s) == float_relation_unordered; 1047 } 1048 1049 /*---------------------------------------------------------------------------- 1050 | Return whether the given value is an invalid floatx80 encoding. 1051 | Invalid floatx80 encodings arise when the integer bit is not set, but 1052 | the exponent is not zero. The only times the integer bit is permitted to 1053 | be zero is in subnormal numbers and the value zero. 1054 | This includes what the Intel software developer's manual calls pseudo-NaNs, 1055 | pseudo-infinities and un-normal numbers. It does not include 1056 | pseudo-denormals, which must still be correctly handled as inputs even 1057 | if they are never generated as outputs. 1058 *----------------------------------------------------------------------------*/ 1059 static inline bool floatx80_invalid_encoding(floatx80 a) 1060 { 1061 #if defined(TARGET_M68K) 1062 /*------------------------------------------------------------------------- 1063 | With m68k, the explicit integer bit can be zero in the case of: 1064 | - zeros (exp == 0, mantissa == 0) 1065 | - denormalized numbers (exp == 0, mantissa != 0) 1066 | - unnormalized numbers (exp != 0, exp < 0x7FFF) 1067 | - infinities (exp == 0x7FFF, mantissa == 0) 1068 | - not-a-numbers (exp == 0x7FFF, mantissa != 0) 1069 | 1070 | For infinities and NaNs, the explicit integer bit can be either one or 1071 | zero. 1072 | 1073 | The IEEE 754 standard does not define a zero integer bit. Such a number 1074 | is an unnormalized number. Hardware does not directly support 1075 | denormalized and unnormalized numbers, but implicitly supports them by 1076 | trapping them as unimplemented data types, allowing efficient conversion 1077 | in software. 1078 | 1079 | See "M68000 FAMILY PROGRAMMER’S REFERENCE MANUAL", 1080 | "1.6 FLOATING-POINT DATA TYPES" 1081 *------------------------------------------------------------------------*/ 1082 return false; 1083 #else 1084 return (a.low & (1ULL << 63)) == 0 && (a.high & 0x7FFF) != 0; 1085 #endif 1086 } 1087 1088 #define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL) 1089 #define floatx80_zero_init make_floatx80_init(0x0000, 0x0000000000000000LL) 1090 #define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL) 1091 #define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL) 1092 #define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL) 1093 #define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL) 1094 1095 /*---------------------------------------------------------------------------- 1096 | Returns the fraction bits of the extended double-precision floating-point 1097 | value `a'. 1098 *----------------------------------------------------------------------------*/ 1099 1100 static inline uint64_t extractFloatx80Frac(floatx80 a) 1101 { 1102 return a.low; 1103 } 1104 1105 /*---------------------------------------------------------------------------- 1106 | Returns the exponent bits of the extended double-precision floating-point 1107 | value `a'. 1108 *----------------------------------------------------------------------------*/ 1109 1110 static inline int32_t extractFloatx80Exp(floatx80 a) 1111 { 1112 return a.high & 0x7FFF; 1113 } 1114 1115 /*---------------------------------------------------------------------------- 1116 | Returns the sign bit of the extended double-precision floating-point value 1117 | `a'. 1118 *----------------------------------------------------------------------------*/ 1119 1120 static inline bool extractFloatx80Sign(floatx80 a) 1121 { 1122 return a.high >> 15; 1123 } 1124 1125 /*---------------------------------------------------------------------------- 1126 | Packs the sign `zSign', exponent `zExp', and significand `zSig' into an 1127 | extended double-precision floating-point value, returning the result. 1128 *----------------------------------------------------------------------------*/ 1129 1130 static inline floatx80 packFloatx80(bool zSign, int32_t zExp, uint64_t zSig) 1131 { 1132 floatx80 z; 1133 1134 z.low = zSig; 1135 z.high = (((uint16_t)zSign) << 15) + zExp; 1136 return z; 1137 } 1138 1139 /*---------------------------------------------------------------------------- 1140 | Normalizes the subnormal extended double-precision floating-point value 1141 | represented by the denormalized significand `aSig'. The normalized exponent 1142 | and significand are stored at the locations pointed to by `zExpPtr' and 1143 | `zSigPtr', respectively. 1144 *----------------------------------------------------------------------------*/ 1145 1146 void normalizeFloatx80Subnormal(uint64_t aSig, int32_t *zExpPtr, 1147 uint64_t *zSigPtr); 1148 1149 /*---------------------------------------------------------------------------- 1150 | Takes two extended double-precision floating-point values `a' and `b', one 1151 | of which is a NaN, and returns the appropriate NaN result. If either `a' or 1152 | `b' is a signaling NaN, the invalid exception is raised. 1153 *----------------------------------------------------------------------------*/ 1154 1155 floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b, float_status *status); 1156 1157 /*---------------------------------------------------------------------------- 1158 | Takes an abstract floating-point value having sign `zSign', exponent `zExp', 1159 | and extended significand formed by the concatenation of `zSig0' and `zSig1', 1160 | and returns the proper extended double-precision floating-point value 1161 | corresponding to the abstract input. Ordinarily, the abstract value is 1162 | rounded and packed into the extended double-precision format, with the 1163 | inexact exception raised if the abstract input cannot be represented 1164 | exactly. However, if the abstract value is too large, the overflow and 1165 | inexact exceptions are raised and an infinity or maximal finite value is 1166 | returned. If the abstract value is too small, the input value is rounded to 1167 | a subnormal number, and the underflow and inexact exceptions are raised if 1168 | the abstract input cannot be represented exactly as a subnormal extended 1169 | double-precision floating-point number. 1170 | If `roundingPrecision' is 32 or 64, the result is rounded to the same 1171 | number of bits as single or double precision, respectively. Otherwise, the 1172 | result is rounded to the full precision of the extended double-precision 1173 | format. 1174 | The input significand must be normalized or smaller. If the input 1175 | significand is not normalized, `zExp' must be 0; in that case, the result 1176 | returned is a subnormal number, and it must not require rounding. The 1177 | handling of underflow and overflow follows the IEC/IEEE Standard for Binary 1178 | Floating-Point Arithmetic. 1179 *----------------------------------------------------------------------------*/ 1180 1181 floatx80 roundAndPackFloatx80(FloatX80RoundPrec roundingPrecision, bool zSign, 1182 int32_t zExp, uint64_t zSig0, uint64_t zSig1, 1183 float_status *status); 1184 1185 /*---------------------------------------------------------------------------- 1186 | Takes an abstract floating-point value having sign `zSign', exponent 1187 | `zExp', and significand formed by the concatenation of `zSig0' and `zSig1', 1188 | and returns the proper extended double-precision floating-point value 1189 | corresponding to the abstract input. This routine is just like 1190 | `roundAndPackFloatx80' except that the input significand does not have to be 1191 | normalized. 1192 *----------------------------------------------------------------------------*/ 1193 1194 floatx80 normalizeRoundAndPackFloatx80(FloatX80RoundPrec roundingPrecision, 1195 bool zSign, int32_t zExp, 1196 uint64_t zSig0, uint64_t zSig1, 1197 float_status *status); 1198 1199 /*---------------------------------------------------------------------------- 1200 | The pattern for a default generated extended double-precision NaN. 1201 *----------------------------------------------------------------------------*/ 1202 floatx80 floatx80_default_nan(float_status *status); 1203 1204 /*---------------------------------------------------------------------------- 1205 | Software IEC/IEEE quadruple-precision conversion routines. 1206 *----------------------------------------------------------------------------*/ 1207 int32_t float128_to_int32(float128, float_status *status); 1208 int32_t float128_to_int32_round_to_zero(float128, float_status *status); 1209 int64_t float128_to_int64(float128, float_status *status); 1210 Int128 float128_to_int128(float128, float_status *status); 1211 int64_t float128_to_int64_round_to_zero(float128, float_status *status); 1212 Int128 float128_to_int128_round_to_zero(float128, float_status *status); 1213 uint64_t float128_to_uint64(float128, float_status *status); 1214 Int128 float128_to_uint128(float128, float_status *status); 1215 uint64_t float128_to_uint64_round_to_zero(float128, float_status *status); 1216 Int128 float128_to_uint128_round_to_zero(float128, float_status *status); 1217 uint32_t float128_to_uint32(float128, float_status *status); 1218 uint32_t float128_to_uint32_round_to_zero(float128, float_status *status); 1219 float32 float128_to_float32(float128, float_status *status); 1220 float64 float128_to_float64(float128, float_status *status); 1221 floatx80 float128_to_floatx80(float128, float_status *status); 1222 1223 /*---------------------------------------------------------------------------- 1224 | Software IEC/IEEE quadruple-precision operations. 1225 *----------------------------------------------------------------------------*/ 1226 float128 float128_round_to_int(float128, float_status *status); 1227 float128 float128_add(float128, float128, float_status *status); 1228 float128 float128_sub(float128, float128, float_status *status); 1229 float128 float128_mul(float128, float128, float_status *status); 1230 float128 float128_muladd(float128, float128, float128, int, 1231 float_status *status); 1232 float128 float128_div(float128, float128, float_status *status); 1233 float128 float128_rem(float128, float128, float_status *status); 1234 float128 float128_sqrt(float128, float_status *status); 1235 FloatRelation float128_compare(float128, float128, float_status *status); 1236 FloatRelation float128_compare_quiet(float128, float128, float_status *status); 1237 float128 float128_min(float128, float128, float_status *status); 1238 float128 float128_max(float128, float128, float_status *status); 1239 float128 float128_minnum(float128, float128, float_status *status); 1240 float128 float128_maxnum(float128, float128, float_status *status); 1241 float128 float128_minnummag(float128, float128, float_status *status); 1242 float128 float128_maxnummag(float128, float128, float_status *status); 1243 float128 float128_minimum_number(float128, float128, float_status *status); 1244 float128 float128_maximum_number(float128, float128, float_status *status); 1245 bool float128_is_quiet_nan(float128, float_status *status); 1246 bool float128_is_signaling_nan(float128, float_status *status); 1247 float128 float128_silence_nan(float128, float_status *status); 1248 float128 float128_scalbn(float128, int, float_status *status); 1249 1250 static inline float128 float128_abs(float128 a) 1251 { 1252 a.high &= 0x7fffffffffffffffLL; 1253 return a; 1254 } 1255 1256 static inline float128 float128_chs(float128 a) 1257 { 1258 a.high ^= 0x8000000000000000LL; 1259 return a; 1260 } 1261 1262 static inline bool float128_is_infinity(float128 a) 1263 { 1264 return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0; 1265 } 1266 1267 static inline bool float128_is_neg(float128 a) 1268 { 1269 return a.high >> 63; 1270 } 1271 1272 static inline bool float128_is_zero(float128 a) 1273 { 1274 return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0; 1275 } 1276 1277 static inline bool float128_is_zero_or_denormal(float128 a) 1278 { 1279 return (a.high & 0x7fff000000000000LL) == 0; 1280 } 1281 1282 static inline bool float128_is_normal(float128 a) 1283 { 1284 return (((a.high >> 48) + 1) & 0x7fff) >= 2; 1285 } 1286 1287 static inline bool float128_is_denormal(float128 a) 1288 { 1289 return float128_is_zero_or_denormal(a) && !float128_is_zero(a); 1290 } 1291 1292 static inline bool float128_is_any_nan(float128 a) 1293 { 1294 return ((a.high >> 48) & 0x7fff) == 0x7fff && 1295 ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0)); 1296 } 1297 1298 static inline bool float128_eq(float128 a, float128 b, float_status *s) 1299 { 1300 return float128_compare(a, b, s) == float_relation_equal; 1301 } 1302 1303 static inline bool float128_le(float128 a, float128 b, float_status *s) 1304 { 1305 return float128_compare(a, b, s) <= float_relation_equal; 1306 } 1307 1308 static inline bool float128_lt(float128 a, float128 b, float_status *s) 1309 { 1310 return float128_compare(a, b, s) < float_relation_equal; 1311 } 1312 1313 static inline bool float128_unordered(float128 a, float128 b, float_status *s) 1314 { 1315 return float128_compare(a, b, s) == float_relation_unordered; 1316 } 1317 1318 static inline bool float128_eq_quiet(float128 a, float128 b, float_status *s) 1319 { 1320 return float128_compare_quiet(a, b, s) == float_relation_equal; 1321 } 1322 1323 static inline bool float128_le_quiet(float128 a, float128 b, float_status *s) 1324 { 1325 return float128_compare_quiet(a, b, s) <= float_relation_equal; 1326 } 1327 1328 static inline bool float128_lt_quiet(float128 a, float128 b, float_status *s) 1329 { 1330 return float128_compare_quiet(a, b, s) < float_relation_equal; 1331 } 1332 1333 static inline bool float128_unordered_quiet(float128 a, float128 b, 1334 float_status *s) 1335 { 1336 return float128_compare_quiet(a, b, s) == float_relation_unordered; 1337 } 1338 1339 #define float128_zero make_float128(0, 0) 1340 1341 /*---------------------------------------------------------------------------- 1342 | The pattern for a default generated quadruple-precision NaN. 1343 *----------------------------------------------------------------------------*/ 1344 float128 float128_default_nan(float_status *status); 1345 1346 #endif /* SOFTFLOAT_H */ 1347