Lines Matching +full:- +full:a +full:-
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
9 * the SoftFloat-2a license
11 * GPL-v2-or-later
14 * taken to be licensed under the Softfloat-2a license unless specifically
20 This C header file is part of the SoftFloat IEC/IEEE Floating-point
21 Arithmetic Package, Release 2a.
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
67 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
79 * version 2 or later. See the COPYING file in the top-level directory.
85 /*----------------------------------------------------------------------------
86 | Software IEC/IEEE floating-point ordering relations
87 *----------------------------------------------------------------------------*/
90 float_relation_less = -1,
96 #include "fpu/softfloat-types.h"
97 #include "fpu/softfloat-helpers.h"
100 /*----------------------------------------------------------------------------
101 | Routine to raise any or all of the software IEC/IEEE floating-point
103 *----------------------------------------------------------------------------*/
106 status->float_exception_flags |= flags; in float_raise()
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);
118 /*----------------------------------------------------------------------------
121 | the muladd function in that this means that a NaN doesn't have its
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 *----------------------------------------------------------------------------*/
135 /*----------------------------------------------------------------------------
136 | Software IEC/IEEE integer-to-floating-point conversion routines.
137 *----------------------------------------------------------------------------*/
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);
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);
192 /*----------------------------------------------------------------------------
193 | Software half-precision conversion routines.
194 *----------------------------------------------------------------------------*/
198 float16 float64_to_float16(float64 a, bool ieee, float_status *status);
199 float64 float16_to_float64(float16 a, bool ieee, float_status *status);
216 uint8_t float16_to_uint8_scalbn(float16 a, FloatRoundMode,
218 uint16_t float16_to_uint16_scalbn(float16 a, FloatRoundMode,
220 uint32_t float16_to_uint32_scalbn(float16 a, FloatRoundMode,
222 uint64_t float16_to_uint64_scalbn(float16 a, FloatRoundMode,
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);
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);
234 /*----------------------------------------------------------------------------
235 | Software half-precision operations.
236 *----------------------------------------------------------------------------*/
263 static inline bool float16_is_any_nan(float16 a) in float16_is_any_nan() argument
265 return ((float16_val(a) & ~0x8000) > 0x7c00); in float16_is_any_nan()
268 static inline bool float16_is_neg(float16 a) in float16_is_neg() argument
270 return float16_val(a) >> 15; in float16_is_neg()
273 static inline bool float16_is_infinity(float16 a) in float16_is_infinity() argument
275 return (float16_val(a) & 0x7fff) == 0x7c00; in float16_is_infinity()
278 static inline bool float16_is_zero(float16 a) in float16_is_zero() argument
280 return (float16_val(a) & 0x7fff) == 0; in float16_is_zero()
283 static inline bool float16_is_zero_or_denormal(float16 a) in float16_is_zero_or_denormal() argument
285 return (float16_val(a) & 0x7c00) == 0; in float16_is_zero_or_denormal()
288 static inline bool float16_is_normal(float16 a) in float16_is_normal() argument
290 return (((float16_val(a) >> 10) + 1) & 0x1f) >= 2; in float16_is_normal()
293 static inline float16 float16_abs(float16 a) in float16_abs() argument
298 return make_float16(float16_val(a) & 0x7fff); in float16_abs()
301 static inline float16 float16_chs(float16 a) in float16_chs() argument
306 return make_float16(float16_val(a) ^ 0x8000); in float16_chs()
309 static inline float16 float16_set_sign(float16 a, int sign) in float16_set_sign() argument
311 return make_float16((float16_val(a) & 0x7fff) | (sign << 15)); in float16_set_sign()
314 static inline bool float16_eq(float16 a, float16 b, float_status *s) in float16_eq() argument
316 return float16_compare(a, b, s) == float_relation_equal; in float16_eq()
319 static inline bool float16_le(float16 a, float16 b, float_status *s) in float16_le() argument
321 return float16_compare(a, b, s) <= float_relation_equal; in float16_le()
324 static inline bool float16_lt(float16 a, float16 b, float_status *s) in float16_lt() argument
326 return float16_compare(a, b, s) < float_relation_equal; in float16_lt()
329 static inline bool float16_unordered(float16 a, float16 b, float_status *s) in float16_unordered() argument
331 return float16_compare(a, b, s) == float_relation_unordered; in float16_unordered()
334 static inline bool float16_eq_quiet(float16 a, float16 b, float_status *s) in float16_eq_quiet() argument
336 return float16_compare_quiet(a, b, s) == float_relation_equal; in float16_eq_quiet()
339 static inline bool float16_le_quiet(float16 a, float16 b, float_status *s) in float16_le_quiet() argument
341 return float16_compare_quiet(a, b, s) <= float_relation_equal; in float16_le_quiet()
344 static inline bool float16_lt_quiet(float16 a, float16 b, float_status *s) in float16_lt_quiet() argument
346 return float16_compare_quiet(a, b, s) < float_relation_equal; in float16_lt_quiet()
349 static inline bool float16_unordered_quiet(float16 a, float16 b, in float16_unordered_quiet() argument
352 return float16_compare_quiet(a, b, s) == float_relation_unordered; in float16_unordered_quiet()
363 /*----------------------------------------------------------------------------
365 *----------------------------------------------------------------------------*/
370 bfloat16 float64_to_bfloat16(float64 a, float_status *status);
371 float64 bfloat16_to_float64(bfloat16 a, float_status *status);
392 uint8_t bfloat16_to_uint8_scalbn(bfloat16 a, FloatRoundMode,
394 uint16_t bfloat16_to_uint16_scalbn(bfloat16 a, FloatRoundMode,
396 uint32_t bfloat16_to_uint32_scalbn(bfloat16 a, FloatRoundMode,
398 uint64_t bfloat16_to_uint64_scalbn(bfloat16 a, FloatRoundMode,
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);
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);
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);
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);
429 /*----------------------------------------------------------------------------
431 *----------------------------------------------------------------------------*/
457 static inline bool bfloat16_is_any_nan(bfloat16 a) in bfloat16_is_any_nan() argument
459 return ((a & ~0x8000) > 0x7F80); in bfloat16_is_any_nan()
462 static inline bool bfloat16_is_neg(bfloat16 a) in bfloat16_is_neg() argument
464 return a >> 15; in bfloat16_is_neg()
467 static inline bool bfloat16_is_infinity(bfloat16 a) in bfloat16_is_infinity() argument
469 return (a & 0x7fff) == 0x7F80; in bfloat16_is_infinity()
472 static inline bool bfloat16_is_zero(bfloat16 a) in bfloat16_is_zero() argument
474 return (a & 0x7fff) == 0; in bfloat16_is_zero()
477 static inline bool bfloat16_is_zero_or_denormal(bfloat16 a) in bfloat16_is_zero_or_denormal() argument
479 return (a & 0x7F80) == 0; in bfloat16_is_zero_or_denormal()
482 static inline bool bfloat16_is_normal(bfloat16 a) in bfloat16_is_normal() argument
484 return (((a >> 7) + 1) & 0xff) >= 2; in bfloat16_is_normal()
487 static inline bfloat16 bfloat16_abs(bfloat16 a) in bfloat16_abs() argument
492 return a & 0x7fff; in bfloat16_abs()
495 static inline bfloat16 bfloat16_chs(bfloat16 a) in bfloat16_chs() argument
500 return a ^ 0x8000; in bfloat16_chs()
503 static inline bfloat16 bfloat16_set_sign(bfloat16 a, int sign) in bfloat16_set_sign() argument
505 return (a & 0x7fff) | (sign << 15); in bfloat16_set_sign()
508 static inline bool bfloat16_eq(bfloat16 a, bfloat16 b, float_status *s) in bfloat16_eq() argument
510 return bfloat16_compare(a, b, s) == float_relation_equal; in bfloat16_eq()
513 static inline bool bfloat16_le(bfloat16 a, bfloat16 b, float_status *s) in bfloat16_le() argument
515 return bfloat16_compare(a, b, s) <= float_relation_equal; in bfloat16_le()
518 static inline bool bfloat16_lt(bfloat16 a, bfloat16 b, float_status *s) in bfloat16_lt() argument
520 return bfloat16_compare(a, b, s) < float_relation_equal; in bfloat16_lt()
523 static inline bool bfloat16_unordered(bfloat16 a, bfloat16 b, float_status *s) in bfloat16_unordered() argument
525 return bfloat16_compare(a, b, s) == float_relation_unordered; in bfloat16_unordered()
528 static inline bool bfloat16_eq_quiet(bfloat16 a, bfloat16 b, float_status *s) in bfloat16_eq_quiet() argument
530 return bfloat16_compare_quiet(a, b, s) == float_relation_equal; in bfloat16_eq_quiet()
533 static inline bool bfloat16_le_quiet(bfloat16 a, bfloat16 b, float_status *s) in bfloat16_le_quiet() argument
535 return bfloat16_compare_quiet(a, b, s) <= float_relation_equal; in bfloat16_le_quiet()
538 static inline bool bfloat16_lt_quiet(bfloat16 a, bfloat16 b, float_status *s) in bfloat16_lt_quiet() argument
540 return bfloat16_compare_quiet(a, b, s) < float_relation_equal; in bfloat16_lt_quiet()
543 static inline bool bfloat16_unordered_quiet(bfloat16 a, bfloat16 b, in bfloat16_unordered_quiet() argument
546 return bfloat16_compare_quiet(a, b, s) == float_relation_unordered; in bfloat16_unordered_quiet()
557 /*----------------------------------------------------------------------------
558 | The pattern for a default generated half-precision NaN.
559 *----------------------------------------------------------------------------*/
562 /*----------------------------------------------------------------------------
563 | Software IEC/IEEE single-precision conversion routines.
564 *----------------------------------------------------------------------------*/
594 /*----------------------------------------------------------------------------
595 | Software IEC/IEEE single-precision operations.
596 *----------------------------------------------------------------------------*/
624 static inline float32 float32_abs(float32 a) in float32_abs() argument
629 return make_float32(float32_val(a) & 0x7fffffff); in float32_abs()
632 static inline float32 float32_chs(float32 a) in float32_chs() argument
637 return make_float32(float32_val(a) ^ 0x80000000); in float32_chs()
640 static inline bool float32_is_infinity(float32 a) in float32_is_infinity() argument
642 return (float32_val(a) & 0x7fffffff) == 0x7f800000; in float32_is_infinity()
645 static inline bool float32_is_neg(float32 a) in float32_is_neg() argument
647 return float32_val(a) >> 31; in float32_is_neg()
650 static inline bool float32_is_zero(float32 a) in float32_is_zero() argument
652 return (float32_val(a) & 0x7fffffff) == 0; in float32_is_zero()
655 static inline bool float32_is_any_nan(float32 a) in float32_is_any_nan() argument
657 return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL); in float32_is_any_nan()
660 static inline bool float32_is_zero_or_denormal(float32 a) in float32_is_zero_or_denormal() argument
662 return (float32_val(a) & 0x7f800000) == 0; in float32_is_zero_or_denormal()
665 static inline bool float32_is_normal(float32 a) in float32_is_normal() argument
667 return (((float32_val(a) >> 23) + 1) & 0xff) >= 2; in float32_is_normal()
670 static inline bool float32_is_denormal(float32 a) in float32_is_denormal() argument
672 return float32_is_zero_or_denormal(a) && !float32_is_zero(a); in float32_is_denormal()
675 static inline bool float32_is_zero_or_normal(float32 a) in float32_is_zero_or_normal() argument
677 return float32_is_normal(a) || float32_is_zero(a); in float32_is_zero_or_normal()
680 static inline float32 float32_set_sign(float32 a, int sign) in float32_set_sign() argument
682 return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31)); in float32_set_sign()
685 static inline bool float32_eq(float32 a, float32 b, float_status *s) in float32_eq() argument
687 return float32_compare(a, b, s) == float_relation_equal; in float32_eq()
690 static inline bool float32_le(float32 a, float32 b, float_status *s) in float32_le() argument
692 return float32_compare(a, b, s) <= float_relation_equal; in float32_le()
695 static inline bool float32_lt(float32 a, float32 b, float_status *s) in float32_lt() argument
697 return float32_compare(a, b, s) < float_relation_equal; in float32_lt()
700 static inline bool float32_unordered(float32 a, float32 b, float_status *s) in float32_unordered() argument
702 return float32_compare(a, b, s) == float_relation_unordered; in float32_unordered()
705 static inline bool float32_eq_quiet(float32 a, float32 b, float_status *s) in float32_eq_quiet() argument
707 return float32_compare_quiet(a, b, s) == float_relation_equal; in float32_eq_quiet()
710 static inline bool float32_le_quiet(float32 a, float32 b, float_status *s) in float32_le_quiet() argument
712 return float32_compare_quiet(a, b, s) <= float_relation_equal; in float32_le_quiet()
715 static inline bool float32_lt_quiet(float32 a, float32 b, float_status *s) in float32_lt_quiet() argument
717 return float32_compare_quiet(a, b, s) < float_relation_equal; in float32_lt_quiet()
720 static inline bool float32_unordered_quiet(float32 a, float32 b, in float32_unordered_quiet() argument
723 return float32_compare_quiet(a, b, s) == float_relation_unordered; in float32_unordered_quiet()
734 /*----------------------------------------------------------------------------
735 | Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
736 | single-precision floating-point value, returning the result. After being
739 | will be added into the exponent. Since a properly normalized significand
741 | than the desired result exponent whenever `zSig' is a complete, normalized
743 *----------------------------------------------------------------------------*/
751 /*----------------------------------------------------------------------------
752 | The pattern for a default generated single-precision NaN.
753 *----------------------------------------------------------------------------*/
756 /*----------------------------------------------------------------------------
757 | Software IEC/IEEE double-precision conversion routines.
758 *----------------------------------------------------------------------------*/
791 /*----------------------------------------------------------------------------
792 | Software IEC/IEEE double-precision operations.
793 *----------------------------------------------------------------------------*/
815 bool float64_is_quiet_nan(float64 a, float_status *status);
820 static inline float64 float64_abs(float64 a) in float64_abs() argument
825 return make_float64(float64_val(a) & 0x7fffffffffffffffLL); in float64_abs()
828 static inline float64 float64_chs(float64 a) in float64_chs() argument
833 return make_float64(float64_val(a) ^ 0x8000000000000000LL); in float64_chs()
836 static inline bool float64_is_infinity(float64 a) in float64_is_infinity() argument
838 return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL; in float64_is_infinity()
841 static inline bool float64_is_neg(float64 a) in float64_is_neg() argument
843 return float64_val(a) >> 63; in float64_is_neg()
846 static inline bool float64_is_zero(float64 a) in float64_is_zero() argument
848 return (float64_val(a) & 0x7fffffffffffffffLL) == 0; in float64_is_zero()
851 static inline bool float64_is_any_nan(float64 a) in float64_is_any_nan() argument
853 return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL); in float64_is_any_nan()
856 static inline bool float64_is_zero_or_denormal(float64 a) in float64_is_zero_or_denormal() argument
858 return (float64_val(a) & 0x7ff0000000000000LL) == 0; in float64_is_zero_or_denormal()
861 static inline bool float64_is_normal(float64 a) in float64_is_normal() argument
863 return (((float64_val(a) >> 52) + 1) & 0x7ff) >= 2; in float64_is_normal()
866 static inline bool float64_is_denormal(float64 a) in float64_is_denormal() argument
868 return float64_is_zero_or_denormal(a) && !float64_is_zero(a); in float64_is_denormal()
871 static inline bool float64_is_zero_or_normal(float64 a) in float64_is_zero_or_normal() argument
873 return float64_is_normal(a) || float64_is_zero(a); in float64_is_zero_or_normal()
876 static inline float64 float64_set_sign(float64 a, int sign) in float64_set_sign() argument
878 return make_float64((float64_val(a) & 0x7fffffffffffffffULL) in float64_set_sign()
882 static inline bool float64_eq(float64 a, float64 b, float_status *s) in float64_eq() argument
884 return float64_compare(a, b, s) == float_relation_equal; in float64_eq()
887 static inline bool float64_le(float64 a, float64 b, float_status *s) in float64_le() argument
889 return float64_compare(a, b, s) <= float_relation_equal; in float64_le()
892 static inline bool float64_lt(float64 a, float64 b, float_status *s) in float64_lt() argument
894 return float64_compare(a, b, s) < float_relation_equal; in float64_lt()
897 static inline bool float64_unordered(float64 a, float64 b, float_status *s) in float64_unordered() argument
899 return float64_compare(a, b, s) == float_relation_unordered; in float64_unordered()
902 static inline bool float64_eq_quiet(float64 a, float64 b, float_status *s) in float64_eq_quiet() argument
904 return float64_compare_quiet(a, b, s) == float_relation_equal; in float64_eq_quiet()
907 static inline bool float64_le_quiet(float64 a, float64 b, float_status *s) in float64_le_quiet() argument
909 return float64_compare_quiet(a, b, s) <= float_relation_equal; in float64_le_quiet()
912 static inline bool float64_lt_quiet(float64 a, float64 b, float_status *s) in float64_lt_quiet() argument
914 return float64_compare_quiet(a, b, s) < float_relation_equal; in float64_lt_quiet()
917 static inline bool float64_unordered_quiet(float64 a, float64 b, in float64_unordered_quiet() argument
920 return float64_compare_quiet(a, b, s) == float_relation_unordered; in float64_unordered_quiet()
932 /*----------------------------------------------------------------------------
933 | The pattern for a default generated double-precision NaN.
934 *----------------------------------------------------------------------------*/
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 *----------------------------------------------------------------------------*/
949 /*----------------------------------------------------------------------------
950 | Software IEC/IEEE extended double-precision conversion routines.
951 *----------------------------------------------------------------------------*/
960 /*----------------------------------------------------------------------------
961 | The pattern for an extended double-precision inf.
962 *----------------------------------------------------------------------------*/
965 /*----------------------------------------------------------------------------
966 | Software IEC/IEEE extended double-precision operations.
967 *----------------------------------------------------------------------------*/
968 floatx80 floatx80_round(floatx80 a, float_status *status);
986 static inline floatx80 floatx80_abs(floatx80 a) in floatx80_abs() argument
988 a.high &= 0x7fff; in floatx80_abs()
989 return a; in floatx80_abs()
992 static inline floatx80 floatx80_chs(floatx80 a) in floatx80_chs() argument
994 a.high ^= 0x8000; in floatx80_chs()
995 return a; in floatx80_chs()
998 static inline bool floatx80_is_infinity(floatx80 a, float_status *status) in floatx80_is_infinity() argument
1001 * It's target-specific whether the Integer bit is permitted in floatx80_is_infinity()
1002 * to be 0 in a valid Infinity value. (x86 says no, m68k says yes). in floatx80_is_infinity()
1004 bool intbit = a.low >> 63; in floatx80_is_infinity()
1007 !(status->floatx80_behaviour & floatx80_pseudo_inf_valid)) { in floatx80_is_infinity()
1010 return (a.high & 0x7fff) == 0x7fff && !(a.low << 1); in floatx80_is_infinity()
1013 static inline bool floatx80_is_neg(floatx80 a) in floatx80_is_neg() argument
1015 return a.high >> 15; in floatx80_is_neg()
1018 static inline bool floatx80_is_zero(floatx80 a) in floatx80_is_zero() argument
1020 return (a.high & 0x7fff) == 0 && a.low == 0; in floatx80_is_zero()
1023 static inline bool floatx80_is_zero_or_denormal(floatx80 a) in floatx80_is_zero_or_denormal() argument
1025 return (a.high & 0x7fff) == 0; in floatx80_is_zero_or_denormal()
1028 static inline bool floatx80_is_any_nan(floatx80 a) in floatx80_is_any_nan() argument
1030 return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1); in floatx80_is_any_nan()
1033 static inline bool floatx80_eq(floatx80 a, floatx80 b, float_status *s) in floatx80_eq() argument
1035 return floatx80_compare(a, b, s) == float_relation_equal; in floatx80_eq()
1038 static inline bool floatx80_le(floatx80 a, floatx80 b, float_status *s) in floatx80_le() argument
1040 return floatx80_compare(a, b, s) <= float_relation_equal; in floatx80_le()
1043 static inline bool floatx80_lt(floatx80 a, floatx80 b, float_status *s) in floatx80_lt() argument
1045 return floatx80_compare(a, b, s) < float_relation_equal; in floatx80_lt()
1048 static inline bool floatx80_unordered(floatx80 a, floatx80 b, float_status *s) in floatx80_unordered() argument
1050 return floatx80_compare(a, b, s) == float_relation_unordered; in floatx80_unordered()
1053 static inline bool floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *s) in floatx80_eq_quiet() argument
1055 return floatx80_compare_quiet(a, b, s) == float_relation_equal; in floatx80_eq_quiet()
1058 static inline bool floatx80_le_quiet(floatx80 a, floatx80 b, float_status *s) in floatx80_le_quiet() argument
1060 return floatx80_compare_quiet(a, b, s) <= float_relation_equal; in floatx80_le_quiet()
1063 static inline bool floatx80_lt_quiet(floatx80 a, floatx80 b, float_status *s) in floatx80_lt_quiet() argument
1065 return floatx80_compare_quiet(a, b, s) < float_relation_equal; in floatx80_lt_quiet()
1068 static inline bool floatx80_unordered_quiet(floatx80 a, floatx80 b, in floatx80_unordered_quiet() argument
1071 return floatx80_compare_quiet(a, b, s) == float_relation_unordered; in floatx80_unordered_quiet()
1074 /*----------------------------------------------------------------------------
1077 | correctly; this is target-specific. In Intel terminology the
1081 | exp == 0, int = 1 : pseudo-denormals
1084 | exp == 0x7fff, int = 0, mantissa == 0 : pseudo-infinities
1086 | exp == 0x7fff, int = 0, mantissa != 0 : pseudo-NaNs
1090 | x87 permits as input also pseudo-denormals.
1091 | m68k permits all those and also pseudo-infinities, pseudo-NaNs and unnormals.
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
1098 *----------------------------------------------------------------------------*/
1099 static inline bool floatx80_invalid_encoding(floatx80 a, float_status *s) in floatx80_invalid_encoding() argument
1101 if ((a.low >> 63) || (a.high & 0x7fff) == 0) { in floatx80_invalid_encoding()
1106 if ((a.high & 0x7fff) == 0x7fff) { in floatx80_invalid_encoding()
1107 if (a.low) { in floatx80_invalid_encoding()
1108 return !(s->floatx80_behaviour & floatx80_pseudo_nan_valid); in floatx80_invalid_encoding()
1110 return !(s->floatx80_behaviour & floatx80_pseudo_inf_valid); in floatx80_invalid_encoding()
1113 return !(s->floatx80_behaviour & floatx80_unnormal_valid); in floatx80_invalid_encoding()
1124 /*----------------------------------------------------------------------------
1125 | Returns the fraction bits of the extended double-precision floating-point
1126 | value `a'.
1127 *----------------------------------------------------------------------------*/
1129 static inline uint64_t extractFloatx80Frac(floatx80 a) in extractFloatx80Frac() argument
1131 return a.low; in extractFloatx80Frac()
1134 /*----------------------------------------------------------------------------
1135 | Returns the exponent bits of the extended double-precision floating-point
1136 | value `a'.
1137 *----------------------------------------------------------------------------*/
1139 static inline int32_t extractFloatx80Exp(floatx80 a) in extractFloatx80Exp() argument
1141 return a.high & 0x7FFF; in extractFloatx80Exp()
1144 /*----------------------------------------------------------------------------
1145 | Returns the sign bit of the extended double-precision floating-point value
1146 | `a'.
1147 *----------------------------------------------------------------------------*/
1149 static inline bool extractFloatx80Sign(floatx80 a) in extractFloatx80Sign() argument
1151 return a.high >> 15; in extractFloatx80Sign()
1154 /*----------------------------------------------------------------------------
1156 | extended double-precision floating-point value, returning the result.
1157 *----------------------------------------------------------------------------*/
1168 /*----------------------------------------------------------------------------
1169 | Normalizes the subnormal extended double-precision floating-point value
1173 *----------------------------------------------------------------------------*/
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 *----------------------------------------------------------------------------*/
1184 floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b, float_status *status);
1186 /*----------------------------------------------------------------------------
1187 | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
1189 | and returns the proper extended double-precision floating-point value
1191 | rounded and packed into the extended double-precision format, with the
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.
1201 | result is rounded to the full precision of the extended double-precision
1205 | returned is a subnormal number, and it must not require rounding. The
1207 | Floating-Point Arithmetic.
1208 *----------------------------------------------------------------------------*/
1214 /*----------------------------------------------------------------------------
1215 | Takes an abstract floating-point value having sign `zSign', exponent
1217 | and returns the proper extended double-precision floating-point value
1221 *----------------------------------------------------------------------------*/
1228 /*----------------------------------------------------------------------------
1229 | The pattern for a default generated extended double-precision NaN.
1230 *----------------------------------------------------------------------------*/
1233 /*----------------------------------------------------------------------------
1234 | Software IEC/IEEE quadruple-precision conversion routines.
1235 *----------------------------------------------------------------------------*/
1252 /*----------------------------------------------------------------------------
1253 | Software IEC/IEEE quadruple-precision operations.
1254 *----------------------------------------------------------------------------*/
1279 static inline float128 float128_abs(float128 a) in float128_abs() argument
1281 a.high &= 0x7fffffffffffffffLL; in float128_abs()
1282 return a; in float128_abs()
1285 static inline float128 float128_chs(float128 a) in float128_chs() argument
1287 a.high ^= 0x8000000000000000LL; in float128_chs()
1288 return a; in float128_chs()
1291 static inline bool float128_is_infinity(float128 a) in float128_is_infinity() argument
1293 return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0; in float128_is_infinity()
1296 static inline bool float128_is_neg(float128 a) in float128_is_neg() argument
1298 return a.high >> 63; in float128_is_neg()
1301 static inline bool float128_is_zero(float128 a) in float128_is_zero() argument
1303 return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0; in float128_is_zero()
1306 static inline bool float128_is_zero_or_denormal(float128 a) in float128_is_zero_or_denormal() argument
1308 return (a.high & 0x7fff000000000000LL) == 0; in float128_is_zero_or_denormal()
1311 static inline bool float128_is_normal(float128 a) in float128_is_normal() argument
1313 return (((a.high >> 48) + 1) & 0x7fff) >= 2; in float128_is_normal()
1316 static inline bool float128_is_denormal(float128 a) in float128_is_denormal() argument
1318 return float128_is_zero_or_denormal(a) && !float128_is_zero(a); in float128_is_denormal()
1321 static inline bool float128_is_any_nan(float128 a) in float128_is_any_nan() argument
1323 return ((a.high >> 48) & 0x7fff) == 0x7fff && in float128_is_any_nan()
1324 ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0)); in float128_is_any_nan()
1327 static inline bool float128_eq(float128 a, float128 b, float_status *s) in float128_eq() argument
1329 return float128_compare(a, b, s) == float_relation_equal; in float128_eq()
1332 static inline bool float128_le(float128 a, float128 b, float_status *s) in float128_le() argument
1334 return float128_compare(a, b, s) <= float_relation_equal; in float128_le()
1337 static inline bool float128_lt(float128 a, float128 b, float_status *s) in float128_lt() argument
1339 return float128_compare(a, b, s) < float_relation_equal; in float128_lt()
1342 static inline bool float128_unordered(float128 a, float128 b, float_status *s) in float128_unordered() argument
1344 return float128_compare(a, b, s) == float_relation_unordered; in float128_unordered()
1347 static inline bool float128_eq_quiet(float128 a, float128 b, float_status *s) in float128_eq_quiet() argument
1349 return float128_compare_quiet(a, b, s) == float_relation_equal; in float128_eq_quiet()
1352 static inline bool float128_le_quiet(float128 a, float128 b, float_status *s) in float128_le_quiet() argument
1354 return float128_compare_quiet(a, b, s) <= float_relation_equal; in float128_le_quiet()
1357 static inline bool float128_lt_quiet(float128 a, float128 b, float_status *s) in float128_lt_quiet() argument
1359 return float128_compare_quiet(a, b, s) < float_relation_equal; in float128_lt_quiet()
1362 static inline bool float128_unordered_quiet(float128 a, float128 b, in float128_unordered_quiet() argument
1365 return float128_compare_quiet(a, b, s) == float_relation_unordered; in float128_unordered_quiet()
1370 /*----------------------------------------------------------------------------
1371 | The pattern for a default generated quadruple-precision NaN.
1372 *----------------------------------------------------------------------------*/