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