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
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.
19 ===============================================================================
20 This C source file is part of the SoftFloat IEC/IEEE Floating-point
21 Arithmetic Package, Release 2a.
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'.
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.
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.
44 ===============================================================================
48 * Copyright (c) 2006, Fabrice Bellard
49 * All rights reserved.
51 * Redistribution and use in source and binary forms, with or without
52 * modification, are permitted provided that the following conditions are met:
54 * 1. Redistributions of source code must retain the above copyright notice,
55 * this list of conditions and the following disclaimer.
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.
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.
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.
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.
82 /* softfloat (and in particular the code in softfloat-specialize.h) is
83 * target-dependent and needs the TARGET_* macros.
85 #include "qemu/osdep.h"
87 #include "qemu/bitops.h"
88 #include "fpu/softfloat.h"
90 /* We only need stdlib for abort() */
92 /*----------------------------------------------------------------------------
93 | Primitive arithmetic functions, including multi-word arithmetic, and
94 | division and square root approximations. (Can be specialized to target if
96 *----------------------------------------------------------------------------*/
97 #include "fpu/softfloat-macros.h"
102 * Fast emulation of guest FP instructions is challenging for two reasons.
103 * First, FP instruction semantics are similar but not identical, particularly
104 * when handling NaNs. Second, emulating at reasonable speed the guest FP
105 * exception flags is not trivial: reading the host's flags register with a
106 * feclearexcept & fetestexcept pair is slow [slightly slower than soft-fp],
107 * and trapping on every FP exception is not fast nor pleasant to work with.
109 * We address these challenges by leveraging the host FPU for a subset of the
110 * operations. To do this we expand on the idea presented in this paper:
112 * Guo, Yu-Chuan, et al. "Translating the ARM Neon and VFP instructions in a
113 * binary translator." Software: Practice and Experience 46.12 (2016):1591-1615.
115 * The idea is thus to leverage the host FPU to (1) compute FP operations
116 * and (2) identify whether FP exceptions occurred while avoiding
117 * expensive exception flag register accesses.
119 * An important optimization shown in the paper is that given that exception
120 * flags are rarely cleared by the guest, we can avoid recomputing some flags.
121 * This is particularly useful for the inexact flag, which is very frequently
122 * raised in floating-point workloads.
124 * We optimize the code further by deferring to soft-fp whenever FP exception
125 * detection might get hairy. Two examples: (1) when at least one operand is
126 * denormal/inf/NaN; (2) when operands are not guaranteed to lead to a 0 result
127 * and the result is < the minimum normal.
129 #define GEN_INPUT_FLUSH__NOCHECK(name, soft_t) \
130 static inline void name(soft_t *a, float_status *s) \
132 if (unlikely(soft_t ## _is_denormal(*a))) { \
133 *a = soft_t ## _set_sign(soft_t ## _zero, \
134 soft_t ## _is_neg(*a)); \
135 float_raise(float_flag_input_denormal, s); \
139 GEN_INPUT_FLUSH__NOCHECK(float32_input_flush__nocheck
, float32
)
140 GEN_INPUT_FLUSH__NOCHECK(float64_input_flush__nocheck
, float64
)
141 #undef GEN_INPUT_FLUSH__NOCHECK
143 #define GEN_INPUT_FLUSH1(name, soft_t) \
144 static inline void name(soft_t *a, float_status *s) \
146 if (likely(!s->flush_inputs_to_zero)) { \
149 soft_t ## _input_flush__nocheck(a, s); \
152 GEN_INPUT_FLUSH1(float32_input_flush1
, float32
)
153 GEN_INPUT_FLUSH1(float64_input_flush1
, float64
)
154 #undef GEN_INPUT_FLUSH1
156 #define GEN_INPUT_FLUSH2(name, soft_t) \
157 static inline void name(soft_t *a, soft_t *b, float_status *s) \
159 if (likely(!s->flush_inputs_to_zero)) { \
162 soft_t ## _input_flush__nocheck(a, s); \
163 soft_t ## _input_flush__nocheck(b, s); \
166 GEN_INPUT_FLUSH2(float32_input_flush2
, float32
)
167 GEN_INPUT_FLUSH2(float64_input_flush2
, float64
)
168 #undef GEN_INPUT_FLUSH2
170 #define GEN_INPUT_FLUSH3(name, soft_t) \
171 static inline void name(soft_t *a, soft_t *b, soft_t *c, float_status *s) \
173 if (likely(!s->flush_inputs_to_zero)) { \
176 soft_t ## _input_flush__nocheck(a, s); \
177 soft_t ## _input_flush__nocheck(b, s); \
178 soft_t ## _input_flush__nocheck(c, s); \
181 GEN_INPUT_FLUSH3(float32_input_flush3
, float32
)
182 GEN_INPUT_FLUSH3(float64_input_flush3
, float64
)
183 #undef GEN_INPUT_FLUSH3
186 * Choose whether to use fpclassify or float32/64_* primitives in the generated
187 * hardfloat functions. Each combination of number of inputs and float size
188 * gets its own value.
190 #if defined(__x86_64__)
191 # define QEMU_HARDFLOAT_1F32_USE_FP 0
192 # define QEMU_HARDFLOAT_1F64_USE_FP 1
193 # define QEMU_HARDFLOAT_2F32_USE_FP 0
194 # define QEMU_HARDFLOAT_2F64_USE_FP 1
195 # define QEMU_HARDFLOAT_3F32_USE_FP 0
196 # define QEMU_HARDFLOAT_3F64_USE_FP 1
198 # define QEMU_HARDFLOAT_1F32_USE_FP 0
199 # define QEMU_HARDFLOAT_1F64_USE_FP 0
200 # define QEMU_HARDFLOAT_2F32_USE_FP 0
201 # define QEMU_HARDFLOAT_2F64_USE_FP 0
202 # define QEMU_HARDFLOAT_3F32_USE_FP 0
203 # define QEMU_HARDFLOAT_3F64_USE_FP 0
207 * QEMU_HARDFLOAT_USE_ISINF chooses whether to use isinf() over
208 * float{32,64}_is_infinity when !USE_FP.
209 * On x86_64/aarch64, using the former over the latter can yield a ~6% speedup.
210 * On power64 however, using isinf() reduces fp-bench performance by up to 50%.
212 #if defined(__x86_64__) || defined(__aarch64__)
213 # define QEMU_HARDFLOAT_USE_ISINF 1
215 # define QEMU_HARDFLOAT_USE_ISINF 0
219 * Some targets clear the FP flags before most FP operations. This prevents
220 * the use of hardfloat, since hardfloat relies on the inexact flag being
223 #if defined(TARGET_PPC) || defined(__FAST_MATH__)
224 # if defined(__FAST_MATH__)
225 # warning disabling hardfloat due to -ffast-math: hardfloat requires an exact \
228 # define QEMU_NO_HARDFLOAT 1
229 # define QEMU_SOFTFLOAT_ATTR QEMU_FLATTEN
231 # define QEMU_NO_HARDFLOAT 0
232 # define QEMU_SOFTFLOAT_ATTR QEMU_FLATTEN __attribute__((noinline))
235 static inline bool can_use_fpu(const float_status
*s
)
237 if (QEMU_NO_HARDFLOAT
) {
240 return likely(s
->float_exception_flags
& float_flag_inexact
&&
241 s
->float_rounding_mode
== float_round_nearest_even
);
245 * Hardfloat generation functions. Each operation can have two flavors:
246 * either using softfloat primitives (e.g. float32_is_zero_or_normal) for
247 * most condition checks, or native ones (e.g. fpclassify).
249 * The flavor is chosen by the callers. Instead of using macros, we rely on the
250 * compiler to propagate constants and inline everything into the callers.
252 * We only generate functions for operations with two inputs, since only
253 * these are common enough to justify consolidating them into common code.
266 typedef bool (*f32_check_fn
)(union_float32 a
, union_float32 b
);
267 typedef bool (*f64_check_fn
)(union_float64 a
, union_float64 b
);
269 typedef float32 (*soft_f32_op2_fn
)(float32 a
, float32 b
, float_status
*s
);
270 typedef float64 (*soft_f64_op2_fn
)(float64 a
, float64 b
, float_status
*s
);
271 typedef float (*hard_f32_op2_fn
)(float a
, float b
);
272 typedef double (*hard_f64_op2_fn
)(double a
, double b
);
274 /* 2-input is-zero-or-normal */
275 static inline bool f32_is_zon2(union_float32 a
, union_float32 b
)
277 if (QEMU_HARDFLOAT_2F32_USE_FP
) {
279 * Not using a temp variable for consecutive fpclassify calls ends up
280 * generating faster code.
282 return (fpclassify(a
.h
) == FP_NORMAL
|| fpclassify(a
.h
) == FP_ZERO
) &&
283 (fpclassify(b
.h
) == FP_NORMAL
|| fpclassify(b
.h
) == FP_ZERO
);
285 return float32_is_zero_or_normal(a
.s
) &&
286 float32_is_zero_or_normal(b
.s
);
289 static inline bool f64_is_zon2(union_float64 a
, union_float64 b
)
291 if (QEMU_HARDFLOAT_2F64_USE_FP
) {
292 return (fpclassify(a
.h
) == FP_NORMAL
|| fpclassify(a
.h
) == FP_ZERO
) &&
293 (fpclassify(b
.h
) == FP_NORMAL
|| fpclassify(b
.h
) == FP_ZERO
);
295 return float64_is_zero_or_normal(a
.s
) &&
296 float64_is_zero_or_normal(b
.s
);
299 /* 3-input is-zero-or-normal */
301 bool f32_is_zon3(union_float32 a
, union_float32 b
, union_float32 c
)
303 if (QEMU_HARDFLOAT_3F32_USE_FP
) {
304 return (fpclassify(a
.h
) == FP_NORMAL
|| fpclassify(a
.h
) == FP_ZERO
) &&
305 (fpclassify(b
.h
) == FP_NORMAL
|| fpclassify(b
.h
) == FP_ZERO
) &&
306 (fpclassify(c
.h
) == FP_NORMAL
|| fpclassify(c
.h
) == FP_ZERO
);
308 return float32_is_zero_or_normal(a
.s
) &&
309 float32_is_zero_or_normal(b
.s
) &&
310 float32_is_zero_or_normal(c
.s
);
314 bool f64_is_zon3(union_float64 a
, union_float64 b
, union_float64 c
)
316 if (QEMU_HARDFLOAT_3F64_USE_FP
) {
317 return (fpclassify(a
.h
) == FP_NORMAL
|| fpclassify(a
.h
) == FP_ZERO
) &&
318 (fpclassify(b
.h
) == FP_NORMAL
|| fpclassify(b
.h
) == FP_ZERO
) &&
319 (fpclassify(c
.h
) == FP_NORMAL
|| fpclassify(c
.h
) == FP_ZERO
);
321 return float64_is_zero_or_normal(a
.s
) &&
322 float64_is_zero_or_normal(b
.s
) &&
323 float64_is_zero_or_normal(c
.s
);
326 static inline bool f32_is_inf(union_float32 a
)
328 if (QEMU_HARDFLOAT_USE_ISINF
) {
331 return float32_is_infinity(a
.s
);
334 static inline bool f64_is_inf(union_float64 a
)
336 if (QEMU_HARDFLOAT_USE_ISINF
) {
339 return float64_is_infinity(a
.s
);
342 static inline float32
343 float32_gen2(float32 xa
, float32 xb
, float_status
*s
,
344 hard_f32_op2_fn hard
, soft_f32_op2_fn soft
,
345 f32_check_fn pre
, f32_check_fn post
)
347 union_float32 ua
, ub
, ur
;
352 if (unlikely(!can_use_fpu(s
))) {
356 float32_input_flush2(&ua
.s
, &ub
.s
, s
);
357 if (unlikely(!pre(ua
, ub
))) {
361 ur
.h
= hard(ua
.h
, ub
.h
);
362 if (unlikely(f32_is_inf(ur
))) {
363 float_raise(float_flag_overflow
, s
);
364 } else if (unlikely(fabsf(ur
.h
) <= FLT_MIN
) && post(ua
, ub
)) {
370 return soft(ua
.s
, ub
.s
, s
);
373 static inline float64
374 float64_gen2(float64 xa
, float64 xb
, float_status
*s
,
375 hard_f64_op2_fn hard
, soft_f64_op2_fn soft
,
376 f64_check_fn pre
, f64_check_fn post
)
378 union_float64 ua
, ub
, ur
;
383 if (unlikely(!can_use_fpu(s
))) {
387 float64_input_flush2(&ua
.s
, &ub
.s
, s
);
388 if (unlikely(!pre(ua
, ub
))) {
392 ur
.h
= hard(ua
.h
, ub
.h
);
393 if (unlikely(f64_is_inf(ur
))) {
394 float_raise(float_flag_overflow
, s
);
395 } else if (unlikely(fabs(ur
.h
) <= DBL_MIN
) && post(ua
, ub
)) {
401 return soft(ua
.s
, ub
.s
, s
);
405 * Classify a floating point number. Everything above float_class_qnan
406 * is a NaN so cls >= float_class_qnan is any NaN.
409 typedef enum __attribute__ ((__packed__
)) {
410 float_class_unclassified
,
414 float_class_qnan
, /* all NaNs from here */
418 #define float_cmask(bit) (1u << (bit))
421 float_cmask_zero
= float_cmask(float_class_zero
),
422 float_cmask_normal
= float_cmask(float_class_normal
),
423 float_cmask_inf
= float_cmask(float_class_inf
),
424 float_cmask_qnan
= float_cmask(float_class_qnan
),
425 float_cmask_snan
= float_cmask(float_class_snan
),
427 float_cmask_infzero
= float_cmask_zero
| float_cmask_inf
,
428 float_cmask_anynan
= float_cmask_qnan
| float_cmask_snan
,
431 /* Flags for parts_minmax. */
433 /* Set for minimum; clear for maximum. */
435 /* Set for the IEEE 754-2008 minNum() and maxNum() operations. */
437 /* Set for the IEEE 754-2008 minNumMag() and minNumMag() operations. */
441 /* Simple helpers for checking if, or what kind of, NaN we have */
442 static inline __attribute__((unused
)) bool is_nan(FloatClass c
)
444 return unlikely(c
>= float_class_qnan
);
447 static inline __attribute__((unused
)) bool is_snan(FloatClass c
)
449 return c
== float_class_snan
;
452 static inline __attribute__((unused
)) bool is_qnan(FloatClass c
)
454 return c
== float_class_qnan
;
458 * Structure holding all of the decomposed parts of a float.
459 * The exponent is unbiased and the fraction is normalized.
461 * The fraction words are stored in big-endian word ordering,
462 * so that truncation from a larger format to a smaller format
463 * can be done simply by ignoring subsequent elements.
471 /* Routines that know the structure may reference the singular name. */
474 * Routines expanded with multiple structures reference "hi" and "lo"
475 * depending on the operation. In FloatParts64, "hi" and "lo" are
476 * both the same word and aliased here.
496 uint64_t frac_hm
; /* high-middle */
497 uint64_t frac_lm
; /* low-middle */
501 /* These apply to the most significant word of each FloatPartsN. */
502 #define DECOMPOSED_BINARY_POINT 63
503 #define DECOMPOSED_IMPLICIT_BIT (1ull << DECOMPOSED_BINARY_POINT)
505 /* Structure holding all of the relevant parameters for a format.
506 * exp_size: the size of the exponent field
507 * exp_bias: the offset applied to the exponent field
508 * exp_max: the maximum normalised exponent
509 * frac_size: the size of the fraction field
510 * frac_shift: shift to normalise the fraction with DECOMPOSED_BINARY_POINT
511 * The following are computed based the size of fraction
512 * round_mask: bits below lsb which must be rounded
513 * The following optional modifiers are available:
514 * arm_althp: handle ARM Alternative Half Precision
526 /* Expand fields based on the size of exponent and fraction */
527 #define FLOAT_PARAMS_(E) \
529 .exp_bias = ((1 << E) - 1) >> 1, \
530 .exp_max = (1 << E) - 1
532 #define FLOAT_PARAMS(E, F) \
535 .frac_shift = (-F - 1) & 63, \
536 .round_mask = (1ull << ((-F - 1) & 63)) - 1
538 static const FloatFmt float16_params
= {
542 static const FloatFmt float16_params_ahp
= {
547 static const FloatFmt bfloat16_params
= {
551 static const FloatFmt float32_params
= {
555 static const FloatFmt float64_params
= {
559 static const FloatFmt float128_params
= {
560 FLOAT_PARAMS(15, 112)
563 #define FLOATX80_PARAMS(R) \
565 .frac_size = R == 64 ? 63 : R, \
567 .round_mask = R == 64 ? -1 : (1ull << ((-R - 1) & 63)) - 1
569 static const FloatFmt floatx80_params
[3] = {
570 [floatx80_precision_s
] = { FLOATX80_PARAMS(23) },
571 [floatx80_precision_d
] = { FLOATX80_PARAMS(52) },
572 [floatx80_precision_x
] = { FLOATX80_PARAMS(64) },
575 /* Unpack a float to parts, but do not canonicalize. */
576 static void unpack_raw64(FloatParts64
*r
, const FloatFmt
*fmt
, uint64_t raw
)
578 const int f_size
= fmt
->frac_size
;
579 const int e_size
= fmt
->exp_size
;
581 *r
= (FloatParts64
) {
582 .cls
= float_class_unclassified
,
583 .sign
= extract64(raw
, f_size
+ e_size
, 1),
584 .exp
= extract64(raw
, f_size
, e_size
),
585 .frac
= extract64(raw
, 0, f_size
)
589 static inline void float16_unpack_raw(FloatParts64
*p
, float16 f
)
591 unpack_raw64(p
, &float16_params
, f
);
594 static inline void bfloat16_unpack_raw(FloatParts64
*p
, bfloat16 f
)
596 unpack_raw64(p
, &bfloat16_params
, f
);
599 static inline void float32_unpack_raw(FloatParts64
*p
, float32 f
)
601 unpack_raw64(p
, &float32_params
, f
);
604 static inline void float64_unpack_raw(FloatParts64
*p
, float64 f
)
606 unpack_raw64(p
, &float64_params
, f
);
609 static void floatx80_unpack_raw(FloatParts128
*p
, floatx80 f
)
611 *p
= (FloatParts128
) {
612 .cls
= float_class_unclassified
,
613 .sign
= extract32(f
.high
, 15, 1),
614 .exp
= extract32(f
.high
, 0, 15),
619 static void float128_unpack_raw(FloatParts128
*p
, float128 f
)
621 const int f_size
= float128_params
.frac_size
- 64;
622 const int e_size
= float128_params
.exp_size
;
624 *p
= (FloatParts128
) {
625 .cls
= float_class_unclassified
,
626 .sign
= extract64(f
.high
, f_size
+ e_size
, 1),
627 .exp
= extract64(f
.high
, f_size
, e_size
),
628 .frac_hi
= extract64(f
.high
, 0, f_size
),
633 /* Pack a float from parts, but do not canonicalize. */
634 static uint64_t pack_raw64(const FloatParts64
*p
, const FloatFmt
*fmt
)
636 const int f_size
= fmt
->frac_size
;
637 const int e_size
= fmt
->exp_size
;
640 ret
= (uint64_t)p
->sign
<< (f_size
+ e_size
);
641 ret
= deposit64(ret
, f_size
, e_size
, p
->exp
);
642 ret
= deposit64(ret
, 0, f_size
, p
->frac
);
646 static inline float16
float16_pack_raw(const FloatParts64
*p
)
648 return make_float16(pack_raw64(p
, &float16_params
));
651 static inline bfloat16
bfloat16_pack_raw(const FloatParts64
*p
)
653 return pack_raw64(p
, &bfloat16_params
);
656 static inline float32
float32_pack_raw(const FloatParts64
*p
)
658 return make_float32(pack_raw64(p
, &float32_params
));
661 static inline float64
float64_pack_raw(const FloatParts64
*p
)
663 return make_float64(pack_raw64(p
, &float64_params
));
666 static float128
float128_pack_raw(const FloatParts128
*p
)
668 const int f_size
= float128_params
.frac_size
- 64;
669 const int e_size
= float128_params
.exp_size
;
672 hi
= (uint64_t)p
->sign
<< (f_size
+ e_size
);
673 hi
= deposit64(hi
, f_size
, e_size
, p
->exp
);
674 hi
= deposit64(hi
, 0, f_size
, p
->frac_hi
);
675 return make_float128(hi
, p
->frac_lo
);
678 /*----------------------------------------------------------------------------
679 | Functions and definitions to determine: (1) whether tininess for underflow
680 | is detected before or after rounding by default, (2) what (if anything)
681 | happens when exceptions are raised, (3) how signaling NaNs are distinguished
682 | from quiet NaNs, (4) the default generated quiet NaNs, and (5) how NaNs
683 | are propagated from function inputs to output. These details are target-
685 *----------------------------------------------------------------------------*/
686 #include "softfloat-specialize.c.inc"
688 #define PARTS_GENERIC_64_128(NAME, P) \
689 QEMU_GENERIC(P, (FloatParts128 *, parts128_##NAME), parts64_##NAME)
691 #define PARTS_GENERIC_64_128_256(NAME, P) \
692 QEMU_GENERIC(P, (FloatParts256 *, parts256_##NAME), \
693 (FloatParts128 *, parts128_##NAME), parts64_##NAME)
695 #define parts_default_nan(P, S) PARTS_GENERIC_64_128(default_nan, P)(P, S)
696 #define parts_silence_nan(P, S) PARTS_GENERIC_64_128(silence_nan, P)(P, S)
698 static void parts64_return_nan(FloatParts64
*a
, float_status
*s
);
699 static void parts128_return_nan(FloatParts128
*a
, float_status
*s
);
701 #define parts_return_nan(P, S) PARTS_GENERIC_64_128(return_nan, P)(P, S)
703 static FloatParts64
*parts64_pick_nan(FloatParts64
*a
, FloatParts64
*b
,
705 static FloatParts128
*parts128_pick_nan(FloatParts128
*a
, FloatParts128
*b
,
708 #define parts_pick_nan(A, B, S) PARTS_GENERIC_64_128(pick_nan, A)(A, B, S)
710 static FloatParts64
*parts64_pick_nan_muladd(FloatParts64
*a
, FloatParts64
*b
,
711 FloatParts64
*c
, float_status
*s
,
712 int ab_mask
, int abc_mask
);
713 static FloatParts128
*parts128_pick_nan_muladd(FloatParts128
*a
,
717 int ab_mask
, int abc_mask
);
719 #define parts_pick_nan_muladd(A, B, C, S, ABM, ABCM) \
720 PARTS_GENERIC_64_128(pick_nan_muladd, A)(A, B, C, S, ABM, ABCM)
722 static void parts64_canonicalize(FloatParts64
*p
, float_status
*status
,
723 const FloatFmt
*fmt
);
724 static void parts128_canonicalize(FloatParts128
*p
, float_status
*status
,
725 const FloatFmt
*fmt
);
727 #define parts_canonicalize(A, S, F) \
728 PARTS_GENERIC_64_128(canonicalize, A)(A, S, F)
730 static void parts64_uncanon_normal(FloatParts64
*p
, float_status
*status
,
731 const FloatFmt
*fmt
);
732 static void parts128_uncanon_normal(FloatParts128
*p
, float_status
*status
,
733 const FloatFmt
*fmt
);
735 #define parts_uncanon_normal(A, S, F) \
736 PARTS_GENERIC_64_128(uncanon_normal, A)(A, S, F)
738 static void parts64_uncanon(FloatParts64
*p
, float_status
*status
,
739 const FloatFmt
*fmt
);
740 static void parts128_uncanon(FloatParts128
*p
, float_status
*status
,
741 const FloatFmt
*fmt
);
743 #define parts_uncanon(A, S, F) \
744 PARTS_GENERIC_64_128(uncanon, A)(A, S, F)
746 static void parts64_add_normal(FloatParts64
*a
, FloatParts64
*b
);
747 static void parts128_add_normal(FloatParts128
*a
, FloatParts128
*b
);
748 static void parts256_add_normal(FloatParts256
*a
, FloatParts256
*b
);
750 #define parts_add_normal(A, B) \
751 PARTS_GENERIC_64_128_256(add_normal, A)(A, B)
753 static bool parts64_sub_normal(FloatParts64
*a
, FloatParts64
*b
);
754 static bool parts128_sub_normal(FloatParts128
*a
, FloatParts128
*b
);
755 static bool parts256_sub_normal(FloatParts256
*a
, FloatParts256
*b
);
757 #define parts_sub_normal(A, B) \
758 PARTS_GENERIC_64_128_256(sub_normal, A)(A, B)
760 static FloatParts64
*parts64_addsub(FloatParts64
*a
, FloatParts64
*b
,
761 float_status
*s
, bool subtract
);
762 static FloatParts128
*parts128_addsub(FloatParts128
*a
, FloatParts128
*b
,
763 float_status
*s
, bool subtract
);
765 #define parts_addsub(A, B, S, Z) \
766 PARTS_GENERIC_64_128(addsub, A)(A, B, S, Z)
768 static FloatParts64
*parts64_mul(FloatParts64
*a
, FloatParts64
*b
,
770 static FloatParts128
*parts128_mul(FloatParts128
*a
, FloatParts128
*b
,
773 #define parts_mul(A, B, S) \
774 PARTS_GENERIC_64_128(mul, A)(A, B, S)
776 static FloatParts64
*parts64_muladd(FloatParts64
*a
, FloatParts64
*b
,
777 FloatParts64
*c
, int flags
,
779 static FloatParts128
*parts128_muladd(FloatParts128
*a
, FloatParts128
*b
,
780 FloatParts128
*c
, int flags
,
783 #define parts_muladd(A, B, C, Z, S) \
784 PARTS_GENERIC_64_128(muladd, A)(A, B, C, Z, S)
786 static FloatParts64
*parts64_div(FloatParts64
*a
, FloatParts64
*b
,
788 static FloatParts128
*parts128_div(FloatParts128
*a
, FloatParts128
*b
,
791 #define parts_div(A, B, S) \
792 PARTS_GENERIC_64_128(div, A)(A, B, S)
794 static FloatParts64
*parts64_modrem(FloatParts64
*a
, FloatParts64
*b
,
795 uint64_t *mod_quot
, float_status
*s
);
796 static FloatParts128
*parts128_modrem(FloatParts128
*a
, FloatParts128
*b
,
797 uint64_t *mod_quot
, float_status
*s
);
799 #define parts_modrem(A, B, Q, S) \
800 PARTS_GENERIC_64_128(modrem, A)(A, B, Q, S)
802 static void parts64_sqrt(FloatParts64
*a
, float_status
*s
, const FloatFmt
*f
);
803 static void parts128_sqrt(FloatParts128
*a
, float_status
*s
, const FloatFmt
*f
);
805 #define parts_sqrt(A, S, F) \
806 PARTS_GENERIC_64_128(sqrt, A)(A, S, F)
808 static bool parts64_round_to_int_normal(FloatParts64
*a
, FloatRoundMode rm
,
809 int scale
, int frac_size
);
810 static bool parts128_round_to_int_normal(FloatParts128
*a
, FloatRoundMode r
,
811 int scale
, int frac_size
);
813 #define parts_round_to_int_normal(A, R, C, F) \
814 PARTS_GENERIC_64_128(round_to_int_normal, A)(A, R, C, F)
816 static void parts64_round_to_int(FloatParts64
*a
, FloatRoundMode rm
,
817 int scale
, float_status
*s
,
818 const FloatFmt
*fmt
);
819 static void parts128_round_to_int(FloatParts128
*a
, FloatRoundMode r
,
820 int scale
, float_status
*s
,
821 const FloatFmt
*fmt
);
823 #define parts_round_to_int(A, R, C, S, F) \
824 PARTS_GENERIC_64_128(round_to_int, A)(A, R, C, S, F)
826 static int64_t parts64_float_to_sint(FloatParts64
*p
, FloatRoundMode rmode
,
827 int scale
, int64_t min
, int64_t max
,
829 static int64_t parts128_float_to_sint(FloatParts128
*p
, FloatRoundMode rmode
,
830 int scale
, int64_t min
, int64_t max
,
833 #define parts_float_to_sint(P, R, Z, MN, MX, S) \
834 PARTS_GENERIC_64_128(float_to_sint, P)(P, R, Z, MN, MX, S)
836 static uint64_t parts64_float_to_uint(FloatParts64
*p
, FloatRoundMode rmode
,
837 int scale
, uint64_t max
,
839 static uint64_t parts128_float_to_uint(FloatParts128
*p
, FloatRoundMode rmode
,
840 int scale
, uint64_t max
,
843 #define parts_float_to_uint(P, R, Z, M, S) \
844 PARTS_GENERIC_64_128(float_to_uint, P)(P, R, Z, M, S)
846 static void parts64_sint_to_float(FloatParts64
*p
, int64_t a
,
847 int scale
, float_status
*s
);
848 static void parts128_sint_to_float(FloatParts128
*p
, int64_t a
,
849 int scale
, float_status
*s
);
851 #define parts_sint_to_float(P, I, Z, S) \
852 PARTS_GENERIC_64_128(sint_to_float, P)(P, I, Z, S)
854 static void parts64_uint_to_float(FloatParts64
*p
, uint64_t a
,
855 int scale
, float_status
*s
);
856 static void parts128_uint_to_float(FloatParts128
*p
, uint64_t a
,
857 int scale
, float_status
*s
);
859 #define parts_uint_to_float(P, I, Z, S) \
860 PARTS_GENERIC_64_128(uint_to_float, P)(P, I, Z, S)
862 static FloatParts64
*parts64_minmax(FloatParts64
*a
, FloatParts64
*b
,
863 float_status
*s
, int flags
);
864 static FloatParts128
*parts128_minmax(FloatParts128
*a
, FloatParts128
*b
,
865 float_status
*s
, int flags
);
867 #define parts_minmax(A, B, S, F) \
868 PARTS_GENERIC_64_128(minmax, A)(A, B, S, F)
870 static int parts64_compare(FloatParts64
*a
, FloatParts64
*b
,
871 float_status
*s
, bool q
);
872 static int parts128_compare(FloatParts128
*a
, FloatParts128
*b
,
873 float_status
*s
, bool q
);
875 #define parts_compare(A, B, S, Q) \
876 PARTS_GENERIC_64_128(compare, A)(A, B, S, Q)
878 static void parts64_scalbn(FloatParts64
*a
, int n
, float_status
*s
);
879 static void parts128_scalbn(FloatParts128
*a
, int n
, float_status
*s
);
881 #define parts_scalbn(A, N, S) \
882 PARTS_GENERIC_64_128(scalbn, A)(A, N, S)
884 static void parts64_log2(FloatParts64
*a
, float_status
*s
, const FloatFmt
*f
);
885 static void parts128_log2(FloatParts128
*a
, float_status
*s
, const FloatFmt
*f
);
887 #define parts_log2(A, S, F) \
888 PARTS_GENERIC_64_128(log2, A)(A, S, F)
891 * Helper functions for softfloat-parts.c.inc, per-size operations.
894 #define FRAC_GENERIC_64_128(NAME, P) \
895 QEMU_GENERIC(P, (FloatParts128 *, frac128_##NAME), frac64_##NAME)
897 #define FRAC_GENERIC_64_128_256(NAME, P) \
898 QEMU_GENERIC(P, (FloatParts256 *, frac256_##NAME), \
899 (FloatParts128 *, frac128_##NAME), frac64_##NAME)
901 static bool frac64_add(FloatParts64
*r
, FloatParts64
*a
, FloatParts64
*b
)
903 return uadd64_overflow(a
->frac
, b
->frac
, &r
->frac
);
906 static bool frac128_add(FloatParts128
*r
, FloatParts128
*a
, FloatParts128
*b
)
909 r
->frac_lo
= uadd64_carry(a
->frac_lo
, b
->frac_lo
, &c
);
910 r
->frac_hi
= uadd64_carry(a
->frac_hi
, b
->frac_hi
, &c
);
914 static bool frac256_add(FloatParts256
*r
, FloatParts256
*a
, FloatParts256
*b
)
917 r
->frac_lo
= uadd64_carry(a
->frac_lo
, b
->frac_lo
, &c
);
918 r
->frac_lm
= uadd64_carry(a
->frac_lm
, b
->frac_lm
, &c
);
919 r
->frac_hm
= uadd64_carry(a
->frac_hm
, b
->frac_hm
, &c
);
920 r
->frac_hi
= uadd64_carry(a
->frac_hi
, b
->frac_hi
, &c
);
924 #define frac_add(R, A, B) FRAC_GENERIC_64_128_256(add, R)(R, A, B)
926 static bool frac64_addi(FloatParts64
*r
, FloatParts64
*a
, uint64_t c
)
928 return uadd64_overflow(a
->frac
, c
, &r
->frac
);
931 static bool frac128_addi(FloatParts128
*r
, FloatParts128
*a
, uint64_t c
)
933 c
= uadd64_overflow(a
->frac_lo
, c
, &r
->frac_lo
);
934 return uadd64_overflow(a
->frac_hi
, c
, &r
->frac_hi
);
937 #define frac_addi(R, A, C) FRAC_GENERIC_64_128(addi, R)(R, A, C)
939 static void frac64_allones(FloatParts64
*a
)
944 static void frac128_allones(FloatParts128
*a
)
946 a
->frac_hi
= a
->frac_lo
= -1;
949 #define frac_allones(A) FRAC_GENERIC_64_128(allones, A)(A)
951 static int frac64_cmp(FloatParts64
*a
, FloatParts64
*b
)
953 return a
->frac
== b
->frac
? 0 : a
->frac
< b
->frac
? -1 : 1;
956 static int frac128_cmp(FloatParts128
*a
, FloatParts128
*b
)
958 uint64_t ta
= a
->frac_hi
, tb
= b
->frac_hi
;
960 ta
= a
->frac_lo
, tb
= b
->frac_lo
;
965 return ta
< tb
? -1 : 1;
968 #define frac_cmp(A, B) FRAC_GENERIC_64_128(cmp, A)(A, B)
970 static void frac64_clear(FloatParts64
*a
)
975 static void frac128_clear(FloatParts128
*a
)
977 a
->frac_hi
= a
->frac_lo
= 0;
980 #define frac_clear(A) FRAC_GENERIC_64_128(clear, A)(A)
982 static bool frac64_div(FloatParts64
*a
, FloatParts64
*b
)
984 uint64_t n1
, n0
, r
, q
;
988 * We want a 2*N / N-bit division to produce exactly an N-bit
989 * result, so that we do not lose any precision and so that we
990 * do not have to renormalize afterward. If A.frac < B.frac,
991 * then division would produce an (N-1)-bit result; shift A left
992 * by one to produce the an N-bit result, and return true to
993 * decrement the exponent to match.
995 * The udiv_qrnnd algorithm that we're using requires normalization,
996 * i.e. the msb of the denominator must be set, which is already true.
998 ret
= a
->frac
< b
->frac
;
1006 q
= udiv_qrnnd(&r
, n0
, n1
, b
->frac
);
1008 /* Set lsb if there is a remainder, to set inexact. */
1009 a
->frac
= q
| (r
!= 0);
1014 static bool frac128_div(FloatParts128
*a
, FloatParts128
*b
)
1016 uint64_t q0
, q1
, a0
, a1
, b0
, b1
;
1017 uint64_t r0
, r1
, r2
, r3
, t0
, t1
, t2
, t3
;
1020 a0
= a
->frac_hi
, a1
= a
->frac_lo
;
1021 b0
= b
->frac_hi
, b1
= b
->frac_lo
;
1023 ret
= lt128(a0
, a1
, b0
, b1
);
1025 a1
= shr_double(a0
, a1
, 1);
1029 /* Use 128/64 -> 64 division as estimate for 192/128 -> 128 division. */
1030 q0
= estimateDiv128To64(a0
, a1
, b0
);
1033 * Estimate is high because B1 was not included (unless B1 == 0).
1034 * Reduce quotient and increase remainder until remainder is non-negative.
1035 * This loop will execute 0 to 2 times.
1037 mul128By64To192(b0
, b1
, q0
, &t0
, &t1
, &t2
);
1038 sub192(a0
, a1
, 0, t0
, t1
, t2
, &r0
, &r1
, &r2
);
1041 add192(r0
, r1
, r2
, 0, b0
, b1
, &r0
, &r1
, &r2
);
1044 /* Repeat using the remainder, producing a second word of quotient. */
1045 q1
= estimateDiv128To64(r1
, r2
, b0
);
1046 mul128By64To192(b0
, b1
, q1
, &t1
, &t2
, &t3
);
1047 sub192(r1
, r2
, 0, t1
, t2
, t3
, &r1
, &r2
, &r3
);
1050 add192(r1
, r2
, r3
, 0, b0
, b1
, &r1
, &r2
, &r3
);
1053 /* Any remainder indicates inexact; set sticky bit. */
1054 q1
|= (r2
| r3
) != 0;
1061 #define frac_div(A, B) FRAC_GENERIC_64_128(div, A)(A, B)
1063 static bool frac64_eqz(FloatParts64
*a
)
1065 return a
->frac
== 0;
1068 static bool frac128_eqz(FloatParts128
*a
)
1070 return (a
->frac_hi
| a
->frac_lo
) == 0;
1073 #define frac_eqz(A) FRAC_GENERIC_64_128(eqz, A)(A)
1075 static void frac64_mulw(FloatParts128
*r
, FloatParts64
*a
, FloatParts64
*b
)
1077 mulu64(&r
->frac_lo
, &r
->frac_hi
, a
->frac
, b
->frac
);
1080 static void frac128_mulw(FloatParts256
*r
, FloatParts128
*a
, FloatParts128
*b
)
1082 mul128To256(a
->frac_hi
, a
->frac_lo
, b
->frac_hi
, b
->frac_lo
,
1083 &r
->frac_hi
, &r
->frac_hm
, &r
->frac_lm
, &r
->frac_lo
);
1086 #define frac_mulw(R, A, B) FRAC_GENERIC_64_128(mulw, A)(R, A, B)
1088 static void frac64_neg(FloatParts64
*a
)
1093 static void frac128_neg(FloatParts128
*a
)
1096 a
->frac_lo
= usub64_borrow(0, a
->frac_lo
, &c
);
1097 a
->frac_hi
= usub64_borrow(0, a
->frac_hi
, &c
);
1100 static void frac256_neg(FloatParts256
*a
)
1103 a
->frac_lo
= usub64_borrow(0, a
->frac_lo
, &c
);
1104 a
->frac_lm
= usub64_borrow(0, a
->frac_lm
, &c
);
1105 a
->frac_hm
= usub64_borrow(0, a
->frac_hm
, &c
);
1106 a
->frac_hi
= usub64_borrow(0, a
->frac_hi
, &c
);
1109 #define frac_neg(A) FRAC_GENERIC_64_128_256(neg, A)(A)
1111 static int frac64_normalize(FloatParts64
*a
)
1114 int shift
= clz64(a
->frac
);
1121 static int frac128_normalize(FloatParts128
*a
)
1124 int shl
= clz64(a
->frac_hi
);
1125 a
->frac_hi
= shl_double(a
->frac_hi
, a
->frac_lo
, shl
);
1128 } else if (a
->frac_lo
) {
1129 int shl
= clz64(a
->frac_lo
);
1130 a
->frac_hi
= a
->frac_lo
<< shl
;
1137 static int frac256_normalize(FloatParts256
*a
)
1139 uint64_t a0
= a
->frac_hi
, a1
= a
->frac_hm
;
1140 uint64_t a2
= a
->frac_lm
, a3
= a
->frac_lo
;
1152 a0
= a1
, a1
= a2
, a2
= a3
, a3
= 0;
1155 a0
= a2
, a1
= a3
, a2
= 0, a3
= 0;
1158 a0
= a3
, a1
= 0, a2
= 0, a3
= 0;
1161 a0
= 0, a1
= 0, a2
= 0, a3
= 0;
1171 a0
= shl_double(a0
, a1
, shl
);
1172 a1
= shl_double(a1
, a2
, shl
);
1173 a2
= shl_double(a2
, a3
, shl
);
1184 #define frac_normalize(A) FRAC_GENERIC_64_128_256(normalize, A)(A)
1186 static void frac64_modrem(FloatParts64
*a
, FloatParts64
*b
, uint64_t *mod_quot
)
1188 uint64_t a0
, a1
, b0
, t0
, t1
, q
, quot
;
1189 int exp_diff
= a
->exp
- b
->exp
;
1195 if (exp_diff
< -1) {
1201 if (exp_diff
== -1) {
1207 quot
= q
= b0
<= a0
;
1213 while (exp_diff
> 0) {
1214 q
= estimateDiv128To64(a0
, a1
, b0
);
1215 q
= q
> 2 ? q
- 2 : 0;
1216 mul64To128(b0
, q
, &t0
, &t1
);
1217 sub128(a0
, a1
, t0
, t1
, &a0
, &a1
);
1218 shortShift128Left(a0
, a1
, 62, &a0
, &a1
);
1220 quot
= (quot
<< 62) + q
;
1225 q
= estimateDiv128To64(a0
, a1
, b0
);
1226 q
= q
> 2 ? (q
- 2) >> (64 - exp_diff
) : 0;
1227 mul64To128(b0
, q
<< (64 - exp_diff
), &t0
, &t1
);
1228 sub128(a0
, a1
, t0
, t1
, &a0
, &a1
);
1229 shortShift128Left(0, b0
, 64 - exp_diff
, &t0
, &t1
);
1230 while (le128(t0
, t1
, a0
, a1
)) {
1232 sub128(a0
, a1
, t0
, t1
, &a0
, &a1
);
1234 quot
= (exp_diff
< 64 ? quot
<< exp_diff
: 0) + q
;
1243 sub128(t0
, t1
, a0
, a1
, &t0
, &t1
);
1244 if (lt128(t0
, t1
, a0
, a1
) ||
1245 (eq128(t0
, t1
, a0
, a1
) && (q
& 1))) {
1254 shortShift128Left(a0
, a1
, shift
, &a0
, &a1
);
1255 } else if (likely(a1
)) {
1261 a
->cls
= float_class_zero
;
1265 a
->exp
= b
->exp
+ exp_diff
- shift
;
1266 a
->frac
= a0
| (a1
!= 0);
1269 static void frac128_modrem(FloatParts128
*a
, FloatParts128
*b
,
1272 uint64_t a0
, a1
, a2
, b0
, b1
, t0
, t1
, t2
, q
, quot
;
1273 int exp_diff
= a
->exp
- b
->exp
;
1280 if (exp_diff
< -1) {
1286 if (exp_diff
== -1) {
1287 shift128Right(a0
, a1
, 1, &a0
, &a1
);
1294 quot
= q
= le128(b0
, b1
, a0
, a1
);
1296 sub128(a0
, a1
, b0
, b1
, &a0
, &a1
);
1300 while (exp_diff
> 0) {
1301 q
= estimateDiv128To64(a0
, a1
, b0
);
1302 q
= q
> 4 ? q
- 4 : 0;
1303 mul128By64To192(b0
, b1
, q
, &t0
, &t1
, &t2
);
1304 sub192(a0
, a1
, a2
, t0
, t1
, t2
, &a0
, &a1
, &a2
);
1305 shortShift192Left(a0
, a1
, a2
, 61, &a0
, &a1
, &a2
);
1307 quot
= (quot
<< 61) + q
;
1312 q
= estimateDiv128To64(a0
, a1
, b0
);
1313 q
= q
> 4 ? (q
- 4) >> (64 - exp_diff
) : 0;
1314 mul128By64To192(b0
, b1
, q
<< (64 - exp_diff
), &t0
, &t1
, &t2
);
1315 sub192(a0
, a1
, a2
, t0
, t1
, t2
, &a0
, &a1
, &a2
);
1316 shortShift192Left(0, b0
, b1
, 64 - exp_diff
, &t0
, &t1
, &t2
);
1317 while (le192(t0
, t1
, t2
, a0
, a1
, a2
)) {
1319 sub192(a0
, a1
, a2
, t0
, t1
, t2
, &a0
, &a1
, &a2
);
1321 quot
= (exp_diff
< 64 ? quot
<< exp_diff
: 0) + q
;
1331 sub192(t0
, t1
, t2
, a0
, a1
, a2
, &t0
, &t1
, &t2
);
1332 if (lt192(t0
, t1
, t2
, a0
, a1
, a2
) ||
1333 (eq192(t0
, t1
, t2
, a0
, a1
, a2
) && (q
& 1))) {
1343 shortShift192Left(a0
, a1
, a2
, shift
, &a0
, &a1
, &a2
);
1344 } else if (likely(a1
)) {
1346 shortShift128Left(a1
, a2
, shift
, &a0
, &a1
);
1349 } else if (likely(a2
)) {
1355 a
->cls
= float_class_zero
;
1359 a
->exp
= b
->exp
+ exp_diff
- shift
;
1361 a
->frac_lo
= a1
| (a2
!= 0);
1364 #define frac_modrem(A, B, Q) FRAC_GENERIC_64_128(modrem, A)(A, B, Q)
1366 static void frac64_shl(FloatParts64
*a
, int c
)
1371 static void frac128_shl(FloatParts128
*a
, int c
)
1373 uint64_t a0
= a
->frac_hi
, a1
= a
->frac_lo
;
1381 a0
= shl_double(a0
, a1
, c
);
1389 #define frac_shl(A, C) FRAC_GENERIC_64_128(shl, A)(A, C)
1391 static void frac64_shr(FloatParts64
*a
, int c
)
1396 static void frac128_shr(FloatParts128
*a
, int c
)
1398 uint64_t a0
= a
->frac_hi
, a1
= a
->frac_lo
;
1406 a1
= shr_double(a0
, a1
, c
);
1414 #define frac_shr(A, C) FRAC_GENERIC_64_128(shr, A)(A, C)
1416 static void frac64_shrjam(FloatParts64
*a
, int c
)
1418 uint64_t a0
= a
->frac
;
1420 if (likely(c
!= 0)) {
1421 if (likely(c
< 64)) {
1422 a0
= (a0
>> c
) | (shr_double(a0
, 0, c
) != 0);
1430 static void frac128_shrjam(FloatParts128
*a
, int c
)
1432 uint64_t a0
= a
->frac_hi
, a1
= a
->frac_lo
;
1433 uint64_t sticky
= 0;
1435 if (unlikely(c
== 0)) {
1437 } else if (likely(c
< 64)) {
1439 } else if (likely(c
< 128)) {
1453 sticky
|= shr_double(a1
, 0, c
);
1454 a1
= shr_double(a0
, a1
, c
);
1458 a
->frac_lo
= a1
| (sticky
!= 0);
1462 static void frac256_shrjam(FloatParts256
*a
, int c
)
1464 uint64_t a0
= a
->frac_hi
, a1
= a
->frac_hm
;
1465 uint64_t a2
= a
->frac_lm
, a3
= a
->frac_lo
;
1466 uint64_t sticky
= 0;
1468 if (unlikely(c
== 0)) {
1470 } else if (likely(c
< 64)) {
1472 } else if (likely(c
< 256)) {
1473 if (unlikely(c
& 128)) {
1475 a3
= a1
, a2
= a0
, a1
= 0, a0
= 0;
1477 if (unlikely(c
& 64)) {
1479 a3
= a2
, a2
= a1
, a1
= a0
, a0
= 0;
1486 sticky
= a0
| a1
| a2
| a3
;
1487 a0
= a1
= a2
= a3
= 0;
1491 sticky
|= shr_double(a3
, 0, c
);
1492 a3
= shr_double(a2
, a3
, c
);
1493 a2
= shr_double(a1
, a2
, c
);
1494 a1
= shr_double(a0
, a1
, c
);
1498 a
->frac_lo
= a3
| (sticky
!= 0);
1504 #define frac_shrjam(A, C) FRAC_GENERIC_64_128_256(shrjam, A)(A, C)
1506 static bool frac64_sub(FloatParts64
*r
, FloatParts64
*a
, FloatParts64
*b
)
1508 return usub64_overflow(a
->frac
, b
->frac
, &r
->frac
);
1511 static bool frac128_sub(FloatParts128
*r
, FloatParts128
*a
, FloatParts128
*b
)
1514 r
->frac_lo
= usub64_borrow(a
->frac_lo
, b
->frac_lo
, &c
);
1515 r
->frac_hi
= usub64_borrow(a
->frac_hi
, b
->frac_hi
, &c
);
1519 static bool frac256_sub(FloatParts256
*r
, FloatParts256
*a
, FloatParts256
*b
)
1522 r
->frac_lo
= usub64_borrow(a
->frac_lo
, b
->frac_lo
, &c
);
1523 r
->frac_lm
= usub64_borrow(a
->frac_lm
, b
->frac_lm
, &c
);
1524 r
->frac_hm
= usub64_borrow(a
->frac_hm
, b
->frac_hm
, &c
);
1525 r
->frac_hi
= usub64_borrow(a
->frac_hi
, b
->frac_hi
, &c
);
1529 #define frac_sub(R, A, B) FRAC_GENERIC_64_128_256(sub, R)(R, A, B)
1531 static void frac64_truncjam(FloatParts64
*r
, FloatParts128
*a
)
1533 r
->frac
= a
->frac_hi
| (a
->frac_lo
!= 0);
1536 static void frac128_truncjam(FloatParts128
*r
, FloatParts256
*a
)
1538 r
->frac_hi
= a
->frac_hi
;
1539 r
->frac_lo
= a
->frac_hm
| ((a
->frac_lm
| a
->frac_lo
) != 0);
1542 #define frac_truncjam(R, A) FRAC_GENERIC_64_128(truncjam, R)(R, A)
1544 static void frac64_widen(FloatParts128
*r
, FloatParts64
*a
)
1546 r
->frac_hi
= a
->frac
;
1550 static void frac128_widen(FloatParts256
*r
, FloatParts128
*a
)
1552 r
->frac_hi
= a
->frac_hi
;
1553 r
->frac_hm
= a
->frac_lo
;
1558 #define frac_widen(A, B) FRAC_GENERIC_64_128(widen, B)(A, B)
1561 * Reciprocal sqrt table. 1 bit of exponent, 6-bits of mantessa.
1562 * From https://git.musl-libc.org/cgit/musl/tree/src/math/sqrt_data.c
1563 * and thus MIT licenced.
1565 static const uint16_t rsqrt_tab
[128] = {
1566 0xb451, 0xb2f0, 0xb196, 0xb044, 0xaef9, 0xadb6, 0xac79, 0xab43,
1567 0xaa14, 0xa8eb, 0xa7c8, 0xa6aa, 0xa592, 0xa480, 0xa373, 0xa26b,
1568 0xa168, 0xa06a, 0x9f70, 0x9e7b, 0x9d8a, 0x9c9d, 0x9bb5, 0x9ad1,
1569 0x99f0, 0x9913, 0x983a, 0x9765, 0x9693, 0x95c4, 0x94f8, 0x9430,
1570 0x936b, 0x92a9, 0x91ea, 0x912e, 0x9075, 0x8fbe, 0x8f0a, 0x8e59,
1571 0x8daa, 0x8cfe, 0x8c54, 0x8bac, 0x8b07, 0x8a64, 0x89c4, 0x8925,
1572 0x8889, 0x87ee, 0x8756, 0x86c0, 0x862b, 0x8599, 0x8508, 0x8479,
1573 0x83ec, 0x8361, 0x82d8, 0x8250, 0x81c9, 0x8145, 0x80c2, 0x8040,
1574 0xff02, 0xfd0e, 0xfb25, 0xf947, 0xf773, 0xf5aa, 0xf3ea, 0xf234,
1575 0xf087, 0xeee3, 0xed47, 0xebb3, 0xea27, 0xe8a3, 0xe727, 0xe5b2,
1576 0xe443, 0xe2dc, 0xe17a, 0xe020, 0xdecb, 0xdd7d, 0xdc34, 0xdaf1,
1577 0xd9b3, 0xd87b, 0xd748, 0xd61a, 0xd4f1, 0xd3cd, 0xd2ad, 0xd192,
1578 0xd07b, 0xcf69, 0xce5b, 0xcd51, 0xcc4a, 0xcb48, 0xca4a, 0xc94f,
1579 0xc858, 0xc764, 0xc674, 0xc587, 0xc49d, 0xc3b7, 0xc2d4, 0xc1f4,
1580 0xc116, 0xc03c, 0xbf65, 0xbe90, 0xbdbe, 0xbcef, 0xbc23, 0xbb59,
1581 0xba91, 0xb9cc, 0xb90a, 0xb84a, 0xb78c, 0xb6d0, 0xb617, 0xb560,
1584 #define partsN(NAME) glue(glue(glue(parts,N),_),NAME)
1585 #define FloatPartsN glue(FloatParts,N)
1586 #define FloatPartsW glue(FloatParts,W)
1591 #include "softfloat-parts-addsub.c.inc"
1592 #include "softfloat-parts.c.inc"
1599 #include "softfloat-parts-addsub.c.inc"
1600 #include "softfloat-parts.c.inc"
1606 #include "softfloat-parts-addsub.c.inc"
1615 * Pack/unpack routines with a specific FloatFmt.
1618 static void float16a_unpack_canonical(FloatParts64
*p
, float16 f
,
1619 float_status
*s
, const FloatFmt
*params
)
1621 float16_unpack_raw(p
, f
);
1622 parts_canonicalize(p
, s
, params
);
1625 static void float16_unpack_canonical(FloatParts64
*p
, float16 f
,
1628 float16a_unpack_canonical(p
, f
, s
, &float16_params
);
1631 static void bfloat16_unpack_canonical(FloatParts64
*p
, bfloat16 f
,
1634 bfloat16_unpack_raw(p
, f
);
1635 parts_canonicalize(p
, s
, &bfloat16_params
);
1638 static float16
float16a_round_pack_canonical(FloatParts64
*p
,
1640 const FloatFmt
*params
)
1642 parts_uncanon(p
, s
, params
);
1643 return float16_pack_raw(p
);
1646 static float16
float16_round_pack_canonical(FloatParts64
*p
,
1649 return float16a_round_pack_canonical(p
, s
, &float16_params
);
1652 static bfloat16
bfloat16_round_pack_canonical(FloatParts64
*p
,
1655 parts_uncanon(p
, s
, &bfloat16_params
);
1656 return bfloat16_pack_raw(p
);
1659 static void float32_unpack_canonical(FloatParts64
*p
, float32 f
,
1662 float32_unpack_raw(p
, f
);
1663 parts_canonicalize(p
, s
, &float32_params
);
1666 static float32
float32_round_pack_canonical(FloatParts64
*p
,
1669 parts_uncanon(p
, s
, &float32_params
);
1670 return float32_pack_raw(p
);
1673 static void float64_unpack_canonical(FloatParts64
*p
, float64 f
,
1676 float64_unpack_raw(p
, f
);
1677 parts_canonicalize(p
, s
, &float64_params
);
1680 static float64
float64_round_pack_canonical(FloatParts64
*p
,
1683 parts_uncanon(p
, s
, &float64_params
);
1684 return float64_pack_raw(p
);
1687 static void float128_unpack_canonical(FloatParts128
*p
, float128 f
,
1690 float128_unpack_raw(p
, f
);
1691 parts_canonicalize(p
, s
, &float128_params
);
1694 static float128
float128_round_pack_canonical(FloatParts128
*p
,
1697 parts_uncanon(p
, s
, &float128_params
);
1698 return float128_pack_raw(p
);
1701 /* Returns false if the encoding is invalid. */
1702 static bool floatx80_unpack_canonical(FloatParts128
*p
, floatx80 f
,
1705 /* Ensure rounding precision is set before beginning. */
1706 switch (s
->floatx80_rounding_precision
) {
1707 case floatx80_precision_x
:
1708 case floatx80_precision_d
:
1709 case floatx80_precision_s
:
1712 g_assert_not_reached();
1715 if (unlikely(floatx80_invalid_encoding(f
))) {
1716 float_raise(float_flag_invalid
, s
);
1720 floatx80_unpack_raw(p
, f
);
1722 if (likely(p
->exp
!= floatx80_params
[floatx80_precision_x
].exp_max
)) {
1723 parts_canonicalize(p
, s
, &floatx80_params
[floatx80_precision_x
]);
1725 /* The explicit integer bit is ignored, after invalid checks. */
1726 p
->frac_hi
&= MAKE_64BIT_MASK(0, 63);
1727 p
->cls
= (p
->frac_hi
== 0 ? float_class_inf
1728 : parts_is_snan_frac(p
->frac_hi
, s
)
1729 ? float_class_snan
: float_class_qnan
);
1734 static floatx80
floatx80_round_pack_canonical(FloatParts128
*p
,
1737 const FloatFmt
*fmt
= &floatx80_params
[s
->floatx80_rounding_precision
];
1742 case float_class_normal
:
1743 if (s
->floatx80_rounding_precision
== floatx80_precision_x
) {
1744 parts_uncanon_normal(p
, s
, fmt
);
1752 frac_truncjam(&p64
, p
);
1753 parts_uncanon_normal(&p64
, s
, fmt
);
1757 if (exp
!= fmt
->exp_max
) {
1760 /* rounded to inf -- fall through to set frac correctly */
1762 case float_class_inf
:
1763 /* x86 and m68k differ in the setting of the integer bit. */
1764 frac
= floatx80_infinity_low
;
1768 case float_class_zero
:
1773 case float_class_snan
:
1774 case float_class_qnan
:
1775 /* NaNs have the integer bit set. */
1776 frac
= p
->frac_hi
| (1ull << 63);
1781 g_assert_not_reached();
1784 return packFloatx80(p
->sign
, exp
, frac
);
1788 * Addition and subtraction
1791 static float16 QEMU_FLATTEN
1792 float16_addsub(float16 a
, float16 b
, float_status
*status
, bool subtract
)
1794 FloatParts64 pa
, pb
, *pr
;
1796 float16_unpack_canonical(&pa
, a
, status
);
1797 float16_unpack_canonical(&pb
, b
, status
);
1798 pr
= parts_addsub(&pa
, &pb
, status
, subtract
);
1800 return float16_round_pack_canonical(pr
, status
);
1803 float16
float16_add(float16 a
, float16 b
, float_status
*status
)
1805 return float16_addsub(a
, b
, status
, false);
1808 float16
float16_sub(float16 a
, float16 b
, float_status
*status
)
1810 return float16_addsub(a
, b
, status
, true);
1813 static float32 QEMU_SOFTFLOAT_ATTR
1814 soft_f32_addsub(float32 a
, float32 b
, float_status
*status
, bool subtract
)
1816 FloatParts64 pa
, pb
, *pr
;
1818 float32_unpack_canonical(&pa
, a
, status
);
1819 float32_unpack_canonical(&pb
, b
, status
);
1820 pr
= parts_addsub(&pa
, &pb
, status
, subtract
);
1822 return float32_round_pack_canonical(pr
, status
);
1825 static float32
soft_f32_add(float32 a
, float32 b
, float_status
*status
)
1827 return soft_f32_addsub(a
, b
, status
, false);
1830 static float32
soft_f32_sub(float32 a
, float32 b
, float_status
*status
)
1832 return soft_f32_addsub(a
, b
, status
, true);
1835 static float64 QEMU_SOFTFLOAT_ATTR
1836 soft_f64_addsub(float64 a
, float64 b
, float_status
*status
, bool subtract
)
1838 FloatParts64 pa
, pb
, *pr
;
1840 float64_unpack_canonical(&pa
, a
, status
);
1841 float64_unpack_canonical(&pb
, b
, status
);
1842 pr
= parts_addsub(&pa
, &pb
, status
, subtract
);
1844 return float64_round_pack_canonical(pr
, status
);
1847 static float64
soft_f64_add(float64 a
, float64 b
, float_status
*status
)
1849 return soft_f64_addsub(a
, b
, status
, false);
1852 static float64
soft_f64_sub(float64 a
, float64 b
, float_status
*status
)
1854 return soft_f64_addsub(a
, b
, status
, true);
1857 static float hard_f32_add(float a
, float b
)
1862 static float hard_f32_sub(float a
, float b
)
1867 static double hard_f64_add(double a
, double b
)
1872 static double hard_f64_sub(double a
, double b
)
1877 static bool f32_addsubmul_post(union_float32 a
, union_float32 b
)
1879 if (QEMU_HARDFLOAT_2F32_USE_FP
) {
1880 return !(fpclassify(a
.h
) == FP_ZERO
&& fpclassify(b
.h
) == FP_ZERO
);
1882 return !(float32_is_zero(a
.s
) && float32_is_zero(b
.s
));
1885 static bool f64_addsubmul_post(union_float64 a
, union_float64 b
)
1887 if (QEMU_HARDFLOAT_2F64_USE_FP
) {
1888 return !(fpclassify(a
.h
) == FP_ZERO
&& fpclassify(b
.h
) == FP_ZERO
);
1890 return !(float64_is_zero(a
.s
) && float64_is_zero(b
.s
));
1894 static float32
float32_addsub(float32 a
, float32 b
, float_status
*s
,
1895 hard_f32_op2_fn hard
, soft_f32_op2_fn soft
)
1897 return float32_gen2(a
, b
, s
, hard
, soft
,
1898 f32_is_zon2
, f32_addsubmul_post
);
1901 static float64
float64_addsub(float64 a
, float64 b
, float_status
*s
,
1902 hard_f64_op2_fn hard
, soft_f64_op2_fn soft
)
1904 return float64_gen2(a
, b
, s
, hard
, soft
,
1905 f64_is_zon2
, f64_addsubmul_post
);
1908 float32 QEMU_FLATTEN
1909 float32_add(float32 a
, float32 b
, float_status
*s
)
1911 return float32_addsub(a
, b
, s
, hard_f32_add
, soft_f32_add
);
1914 float32 QEMU_FLATTEN
1915 float32_sub(float32 a
, float32 b
, float_status
*s
)
1917 return float32_addsub(a
, b
, s
, hard_f32_sub
, soft_f32_sub
);
1920 float64 QEMU_FLATTEN
1921 float64_add(float64 a
, float64 b
, float_status
*s
)
1923 return float64_addsub(a
, b
, s
, hard_f64_add
, soft_f64_add
);
1926 float64 QEMU_FLATTEN
1927 float64_sub(float64 a
, float64 b
, float_status
*s
)
1929 return float64_addsub(a
, b
, s
, hard_f64_sub
, soft_f64_sub
);
1932 static bfloat16 QEMU_FLATTEN
1933 bfloat16_addsub(bfloat16 a
, bfloat16 b
, float_status
*status
, bool subtract
)
1935 FloatParts64 pa
, pb
, *pr
;
1937 bfloat16_unpack_canonical(&pa
, a
, status
);
1938 bfloat16_unpack_canonical(&pb
, b
, status
);
1939 pr
= parts_addsub(&pa
, &pb
, status
, subtract
);
1941 return bfloat16_round_pack_canonical(pr
, status
);
1944 bfloat16
bfloat16_add(bfloat16 a
, bfloat16 b
, float_status
*status
)
1946 return bfloat16_addsub(a
, b
, status
, false);
1949 bfloat16
bfloat16_sub(bfloat16 a
, bfloat16 b
, float_status
*status
)
1951 return bfloat16_addsub(a
, b
, status
, true);
1954 static float128 QEMU_FLATTEN
1955 float128_addsub(float128 a
, float128 b
, float_status
*status
, bool subtract
)
1957 FloatParts128 pa
, pb
, *pr
;
1959 float128_unpack_canonical(&pa
, a
, status
);
1960 float128_unpack_canonical(&pb
, b
, status
);
1961 pr
= parts_addsub(&pa
, &pb
, status
, subtract
);
1963 return float128_round_pack_canonical(pr
, status
);
1966 float128
float128_add(float128 a
, float128 b
, float_status
*status
)
1968 return float128_addsub(a
, b
, status
, false);
1971 float128
float128_sub(float128 a
, float128 b
, float_status
*status
)
1973 return float128_addsub(a
, b
, status
, true);
1976 static floatx80 QEMU_FLATTEN
1977 floatx80_addsub(floatx80 a
, floatx80 b
, float_status
*status
, bool subtract
)
1979 FloatParts128 pa
, pb
, *pr
;
1981 if (!floatx80_unpack_canonical(&pa
, a
, status
) ||
1982 !floatx80_unpack_canonical(&pb
, b
, status
)) {
1983 return floatx80_default_nan(status
);
1986 pr
= parts_addsub(&pa
, &pb
, status
, subtract
);
1987 return floatx80_round_pack_canonical(pr
, status
);
1990 floatx80
floatx80_add(floatx80 a
, floatx80 b
, float_status
*status
)
1992 return floatx80_addsub(a
, b
, status
, false);
1995 floatx80
floatx80_sub(floatx80 a
, floatx80 b
, float_status
*status
)
1997 return floatx80_addsub(a
, b
, status
, true);
2004 float16 QEMU_FLATTEN
float16_mul(float16 a
, float16 b
, float_status
*status
)
2006 FloatParts64 pa
, pb
, *pr
;
2008 float16_unpack_canonical(&pa
, a
, status
);
2009 float16_unpack_canonical(&pb
, b
, status
);
2010 pr
= parts_mul(&pa
, &pb
, status
);
2012 return float16_round_pack_canonical(pr
, status
);
2015 static float32 QEMU_SOFTFLOAT_ATTR
2016 soft_f32_mul(float32 a
, float32 b
, float_status
*status
)
2018 FloatParts64 pa
, pb
, *pr
;
2020 float32_unpack_canonical(&pa
, a
, status
);
2021 float32_unpack_canonical(&pb
, b
, status
);
2022 pr
= parts_mul(&pa
, &pb
, status
);
2024 return float32_round_pack_canonical(pr
, status
);
2027 static float64 QEMU_SOFTFLOAT_ATTR
2028 soft_f64_mul(float64 a
, float64 b
, float_status
*status
)
2030 FloatParts64 pa
, pb
, *pr
;
2032 float64_unpack_canonical(&pa
, a
, status
);
2033 float64_unpack_canonical(&pb
, b
, status
);
2034 pr
= parts_mul(&pa
, &pb
, status
);
2036 return float64_round_pack_canonical(pr
, status
);
2039 static float hard_f32_mul(float a
, float b
)
2044 static double hard_f64_mul(double a
, double b
)
2049 float32 QEMU_FLATTEN
2050 float32_mul(float32 a
, float32 b
, float_status
*s
)
2052 return float32_gen2(a
, b
, s
, hard_f32_mul
, soft_f32_mul
,
2053 f32_is_zon2
, f32_addsubmul_post
);
2056 float64 QEMU_FLATTEN
2057 float64_mul(float64 a
, float64 b
, float_status
*s
)
2059 return float64_gen2(a
, b
, s
, hard_f64_mul
, soft_f64_mul
,
2060 f64_is_zon2
, f64_addsubmul_post
);
2063 bfloat16 QEMU_FLATTEN
2064 bfloat16_mul(bfloat16 a
, bfloat16 b
, float_status
*status
)
2066 FloatParts64 pa
, pb
, *pr
;
2068 bfloat16_unpack_canonical(&pa
, a
, status
);
2069 bfloat16_unpack_canonical(&pb
, b
, status
);
2070 pr
= parts_mul(&pa
, &pb
, status
);
2072 return bfloat16_round_pack_canonical(pr
, status
);
2075 float128 QEMU_FLATTEN
2076 float128_mul(float128 a
, float128 b
, float_status
*status
)
2078 FloatParts128 pa
, pb
, *pr
;
2080 float128_unpack_canonical(&pa
, a
, status
);
2081 float128_unpack_canonical(&pb
, b
, status
);
2082 pr
= parts_mul(&pa
, &pb
, status
);
2084 return float128_round_pack_canonical(pr
, status
);
2087 floatx80 QEMU_FLATTEN
2088 floatx80_mul(floatx80 a
, floatx80 b
, float_status
*status
)
2090 FloatParts128 pa
, pb
, *pr
;
2092 if (!floatx80_unpack_canonical(&pa
, a
, status
) ||
2093 !floatx80_unpack_canonical(&pb
, b
, status
)) {
2094 return floatx80_default_nan(status
);
2097 pr
= parts_mul(&pa
, &pb
, status
);
2098 return floatx80_round_pack_canonical(pr
, status
);
2102 * Fused multiply-add
2105 float16 QEMU_FLATTEN
float16_muladd(float16 a
, float16 b
, float16 c
,
2106 int flags
, float_status
*status
)
2108 FloatParts64 pa
, pb
, pc
, *pr
;
2110 float16_unpack_canonical(&pa
, a
, status
);
2111 float16_unpack_canonical(&pb
, b
, status
);
2112 float16_unpack_canonical(&pc
, c
, status
);
2113 pr
= parts_muladd(&pa
, &pb
, &pc
, flags
, status
);
2115 return float16_round_pack_canonical(pr
, status
);
2118 static float32 QEMU_SOFTFLOAT_ATTR
2119 soft_f32_muladd(float32 a
, float32 b
, float32 c
, int flags
,
2120 float_status
*status
)
2122 FloatParts64 pa
, pb
, pc
, *pr
;
2124 float32_unpack_canonical(&pa
, a
, status
);
2125 float32_unpack_canonical(&pb
, b
, status
);
2126 float32_unpack_canonical(&pc
, c
, status
);
2127 pr
= parts_muladd(&pa
, &pb
, &pc
, flags
, status
);
2129 return float32_round_pack_canonical(pr
, status
);
2132 static float64 QEMU_SOFTFLOAT_ATTR
2133 soft_f64_muladd(float64 a
, float64 b
, float64 c
, int flags
,
2134 float_status
*status
)
2136 FloatParts64 pa
, pb
, pc
, *pr
;
2138 float64_unpack_canonical(&pa
, a
, status
);
2139 float64_unpack_canonical(&pb
, b
, status
);
2140 float64_unpack_canonical(&pc
, c
, status
);
2141 pr
= parts_muladd(&pa
, &pb
, &pc
, flags
, status
);
2143 return float64_round_pack_canonical(pr
, status
);
2146 static bool force_soft_fma
;
2148 float32 QEMU_FLATTEN
2149 float32_muladd(float32 xa
, float32 xb
, float32 xc
, int flags
, float_status
*s
)
2151 union_float32 ua
, ub
, uc
, ur
;
2157 if (unlikely(!can_use_fpu(s
))) {
2160 if (unlikely(flags
& float_muladd_halve_result
)) {
2164 float32_input_flush3(&ua
.s
, &ub
.s
, &uc
.s
, s
);
2165 if (unlikely(!f32_is_zon3(ua
, ub
, uc
))) {
2169 if (unlikely(force_soft_fma
)) {
2174 * When (a || b) == 0, there's no need to check for under/over flow,
2175 * since we know the addend is (normal || 0) and the product is 0.
2177 if (float32_is_zero(ua
.s
) || float32_is_zero(ub
.s
)) {
2181 prod_sign
= float32_is_neg(ua
.s
) ^ float32_is_neg(ub
.s
);
2182 prod_sign
^= !!(flags
& float_muladd_negate_product
);
2183 up
.s
= float32_set_sign(float32_zero
, prod_sign
);
2185 if (flags
& float_muladd_negate_c
) {
2190 union_float32 ua_orig
= ua
;
2191 union_float32 uc_orig
= uc
;
2193 if (flags
& float_muladd_negate_product
) {
2196 if (flags
& float_muladd_negate_c
) {
2200 ur
.h
= fmaf(ua
.h
, ub
.h
, uc
.h
);
2202 if (unlikely(f32_is_inf(ur
))) {
2203 float_raise(float_flag_overflow
, s
);
2204 } else if (unlikely(fabsf(ur
.h
) <= FLT_MIN
)) {
2210 if (flags
& float_muladd_negate_result
) {
2211 return float32_chs(ur
.s
);
2216 return soft_f32_muladd(ua
.s
, ub
.s
, uc
.s
, flags
, s
);
2219 float64 QEMU_FLATTEN
2220 float64_muladd(float64 xa
, float64 xb
, float64 xc
, int flags
, float_status
*s
)
2222 union_float64 ua
, ub
, uc
, ur
;
2228 if (unlikely(!can_use_fpu(s
))) {
2231 if (unlikely(flags
& float_muladd_halve_result
)) {
2235 float64_input_flush3(&ua
.s
, &ub
.s
, &uc
.s
, s
);
2236 if (unlikely(!f64_is_zon3(ua
, ub
, uc
))) {
2240 if (unlikely(force_soft_fma
)) {
2245 * When (a || b) == 0, there's no need to check for under/over flow,
2246 * since we know the addend is (normal || 0) and the product is 0.
2248 if (float64_is_zero(ua
.s
) || float64_is_zero(ub
.s
)) {
2252 prod_sign
= float64_is_neg(ua
.s
) ^ float64_is_neg(ub
.s
);
2253 prod_sign
^= !!(flags
& float_muladd_negate_product
);
2254 up
.s
= float64_set_sign(float64_zero
, prod_sign
);
2256 if (flags
& float_muladd_negate_c
) {
2261 union_float64 ua_orig
= ua
;
2262 union_float64 uc_orig
= uc
;
2264 if (flags
& float_muladd_negate_product
) {
2267 if (flags
& float_muladd_negate_c
) {
2271 ur
.h
= fma(ua
.h
, ub
.h
, uc
.h
);
2273 if (unlikely(f64_is_inf(ur
))) {
2274 float_raise(float_flag_overflow
, s
);
2275 } else if (unlikely(fabs(ur
.h
) <= FLT_MIN
)) {
2281 if (flags
& float_muladd_negate_result
) {
2282 return float64_chs(ur
.s
);
2287 return soft_f64_muladd(ua
.s
, ub
.s
, uc
.s
, flags
, s
);
2290 bfloat16 QEMU_FLATTEN
bfloat16_muladd(bfloat16 a
, bfloat16 b
, bfloat16 c
,
2291 int flags
, float_status
*status
)
2293 FloatParts64 pa
, pb
, pc
, *pr
;
2295 bfloat16_unpack_canonical(&pa
, a
, status
);
2296 bfloat16_unpack_canonical(&pb
, b
, status
);
2297 bfloat16_unpack_canonical(&pc
, c
, status
);
2298 pr
= parts_muladd(&pa
, &pb
, &pc
, flags
, status
);
2300 return bfloat16_round_pack_canonical(pr
, status
);
2303 float128 QEMU_FLATTEN
float128_muladd(float128 a
, float128 b
, float128 c
,
2304 int flags
, float_status
*status
)
2306 FloatParts128 pa
, pb
, pc
, *pr
;
2308 float128_unpack_canonical(&pa
, a
, status
);
2309 float128_unpack_canonical(&pb
, b
, status
);
2310 float128_unpack_canonical(&pc
, c
, status
);
2311 pr
= parts_muladd(&pa
, &pb
, &pc
, flags
, status
);
2313 return float128_round_pack_canonical(pr
, status
);
2320 float16
float16_div(float16 a
, float16 b
, float_status
*status
)
2322 FloatParts64 pa
, pb
, *pr
;
2324 float16_unpack_canonical(&pa
, a
, status
);
2325 float16_unpack_canonical(&pb
, b
, status
);
2326 pr
= parts_div(&pa
, &pb
, status
);
2328 return float16_round_pack_canonical(pr
, status
);
2331 static float32 QEMU_SOFTFLOAT_ATTR
2332 soft_f32_div(float32 a
, float32 b
, float_status
*status
)
2334 FloatParts64 pa
, pb
, *pr
;
2336 float32_unpack_canonical(&pa
, a
, status
);
2337 float32_unpack_canonical(&pb
, b
, status
);
2338 pr
= parts_div(&pa
, &pb
, status
);
2340 return float32_round_pack_canonical(pr
, status
);
2343 static float64 QEMU_SOFTFLOAT_ATTR
2344 soft_f64_div(float64 a
, float64 b
, float_status
*status
)
2346 FloatParts64 pa
, pb
, *pr
;
2348 float64_unpack_canonical(&pa
, a
, status
);
2349 float64_unpack_canonical(&pb
, b
, status
);
2350 pr
= parts_div(&pa
, &pb
, status
);
2352 return float64_round_pack_canonical(pr
, status
);
2355 static float hard_f32_div(float a
, float b
)
2360 static double hard_f64_div(double a
, double b
)
2365 static bool f32_div_pre(union_float32 a
, union_float32 b
)
2367 if (QEMU_HARDFLOAT_2F32_USE_FP
) {
2368 return (fpclassify(a
.h
) == FP_NORMAL
|| fpclassify(a
.h
) == FP_ZERO
) &&
2369 fpclassify(b
.h
) == FP_NORMAL
;
2371 return float32_is_zero_or_normal(a
.s
) && float32_is_normal(b
.s
);
2374 static bool f64_div_pre(union_float64 a
, union_float64 b
)
2376 if (QEMU_HARDFLOAT_2F64_USE_FP
) {
2377 return (fpclassify(a
.h
) == FP_NORMAL
|| fpclassify(a
.h
) == FP_ZERO
) &&
2378 fpclassify(b
.h
) == FP_NORMAL
;
2380 return float64_is_zero_or_normal(a
.s
) && float64_is_normal(b
.s
);
2383 static bool f32_div_post(union_float32 a
, union_float32 b
)
2385 if (QEMU_HARDFLOAT_2F32_USE_FP
) {
2386 return fpclassify(a
.h
) != FP_ZERO
;
2388 return !float32_is_zero(a
.s
);
2391 static bool f64_div_post(union_float64 a
, union_float64 b
)
2393 if (QEMU_HARDFLOAT_2F64_USE_FP
) {
2394 return fpclassify(a
.h
) != FP_ZERO
;
2396 return !float64_is_zero(a
.s
);
2399 float32 QEMU_FLATTEN
2400 float32_div(float32 a
, float32 b
, float_status
*s
)
2402 return float32_gen2(a
, b
, s
, hard_f32_div
, soft_f32_div
,
2403 f32_div_pre
, f32_div_post
);
2406 float64 QEMU_FLATTEN
2407 float64_div(float64 a
, float64 b
, float_status
*s
)
2409 return float64_gen2(a
, b
, s
, hard_f64_div
, soft_f64_div
,
2410 f64_div_pre
, f64_div_post
);
2413 bfloat16 QEMU_FLATTEN
2414 bfloat16_div(bfloat16 a
, bfloat16 b
, float_status
*status
)
2416 FloatParts64 pa
, pb
, *pr
;
2418 bfloat16_unpack_canonical(&pa
, a
, status
);
2419 bfloat16_unpack_canonical(&pb
, b
, status
);
2420 pr
= parts_div(&pa
, &pb
, status
);
2422 return bfloat16_round_pack_canonical(pr
, status
);
2425 float128 QEMU_FLATTEN
2426 float128_div(float128 a
, float128 b
, float_status
*status
)
2428 FloatParts128 pa
, pb
, *pr
;
2430 float128_unpack_canonical(&pa
, a
, status
);
2431 float128_unpack_canonical(&pb
, b
, status
);
2432 pr
= parts_div(&pa
, &pb
, status
);
2434 return float128_round_pack_canonical(pr
, status
);
2437 floatx80
floatx80_div(floatx80 a
, floatx80 b
, float_status
*status
)
2439 FloatParts128 pa
, pb
, *pr
;
2441 if (!floatx80_unpack_canonical(&pa
, a
, status
) ||
2442 !floatx80_unpack_canonical(&pb
, b
, status
)) {
2443 return floatx80_default_nan(status
);
2446 pr
= parts_div(&pa
, &pb
, status
);
2447 return floatx80_round_pack_canonical(pr
, status
);
2454 float32
float32_rem(float32 a
, float32 b
, float_status
*status
)
2456 FloatParts64 pa
, pb
, *pr
;
2458 float32_unpack_canonical(&pa
, a
, status
);
2459 float32_unpack_canonical(&pb
, b
, status
);
2460 pr
= parts_modrem(&pa
, &pb
, NULL
, status
);
2462 return float32_round_pack_canonical(pr
, status
);
2465 float64
float64_rem(float64 a
, float64 b
, float_status
*status
)
2467 FloatParts64 pa
, pb
, *pr
;
2469 float64_unpack_canonical(&pa
, a
, status
);
2470 float64_unpack_canonical(&pb
, b
, status
);
2471 pr
= parts_modrem(&pa
, &pb
, NULL
, status
);
2473 return float64_round_pack_canonical(pr
, status
);
2476 float128
float128_rem(float128 a
, float128 b
, float_status
*status
)
2478 FloatParts128 pa
, pb
, *pr
;
2480 float128_unpack_canonical(&pa
, a
, status
);
2481 float128_unpack_canonical(&pb
, b
, status
);
2482 pr
= parts_modrem(&pa
, &pb
, NULL
, status
);
2484 return float128_round_pack_canonical(pr
, status
);
2488 * Returns the remainder of the extended double-precision floating-point value
2489 * `a' with respect to the corresponding value `b'.
2490 * If 'mod' is false, the operation is performed according to the IEC/IEEE
2491 * Standard for Binary Floating-Point Arithmetic. If 'mod' is true, return
2492 * the remainder based on truncating the quotient toward zero instead and
2493 * *quotient is set to the low 64 bits of the absolute value of the integer
2496 floatx80
floatx80_modrem(floatx80 a
, floatx80 b
, bool mod
,
2497 uint64_t *quotient
, float_status
*status
)
2499 FloatParts128 pa
, pb
, *pr
;
2502 if (!floatx80_unpack_canonical(&pa
, a
, status
) ||
2503 !floatx80_unpack_canonical(&pb
, b
, status
)) {
2504 return floatx80_default_nan(status
);
2506 pr
= parts_modrem(&pa
, &pb
, mod
? quotient
: NULL
, status
);
2508 return floatx80_round_pack_canonical(pr
, status
);
2511 floatx80
floatx80_rem(floatx80 a
, floatx80 b
, float_status
*status
)
2514 return floatx80_modrem(a
, b
, false, "ient
, status
);
2517 floatx80
floatx80_mod(floatx80 a
, floatx80 b
, float_status
*status
)
2520 return floatx80_modrem(a
, b
, true, "ient
, status
);
2524 * Float to Float conversions
2526 * Returns the result of converting one float format to another. The
2527 * conversion is performed according to the IEC/IEEE Standard for
2528 * Binary Floating-Point Arithmetic.
2530 * Usually this only needs to take care of raising invalid exceptions
2531 * and handling the conversion on NaNs.
2534 static void parts_float_to_ahp(FloatParts64
*a
, float_status
*s
)
2537 case float_class_qnan
:
2538 case float_class_snan
:
2540 * There is no NaN in the destination format. Raise Invalid
2541 * and return a zero with the sign of the input NaN.
2543 float_raise(float_flag_invalid
, s
);
2544 a
->cls
= float_class_zero
;
2547 case float_class_inf
:
2549 * There is no Inf in the destination format. Raise Invalid
2550 * and return the maximum normal with the correct sign.
2552 float_raise(float_flag_invalid
, s
);
2553 a
->cls
= float_class_normal
;
2554 a
->exp
= float16_params_ahp
.exp_max
;
2555 a
->frac
= MAKE_64BIT_MASK(float16_params_ahp
.frac_shift
,
2556 float16_params_ahp
.frac_size
+ 1);
2559 case float_class_normal
:
2560 case float_class_zero
:
2564 g_assert_not_reached();
2568 static void parts64_float_to_float(FloatParts64
*a
, float_status
*s
)
2570 if (is_nan(a
->cls
)) {
2571 parts_return_nan(a
, s
);
2575 static void parts128_float_to_float(FloatParts128
*a
, float_status
*s
)
2577 if (is_nan(a
->cls
)) {
2578 parts_return_nan(a
, s
);
2582 #define parts_float_to_float(P, S) \
2583 PARTS_GENERIC_64_128(float_to_float, P)(P, S)
2585 static void parts_float_to_float_narrow(FloatParts64
*a
, FloatParts128
*b
,
2592 if (a
->cls
== float_class_normal
) {
2593 frac_truncjam(a
, b
);
2594 } else if (is_nan(a
->cls
)) {
2595 /* Discard the low bits of the NaN. */
2596 a
->frac
= b
->frac_hi
;
2597 parts_return_nan(a
, s
);
2601 static void parts_float_to_float_widen(FloatParts128
*a
, FloatParts64
*b
,
2609 if (is_nan(a
->cls
)) {
2610 parts_return_nan(a
, s
);
2614 float32
float16_to_float32(float16 a
, bool ieee
, float_status
*s
)
2616 const FloatFmt
*fmt16
= ieee
? &float16_params
: &float16_params_ahp
;
2619 float16a_unpack_canonical(&p
, a
, s
, fmt16
);
2620 parts_float_to_float(&p
, s
);
2621 return float32_round_pack_canonical(&p
, s
);
2624 float64
float16_to_float64(float16 a
, bool ieee
, float_status
*s
)
2626 const FloatFmt
*fmt16
= ieee
? &float16_params
: &float16_params_ahp
;
2629 float16a_unpack_canonical(&p
, a
, s
, fmt16
);
2630 parts_float_to_float(&p
, s
);
2631 return float64_round_pack_canonical(&p
, s
);
2634 float16
float32_to_float16(float32 a
, bool ieee
, float_status
*s
)
2637 const FloatFmt
*fmt
;
2639 float32_unpack_canonical(&p
, a
, s
);
2641 parts_float_to_float(&p
, s
);
2642 fmt
= &float16_params
;
2644 parts_float_to_ahp(&p
, s
);
2645 fmt
= &float16_params_ahp
;
2647 return float16a_round_pack_canonical(&p
, s
, fmt
);
2650 static float64 QEMU_SOFTFLOAT_ATTR
2651 soft_float32_to_float64(float32 a
, float_status
*s
)
2655 float32_unpack_canonical(&p
, a
, s
);
2656 parts_float_to_float(&p
, s
);
2657 return float64_round_pack_canonical(&p
, s
);
2660 float64
float32_to_float64(float32 a
, float_status
*s
)
2662 if (likely(float32_is_normal(a
))) {
2663 /* Widening conversion can never produce inexact results. */
2669 } else if (float32_is_zero(a
)) {
2670 return float64_set_sign(float64_zero
, float32_is_neg(a
));
2672 return soft_float32_to_float64(a
, s
);
2676 float16
float64_to_float16(float64 a
, bool ieee
, float_status
*s
)
2679 const FloatFmt
*fmt
;
2681 float64_unpack_canonical(&p
, a
, s
);
2683 parts_float_to_float(&p
, s
);
2684 fmt
= &float16_params
;
2686 parts_float_to_ahp(&p
, s
);
2687 fmt
= &float16_params_ahp
;
2689 return float16a_round_pack_canonical(&p
, s
, fmt
);
2692 float32
float64_to_float32(float64 a
, float_status
*s
)
2696 float64_unpack_canonical(&p
, a
, s
);
2697 parts_float_to_float(&p
, s
);
2698 return float32_round_pack_canonical(&p
, s
);
2701 float32
bfloat16_to_float32(bfloat16 a
, float_status
*s
)
2705 bfloat16_unpack_canonical(&p
, a
, s
);
2706 parts_float_to_float(&p
, s
);
2707 return float32_round_pack_canonical(&p
, s
);
2710 float64
bfloat16_to_float64(bfloat16 a
, float_status
*s
)
2714 bfloat16_unpack_canonical(&p
, a
, s
);
2715 parts_float_to_float(&p
, s
);
2716 return float64_round_pack_canonical(&p
, s
);
2719 bfloat16
float32_to_bfloat16(float32 a
, float_status
*s
)
2723 float32_unpack_canonical(&p
, a
, s
);
2724 parts_float_to_float(&p
, s
);
2725 return bfloat16_round_pack_canonical(&p
, s
);
2728 bfloat16
float64_to_bfloat16(float64 a
, float_status
*s
)
2732 float64_unpack_canonical(&p
, a
, s
);
2733 parts_float_to_float(&p
, s
);
2734 return bfloat16_round_pack_canonical(&p
, s
);
2737 float32
float128_to_float32(float128 a
, float_status
*s
)
2742 float128_unpack_canonical(&p128
, a
, s
);
2743 parts_float_to_float_narrow(&p64
, &p128
, s
);
2744 return float32_round_pack_canonical(&p64
, s
);
2747 float64
float128_to_float64(float128 a
, float_status
*s
)
2752 float128_unpack_canonical(&p128
, a
, s
);
2753 parts_float_to_float_narrow(&p64
, &p128
, s
);
2754 return float64_round_pack_canonical(&p64
, s
);
2757 float128
float32_to_float128(float32 a
, float_status
*s
)
2762 float32_unpack_canonical(&p64
, a
, s
);
2763 parts_float_to_float_widen(&p128
, &p64
, s
);
2764 return float128_round_pack_canonical(&p128
, s
);
2767 float128
float64_to_float128(float64 a
, float_status
*s
)
2772 float64_unpack_canonical(&p64
, a
, s
);
2773 parts_float_to_float_widen(&p128
, &p64
, s
);
2774 return float128_round_pack_canonical(&p128
, s
);
2777 float32
floatx80_to_float32(floatx80 a
, float_status
*s
)
2782 if (floatx80_unpack_canonical(&p128
, a
, s
)) {
2783 parts_float_to_float_narrow(&p64
, &p128
, s
);
2785 parts_default_nan(&p64
, s
);
2787 return float32_round_pack_canonical(&p64
, s
);
2790 float64
floatx80_to_float64(floatx80 a
, float_status
*s
)
2795 if (floatx80_unpack_canonical(&p128
, a
, s
)) {
2796 parts_float_to_float_narrow(&p64
, &p128
, s
);
2798 parts_default_nan(&p64
, s
);
2800 return float64_round_pack_canonical(&p64
, s
);
2803 float128
floatx80_to_float128(floatx80 a
, float_status
*s
)
2807 if (floatx80_unpack_canonical(&p
, a
, s
)) {
2808 parts_float_to_float(&p
, s
);
2810 parts_default_nan(&p
, s
);
2812 return float128_round_pack_canonical(&p
, s
);
2815 floatx80
float32_to_floatx80(float32 a
, float_status
*s
)
2820 float32_unpack_canonical(&p64
, a
, s
);
2821 parts_float_to_float_widen(&p128
, &p64
, s
);
2822 return floatx80_round_pack_canonical(&p128
, s
);
2825 floatx80
float64_to_floatx80(float64 a
, float_status
*s
)
2830 float64_unpack_canonical(&p64
, a
, s
);
2831 parts_float_to_float_widen(&p128
, &p64
, s
);
2832 return floatx80_round_pack_canonical(&p128
, s
);
2835 floatx80
float128_to_floatx80(float128 a
, float_status
*s
)
2839 float128_unpack_canonical(&p
, a
, s
);
2840 parts_float_to_float(&p
, s
);
2841 return floatx80_round_pack_canonical(&p
, s
);
2845 * Round to integral value
2848 float16
float16_round_to_int(float16 a
, float_status
*s
)
2852 float16_unpack_canonical(&p
, a
, s
);
2853 parts_round_to_int(&p
, s
->float_rounding_mode
, 0, s
, &float16_params
);
2854 return float16_round_pack_canonical(&p
, s
);
2857 float32
float32_round_to_int(float32 a
, float_status
*s
)
2861 float32_unpack_canonical(&p
, a
, s
);
2862 parts_round_to_int(&p
, s
->float_rounding_mode
, 0, s
, &float32_params
);
2863 return float32_round_pack_canonical(&p
, s
);
2866 float64
float64_round_to_int(float64 a
, float_status
*s
)
2870 float64_unpack_canonical(&p
, a
, s
);
2871 parts_round_to_int(&p
, s
->float_rounding_mode
, 0, s
, &float64_params
);
2872 return float64_round_pack_canonical(&p
, s
);
2875 bfloat16
bfloat16_round_to_int(bfloat16 a
, float_status
*s
)
2879 bfloat16_unpack_canonical(&p
, a
, s
);
2880 parts_round_to_int(&p
, s
->float_rounding_mode
, 0, s
, &bfloat16_params
);
2881 return bfloat16_round_pack_canonical(&p
, s
);
2884 float128
float128_round_to_int(float128 a
, float_status
*s
)
2888 float128_unpack_canonical(&p
, a
, s
);
2889 parts_round_to_int(&p
, s
->float_rounding_mode
, 0, s
, &float128_params
);
2890 return float128_round_pack_canonical(&p
, s
);
2893 floatx80
floatx80_round_to_int(floatx80 a
, float_status
*status
)
2897 if (!floatx80_unpack_canonical(&p
, a
, status
)) {
2898 return floatx80_default_nan(status
);
2901 parts_round_to_int(&p
, status
->float_rounding_mode
, 0, status
,
2902 &floatx80_params
[status
->floatx80_rounding_precision
]);
2903 return floatx80_round_pack_canonical(&p
, status
);
2907 * Floating-point to signed integer conversions
2910 int8_t float16_to_int8_scalbn(float16 a
, FloatRoundMode rmode
, int scale
,
2915 float16_unpack_canonical(&p
, a
, s
);
2916 return parts_float_to_sint(&p
, rmode
, scale
, INT8_MIN
, INT8_MAX
, s
);
2919 int16_t float16_to_int16_scalbn(float16 a
, FloatRoundMode rmode
, int scale
,
2924 float16_unpack_canonical(&p
, a
, s
);
2925 return parts_float_to_sint(&p
, rmode
, scale
, INT16_MIN
, INT16_MAX
, s
);
2928 int32_t float16_to_int32_scalbn(float16 a
, FloatRoundMode rmode
, int scale
,
2933 float16_unpack_canonical(&p
, a
, s
);
2934 return parts_float_to_sint(&p
, rmode
, scale
, INT32_MIN
, INT32_MAX
, s
);
2937 int64_t float16_to_int64_scalbn(float16 a
, FloatRoundMode rmode
, int scale
,
2942 float16_unpack_canonical(&p
, a
, s
);
2943 return parts_float_to_sint(&p
, rmode
, scale
, INT64_MIN
, INT64_MAX
, s
);
2946 int16_t float32_to_int16_scalbn(float32 a
, FloatRoundMode rmode
, int scale
,
2951 float32_unpack_canonical(&p
, a
, s
);
2952 return parts_float_to_sint(&p
, rmode
, scale
, INT16_MIN
, INT16_MAX
, s
);
2955 int32_t float32_to_int32_scalbn(float32 a
, FloatRoundMode rmode
, int scale
,
2960 float32_unpack_canonical(&p
, a
, s
);
2961 return parts_float_to_sint(&p
, rmode
, scale
, INT32_MIN
, INT32_MAX
, s
);
2964 int64_t float32_to_int64_scalbn(float32 a
, FloatRoundMode rmode
, int scale
,
2969 float32_unpack_canonical(&p
, a
, s
);
2970 return parts_float_to_sint(&p
, rmode
, scale
, INT64_MIN
, INT64_MAX
, s
);
2973 int16_t float64_to_int16_scalbn(float64 a
, FloatRoundMode rmode
, int scale
,
2978 float64_unpack_canonical(&p
, a
, s
);
2979 return parts_float_to_sint(&p
, rmode
, scale
, INT16_MIN
, INT16_MAX
, s
);
2982 int32_t float64_to_int32_scalbn(float64 a
, FloatRoundMode rmode
, int scale
,
2987 float64_unpack_canonical(&p
, a
, s
);
2988 return parts_float_to_sint(&p
, rmode
, scale
, INT32_MIN
, INT32_MAX
, s
);
2991 int64_t float64_to_int64_scalbn(float64 a
, FloatRoundMode rmode
, int scale
,
2996 float64_unpack_canonical(&p
, a
, s
);
2997 return parts_float_to_sint(&p
, rmode
, scale
, INT64_MIN
, INT64_MAX
, s
);
3000 int16_t bfloat16_to_int16_scalbn(bfloat16 a
, FloatRoundMode rmode
, int scale
,
3005 bfloat16_unpack_canonical(&p
, a
, s
);
3006 return parts_float_to_sint(&p
, rmode
, scale
, INT16_MIN
, INT16_MAX
, s
);
3009 int32_t bfloat16_to_int32_scalbn(bfloat16 a
, FloatRoundMode rmode
, int scale
,
3014 bfloat16_unpack_canonical(&p
, a
, s
);
3015 return parts_float_to_sint(&p
, rmode
, scale
, INT32_MIN
, INT32_MAX
, s
);
3018 int64_t bfloat16_to_int64_scalbn(bfloat16 a
, FloatRoundMode rmode
, int scale
,
3023 bfloat16_unpack_canonical(&p
, a
, s
);
3024 return parts_float_to_sint(&p
, rmode
, scale
, INT64_MIN
, INT64_MAX
, s
);
3027 static int32_t float128_to_int32_scalbn(float128 a
, FloatRoundMode rmode
,
3028 int scale
, float_status
*s
)
3032 float128_unpack_canonical(&p
, a
, s
);
3033 return parts_float_to_sint(&p
, rmode
, scale
, INT32_MIN
, INT32_MAX
, s
);
3036 static int64_t float128_to_int64_scalbn(float128 a
, FloatRoundMode rmode
,
3037 int scale
, float_status
*s
)
3041 float128_unpack_canonical(&p
, a
, s
);
3042 return parts_float_to_sint(&p
, rmode
, scale
, INT64_MIN
, INT64_MAX
, s
);
3045 static int32_t floatx80_to_int32_scalbn(floatx80 a
, FloatRoundMode rmode
,
3046 int scale
, float_status
*s
)
3050 if (!floatx80_unpack_canonical(&p
, a
, s
)) {
3051 parts_default_nan(&p
, s
);
3053 return parts_float_to_sint(&p
, rmode
, scale
, INT32_MIN
, INT32_MAX
, s
);
3056 static int64_t floatx80_to_int64_scalbn(floatx80 a
, FloatRoundMode rmode
,
3057 int scale
, float_status
*s
)
3061 if (!floatx80_unpack_canonical(&p
, a
, s
)) {
3062 parts_default_nan(&p
, s
);
3064 return parts_float_to_sint(&p
, rmode
, scale
, INT64_MIN
, INT64_MAX
, s
);
3067 int8_t float16_to_int8(float16 a
, float_status
*s
)
3069 return float16_to_int8_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3072 int16_t float16_to_int16(float16 a
, float_status
*s
)
3074 return float16_to_int16_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3077 int32_t float16_to_int32(float16 a
, float_status
*s
)
3079 return float16_to_int32_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3082 int64_t float16_to_int64(float16 a
, float_status
*s
)
3084 return float16_to_int64_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3087 int16_t float32_to_int16(float32 a
, float_status
*s
)
3089 return float32_to_int16_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3092 int32_t float32_to_int32(float32 a
, float_status
*s
)
3094 return float32_to_int32_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3097 int64_t float32_to_int64(float32 a
, float_status
*s
)
3099 return float32_to_int64_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3102 int16_t float64_to_int16(float64 a
, float_status
*s
)
3104 return float64_to_int16_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3107 int32_t float64_to_int32(float64 a
, float_status
*s
)
3109 return float64_to_int32_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3112 int64_t float64_to_int64(float64 a
, float_status
*s
)
3114 return float64_to_int64_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3117 int32_t float128_to_int32(float128 a
, float_status
*s
)
3119 return float128_to_int32_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3122 int64_t float128_to_int64(float128 a
, float_status
*s
)
3124 return float128_to_int64_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3127 int32_t floatx80_to_int32(floatx80 a
, float_status
*s
)
3129 return floatx80_to_int32_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3132 int64_t floatx80_to_int64(floatx80 a
, float_status
*s
)
3134 return floatx80_to_int64_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3137 int16_t float16_to_int16_round_to_zero(float16 a
, float_status
*s
)
3139 return float16_to_int16_scalbn(a
, float_round_to_zero
, 0, s
);
3142 int32_t float16_to_int32_round_to_zero(float16 a
, float_status
*s
)
3144 return float16_to_int32_scalbn(a
, float_round_to_zero
, 0, s
);
3147 int64_t float16_to_int64_round_to_zero(float16 a
, float_status
*s
)
3149 return float16_to_int64_scalbn(a
, float_round_to_zero
, 0, s
);
3152 int16_t float32_to_int16_round_to_zero(float32 a
, float_status
*s
)
3154 return float32_to_int16_scalbn(a
, float_round_to_zero
, 0, s
);
3157 int32_t float32_to_int32_round_to_zero(float32 a
, float_status
*s
)
3159 return float32_to_int32_scalbn(a
, float_round_to_zero
, 0, s
);
3162 int64_t float32_to_int64_round_to_zero(float32 a
, float_status
*s
)
3164 return float32_to_int64_scalbn(a
, float_round_to_zero
, 0, s
);
3167 int16_t float64_to_int16_round_to_zero(float64 a
, float_status
*s
)
3169 return float64_to_int16_scalbn(a
, float_round_to_zero
, 0, s
);
3172 int32_t float64_to_int32_round_to_zero(float64 a
, float_status
*s
)
3174 return float64_to_int32_scalbn(a
, float_round_to_zero
, 0, s
);
3177 int64_t float64_to_int64_round_to_zero(float64 a
, float_status
*s
)
3179 return float64_to_int64_scalbn(a
, float_round_to_zero
, 0, s
);
3182 int32_t float128_to_int32_round_to_zero(float128 a
, float_status
*s
)
3184 return float128_to_int32_scalbn(a
, float_round_to_zero
, 0, s
);
3187 int64_t float128_to_int64_round_to_zero(float128 a
, float_status
*s
)
3189 return float128_to_int64_scalbn(a
, float_round_to_zero
, 0, s
);
3192 int32_t floatx80_to_int32_round_to_zero(floatx80 a
, float_status
*s
)
3194 return floatx80_to_int32_scalbn(a
, float_round_to_zero
, 0, s
);
3197 int64_t floatx80_to_int64_round_to_zero(floatx80 a
, float_status
*s
)
3199 return floatx80_to_int64_scalbn(a
, float_round_to_zero
, 0, s
);
3202 int16_t bfloat16_to_int16(bfloat16 a
, float_status
*s
)
3204 return bfloat16_to_int16_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3207 int32_t bfloat16_to_int32(bfloat16 a
, float_status
*s
)
3209 return bfloat16_to_int32_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3212 int64_t bfloat16_to_int64(bfloat16 a
, float_status
*s
)
3214 return bfloat16_to_int64_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3217 int16_t bfloat16_to_int16_round_to_zero(bfloat16 a
, float_status
*s
)
3219 return bfloat16_to_int16_scalbn(a
, float_round_to_zero
, 0, s
);
3222 int32_t bfloat16_to_int32_round_to_zero(bfloat16 a
, float_status
*s
)
3224 return bfloat16_to_int32_scalbn(a
, float_round_to_zero
, 0, s
);
3227 int64_t bfloat16_to_int64_round_to_zero(bfloat16 a
, float_status
*s
)
3229 return bfloat16_to_int64_scalbn(a
, float_round_to_zero
, 0, s
);
3233 * Floating-point to unsigned integer conversions
3236 uint8_t float16_to_uint8_scalbn(float16 a
, FloatRoundMode rmode
, int scale
,
3241 float16_unpack_canonical(&p
, a
, s
);
3242 return parts_float_to_uint(&p
, rmode
, scale
, UINT8_MAX
, s
);
3245 uint16_t float16_to_uint16_scalbn(float16 a
, FloatRoundMode rmode
, int scale
,
3250 float16_unpack_canonical(&p
, a
, s
);
3251 return parts_float_to_uint(&p
, rmode
, scale
, UINT16_MAX
, s
);
3254 uint32_t float16_to_uint32_scalbn(float16 a
, FloatRoundMode rmode
, int scale
,
3259 float16_unpack_canonical(&p
, a
, s
);
3260 return parts_float_to_uint(&p
, rmode
, scale
, UINT32_MAX
, s
);
3263 uint64_t float16_to_uint64_scalbn(float16 a
, FloatRoundMode rmode
, int scale
,
3268 float16_unpack_canonical(&p
, a
, s
);
3269 return parts_float_to_uint(&p
, rmode
, scale
, UINT64_MAX
, s
);
3272 uint16_t float32_to_uint16_scalbn(float32 a
, FloatRoundMode rmode
, int scale
,
3277 float32_unpack_canonical(&p
, a
, s
);
3278 return parts_float_to_uint(&p
, rmode
, scale
, UINT16_MAX
, s
);
3281 uint32_t float32_to_uint32_scalbn(float32 a
, FloatRoundMode rmode
, int scale
,
3286 float32_unpack_canonical(&p
, a
, s
);
3287 return parts_float_to_uint(&p
, rmode
, scale
, UINT32_MAX
, s
);
3290 uint64_t float32_to_uint64_scalbn(float32 a
, FloatRoundMode rmode
, int scale
,
3295 float32_unpack_canonical(&p
, a
, s
);
3296 return parts_float_to_uint(&p
, rmode
, scale
, UINT64_MAX
, s
);
3299 uint16_t float64_to_uint16_scalbn(float64 a
, FloatRoundMode rmode
, int scale
,
3304 float64_unpack_canonical(&p
, a
, s
);
3305 return parts_float_to_uint(&p
, rmode
, scale
, UINT16_MAX
, s
);
3308 uint32_t float64_to_uint32_scalbn(float64 a
, FloatRoundMode rmode
, int scale
,
3313 float64_unpack_canonical(&p
, a
, s
);
3314 return parts_float_to_uint(&p
, rmode
, scale
, UINT32_MAX
, s
);
3317 uint64_t float64_to_uint64_scalbn(float64 a
, FloatRoundMode rmode
, int scale
,
3322 float64_unpack_canonical(&p
, a
, s
);
3323 return parts_float_to_uint(&p
, rmode
, scale
, UINT64_MAX
, s
);
3326 uint16_t bfloat16_to_uint16_scalbn(bfloat16 a
, FloatRoundMode rmode
,
3327 int scale
, float_status
*s
)
3331 bfloat16_unpack_canonical(&p
, a
, s
);
3332 return parts_float_to_uint(&p
, rmode
, scale
, UINT16_MAX
, s
);
3335 uint32_t bfloat16_to_uint32_scalbn(bfloat16 a
, FloatRoundMode rmode
,
3336 int scale
, float_status
*s
)
3340 bfloat16_unpack_canonical(&p
, a
, s
);
3341 return parts_float_to_uint(&p
, rmode
, scale
, UINT32_MAX
, s
);
3344 uint64_t bfloat16_to_uint64_scalbn(bfloat16 a
, FloatRoundMode rmode
,
3345 int scale
, float_status
*s
)
3349 bfloat16_unpack_canonical(&p
, a
, s
);
3350 return parts_float_to_uint(&p
, rmode
, scale
, UINT64_MAX
, s
);
3353 static uint32_t float128_to_uint32_scalbn(float128 a
, FloatRoundMode rmode
,
3354 int scale
, float_status
*s
)
3358 float128_unpack_canonical(&p
, a
, s
);
3359 return parts_float_to_uint(&p
, rmode
, scale
, UINT32_MAX
, s
);
3362 static uint64_t float128_to_uint64_scalbn(float128 a
, FloatRoundMode rmode
,
3363 int scale
, float_status
*s
)
3367 float128_unpack_canonical(&p
, a
, s
);
3368 return parts_float_to_uint(&p
, rmode
, scale
, UINT64_MAX
, s
);
3371 uint8_t float16_to_uint8(float16 a
, float_status
*s
)
3373 return float16_to_uint8_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3376 uint16_t float16_to_uint16(float16 a
, float_status
*s
)
3378 return float16_to_uint16_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3381 uint32_t float16_to_uint32(float16 a
, float_status
*s
)
3383 return float16_to_uint32_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3386 uint64_t float16_to_uint64(float16 a
, float_status
*s
)
3388 return float16_to_uint64_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3391 uint16_t float32_to_uint16(float32 a
, float_status
*s
)
3393 return float32_to_uint16_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3396 uint32_t float32_to_uint32(float32 a
, float_status
*s
)
3398 return float32_to_uint32_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3401 uint64_t float32_to_uint64(float32 a
, float_status
*s
)
3403 return float32_to_uint64_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3406 uint16_t float64_to_uint16(float64 a
, float_status
*s
)
3408 return float64_to_uint16_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3411 uint32_t float64_to_uint32(float64 a
, float_status
*s
)
3413 return float64_to_uint32_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3416 uint64_t float64_to_uint64(float64 a
, float_status
*s
)
3418 return float64_to_uint64_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3421 uint32_t float128_to_uint32(float128 a
, float_status
*s
)
3423 return float128_to_uint32_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3426 uint64_t float128_to_uint64(float128 a
, float_status
*s
)
3428 return float128_to_uint64_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3431 uint16_t float16_to_uint16_round_to_zero(float16 a
, float_status
*s
)
3433 return float16_to_uint16_scalbn(a
, float_round_to_zero
, 0, s
);
3436 uint32_t float16_to_uint32_round_to_zero(float16 a
, float_status
*s
)
3438 return float16_to_uint32_scalbn(a
, float_round_to_zero
, 0, s
);
3441 uint64_t float16_to_uint64_round_to_zero(float16 a
, float_status
*s
)
3443 return float16_to_uint64_scalbn(a
, float_round_to_zero
, 0, s
);
3446 uint16_t float32_to_uint16_round_to_zero(float32 a
, float_status
*s
)
3448 return float32_to_uint16_scalbn(a
, float_round_to_zero
, 0, s
);
3451 uint32_t float32_to_uint32_round_to_zero(float32 a
, float_status
*s
)
3453 return float32_to_uint32_scalbn(a
, float_round_to_zero
, 0, s
);
3456 uint64_t float32_to_uint64_round_to_zero(float32 a
, float_status
*s
)
3458 return float32_to_uint64_scalbn(a
, float_round_to_zero
, 0, s
);
3461 uint16_t float64_to_uint16_round_to_zero(float64 a
, float_status
*s
)
3463 return float64_to_uint16_scalbn(a
, float_round_to_zero
, 0, s
);
3466 uint32_t float64_to_uint32_round_to_zero(float64 a
, float_status
*s
)
3468 return float64_to_uint32_scalbn(a
, float_round_to_zero
, 0, s
);
3471 uint64_t float64_to_uint64_round_to_zero(float64 a
, float_status
*s
)
3473 return float64_to_uint64_scalbn(a
, float_round_to_zero
, 0, s
);
3476 uint32_t float128_to_uint32_round_to_zero(float128 a
, float_status
*s
)
3478 return float128_to_uint32_scalbn(a
, float_round_to_zero
, 0, s
);
3481 uint64_t float128_to_uint64_round_to_zero(float128 a
, float_status
*s
)
3483 return float128_to_uint64_scalbn(a
, float_round_to_zero
, 0, s
);
3486 uint16_t bfloat16_to_uint16(bfloat16 a
, float_status
*s
)
3488 return bfloat16_to_uint16_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3491 uint32_t bfloat16_to_uint32(bfloat16 a
, float_status
*s
)
3493 return bfloat16_to_uint32_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3496 uint64_t bfloat16_to_uint64(bfloat16 a
, float_status
*s
)
3498 return bfloat16_to_uint64_scalbn(a
, s
->float_rounding_mode
, 0, s
);
3501 uint16_t bfloat16_to_uint16_round_to_zero(bfloat16 a
, float_status
*s
)
3503 return bfloat16_to_uint16_scalbn(a
, float_round_to_zero
, 0, s
);
3506 uint32_t bfloat16_to_uint32_round_to_zero(bfloat16 a
, float_status
*s
)
3508 return bfloat16_to_uint32_scalbn(a
, float_round_to_zero
, 0, s
);
3511 uint64_t bfloat16_to_uint64_round_to_zero(bfloat16 a
, float_status
*s
)
3513 return bfloat16_to_uint64_scalbn(a
, float_round_to_zero
, 0, s
);
3517 * Signed integer to floating-point conversions
3520 float16
int64_to_float16_scalbn(int64_t a
, int scale
, float_status
*status
)
3524 parts_sint_to_float(&p
, a
, scale
, status
);
3525 return float16_round_pack_canonical(&p
, status
);
3528 float16
int32_to_float16_scalbn(int32_t a
, int scale
, float_status
*status
)
3530 return int64_to_float16_scalbn(a
, scale
, status
);
3533 float16
int16_to_float16_scalbn(int16_t a
, int scale
, float_status
*status
)
3535 return int64_to_float16_scalbn(a
, scale
, status
);
3538 float16
int64_to_float16(int64_t a
, float_status
*status
)
3540 return int64_to_float16_scalbn(a
, 0, status
);
3543 float16
int32_to_float16(int32_t a
, float_status
*status
)
3545 return int64_to_float16_scalbn(a
, 0, status
);
3548 float16
int16_to_float16(int16_t a
, float_status
*status
)
3550 return int64_to_float16_scalbn(a
, 0, status
);
3553 float16
int8_to_float16(int8_t a
, float_status
*status
)
3555 return int64_to_float16_scalbn(a
, 0, status
);
3558 float32
int64_to_float32_scalbn(int64_t a
, int scale
, float_status
*status
)
3562 parts64_sint_to_float(&p
, a
, scale
, status
);
3563 return float32_round_pack_canonical(&p
, status
);
3566 float32
int32_to_float32_scalbn(int32_t a
, int scale
, float_status
*status
)
3568 return int64_to_float32_scalbn(a
, scale
, status
);
3571 float32
int16_to_float32_scalbn(int16_t a
, int scale
, float_status
*status
)
3573 return int64_to_float32_scalbn(a
, scale
, status
);
3576 float32
int64_to_float32(int64_t a
, float_status
*status
)
3578 return int64_to_float32_scalbn(a
, 0, status
);
3581 float32
int32_to_float32(int32_t a
, float_status
*status
)
3583 return int64_to_float32_scalbn(a
, 0, status
);
3586 float32
int16_to_float32(int16_t a
, float_status
*status
)
3588 return int64_to_float32_scalbn(a
, 0, status
);
3591 float64
int64_to_float64_scalbn(int64_t a
, int scale
, float_status
*status
)
3595 parts_sint_to_float(&p
, a
, scale
, status
);
3596 return float64_round_pack_canonical(&p
, status
);
3599 float64
int32_to_float64_scalbn(int32_t a
, int scale
, float_status
*status
)
3601 return int64_to_float64_scalbn(a
, scale
, status
);
3604 float64
int16_to_float64_scalbn(int16_t a
, int scale
, float_status
*status
)
3606 return int64_to_float64_scalbn(a
, scale
, status
);
3609 float64
int64_to_float64(int64_t a
, float_status
*status
)
3611 return int64_to_float64_scalbn(a
, 0, status
);
3614 float64
int32_to_float64(int32_t a
, float_status
*status
)
3616 return int64_to_float64_scalbn(a
, 0, status
);
3619 float64
int16_to_float64(int16_t a
, float_status
*status
)
3621 return int64_to_float64_scalbn(a
, 0, status
);
3624 bfloat16
int64_to_bfloat16_scalbn(int64_t a
, int scale
, float_status
*status
)
3628 parts_sint_to_float(&p
, a
, scale
, status
);
3629 return bfloat16_round_pack_canonical(&p
, status
);
3632 bfloat16
int32_to_bfloat16_scalbn(int32_t a
, int scale
, float_status
*status
)
3634 return int64_to_bfloat16_scalbn(a
, scale
, status
);
3637 bfloat16
int16_to_bfloat16_scalbn(int16_t a
, int scale
, float_status
*status
)
3639 return int64_to_bfloat16_scalbn(a
, scale
, status
);
3642 bfloat16
int64_to_bfloat16(int64_t a
, float_status
*status
)
3644 return int64_to_bfloat16_scalbn(a
, 0, status
);
3647 bfloat16
int32_to_bfloat16(int32_t a
, float_status
*status
)
3649 return int64_to_bfloat16_scalbn(a
, 0, status
);
3652 bfloat16
int16_to_bfloat16(int16_t a
, float_status
*status
)
3654 return int64_to_bfloat16_scalbn(a
, 0, status
);
3657 float128
int64_to_float128(int64_t a
, float_status
*status
)
3661 parts_sint_to_float(&p
, a
, 0, status
);
3662 return float128_round_pack_canonical(&p
, status
);
3665 float128
int32_to_float128(int32_t a
, float_status
*status
)
3667 return int64_to_float128(a
, status
);
3670 floatx80
int64_to_floatx80(int64_t a
, float_status
*status
)
3674 parts_sint_to_float(&p
, a
, 0, status
);
3675 return floatx80_round_pack_canonical(&p
, status
);
3678 floatx80
int32_to_floatx80(int32_t a
, float_status
*status
)
3680 return int64_to_floatx80(a
, status
);
3684 * Unsigned Integer to floating-point conversions
3687 float16
uint64_to_float16_scalbn(uint64_t a
, int scale
, float_status
*status
)
3691 parts_uint_to_float(&p
, a
, scale
, status
);
3692 return float16_round_pack_canonical(&p
, status
);
3695 float16
uint32_to_float16_scalbn(uint32_t a
, int scale
, float_status
*status
)
3697 return uint64_to_float16_scalbn(a
, scale
, status
);
3700 float16
uint16_to_float16_scalbn(uint16_t a
, int scale
, float_status
*status
)
3702 return uint64_to_float16_scalbn(a
, scale
, status
);
3705 float16
uint64_to_float16(uint64_t a
, float_status
*status
)
3707 return uint64_to_float16_scalbn(a
, 0, status
);
3710 float16
uint32_to_float16(uint32_t a
, float_status
*status
)
3712 return uint64_to_float16_scalbn(a
, 0, status
);
3715 float16
uint16_to_float16(uint16_t a
, float_status
*status
)
3717 return uint64_to_float16_scalbn(a
, 0, status
);
3720 float16
uint8_to_float16(uint8_t a
, float_status
*status
)
3722 return uint64_to_float16_scalbn(a
, 0, status
);
3725 float32
uint64_to_float32_scalbn(uint64_t a
, int scale
, float_status
*status
)
3729 parts_uint_to_float(&p
, a
, scale
, status
);
3730 return float32_round_pack_canonical(&p
, status
);
3733 float32
uint32_to_float32_scalbn(uint32_t a
, int scale
, float_status
*status
)
3735 return uint64_to_float32_scalbn(a
, scale
, status
);
3738 float32
uint16_to_float32_scalbn(uint16_t a
, int scale
, float_status
*status
)
3740 return uint64_to_float32_scalbn(a
, scale
, status
);
3743 float32
uint64_to_float32(uint64_t a
, float_status
*status
)
3745 return uint64_to_float32_scalbn(a
, 0, status
);
3748 float32
uint32_to_float32(uint32_t a
, float_status
*status
)
3750 return uint64_to_float32_scalbn(a
, 0, status
);
3753 float32
uint16_to_float32(uint16_t a
, float_status
*status
)
3755 return uint64_to_float32_scalbn(a
, 0, status
);
3758 float64
uint64_to_float64_scalbn(uint64_t a
, int scale
, float_status
*status
)
3762 parts_uint_to_float(&p
, a
, scale
, status
);
3763 return float64_round_pack_canonical(&p
, status
);
3766 float64
uint32_to_float64_scalbn(uint32_t a
, int scale
, float_status
*status
)
3768 return uint64_to_float64_scalbn(a
, scale
, status
);
3771 float64
uint16_to_float64_scalbn(uint16_t a
, int scale
, float_status
*status
)
3773 return uint64_to_float64_scalbn(a
, scale
, status
);
3776 float64
uint64_to_float64(uint64_t a
, float_status
*status
)
3778 return uint64_to_float64_scalbn(a
, 0, status
);
3781 float64
uint32_to_float64(uint32_t a
, float_status
*status
)
3783 return uint64_to_float64_scalbn(a
, 0, status
);
3786 float64
uint16_to_float64(uint16_t a
, float_status
*status
)
3788 return uint64_to_float64_scalbn(a
, 0, status
);
3791 bfloat16
uint64_to_bfloat16_scalbn(uint64_t a
, int scale
, float_status
*status
)
3795 parts_uint_to_float(&p
, a
, scale
, status
);
3796 return bfloat16_round_pack_canonical(&p
, status
);
3799 bfloat16
uint32_to_bfloat16_scalbn(uint32_t a
, int scale
, float_status
*status
)
3801 return uint64_to_bfloat16_scalbn(a
, scale
, status
);
3804 bfloat16
uint16_to_bfloat16_scalbn(uint16_t a
, int scale
, float_status
*status
)
3806 return uint64_to_bfloat16_scalbn(a
, scale
, status
);
3809 bfloat16
uint64_to_bfloat16(uint64_t a
, float_status
*status
)
3811 return uint64_to_bfloat16_scalbn(a
, 0, status
);
3814 bfloat16
uint32_to_bfloat16(uint32_t a
, float_status
*status
)
3816 return uint64_to_bfloat16_scalbn(a
, 0, status
);
3819 bfloat16
uint16_to_bfloat16(uint16_t a
, float_status
*status
)
3821 return uint64_to_bfloat16_scalbn(a
, 0, status
);
3824 float128
uint64_to_float128(uint64_t a
, float_status
*status
)
3828 parts_uint_to_float(&p
, a
, 0, status
);
3829 return float128_round_pack_canonical(&p
, status
);
3833 * Minimum and maximum
3836 static float16
float16_minmax(float16 a
, float16 b
, float_status
*s
, int flags
)
3838 FloatParts64 pa
, pb
, *pr
;
3840 float16_unpack_canonical(&pa
, a
, s
);
3841 float16_unpack_canonical(&pb
, b
, s
);
3842 pr
= parts_minmax(&pa
, &pb
, s
, flags
);
3844 return float16_round_pack_canonical(pr
, s
);
3847 static bfloat16
bfloat16_minmax(bfloat16 a
, bfloat16 b
,
3848 float_status
*s
, int flags
)
3850 FloatParts64 pa
, pb
, *pr
;
3852 bfloat16_unpack_canonical(&pa
, a
, s
);
3853 bfloat16_unpack_canonical(&pb
, b
, s
);
3854 pr
= parts_minmax(&pa
, &pb
, s
, flags
);
3856 return bfloat16_round_pack_canonical(pr
, s
);
3859 static float32
float32_minmax(float32 a
, float32 b
, float_status
*s
, int flags
)
3861 FloatParts64 pa
, pb
, *pr
;
3863 float32_unpack_canonical(&pa
, a
, s
);
3864 float32_unpack_canonical(&pb
, b
, s
);
3865 pr
= parts_minmax(&pa
, &pb
, s
, flags
);
3867 return float32_round_pack_canonical(pr
, s
);
3870 static float64
float64_minmax(float64 a
, float64 b
, float_status
*s
, int flags
)
3872 FloatParts64 pa
, pb
, *pr
;
3874 float64_unpack_canonical(&pa
, a
, s
);
3875 float64_unpack_canonical(&pb
, b
, s
);
3876 pr
= parts_minmax(&pa
, &pb
, s
, flags
);
3878 return float64_round_pack_canonical(pr
, s
);
3881 static float128
float128_minmax(float128 a
, float128 b
,
3882 float_status
*s
, int flags
)
3884 FloatParts128 pa
, pb
, *pr
;
3886 float128_unpack_canonical(&pa
, a
, s
);
3887 float128_unpack_canonical(&pb
, b
, s
);
3888 pr
= parts_minmax(&pa
, &pb
, s
, flags
);
3890 return float128_round_pack_canonical(pr
, s
);
3893 #define MINMAX_1(type, name, flags) \
3894 type type##_##name(type a, type b, float_status *s) \
3895 { return type##_minmax(a, b, s, flags); }
3897 #define MINMAX_2(type) \
3898 MINMAX_1(type, max, 0) \
3899 MINMAX_1(type, maxnum, minmax_isnum) \
3900 MINMAX_1(type, maxnummag, minmax_isnum | minmax_ismag) \
3901 MINMAX_1(type, min, minmax_ismin) \
3902 MINMAX_1(type, minnum, minmax_ismin | minmax_isnum) \
3903 MINMAX_1(type, minnummag, minmax_ismin | minmax_isnum | minmax_ismag)
3915 * Floating point compare
3918 static FloatRelation QEMU_FLATTEN
3919 float16_do_compare(float16 a
, float16 b
, float_status
*s
, bool is_quiet
)
3921 FloatParts64 pa
, pb
;
3923 float16_unpack_canonical(&pa
, a
, s
);
3924 float16_unpack_canonical(&pb
, b
, s
);
3925 return parts_compare(&pa
, &pb
, s
, is_quiet
);
3928 FloatRelation
float16_compare(float16 a
, float16 b
, float_status
*s
)
3930 return float16_do_compare(a
, b
, s
, false);
3933 FloatRelation
float16_compare_quiet(float16 a
, float16 b
, float_status
*s
)
3935 return float16_do_compare(a
, b
, s
, true);
3938 static FloatRelation QEMU_SOFTFLOAT_ATTR
3939 float32_do_compare(float32 a
, float32 b
, float_status
*s
, bool is_quiet
)
3941 FloatParts64 pa
, pb
;
3943 float32_unpack_canonical(&pa
, a
, s
);
3944 float32_unpack_canonical(&pb
, b
, s
);
3945 return parts_compare(&pa
, &pb
, s
, is_quiet
);
3948 static FloatRelation QEMU_FLATTEN
3949 float32_hs_compare(float32 xa
, float32 xb
, float_status
*s
, bool is_quiet
)
3951 union_float32 ua
, ub
;
3956 if (QEMU_NO_HARDFLOAT
) {
3960 float32_input_flush2(&ua
.s
, &ub
.s
, s
);
3961 if (isgreaterequal(ua
.h
, ub
.h
)) {
3962 if (isgreater(ua
.h
, ub
.h
)) {
3963 return float_relation_greater
;
3965 return float_relation_equal
;
3967 if (likely(isless(ua
.h
, ub
.h
))) {
3968 return float_relation_less
;
3971 * The only condition remaining is unordered.
3972 * Fall through to set flags.
3975 return float32_do_compare(ua
.s
, ub
.s
, s
, is_quiet
);
3978 FloatRelation
float32_compare(float32 a
, float32 b
, float_status
*s
)
3980 return float32_hs_compare(a
, b
, s
, false);
3983 FloatRelation
float32_compare_quiet(float32 a
, float32 b
, float_status
*s
)
3985 return float32_hs_compare(a
, b
, s
, true);
3988 static FloatRelation QEMU_SOFTFLOAT_ATTR
3989 float64_do_compare(float64 a
, float64 b
, float_status
*s
, bool is_quiet
)
3991 FloatParts64 pa
, pb
;
3993 float64_unpack_canonical(&pa
, a
, s
);
3994 float64_unpack_canonical(&pb
, b
, s
);
3995 return parts_compare(&pa
, &pb
, s
, is_quiet
);
3998 static FloatRelation QEMU_FLATTEN
3999 float64_hs_compare(float64 xa
, float64 xb
, float_status
*s
, bool is_quiet
)
4001 union_float64 ua
, ub
;
4006 if (QEMU_NO_HARDFLOAT
) {
4010 float64_input_flush2(&ua
.s
, &ub
.s
, s
);
4011 if (isgreaterequal(ua
.h
, ub
.h
)) {
4012 if (isgreater(ua
.h
, ub
.h
)) {
4013 return float_relation_greater
;
4015 return float_relation_equal
;
4017 if (likely(isless(ua
.h
, ub
.h
))) {
4018 return float_relation_less
;
4021 * The only condition remaining is unordered.
4022 * Fall through to set flags.
4025 return float64_do_compare(ua
.s
, ub
.s
, s
, is_quiet
);
4028 FloatRelation
float64_compare(float64 a
, float64 b
, float_status
*s
)
4030 return float64_hs_compare(a
, b
, s
, false);
4033 FloatRelation
float64_compare_quiet(float64 a
, float64 b
, float_status
*s
)
4035 return float64_hs_compare(a
, b
, s
, true);
4038 static FloatRelation QEMU_FLATTEN
4039 bfloat16_do_compare(bfloat16 a
, bfloat16 b
, float_status
*s
, bool is_quiet
)
4041 FloatParts64 pa
, pb
;
4043 bfloat16_unpack_canonical(&pa
, a
, s
);
4044 bfloat16_unpack_canonical(&pb
, b
, s
);
4045 return parts_compare(&pa
, &pb
, s
, is_quiet
);
4048 FloatRelation
bfloat16_compare(bfloat16 a
, bfloat16 b
, float_status
*s
)
4050 return bfloat16_do_compare(a
, b
, s
, false);
4053 FloatRelation
bfloat16_compare_quiet(bfloat16 a
, bfloat16 b
, float_status
*s
)
4055 return bfloat16_do_compare(a
, b
, s
, true);
4058 static FloatRelation QEMU_FLATTEN
4059 float128_do_compare(float128 a
, float128 b
, float_status
*s
, bool is_quiet
)
4061 FloatParts128 pa
, pb
;
4063 float128_unpack_canonical(&pa
, a
, s
);
4064 float128_unpack_canonical(&pb
, b
, s
);
4065 return parts_compare(&pa
, &pb
, s
, is_quiet
);
4068 FloatRelation
float128_compare(float128 a
, float128 b
, float_status
*s
)
4070 return float128_do_compare(a
, b
, s
, false);
4073 FloatRelation
float128_compare_quiet(float128 a
, float128 b
, float_status
*s
)
4075 return float128_do_compare(a
, b
, s
, true);
4078 static FloatRelation QEMU_FLATTEN
4079 floatx80_do_compare(floatx80 a
, floatx80 b
, float_status
*s
, bool is_quiet
)
4081 FloatParts128 pa
, pb
;
4083 if (!floatx80_unpack_canonical(&pa
, a
, s
) ||
4084 !floatx80_unpack_canonical(&pb
, b
, s
)) {
4085 return float_relation_unordered
;
4087 return parts_compare(&pa
, &pb
, s
, is_quiet
);
4090 FloatRelation
floatx80_compare(floatx80 a
, floatx80 b
, float_status
*s
)
4092 return floatx80_do_compare(a
, b
, s
, false);
4095 FloatRelation
floatx80_compare_quiet(floatx80 a
, floatx80 b
, float_status
*s
)
4097 return floatx80_do_compare(a
, b
, s
, true);
4104 float16
float16_scalbn(float16 a
, int n
, float_status
*status
)
4108 float16_unpack_canonical(&p
, a
, status
);
4109 parts_scalbn(&p
, n
, status
);
4110 return float16_round_pack_canonical(&p
, status
);
4113 float32
float32_scalbn(float32 a
, int n
, float_status
*status
)
4117 float32_unpack_canonical(&p
, a
, status
);
4118 parts_scalbn(&p
, n
, status
);
4119 return float32_round_pack_canonical(&p
, status
);
4122 float64
float64_scalbn(float64 a
, int n
, float_status
*status
)
4126 float64_unpack_canonical(&p
, a
, status
);
4127 parts_scalbn(&p
, n
, status
);
4128 return float64_round_pack_canonical(&p
, status
);
4131 bfloat16
bfloat16_scalbn(bfloat16 a
, int n
, float_status
*status
)
4135 bfloat16_unpack_canonical(&p
, a
, status
);
4136 parts_scalbn(&p
, n
, status
);
4137 return bfloat16_round_pack_canonical(&p
, status
);
4140 float128
float128_scalbn(float128 a
, int n
, float_status
*status
)
4144 float128_unpack_canonical(&p
, a
, status
);
4145 parts_scalbn(&p
, n
, status
);
4146 return float128_round_pack_canonical(&p
, status
);
4149 floatx80
floatx80_scalbn(floatx80 a
, int n
, float_status
*status
)
4153 if (!floatx80_unpack_canonical(&p
, a
, status
)) {
4154 return floatx80_default_nan(status
);
4156 parts_scalbn(&p
, n
, status
);
4157 return floatx80_round_pack_canonical(&p
, status
);
4164 float16 QEMU_FLATTEN
float16_sqrt(float16 a
, float_status
*status
)
4168 float16_unpack_canonical(&p
, a
, status
);
4169 parts_sqrt(&p
, status
, &float16_params
);
4170 return float16_round_pack_canonical(&p
, status
);
4173 static float32 QEMU_SOFTFLOAT_ATTR
4174 soft_f32_sqrt(float32 a
, float_status
*status
)
4178 float32_unpack_canonical(&p
, a
, status
);
4179 parts_sqrt(&p
, status
, &float32_params
);
4180 return float32_round_pack_canonical(&p
, status
);
4183 static float64 QEMU_SOFTFLOAT_ATTR
4184 soft_f64_sqrt(float64 a
, float_status
*status
)
4188 float64_unpack_canonical(&p
, a
, status
);
4189 parts_sqrt(&p
, status
, &float64_params
);
4190 return float64_round_pack_canonical(&p
, status
);
4193 float32 QEMU_FLATTEN
float32_sqrt(float32 xa
, float_status
*s
)
4195 union_float32 ua
, ur
;
4198 if (unlikely(!can_use_fpu(s
))) {
4202 float32_input_flush1(&ua
.s
, s
);
4203 if (QEMU_HARDFLOAT_1F32_USE_FP
) {
4204 if (unlikely(!(fpclassify(ua
.h
) == FP_NORMAL
||
4205 fpclassify(ua
.h
) == FP_ZERO
) ||
4209 } else if (unlikely(!float32_is_zero_or_normal(ua
.s
) ||
4210 float32_is_neg(ua
.s
))) {
4217 return soft_f32_sqrt(ua
.s
, s
);
4220 float64 QEMU_FLATTEN
float64_sqrt(float64 xa
, float_status
*s
)
4222 union_float64 ua
, ur
;
4225 if (unlikely(!can_use_fpu(s
))) {
4229 float64_input_flush1(&ua
.s
, s
);
4230 if (QEMU_HARDFLOAT_1F64_USE_FP
) {
4231 if (unlikely(!(fpclassify(ua
.h
) == FP_NORMAL
||
4232 fpclassify(ua
.h
) == FP_ZERO
) ||
4236 } else if (unlikely(!float64_is_zero_or_normal(ua
.s
) ||
4237 float64_is_neg(ua
.s
))) {
4244 return soft_f64_sqrt(ua
.s
, s
);
4247 bfloat16 QEMU_FLATTEN
bfloat16_sqrt(bfloat16 a
, float_status
*status
)
4251 bfloat16_unpack_canonical(&p
, a
, status
);
4252 parts_sqrt(&p
, status
, &bfloat16_params
);
4253 return bfloat16_round_pack_canonical(&p
, status
);
4256 float128 QEMU_FLATTEN
float128_sqrt(float128 a
, float_status
*status
)
4260 float128_unpack_canonical(&p
, a
, status
);
4261 parts_sqrt(&p
, status
, &float128_params
);
4262 return float128_round_pack_canonical(&p
, status
);
4265 floatx80
floatx80_sqrt(floatx80 a
, float_status
*s
)
4269 if (!floatx80_unpack_canonical(&p
, a
, s
)) {
4270 return floatx80_default_nan(s
);
4272 parts_sqrt(&p
, s
, &floatx80_params
[s
->floatx80_rounding_precision
]);
4273 return floatx80_round_pack_canonical(&p
, s
);
4279 float32
float32_log2(float32 a
, float_status
*status
)
4283 float32_unpack_canonical(&p
, a
, status
);
4284 parts_log2(&p
, status
, &float32_params
);
4285 return float32_round_pack_canonical(&p
, status
);
4288 float64
float64_log2(float64 a
, float_status
*status
)
4292 float64_unpack_canonical(&p
, a
, status
);
4293 parts_log2(&p
, status
, &float64_params
);
4294 return float64_round_pack_canonical(&p
, status
);
4297 /*----------------------------------------------------------------------------
4298 | The pattern for a default generated NaN.
4299 *----------------------------------------------------------------------------*/
4301 float16
float16_default_nan(float_status
*status
)
4305 parts_default_nan(&p
, status
);
4306 p
.frac
>>= float16_params
.frac_shift
;
4307 return float16_pack_raw(&p
);
4310 float32
float32_default_nan(float_status
*status
)
4314 parts_default_nan(&p
, status
);
4315 p
.frac
>>= float32_params
.frac_shift
;
4316 return float32_pack_raw(&p
);
4319 float64
float64_default_nan(float_status
*status
)
4323 parts_default_nan(&p
, status
);
4324 p
.frac
>>= float64_params
.frac_shift
;
4325 return float64_pack_raw(&p
);
4328 float128
float128_default_nan(float_status
*status
)
4332 parts_default_nan(&p
, status
);
4333 frac_shr(&p
, float128_params
.frac_shift
);
4334 return float128_pack_raw(&p
);
4337 bfloat16
bfloat16_default_nan(float_status
*status
)
4341 parts_default_nan(&p
, status
);
4342 p
.frac
>>= bfloat16_params
.frac_shift
;
4343 return bfloat16_pack_raw(&p
);
4346 /*----------------------------------------------------------------------------
4347 | Returns a quiet NaN from a signalling NaN for the floating point value `a'.
4348 *----------------------------------------------------------------------------*/
4350 float16
float16_silence_nan(float16 a
, float_status
*status
)
4354 float16_unpack_raw(&p
, a
);
4355 p
.frac
<<= float16_params
.frac_shift
;
4356 parts_silence_nan(&p
, status
);
4357 p
.frac
>>= float16_params
.frac_shift
;
4358 return float16_pack_raw(&p
);
4361 float32
float32_silence_nan(float32 a
, float_status
*status
)
4365 float32_unpack_raw(&p
, a
);
4366 p
.frac
<<= float32_params
.frac_shift
;
4367 parts_silence_nan(&p
, status
);
4368 p
.frac
>>= float32_params
.frac_shift
;
4369 return float32_pack_raw(&p
);
4372 float64
float64_silence_nan(float64 a
, float_status
*status
)
4376 float64_unpack_raw(&p
, a
);
4377 p
.frac
<<= float64_params
.frac_shift
;
4378 parts_silence_nan(&p
, status
);
4379 p
.frac
>>= float64_params
.frac_shift
;
4380 return float64_pack_raw(&p
);
4383 bfloat16
bfloat16_silence_nan(bfloat16 a
, float_status
*status
)
4387 bfloat16_unpack_raw(&p
, a
);
4388 p
.frac
<<= bfloat16_params
.frac_shift
;
4389 parts_silence_nan(&p
, status
);
4390 p
.frac
>>= bfloat16_params
.frac_shift
;
4391 return bfloat16_pack_raw(&p
);
4394 float128
float128_silence_nan(float128 a
, float_status
*status
)
4398 float128_unpack_raw(&p
, a
);
4399 frac_shl(&p
, float128_params
.frac_shift
);
4400 parts_silence_nan(&p
, status
);
4401 frac_shr(&p
, float128_params
.frac_shift
);
4402 return float128_pack_raw(&p
);
4405 /*----------------------------------------------------------------------------
4406 | If `a' is denormal and we are in flush-to-zero mode then set the
4407 | input-denormal exception and return zero. Otherwise just return the value.
4408 *----------------------------------------------------------------------------*/
4410 static bool parts_squash_denormal(FloatParts64 p
, float_status
*status
)
4412 if (p
.exp
== 0 && p
.frac
!= 0) {
4413 float_raise(float_flag_input_denormal
, status
);
4420 float16
float16_squash_input_denormal(float16 a
, float_status
*status
)
4422 if (status
->flush_inputs_to_zero
) {
4425 float16_unpack_raw(&p
, a
);
4426 if (parts_squash_denormal(p
, status
)) {
4427 return float16_set_sign(float16_zero
, p
.sign
);
4433 float32
float32_squash_input_denormal(float32 a
, float_status
*status
)
4435 if (status
->flush_inputs_to_zero
) {
4438 float32_unpack_raw(&p
, a
);
4439 if (parts_squash_denormal(p
, status
)) {
4440 return float32_set_sign(float32_zero
, p
.sign
);
4446 float64
float64_squash_input_denormal(float64 a
, float_status
*status
)
4448 if (status
->flush_inputs_to_zero
) {
4451 float64_unpack_raw(&p
, a
);
4452 if (parts_squash_denormal(p
, status
)) {
4453 return float64_set_sign(float64_zero
, p
.sign
);
4459 bfloat16
bfloat16_squash_input_denormal(bfloat16 a
, float_status
*status
)
4461 if (status
->flush_inputs_to_zero
) {
4464 bfloat16_unpack_raw(&p
, a
);
4465 if (parts_squash_denormal(p
, status
)) {
4466 return bfloat16_set_sign(bfloat16_zero
, p
.sign
);
4472 /*----------------------------------------------------------------------------
4473 | Normalizes the subnormal extended double-precision floating-point value
4474 | represented by the denormalized significand `aSig'. The normalized exponent
4475 | and significand are stored at the locations pointed to by `zExpPtr' and
4476 | `zSigPtr', respectively.
4477 *----------------------------------------------------------------------------*/
4479 void normalizeFloatx80Subnormal(uint64_t aSig
, int32_t *zExpPtr
,
4484 shiftCount
= clz64(aSig
);
4485 *zSigPtr
= aSig
<<shiftCount
;
4486 *zExpPtr
= 1 - shiftCount
;
4489 /*----------------------------------------------------------------------------
4490 | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
4491 | and extended significand formed by the concatenation of `zSig0' and `zSig1',
4492 | and returns the proper extended double-precision floating-point value
4493 | corresponding to the abstract input. Ordinarily, the abstract value is
4494 | rounded and packed into the extended double-precision format, with the
4495 | inexact exception raised if the abstract input cannot be represented
4496 | exactly. However, if the abstract value is too large, the overflow and
4497 | inexact exceptions are raised and an infinity or maximal finite value is
4498 | returned. If the abstract value is too small, the input value is rounded to
4499 | a subnormal number, and the underflow and inexact exceptions are raised if
4500 | the abstract input cannot be represented exactly as a subnormal extended
4501 | double-precision floating-point number.
4502 | If `roundingPrecision' is floatx80_precision_s or floatx80_precision_d,
4503 | the result is rounded to the same number of bits as single or double
4504 | precision, respectively. Otherwise, the result is rounded to the full
4505 | precision of the extended double-precision format.
4506 | The input significand must be normalized or smaller. If the input
4507 | significand is not normalized, `zExp' must be 0; in that case, the result
4508 | returned is a subnormal number, and it must not require rounding. The
4509 | handling of underflow and overflow follows the IEC/IEEE Standard for Binary
4510 | Floating-Point Arithmetic.
4511 *----------------------------------------------------------------------------*/
4513 floatx80
roundAndPackFloatx80(FloatX80RoundPrec roundingPrecision
, bool zSign
,
4514 int32_t zExp
, uint64_t zSig0
, uint64_t zSig1
,
4515 float_status
*status
)
4517 FloatRoundMode roundingMode
;
4518 bool roundNearestEven
, increment
, isTiny
;
4519 int64_t roundIncrement
, roundMask
, roundBits
;
4521 roundingMode
= status
->float_rounding_mode
;
4522 roundNearestEven
= ( roundingMode
== float_round_nearest_even
);
4523 switch (roundingPrecision
) {
4524 case floatx80_precision_x
:
4526 case floatx80_precision_d
:
4527 roundIncrement
= UINT64_C(0x0000000000000400);
4528 roundMask
= UINT64_C(0x00000000000007FF);
4530 case floatx80_precision_s
:
4531 roundIncrement
= UINT64_C(0x0000008000000000);
4532 roundMask
= UINT64_C(0x000000FFFFFFFFFF);
4535 g_assert_not_reached();
4537 zSig0
|= ( zSig1
!= 0 );
4538 switch (roundingMode
) {
4539 case float_round_nearest_even
:
4540 case float_round_ties_away
:
4542 case float_round_to_zero
:
4545 case float_round_up
:
4546 roundIncrement
= zSign
? 0 : roundMask
;
4548 case float_round_down
:
4549 roundIncrement
= zSign
? roundMask
: 0;
4554 roundBits
= zSig0
& roundMask
;
4555 if ( 0x7FFD <= (uint32_t) ( zExp
- 1 ) ) {
4556 if ( ( 0x7FFE < zExp
)
4557 || ( ( zExp
== 0x7FFE ) && ( zSig0
+ roundIncrement
< zSig0
) )
4562 if (status
->flush_to_zero
) {
4563 float_raise(float_flag_output_denormal
, status
);
4564 return packFloatx80(zSign
, 0, 0);
4566 isTiny
= status
->tininess_before_rounding
4568 || (zSig0
<= zSig0
+ roundIncrement
);
4569 shift64RightJamming( zSig0
, 1 - zExp
, &zSig0
);
4571 roundBits
= zSig0
& roundMask
;
4572 if (isTiny
&& roundBits
) {
4573 float_raise(float_flag_underflow
, status
);
4576 float_raise(float_flag_inexact
, status
);
4578 zSig0
+= roundIncrement
;
4579 if ( (int64_t) zSig0
< 0 ) zExp
= 1;
4580 roundIncrement
= roundMask
+ 1;
4581 if ( roundNearestEven
&& ( roundBits
<<1 == roundIncrement
) ) {
4582 roundMask
|= roundIncrement
;
4584 zSig0
&= ~ roundMask
;
4585 return packFloatx80( zSign
, zExp
, zSig0
);
4589 float_raise(float_flag_inexact
, status
);
4591 zSig0
+= roundIncrement
;
4592 if ( zSig0
< roundIncrement
) {
4594 zSig0
= UINT64_C(0x8000000000000000);
4596 roundIncrement
= roundMask
+ 1;
4597 if ( roundNearestEven
&& ( roundBits
<<1 == roundIncrement
) ) {
4598 roundMask
|= roundIncrement
;
4600 zSig0
&= ~ roundMask
;
4601 if ( zSig0
== 0 ) zExp
= 0;
4602 return packFloatx80( zSign
, zExp
, zSig0
);
4604 switch (roundingMode
) {
4605 case float_round_nearest_even
:
4606 case float_round_ties_away
:
4607 increment
= ((int64_t)zSig1
< 0);
4609 case float_round_to_zero
:
4612 case float_round_up
:
4613 increment
= !zSign
&& zSig1
;
4615 case float_round_down
:
4616 increment
= zSign
&& zSig1
;
4621 if ( 0x7FFD <= (uint32_t) ( zExp
- 1 ) ) {
4622 if ( ( 0x7FFE < zExp
)
4623 || ( ( zExp
== 0x7FFE )
4624 && ( zSig0
== UINT64_C(0xFFFFFFFFFFFFFFFF) )
4630 float_raise(float_flag_overflow
| float_flag_inexact
, status
);
4631 if ( ( roundingMode
== float_round_to_zero
)
4632 || ( zSign
&& ( roundingMode
== float_round_up
) )
4633 || ( ! zSign
&& ( roundingMode
== float_round_down
) )
4635 return packFloatx80( zSign
, 0x7FFE, ~ roundMask
);
4637 return packFloatx80(zSign
,
4638 floatx80_infinity_high
,
4639 floatx80_infinity_low
);
4642 isTiny
= status
->tininess_before_rounding
4645 || (zSig0
< UINT64_C(0xFFFFFFFFFFFFFFFF));
4646 shift64ExtraRightJamming( zSig0
, zSig1
, 1 - zExp
, &zSig0
, &zSig1
);
4648 if (isTiny
&& zSig1
) {
4649 float_raise(float_flag_underflow
, status
);
4652 float_raise(float_flag_inexact
, status
);
4654 switch (roundingMode
) {
4655 case float_round_nearest_even
:
4656 case float_round_ties_away
:
4657 increment
= ((int64_t)zSig1
< 0);
4659 case float_round_to_zero
:
4662 case float_round_up
:
4663 increment
= !zSign
&& zSig1
;
4665 case float_round_down
:
4666 increment
= zSign
&& zSig1
;
4673 if (!(zSig1
<< 1) && roundNearestEven
) {
4676 if ( (int64_t) zSig0
< 0 ) zExp
= 1;
4678 return packFloatx80( zSign
, zExp
, zSig0
);
4682 float_raise(float_flag_inexact
, status
);
4688 zSig0
= UINT64_C(0x8000000000000000);
4691 if (!(zSig1
<< 1) && roundNearestEven
) {
4697 if ( zSig0
== 0 ) zExp
= 0;
4699 return packFloatx80( zSign
, zExp
, zSig0
);
4703 /*----------------------------------------------------------------------------
4704 | Takes an abstract floating-point value having sign `zSign', exponent
4705 | `zExp', and significand formed by the concatenation of `zSig0' and `zSig1',
4706 | and returns the proper extended double-precision floating-point value
4707 | corresponding to the abstract input. This routine is just like
4708 | `roundAndPackFloatx80' except that the input significand does not have to be
4710 *----------------------------------------------------------------------------*/
4712 floatx80
normalizeRoundAndPackFloatx80(FloatX80RoundPrec roundingPrecision
,
4713 bool zSign
, int32_t zExp
,
4714 uint64_t zSig0
, uint64_t zSig1
,
4715 float_status
*status
)
4724 shiftCount
= clz64(zSig0
);
4725 shortShift128Left( zSig0
, zSig1
, shiftCount
, &zSig0
, &zSig1
);
4727 return roundAndPackFloatx80(roundingPrecision
, zSign
, zExp
,
4728 zSig0
, zSig1
, status
);
4732 /*----------------------------------------------------------------------------
4733 | Returns the binary exponential of the single-precision floating-point value
4734 | `a'. The operation is performed according to the IEC/IEEE Standard for
4735 | Binary Floating-Point Arithmetic.
4737 | Uses the following identities:
4739 | 1. -------------------------------------------------------------------------
4743 | 2. -------------------------------------------------------------------------
4746 | e = 1 + --- + --- + --- + --- + --- + ... + --- + ...
4748 *----------------------------------------------------------------------------*/
4750 static const float64 float32_exp2_coefficients
[15] =
4752 const_float64( 0x3ff0000000000000ll
), /* 1 */
4753 const_float64( 0x3fe0000000000000ll
), /* 2 */
4754 const_float64( 0x3fc5555555555555ll
), /* 3 */
4755 const_float64( 0x3fa5555555555555ll
), /* 4 */
4756 const_float64( 0x3f81111111111111ll
), /* 5 */
4757 const_float64( 0x3f56c16c16c16c17ll
), /* 6 */
4758 const_float64( 0x3f2a01a01a01a01all
), /* 7 */
4759 const_float64( 0x3efa01a01a01a01all
), /* 8 */
4760 const_float64( 0x3ec71de3a556c734ll
), /* 9 */
4761 const_float64( 0x3e927e4fb7789f5cll
), /* 10 */
4762 const_float64( 0x3e5ae64567f544e4ll
), /* 11 */
4763 const_float64( 0x3e21eed8eff8d898ll
), /* 12 */
4764 const_float64( 0x3de6124613a86d09ll
), /* 13 */
4765 const_float64( 0x3da93974a8c07c9dll
), /* 14 */
4766 const_float64( 0x3d6ae7f3e733b81fll
), /* 15 */
4769 float32
float32_exp2(float32 a
, float_status
*status
)
4771 FloatParts64 xp
, xnp
, tp
, rp
;
4774 float32_unpack_canonical(&xp
, a
, status
);
4775 if (unlikely(xp
.cls
!= float_class_normal
)) {
4777 case float_class_snan
:
4778 case float_class_qnan
:
4779 parts_return_nan(&xp
, status
);
4780 return float32_round_pack_canonical(&xp
, status
);
4781 case float_class_inf
:
4782 return xp
.sign
? float32_zero
: a
;
4783 case float_class_zero
:
4788 g_assert_not_reached();
4791 float_raise(float_flag_inexact
, status
);
4793 float64_unpack_canonical(&xnp
, float64_ln2
, status
);
4794 xp
= *parts_mul(&xp
, &tp
, status
);
4797 float64_unpack_canonical(&rp
, float64_one
, status
);
4798 for (i
= 0 ; i
< 15 ; i
++) {
4799 float64_unpack_canonical(&tp
, float32_exp2_coefficients
[i
], status
);
4800 rp
= *parts_muladd(&tp
, &xp
, &rp
, 0, status
);
4801 xnp
= *parts_mul(&xnp
, &xp
, status
);
4804 return float32_round_pack_canonical(&rp
, status
);
4807 /*----------------------------------------------------------------------------
4808 | Rounds the extended double-precision floating-point value `a'
4809 | to the precision provided by floatx80_rounding_precision and returns the
4810 | result as an extended double-precision floating-point value.
4811 | The operation is performed according to the IEC/IEEE Standard for Binary
4812 | Floating-Point Arithmetic.
4813 *----------------------------------------------------------------------------*/
4815 floatx80
floatx80_round(floatx80 a
, float_status
*status
)
4819 if (!floatx80_unpack_canonical(&p
, a
, status
)) {
4820 return floatx80_default_nan(status
);
4822 return floatx80_round_pack_canonical(&p
, status
);
4825 static void __attribute__((constructor
)) softfloat_init(void)
4827 union_float64 ua
, ub
, uc
, ur
;
4829 if (QEMU_NO_HARDFLOAT
) {
4833 * Test that the host's FMA is not obviously broken. For example,
4834 * glibc < 2.23 can perform an incorrect FMA on certain hosts; see
4835 * https://sourceware.org/bugzilla/show_bug.cgi?id=13304
4837 ua
.s
= 0x0020000000000001ULL
;
4838 ub
.s
= 0x3ca0000000000000ULL
;
4839 uc
.s
= 0x0020000000000000ULL
;
4840 ur
.h
= fma(ua
.h
, ub
.h
, uc
.h
);
4841 if (ur
.s
!= 0x0020000000000001ULL
) {
4842 force_soft_fma
= true;