include/fpu/softfloat.h

   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 #define LIT64( a ) a##LL
  86
  87 /*----------------------------------------------------------------------------
  88 | Software IEC/IEEE floating-point ordering relations
  89 *----------------------------------------------------------------------------*/
  90 enum {
  91     float_relation_less      = -1,
  92     float_relation_equal     =  0,
  93     float_relation_greater   =  1,
  94     float_relation_unordered =  2
  95 };
  96
  97 #include "fpu/softfloat-types.h"
  98
  99 static inline void set_float_detect_tininess(int val, float_status *status)
 100 {
 101     status->float_detect_tininess = val;
 102 }
 103 static inline void set_float_rounding_mode(int val, float_status *status)
 104 {
 105     status->float_rounding_mode = val;
 106 }
 107 static inline void set_float_exception_flags(int val, float_status *status)
 108 {
 109     status->float_exception_flags = val;
 110 }
 111 static inline void set_floatx80_rounding_precision(int val,
 112                                                    float_status *status)
 113 {
 114     status->floatx80_rounding_precision = val;
 115 }
 116 static inline void set_flush_to_zero(flag val, float_status *status)
 117 {
 118     status->flush_to_zero = val;
 119 }
 120 static inline void set_flush_inputs_to_zero(flag val, float_status *status)
 121 {
 122     status->flush_inputs_to_zero = val;
 123 }
 124 static inline void set_default_nan_mode(flag val, float_status *status)
 125 {
 126     status->default_nan_mode = val;
 127 }
 128 static inline void set_snan_bit_is_one(flag val, float_status *status)
 129 {
 130     status->snan_bit_is_one = val;
 131 }
 132 static inline int get_float_detect_tininess(float_status *status)
 133 {
 134     return status->float_detect_tininess;
 135 }
 136 static inline int get_float_rounding_mode(float_status *status)
 137 {
 138     return status->float_rounding_mode;
 139 }
 140 static inline int get_float_exception_flags(float_status *status)
 141 {
 142     return status->float_exception_flags;
 143 }
 144 static inline int get_floatx80_rounding_precision(float_status *status)
 145 {
 146     return status->floatx80_rounding_precision;
 147 }
 148 static inline flag get_flush_to_zero(float_status *status)
 149 {
 150     return status->flush_to_zero;
 151 }
 152 static inline flag get_flush_inputs_to_zero(float_status *status)
 153 {
 154     return status->flush_inputs_to_zero;
 155 }
 156 static inline flag get_default_nan_mode(float_status *status)
 157 {
 158     return status->default_nan_mode;
 159 }
 160
 161 /*----------------------------------------------------------------------------
 162 | Routine to raise any or all of the software IEC/IEEE floating-point
 163 | exception flags.
 164 *----------------------------------------------------------------------------*/
 165 void float_raise(uint8_t flags, float_status *status);
 166
 167 /*----------------------------------------------------------------------------
 168 | If `a' is denormal and we are in flush-to-zero mode then set the
 169 | input-denormal exception and return zero. Otherwise just return the value.
 170 *----------------------------------------------------------------------------*/
 171 float16 float16_squash_input_denormal(float16 a, float_status *status);
 172 float32 float32_squash_input_denormal(float32 a, float_status *status);
 173 float64 float64_squash_input_denormal(float64 a, float_status *status);
 174
 175 /*----------------------------------------------------------------------------
 176 | Options to indicate which negations to perform in float*_muladd()
 177 | Using these differs from negating an input or output before calling
 178 | the muladd function in that this means that a NaN doesn't have its
 179 | sign bit inverted before it is propagated.
 180 | We also support halving the result before rounding, as a special
 181 | case to support the ARM fused-sqrt-step instruction FRSQRTS.
 182 *----------------------------------------------------------------------------*/
 183 enum {
 184     float_muladd_negate_c = 1,
 185     float_muladd_negate_product = 2,
 186     float_muladd_negate_result = 4,
 187     float_muladd_halve_result = 8,
 188 };
 189
 190 /*----------------------------------------------------------------------------
 191 | Software IEC/IEEE integer-to-floating-point conversion routines.
 192 *----------------------------------------------------------------------------*/
 193 float32 int32_to_float32(int32_t, float_status *status);
 194 float64 int32_to_float64(int32_t, float_status *status);
 195 float32 uint32_to_float32(uint32_t, float_status *status);
 196 float64 uint32_to_float64(uint32_t, float_status *status);
 197 floatx80 int32_to_floatx80(int32_t, float_status *status);
 198 float128 int32_to_float128(int32_t, float_status *status);
 199 float32 int64_to_float32(int64_t, float_status *status);
 200 float64 int64_to_float64(int64_t, float_status *status);
 201 floatx80 int64_to_floatx80(int64_t, float_status *status);
 202 float128 int64_to_float128(int64_t, float_status *status);
 203 float32 uint64_to_float32(uint64_t, float_status *status);
 204 float64 uint64_to_float64(uint64_t, float_status *status);
 205 float128 uint64_to_float128(uint64_t, float_status *status);
 206
 207 /* We provide the int16 versions for symmetry of API with float-to-int */
 208 static inline float32 int16_to_float32(int16_t v, float_status *status)
 209 {
 210     return int32_to_float32(v, status);
 211 }
 212
 213 static inline float32 uint16_to_float32(uint16_t v, float_status *status)
 214 {
 215     return uint32_to_float32(v, status);
 216 }
 217
 218 static inline float64 int16_to_float64(int16_t v, float_status *status)
 219 {
 220     return int32_to_float64(v, status);
 221 }
 222
 223 static inline float64 uint16_to_float64(uint16_t v, float_status *status)
 224 {
 225     return uint32_to_float64(v, status);
 226 }
 227
 228 /*----------------------------------------------------------------------------
 229 | Software half-precision conversion routines.
 230 *----------------------------------------------------------------------------*/
 231 float16 float32_to_float16(float32, flag, float_status *status);
 232 float32 float16_to_float32(float16, flag, float_status *status);
 233 float16 float64_to_float16(float64 a, flag ieee, float_status *status);
 234 float64 float16_to_float64(float16 a, flag ieee, float_status *status);
 235
 236 /*----------------------------------------------------------------------------
 237 | Software half-precision operations.
 238 *----------------------------------------------------------------------------*/
 239
 240 float16 float16_round_to_int(float16, float_status *status);
 241 float16 float16_add(float16, float16, float_status *status);
 242 float16 float16_sub(float16, float16, float_status *status);
 243 float16 float16_mul(float16, float16, float_status *status);
 244 float16 float16_muladd(float16, float16, float16, int, float_status *status);
 245 float16 float16_div(float16, float16, float_status *status);
 246
 247 int float16_is_quiet_nan(float16, float_status *status);
 248 int float16_is_signaling_nan(float16, float_status *status);
 249 float16 float16_maybe_silence_nan(float16, float_status *status);
 250
 251 static inline int float16_is_any_nan(float16 a)
 252 {
 253     return ((float16_val(a) & ~0x8000) > 0x7c00);
 254 }
 255
 256 static inline int float16_is_neg(float16 a)
 257 {
 258     return float16_val(a) >> 15;
 259 }
 260
 261 static inline int float16_is_infinity(float16 a)
 262 {
 263     return (float16_val(a) & 0x7fff) == 0x7c00;
 264 }
 265
 266 static inline int float16_is_zero(float16 a)
 267 {
 268     return (float16_val(a) & 0x7fff) == 0;
 269 }
 270
 271 static inline int float16_is_zero_or_denormal(float16 a)
 272 {
 273     return (float16_val(a) & 0x7c00) == 0;
 274 }
 275
 276 static inline float16 float16_abs(float16 a)
 277 {
 278     /* Note that abs does *not* handle NaN specially, nor does
 279      * it flush denormal inputs to zero.
 280      */
 281     return make_float16(float16_val(a) & 0x7fff);
 282 }
 283
 284 static inline float16 float16_chs(float16 a)
 285 {
 286     /* Note that chs does *not* handle NaN specially, nor does
 287      * it flush denormal inputs to zero.
 288      */
 289     return make_float16(float16_val(a) ^ 0x8000);
 290 }
 291
 292 static inline float16 float16_set_sign(float16 a, int sign)
 293 {
 294     return make_float16((float16_val(a) & 0x7fff) | (sign << 15));
 295 }
 296
 297 #define float16_zero make_float16(0)
 298 #define float16_one make_float16(0x3c00)
 299 #define float16_half make_float16(0x3800)
 300 #define float16_infinity make_float16(0x7c00)
 301
 302 /*----------------------------------------------------------------------------
 303 | The pattern for a default generated half-precision NaN.
 304 *----------------------------------------------------------------------------*/
 305 float16 float16_default_nan(float_status *status);
 306
 307 /*----------------------------------------------------------------------------
 308 | Software IEC/IEEE single-precision conversion routines.
 309 *----------------------------------------------------------------------------*/
 310 int16_t float32_to_int16(float32, float_status *status);
 311 uint16_t float32_to_uint16(float32, float_status *status);
 312 int16_t float32_to_int16_round_to_zero(float32, float_status *status);
 313 uint16_t float32_to_uint16_round_to_zero(float32, float_status *status);
 314 int32_t float32_to_int32(float32, float_status *status);
 315 int32_t float32_to_int32_round_to_zero(float32, float_status *status);
 316 uint32_t float32_to_uint32(float32, float_status *status);
 317 uint32_t float32_to_uint32_round_to_zero(float32, float_status *status);
 318 int64_t float32_to_int64(float32, float_status *status);
 319 uint64_t float32_to_uint64(float32, float_status *status);
 320 uint64_t float32_to_uint64_round_to_zero(float32, float_status *status);
 321 int64_t float32_to_int64_round_to_zero(float32, float_status *status);
 322 float64 float32_to_float64(float32, float_status *status);
 323 floatx80 float32_to_floatx80(float32, float_status *status);
 324 float128 float32_to_float128(float32, float_status *status);
 325
 326 /*----------------------------------------------------------------------------
 327 | Software IEC/IEEE single-precision operations.
 328 *----------------------------------------------------------------------------*/
 329 float32 float32_round_to_int(float32, float_status *status);
 330 float32 float32_add(float32, float32, float_status *status);
 331 float32 float32_sub(float32, float32, float_status *status);
 332 float32 float32_mul(float32, float32, float_status *status);
 333 float32 float32_div(float32, float32, float_status *status);
 334 float32 float32_rem(float32, float32, float_status *status);
 335 float32 float32_muladd(float32, float32, float32, int, float_status *status);
 336 float32 float32_sqrt(float32, float_status *status);
 337 float32 float32_exp2(float32, float_status *status);
 338 float32 float32_log2(float32, float_status *status);
 339 int float32_eq(float32, float32, float_status *status);
 340 int float32_le(float32, float32, float_status *status);
 341 int float32_lt(float32, float32, float_status *status);
 342 int float32_unordered(float32, float32, float_status *status);
 343 int float32_eq_quiet(float32, float32, float_status *status);
 344 int float32_le_quiet(float32, float32, float_status *status);
 345 int float32_lt_quiet(float32, float32, float_status *status);
 346 int float32_unordered_quiet(float32, float32, float_status *status);
 347 int float32_compare(float32, float32, float_status *status);
 348 int float32_compare_quiet(float32, float32, float_status *status);
 349 float32 float32_min(float32, float32, float_status *status);
 350 float32 float32_max(float32, float32, float_status *status);
 351 float32 float32_minnum(float32, float32, float_status *status);
 352 float32 float32_maxnum(float32, float32, float_status *status);
 353 float32 float32_minnummag(float32, float32, float_status *status);
 354 float32 float32_maxnummag(float32, float32, float_status *status);
 355 int float32_is_quiet_nan(float32, float_status *status);
 356 int float32_is_signaling_nan(float32, float_status *status);
 357 float32 float32_maybe_silence_nan(float32, float_status *status);
 358 float32 float32_scalbn(float32, int, float_status *status);
 359
 360 static inline float32 float32_abs(float32 a)
 361 {
 362     /* Note that abs does *not* handle NaN specially, nor does
 363      * it flush denormal inputs to zero.
 364      */
 365     return make_float32(float32_val(a) & 0x7fffffff);
 366 }
 367
 368 static inline float32 float32_chs(float32 a)
 369 {
 370     /* Note that chs does *not* handle NaN specially, nor does
 371      * it flush denormal inputs to zero.
 372      */
 373     return make_float32(float32_val(a) ^ 0x80000000);
 374 }
 375
 376 static inline int float32_is_infinity(float32 a)
 377 {
 378     return (float32_val(a) & 0x7fffffff) == 0x7f800000;
 379 }
 380
 381 static inline int float32_is_neg(float32 a)
 382 {
 383     return float32_val(a) >> 31;
 384 }
 385
 386 static inline int float32_is_zero(float32 a)
 387 {
 388     return (float32_val(a) & 0x7fffffff) == 0;
 389 }
 390
 391 static inline int float32_is_any_nan(float32 a)
 392 {
 393     return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL);
 394 }
 395
 396 static inline int float32_is_zero_or_denormal(float32 a)
 397 {
 398     return (float32_val(a) & 0x7f800000) == 0;
 399 }
 400
 401 static inline float32 float32_set_sign(float32 a, int sign)
 402 {
 403     return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31));
 404 }
 405
 406 #define float32_zero make_float32(0)
 407 #define float32_one make_float32(0x3f800000)
 408 #define float32_half make_float32(0x3f000000)
 409 #define float32_infinity make_float32(0x7f800000)
 410
 411
 412 /*----------------------------------------------------------------------------
 413 | The pattern for a default generated single-precision NaN.
 414 *----------------------------------------------------------------------------*/
 415 float32 float32_default_nan(float_status *status);
 416
 417 /*----------------------------------------------------------------------------
 418 | Software IEC/IEEE double-precision conversion routines.
 419 *----------------------------------------------------------------------------*/
 420 int16_t float64_to_int16(float64, float_status *status);
 421 uint16_t float64_to_uint16(float64, float_status *status);
 422 int16_t float64_to_int16_round_to_zero(float64, float_status *status);
 423 uint16_t float64_to_uint16_round_to_zero(float64, float_status *status);
 424 int32_t float64_to_int32(float64, float_status *status);
 425 int32_t float64_to_int32_round_to_zero(float64, float_status *status);
 426 uint32_t float64_to_uint32(float64, float_status *status);
 427 uint32_t float64_to_uint32_round_to_zero(float64, float_status *status);
 428 int64_t float64_to_int64(float64, float_status *status);
 429 int64_t float64_to_int64_round_to_zero(float64, float_status *status);
 430 uint64_t float64_to_uint64(float64 a, float_status *status);
 431 uint64_t float64_to_uint64_round_to_zero(float64 a, float_status *status);
 432 float32 float64_to_float32(float64, float_status *status);
 433 floatx80 float64_to_floatx80(float64, float_status *status);
 434 float128 float64_to_float128(float64, float_status *status);
 435
 436 /*----------------------------------------------------------------------------
 437 | Software IEC/IEEE double-precision operations.
 438 *----------------------------------------------------------------------------*/
 439 float64 float64_round_to_int(float64, float_status *status);
 440 float64 float64_trunc_to_int(float64, float_status *status);
 441 float64 float64_add(float64, float64, float_status *status);
 442 float64 float64_sub(float64, float64, float_status *status);
 443 float64 float64_mul(float64, float64, float_status *status);
 444 float64 float64_div(float64, float64, float_status *status);
 445 float64 float64_rem(float64, float64, float_status *status);
 446 float64 float64_muladd(float64, float64, float64, int, float_status *status);
 447 float64 float64_sqrt(float64, float_status *status);
 448 float64 float64_log2(float64, float_status *status);
 449 int float64_eq(float64, float64, float_status *status);
 450 int float64_le(float64, float64, float_status *status);
 451 int float64_lt(float64, float64, float_status *status);
 452 int float64_unordered(float64, float64, float_status *status);
 453 int float64_eq_quiet(float64, float64, float_status *status);
 454 int float64_le_quiet(float64, float64, float_status *status);
 455 int float64_lt_quiet(float64, float64, float_status *status);
 456 int float64_unordered_quiet(float64, float64, float_status *status);
 457 int float64_compare(float64, float64, float_status *status);
 458 int float64_compare_quiet(float64, float64, float_status *status);
 459 float64 float64_min(float64, float64, float_status *status);
 460 float64 float64_max(float64, float64, float_status *status);
 461 float64 float64_minnum(float64, float64, float_status *status);
 462 float64 float64_maxnum(float64, float64, float_status *status);
 463 float64 float64_minnummag(float64, float64, float_status *status);
 464 float64 float64_maxnummag(float64, float64, float_status *status);
 465 int float64_is_quiet_nan(float64 a, float_status *status);
 466 int float64_is_signaling_nan(float64, float_status *status);
 467 float64 float64_maybe_silence_nan(float64, float_status *status);
 468 float64 float64_scalbn(float64, int, float_status *status);
 469
 470 static inline float64 float64_abs(float64 a)
 471 {
 472     /* Note that abs does *not* handle NaN specially, nor does
 473      * it flush denormal inputs to zero.
 474      */
 475     return make_float64(float64_val(a) & 0x7fffffffffffffffLL);
 476 }
 477
 478 static inline float64 float64_chs(float64 a)
 479 {
 480     /* Note that chs does *not* handle NaN specially, nor does
 481      * it flush denormal inputs to zero.
 482      */
 483     return make_float64(float64_val(a) ^ 0x8000000000000000LL);
 484 }
 485
 486 static inline int float64_is_infinity(float64 a)
 487 {
 488     return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL;
 489 }
 490
 491 static inline int float64_is_neg(float64 a)
 492 {
 493     return float64_val(a) >> 63;
 494 }
 495
 496 static inline int float64_is_zero(float64 a)
 497 {
 498     return (float64_val(a) & 0x7fffffffffffffffLL) == 0;
 499 }
 500
 501 static inline int float64_is_any_nan(float64 a)
 502 {
 503     return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL);
 504 }
 505
 506 static inline int float64_is_zero_or_denormal(float64 a)
 507 {
 508     return (float64_val(a) & 0x7ff0000000000000LL) == 0;
 509 }
 510
 511 static inline float64 float64_set_sign(float64 a, int sign)
 512 {
 513     return make_float64((float64_val(a) & 0x7fffffffffffffffULL)
 514                         | ((int64_t)sign << 63));
 515 }
 516
 517 #define float64_zero make_float64(0)
 518 #define float64_one make_float64(0x3ff0000000000000LL)
 519 #define float64_ln2 make_float64(0x3fe62e42fefa39efLL)
 520 #define float64_half make_float64(0x3fe0000000000000LL)
 521 #define float64_infinity make_float64(0x7ff0000000000000LL)
 522
 523 /*----------------------------------------------------------------------------
 524 | The pattern for a default generated double-precision NaN.
 525 *----------------------------------------------------------------------------*/
 526 float64 float64_default_nan(float_status *status);
 527
 528 /*----------------------------------------------------------------------------
 529 | Software IEC/IEEE extended double-precision conversion routines.
 530 *----------------------------------------------------------------------------*/
 531 int32_t floatx80_to_int32(floatx80, float_status *status);
 532 int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status);
 533 int64_t floatx80_to_int64(floatx80, float_status *status);
 534 int64_t floatx80_to_int64_round_to_zero(floatx80, float_status *status);
 535 float32 floatx80_to_float32(floatx80, float_status *status);
 536 float64 floatx80_to_float64(floatx80, float_status *status);
 537 float128 floatx80_to_float128(floatx80, float_status *status);
 538
 539 /*----------------------------------------------------------------------------
 540 | Software IEC/IEEE extended double-precision operations.
 541 *----------------------------------------------------------------------------*/
 542 floatx80 floatx80_round(floatx80 a, float_status *status);
 543 floatx80 floatx80_round_to_int(floatx80, float_status *status);
 544 floatx80 floatx80_add(floatx80, floatx80, float_status *status);
 545 floatx80 floatx80_sub(floatx80, floatx80, float_status *status);
 546 floatx80 floatx80_mul(floatx80, floatx80, float_status *status);
 547 floatx80 floatx80_div(floatx80, floatx80, float_status *status);
 548 floatx80 floatx80_rem(floatx80, floatx80, float_status *status);
 549 floatx80 floatx80_sqrt(floatx80, float_status *status);
 550 int floatx80_eq(floatx80, floatx80, float_status *status);
 551 int floatx80_le(floatx80, floatx80, float_status *status);
 552 int floatx80_lt(floatx80, floatx80, float_status *status);
 553 int floatx80_unordered(floatx80, floatx80, float_status *status);
 554 int floatx80_eq_quiet(floatx80, floatx80, float_status *status);
 555 int floatx80_le_quiet(floatx80, floatx80, float_status *status);
 556 int floatx80_lt_quiet(floatx80, floatx80, float_status *status);
 557 int floatx80_unordered_quiet(floatx80, floatx80, float_status *status);
 558 int floatx80_compare(floatx80, floatx80, float_status *status);
 559 int floatx80_compare_quiet(floatx80, floatx80, float_status *status);
 560 int floatx80_is_quiet_nan(floatx80, float_status *status);
 561 int floatx80_is_signaling_nan(floatx80, float_status *status);
 562 floatx80 floatx80_maybe_silence_nan(floatx80, float_status *status);
 563 floatx80 floatx80_scalbn(floatx80, int, float_status *status);
 564
 565 static inline floatx80 floatx80_abs(floatx80 a)
 566 {
 567     a.high &= 0x7fff;
 568     return a;
 569 }
 570
 571 static inline floatx80 floatx80_chs(floatx80 a)
 572 {
 573     a.high ^= 0x8000;
 574     return a;
 575 }
 576
 577 static inline int floatx80_is_infinity(floatx80 a)
 578 {
 579     return (a.high & 0x7fff) == 0x7fff && a.low == 0x8000000000000000LL;
 580 }
 581
 582 static inline int floatx80_is_neg(floatx80 a)
 583 {
 584     return a.high >> 15;
 585 }
 586
 587 static inline int floatx80_is_zero(floatx80 a)
 588 {
 589     return (a.high & 0x7fff) == 0 && a.low == 0;
 590 }
 591
 592 static inline int floatx80_is_zero_or_denormal(floatx80 a)
 593 {
 594     return (a.high & 0x7fff) == 0;
 595 }
 596
 597 static inline int floatx80_is_any_nan(floatx80 a)
 598 {
 599     return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1);
 600 }
 601
 602 /*----------------------------------------------------------------------------
 603 | Return whether the given value is an invalid floatx80 encoding.
 604 | Invalid floatx80 encodings arise when the integer bit is not set, but
 605 | the exponent is not zero. The only times the integer bit is permitted to
 606 | be zero is in subnormal numbers and the value zero.
 607 | This includes what the Intel software developer's manual calls pseudo-NaNs,
 608 | pseudo-infinities and un-normal numbers. It does not include
 609 | pseudo-denormals, which must still be correctly handled as inputs even
 610 | if they are never generated as outputs.
 611 *----------------------------------------------------------------------------*/
 612 static inline bool floatx80_invalid_encoding(floatx80 a)
 613 {
 614     return (a.low & (1ULL << 63)) == 0 && (a.high & 0x7FFF) != 0;
 615 }
 616
 617 #define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL)
 618 #define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL)
 619 #define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL)
 620 #define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL)
 621 #define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL)
 622 #define floatx80_infinity make_floatx80(0x7fff, 0x8000000000000000LL)
 623
 624 /*----------------------------------------------------------------------------
 625 | The pattern for a default generated extended double-precision NaN.
 626 *----------------------------------------------------------------------------*/
 627 floatx80 floatx80_default_nan(float_status *status);
 628
 629 /*----------------------------------------------------------------------------
 630 | Software IEC/IEEE quadruple-precision conversion routines.
 631 *----------------------------------------------------------------------------*/
 632 int32_t float128_to_int32(float128, float_status *status);
 633 int32_t float128_to_int32_round_to_zero(float128, float_status *status);
 634 int64_t float128_to_int64(float128, float_status *status);
 635 int64_t float128_to_int64_round_to_zero(float128, float_status *status);
 636 uint64_t float128_to_uint64(float128, float_status *status);
 637 uint64_t float128_to_uint64_round_to_zero(float128, float_status *status);
 638 uint32_t float128_to_uint32_round_to_zero(float128, float_status *status);
 639 float32 float128_to_float32(float128, float_status *status);
 640 float64 float128_to_float64(float128, float_status *status);
 641 floatx80 float128_to_floatx80(float128, float_status *status);
 642
 643 /*----------------------------------------------------------------------------
 644 | Software IEC/IEEE quadruple-precision operations.
 645 *----------------------------------------------------------------------------*/
 646 float128 float128_round_to_int(float128, float_status *status);
 647 float128 float128_add(float128, float128, float_status *status);
 648 float128 float128_sub(float128, float128, float_status *status);
 649 float128 float128_mul(float128, float128, float_status *status);
 650 float128 float128_div(float128, float128, float_status *status);
 651 float128 float128_rem(float128, float128, float_status *status);
 652 float128 float128_sqrt(float128, float_status *status);
 653 int float128_eq(float128, float128, float_status *status);
 654 int float128_le(float128, float128, float_status *status);
 655 int float128_lt(float128, float128, float_status *status);
 656 int float128_unordered(float128, float128, float_status *status);
 657 int float128_eq_quiet(float128, float128, float_status *status);
 658 int float128_le_quiet(float128, float128, float_status *status);
 659 int float128_lt_quiet(float128, float128, float_status *status);
 660 int float128_unordered_quiet(float128, float128, float_status *status);
 661 int float128_compare(float128, float128, float_status *status);
 662 int float128_compare_quiet(float128, float128, float_status *status);
 663 int float128_is_quiet_nan(float128, float_status *status);
 664 int float128_is_signaling_nan(float128, float_status *status);
 665 float128 float128_maybe_silence_nan(float128, float_status *status);
 666 float128 float128_scalbn(float128, int, float_status *status);
 667
 668 static inline float128 float128_abs(float128 a)
 669 {
 670     a.high &= 0x7fffffffffffffffLL;
 671     return a;
 672 }
 673
 674 static inline float128 float128_chs(float128 a)
 675 {
 676     a.high ^= 0x8000000000000000LL;
 677     return a;
 678 }
 679
 680 static inline int float128_is_infinity(float128 a)
 681 {
 682     return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0;
 683 }
 684
 685 static inline int float128_is_neg(float128 a)
 686 {
 687     return a.high >> 63;
 688 }
 689
 690 static inline int float128_is_zero(float128 a)
 691 {
 692     return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0;
 693 }
 694
 695 static inline int float128_is_zero_or_denormal(float128 a)
 696 {
 697     return (a.high & 0x7fff000000000000LL) == 0;
 698 }
 699
 700 static inline int float128_is_any_nan(float128 a)
 701 {
 702     return ((a.high >> 48) & 0x7fff) == 0x7fff &&
 703         ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));
 704 }
 705
 706 #define float128_zero make_float128(0, 0)
 707
 708 /*----------------------------------------------------------------------------
 709 | The pattern for a default generated quadruple-precision NaN.
 710 *----------------------------------------------------------------------------*/
 711 float128 float128_default_nan(float_status *status);
 712
 713 #endif /* SOFTFLOAT_H */