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