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