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