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 /* Without scaling, there are no overflow concerns. */
3563 if (likely(scale
== 0) && can_use_fpu(status
)) {
3569 parts64_sint_to_float(&p
, a
, scale
, status
);
3570 return float32_round_pack_canonical(&p
, status
);
3573 float32
int32_to_float32_scalbn(int32_t a
, int scale
, float_status
*status
)
3575 return int64_to_float32_scalbn(a
, scale
, status
);
3578 float32
int16_to_float32_scalbn(int16_t a
, int scale
, float_status
*status
)
3580 return int64_to_float32_scalbn(a
, scale
, status
);
3583 float32
int64_to_float32(int64_t a
, float_status
*status
)
3585 return int64_to_float32_scalbn(a
, 0, status
);
3588 float32
int32_to_float32(int32_t a
, float_status
*status
)
3590 return int64_to_float32_scalbn(a
, 0, status
);
3593 float32
int16_to_float32(int16_t a
, float_status
*status
)
3595 return int64_to_float32_scalbn(a
, 0, status
);
3598 float64
int64_to_float64_scalbn(int64_t a
, int scale
, float_status
*status
)
3602 /* Without scaling, there are no overflow concerns. */
3603 if (likely(scale
== 0) && can_use_fpu(status
)) {
3609 parts_sint_to_float(&p
, a
, scale
, status
);
3610 return float64_round_pack_canonical(&p
, status
);
3613 float64
int32_to_float64_scalbn(int32_t a
, int scale
, float_status
*status
)
3615 return int64_to_float64_scalbn(a
, scale
, status
);
3618 float64
int16_to_float64_scalbn(int16_t a
, int scale
, float_status
*status
)
3620 return int64_to_float64_scalbn(a
, scale
, status
);
3623 float64
int64_to_float64(int64_t a
, float_status
*status
)
3625 return int64_to_float64_scalbn(a
, 0, status
);
3628 float64
int32_to_float64(int32_t a
, float_status
*status
)
3630 return int64_to_float64_scalbn(a
, 0, status
);
3633 float64
int16_to_float64(int16_t a
, float_status
*status
)
3635 return int64_to_float64_scalbn(a
, 0, status
);
3638 bfloat16
int64_to_bfloat16_scalbn(int64_t a
, int scale
, float_status
*status
)
3642 parts_sint_to_float(&p
, a
, scale
, status
);
3643 return bfloat16_round_pack_canonical(&p
, status
);
3646 bfloat16
int32_to_bfloat16_scalbn(int32_t a
, int scale
, float_status
*status
)
3648 return int64_to_bfloat16_scalbn(a
, scale
, status
);
3651 bfloat16
int16_to_bfloat16_scalbn(int16_t a
, int scale
, float_status
*status
)
3653 return int64_to_bfloat16_scalbn(a
, scale
, status
);
3656 bfloat16
int64_to_bfloat16(int64_t a
, float_status
*status
)
3658 return int64_to_bfloat16_scalbn(a
, 0, status
);
3661 bfloat16
int32_to_bfloat16(int32_t a
, float_status
*status
)
3663 return int64_to_bfloat16_scalbn(a
, 0, status
);
3666 bfloat16
int16_to_bfloat16(int16_t a
, float_status
*status
)
3668 return int64_to_bfloat16_scalbn(a
, 0, status
);
3671 float128
int64_to_float128(int64_t a
, float_status
*status
)
3675 parts_sint_to_float(&p
, a
, 0, status
);
3676 return float128_round_pack_canonical(&p
, status
);
3679 float128
int32_to_float128(int32_t a
, float_status
*status
)
3681 return int64_to_float128(a
, status
);
3684 floatx80
int64_to_floatx80(int64_t a
, float_status
*status
)
3688 parts_sint_to_float(&p
, a
, 0, status
);
3689 return floatx80_round_pack_canonical(&p
, status
);
3692 floatx80
int32_to_floatx80(int32_t a
, float_status
*status
)
3694 return int64_to_floatx80(a
, status
);
3698 * Unsigned Integer to floating-point conversions
3701 float16
uint64_to_float16_scalbn(uint64_t a
, int scale
, float_status
*status
)
3705 parts_uint_to_float(&p
, a
, scale
, status
);
3706 return float16_round_pack_canonical(&p
, status
);
3709 float16
uint32_to_float16_scalbn(uint32_t a
, int scale
, float_status
*status
)
3711 return uint64_to_float16_scalbn(a
, scale
, status
);
3714 float16
uint16_to_float16_scalbn(uint16_t a
, int scale
, float_status
*status
)
3716 return uint64_to_float16_scalbn(a
, scale
, status
);
3719 float16
uint64_to_float16(uint64_t a
, float_status
*status
)
3721 return uint64_to_float16_scalbn(a
, 0, status
);
3724 float16
uint32_to_float16(uint32_t a
, float_status
*status
)
3726 return uint64_to_float16_scalbn(a
, 0, status
);
3729 float16
uint16_to_float16(uint16_t a
, float_status
*status
)
3731 return uint64_to_float16_scalbn(a
, 0, status
);
3734 float16
uint8_to_float16(uint8_t a
, float_status
*status
)
3736 return uint64_to_float16_scalbn(a
, 0, status
);
3739 float32
uint64_to_float32_scalbn(uint64_t a
, int scale
, float_status
*status
)
3743 /* Without scaling, there are no overflow concerns. */
3744 if (likely(scale
== 0) && can_use_fpu(status
)) {
3750 parts_uint_to_float(&p
, a
, scale
, status
);
3751 return float32_round_pack_canonical(&p
, status
);
3754 float32
uint32_to_float32_scalbn(uint32_t a
, int scale
, float_status
*status
)
3756 return uint64_to_float32_scalbn(a
, scale
, status
);
3759 float32
uint16_to_float32_scalbn(uint16_t a
, int scale
, float_status
*status
)
3761 return uint64_to_float32_scalbn(a
, scale
, status
);
3764 float32
uint64_to_float32(uint64_t a
, float_status
*status
)
3766 return uint64_to_float32_scalbn(a
, 0, status
);
3769 float32
uint32_to_float32(uint32_t a
, float_status
*status
)
3771 return uint64_to_float32_scalbn(a
, 0, status
);
3774 float32
uint16_to_float32(uint16_t a
, float_status
*status
)
3776 return uint64_to_float32_scalbn(a
, 0, status
);
3779 float64
uint64_to_float64_scalbn(uint64_t a
, int scale
, float_status
*status
)
3783 /* Without scaling, there are no overflow concerns. */
3784 if (likely(scale
== 0) && can_use_fpu(status
)) {
3790 parts_uint_to_float(&p
, a
, scale
, status
);
3791 return float64_round_pack_canonical(&p
, status
);
3794 float64
uint32_to_float64_scalbn(uint32_t a
, int scale
, float_status
*status
)
3796 return uint64_to_float64_scalbn(a
, scale
, status
);
3799 float64
uint16_to_float64_scalbn(uint16_t a
, int scale
, float_status
*status
)
3801 return uint64_to_float64_scalbn(a
, scale
, status
);
3804 float64
uint64_to_float64(uint64_t a
, float_status
*status
)
3806 return uint64_to_float64_scalbn(a
, 0, status
);
3809 float64
uint32_to_float64(uint32_t a
, float_status
*status
)
3811 return uint64_to_float64_scalbn(a
, 0, status
);
3814 float64
uint16_to_float64(uint16_t a
, float_status
*status
)
3816 return uint64_to_float64_scalbn(a
, 0, status
);
3819 bfloat16
uint64_to_bfloat16_scalbn(uint64_t a
, int scale
, float_status
*status
)
3823 parts_uint_to_float(&p
, a
, scale
, status
);
3824 return bfloat16_round_pack_canonical(&p
, status
);
3827 bfloat16
uint32_to_bfloat16_scalbn(uint32_t a
, int scale
, float_status
*status
)
3829 return uint64_to_bfloat16_scalbn(a
, scale
, status
);
3832 bfloat16
uint16_to_bfloat16_scalbn(uint16_t a
, int scale
, float_status
*status
)
3834 return uint64_to_bfloat16_scalbn(a
, scale
, status
);
3837 bfloat16
uint64_to_bfloat16(uint64_t a
, float_status
*status
)
3839 return uint64_to_bfloat16_scalbn(a
, 0, status
);
3842 bfloat16
uint32_to_bfloat16(uint32_t a
, float_status
*status
)
3844 return uint64_to_bfloat16_scalbn(a
, 0, status
);
3847 bfloat16
uint16_to_bfloat16(uint16_t a
, float_status
*status
)
3849 return uint64_to_bfloat16_scalbn(a
, 0, status
);
3852 float128
uint64_to_float128(uint64_t a
, float_status
*status
)
3856 parts_uint_to_float(&p
, a
, 0, status
);
3857 return float128_round_pack_canonical(&p
, status
);
3861 * Minimum and maximum
3864 static float16
float16_minmax(float16 a
, float16 b
, float_status
*s
, int flags
)
3866 FloatParts64 pa
, pb
, *pr
;
3868 float16_unpack_canonical(&pa
, a
, s
);
3869 float16_unpack_canonical(&pb
, b
, s
);
3870 pr
= parts_minmax(&pa
, &pb
, s
, flags
);
3872 return float16_round_pack_canonical(pr
, s
);
3875 static bfloat16
bfloat16_minmax(bfloat16 a
, bfloat16 b
,
3876 float_status
*s
, int flags
)
3878 FloatParts64 pa
, pb
, *pr
;
3880 bfloat16_unpack_canonical(&pa
, a
, s
);
3881 bfloat16_unpack_canonical(&pb
, b
, s
);
3882 pr
= parts_minmax(&pa
, &pb
, s
, flags
);
3884 return bfloat16_round_pack_canonical(pr
, s
);
3887 static float32
float32_minmax(float32 a
, float32 b
, float_status
*s
, int flags
)
3889 FloatParts64 pa
, pb
, *pr
;
3891 float32_unpack_canonical(&pa
, a
, s
);
3892 float32_unpack_canonical(&pb
, b
, s
);
3893 pr
= parts_minmax(&pa
, &pb
, s
, flags
);
3895 return float32_round_pack_canonical(pr
, s
);
3898 static float64
float64_minmax(float64 a
, float64 b
, float_status
*s
, int flags
)
3900 FloatParts64 pa
, pb
, *pr
;
3902 float64_unpack_canonical(&pa
, a
, s
);
3903 float64_unpack_canonical(&pb
, b
, s
);
3904 pr
= parts_minmax(&pa
, &pb
, s
, flags
);
3906 return float64_round_pack_canonical(pr
, s
);
3909 static float128
float128_minmax(float128 a
, float128 b
,
3910 float_status
*s
, int flags
)
3912 FloatParts128 pa
, pb
, *pr
;
3914 float128_unpack_canonical(&pa
, a
, s
);
3915 float128_unpack_canonical(&pb
, b
, s
);
3916 pr
= parts_minmax(&pa
, &pb
, s
, flags
);
3918 return float128_round_pack_canonical(pr
, s
);
3921 #define MINMAX_1(type, name, flags) \
3922 type type##_##name(type a, type b, float_status *s) \
3923 { return type##_minmax(a, b, s, flags); }
3925 #define MINMAX_2(type) \
3926 MINMAX_1(type, max, 0) \
3927 MINMAX_1(type, maxnum, minmax_isnum) \
3928 MINMAX_1(type, maxnummag, minmax_isnum | minmax_ismag) \
3929 MINMAX_1(type, min, minmax_ismin) \
3930 MINMAX_1(type, minnum, minmax_ismin | minmax_isnum) \
3931 MINMAX_1(type, minnummag, minmax_ismin | minmax_isnum | minmax_ismag)
3943 * Floating point compare
3946 static FloatRelation QEMU_FLATTEN
3947 float16_do_compare(float16 a
, float16 b
, float_status
*s
, bool is_quiet
)
3949 FloatParts64 pa
, pb
;
3951 float16_unpack_canonical(&pa
, a
, s
);
3952 float16_unpack_canonical(&pb
, b
, s
);
3953 return parts_compare(&pa
, &pb
, s
, is_quiet
);
3956 FloatRelation
float16_compare(float16 a
, float16 b
, float_status
*s
)
3958 return float16_do_compare(a
, b
, s
, false);
3961 FloatRelation
float16_compare_quiet(float16 a
, float16 b
, float_status
*s
)
3963 return float16_do_compare(a
, b
, s
, true);
3966 static FloatRelation QEMU_SOFTFLOAT_ATTR
3967 float32_do_compare(float32 a
, float32 b
, float_status
*s
, bool is_quiet
)
3969 FloatParts64 pa
, pb
;
3971 float32_unpack_canonical(&pa
, a
, s
);
3972 float32_unpack_canonical(&pb
, b
, s
);
3973 return parts_compare(&pa
, &pb
, s
, is_quiet
);
3976 static FloatRelation QEMU_FLATTEN
3977 float32_hs_compare(float32 xa
, float32 xb
, float_status
*s
, bool is_quiet
)
3979 union_float32 ua
, ub
;
3984 if (QEMU_NO_HARDFLOAT
) {
3988 float32_input_flush2(&ua
.s
, &ub
.s
, s
);
3989 if (isgreaterequal(ua
.h
, ub
.h
)) {
3990 if (isgreater(ua
.h
, ub
.h
)) {
3991 return float_relation_greater
;
3993 return float_relation_equal
;
3995 if (likely(isless(ua
.h
, ub
.h
))) {
3996 return float_relation_less
;
3999 * The only condition remaining is unordered.
4000 * Fall through to set flags.
4003 return float32_do_compare(ua
.s
, ub
.s
, s
, is_quiet
);
4006 FloatRelation
float32_compare(float32 a
, float32 b
, float_status
*s
)
4008 return float32_hs_compare(a
, b
, s
, false);
4011 FloatRelation
float32_compare_quiet(float32 a
, float32 b
, float_status
*s
)
4013 return float32_hs_compare(a
, b
, s
, true);
4016 static FloatRelation QEMU_SOFTFLOAT_ATTR
4017 float64_do_compare(float64 a
, float64 b
, float_status
*s
, bool is_quiet
)
4019 FloatParts64 pa
, pb
;
4021 float64_unpack_canonical(&pa
, a
, s
);
4022 float64_unpack_canonical(&pb
, b
, s
);
4023 return parts_compare(&pa
, &pb
, s
, is_quiet
);
4026 static FloatRelation QEMU_FLATTEN
4027 float64_hs_compare(float64 xa
, float64 xb
, float_status
*s
, bool is_quiet
)
4029 union_float64 ua
, ub
;
4034 if (QEMU_NO_HARDFLOAT
) {
4038 float64_input_flush2(&ua
.s
, &ub
.s
, s
);
4039 if (isgreaterequal(ua
.h
, ub
.h
)) {
4040 if (isgreater(ua
.h
, ub
.h
)) {
4041 return float_relation_greater
;
4043 return float_relation_equal
;
4045 if (likely(isless(ua
.h
, ub
.h
))) {
4046 return float_relation_less
;
4049 * The only condition remaining is unordered.
4050 * Fall through to set flags.
4053 return float64_do_compare(ua
.s
, ub
.s
, s
, is_quiet
);
4056 FloatRelation
float64_compare(float64 a
, float64 b
, float_status
*s
)
4058 return float64_hs_compare(a
, b
, s
, false);
4061 FloatRelation
float64_compare_quiet(float64 a
, float64 b
, float_status
*s
)
4063 return float64_hs_compare(a
, b
, s
, true);
4066 static FloatRelation QEMU_FLATTEN
4067 bfloat16_do_compare(bfloat16 a
, bfloat16 b
, float_status
*s
, bool is_quiet
)
4069 FloatParts64 pa
, pb
;
4071 bfloat16_unpack_canonical(&pa
, a
, s
);
4072 bfloat16_unpack_canonical(&pb
, b
, s
);
4073 return parts_compare(&pa
, &pb
, s
, is_quiet
);
4076 FloatRelation
bfloat16_compare(bfloat16 a
, bfloat16 b
, float_status
*s
)
4078 return bfloat16_do_compare(a
, b
, s
, false);
4081 FloatRelation
bfloat16_compare_quiet(bfloat16 a
, bfloat16 b
, float_status
*s
)
4083 return bfloat16_do_compare(a
, b
, s
, true);
4086 static FloatRelation QEMU_FLATTEN
4087 float128_do_compare(float128 a
, float128 b
, float_status
*s
, bool is_quiet
)
4089 FloatParts128 pa
, pb
;
4091 float128_unpack_canonical(&pa
, a
, s
);
4092 float128_unpack_canonical(&pb
, b
, s
);
4093 return parts_compare(&pa
, &pb
, s
, is_quiet
);
4096 FloatRelation
float128_compare(float128 a
, float128 b
, float_status
*s
)
4098 return float128_do_compare(a
, b
, s
, false);
4101 FloatRelation
float128_compare_quiet(float128 a
, float128 b
, float_status
*s
)
4103 return float128_do_compare(a
, b
, s
, true);
4106 static FloatRelation QEMU_FLATTEN
4107 floatx80_do_compare(floatx80 a
, floatx80 b
, float_status
*s
, bool is_quiet
)
4109 FloatParts128 pa
, pb
;
4111 if (!floatx80_unpack_canonical(&pa
, a
, s
) ||
4112 !floatx80_unpack_canonical(&pb
, b
, s
)) {
4113 return float_relation_unordered
;
4115 return parts_compare(&pa
, &pb
, s
, is_quiet
);
4118 FloatRelation
floatx80_compare(floatx80 a
, floatx80 b
, float_status
*s
)
4120 return floatx80_do_compare(a
, b
, s
, false);
4123 FloatRelation
floatx80_compare_quiet(floatx80 a
, floatx80 b
, float_status
*s
)
4125 return floatx80_do_compare(a
, b
, s
, true);
4132 float16
float16_scalbn(float16 a
, int n
, float_status
*status
)
4136 float16_unpack_canonical(&p
, a
, status
);
4137 parts_scalbn(&p
, n
, status
);
4138 return float16_round_pack_canonical(&p
, status
);
4141 float32
float32_scalbn(float32 a
, int n
, float_status
*status
)
4145 float32_unpack_canonical(&p
, a
, status
);
4146 parts_scalbn(&p
, n
, status
);
4147 return float32_round_pack_canonical(&p
, status
);
4150 float64
float64_scalbn(float64 a
, int n
, float_status
*status
)
4154 float64_unpack_canonical(&p
, a
, status
);
4155 parts_scalbn(&p
, n
, status
);
4156 return float64_round_pack_canonical(&p
, status
);
4159 bfloat16
bfloat16_scalbn(bfloat16 a
, int n
, float_status
*status
)
4163 bfloat16_unpack_canonical(&p
, a
, status
);
4164 parts_scalbn(&p
, n
, status
);
4165 return bfloat16_round_pack_canonical(&p
, status
);
4168 float128
float128_scalbn(float128 a
, int n
, float_status
*status
)
4172 float128_unpack_canonical(&p
, a
, status
);
4173 parts_scalbn(&p
, n
, status
);
4174 return float128_round_pack_canonical(&p
, status
);
4177 floatx80
floatx80_scalbn(floatx80 a
, int n
, float_status
*status
)
4181 if (!floatx80_unpack_canonical(&p
, a
, status
)) {
4182 return floatx80_default_nan(status
);
4184 parts_scalbn(&p
, n
, status
);
4185 return floatx80_round_pack_canonical(&p
, status
);
4192 float16 QEMU_FLATTEN
float16_sqrt(float16 a
, float_status
*status
)
4196 float16_unpack_canonical(&p
, a
, status
);
4197 parts_sqrt(&p
, status
, &float16_params
);
4198 return float16_round_pack_canonical(&p
, status
);
4201 static float32 QEMU_SOFTFLOAT_ATTR
4202 soft_f32_sqrt(float32 a
, float_status
*status
)
4206 float32_unpack_canonical(&p
, a
, status
);
4207 parts_sqrt(&p
, status
, &float32_params
);
4208 return float32_round_pack_canonical(&p
, status
);
4211 static float64 QEMU_SOFTFLOAT_ATTR
4212 soft_f64_sqrt(float64 a
, float_status
*status
)
4216 float64_unpack_canonical(&p
, a
, status
);
4217 parts_sqrt(&p
, status
, &float64_params
);
4218 return float64_round_pack_canonical(&p
, status
);
4221 float32 QEMU_FLATTEN
float32_sqrt(float32 xa
, float_status
*s
)
4223 union_float32 ua
, ur
;
4226 if (unlikely(!can_use_fpu(s
))) {
4230 float32_input_flush1(&ua
.s
, s
);
4231 if (QEMU_HARDFLOAT_1F32_USE_FP
) {
4232 if (unlikely(!(fpclassify(ua
.h
) == FP_NORMAL
||
4233 fpclassify(ua
.h
) == FP_ZERO
) ||
4237 } else if (unlikely(!float32_is_zero_or_normal(ua
.s
) ||
4238 float32_is_neg(ua
.s
))) {
4245 return soft_f32_sqrt(ua
.s
, s
);
4248 float64 QEMU_FLATTEN
float64_sqrt(float64 xa
, float_status
*s
)
4250 union_float64 ua
, ur
;
4253 if (unlikely(!can_use_fpu(s
))) {
4257 float64_input_flush1(&ua
.s
, s
);
4258 if (QEMU_HARDFLOAT_1F64_USE_FP
) {
4259 if (unlikely(!(fpclassify(ua
.h
) == FP_NORMAL
||
4260 fpclassify(ua
.h
) == FP_ZERO
) ||
4264 } else if (unlikely(!float64_is_zero_or_normal(ua
.s
) ||
4265 float64_is_neg(ua
.s
))) {
4272 return soft_f64_sqrt(ua
.s
, s
);
4275 bfloat16 QEMU_FLATTEN
bfloat16_sqrt(bfloat16 a
, float_status
*status
)
4279 bfloat16_unpack_canonical(&p
, a
, status
);
4280 parts_sqrt(&p
, status
, &bfloat16_params
);
4281 return bfloat16_round_pack_canonical(&p
, status
);
4284 float128 QEMU_FLATTEN
float128_sqrt(float128 a
, float_status
*status
)
4288 float128_unpack_canonical(&p
, a
, status
);
4289 parts_sqrt(&p
, status
, &float128_params
);
4290 return float128_round_pack_canonical(&p
, status
);
4293 floatx80
floatx80_sqrt(floatx80 a
, float_status
*s
)
4297 if (!floatx80_unpack_canonical(&p
, a
, s
)) {
4298 return floatx80_default_nan(s
);
4300 parts_sqrt(&p
, s
, &floatx80_params
[s
->floatx80_rounding_precision
]);
4301 return floatx80_round_pack_canonical(&p
, s
);
4307 float32
float32_log2(float32 a
, float_status
*status
)
4311 float32_unpack_canonical(&p
, a
, status
);
4312 parts_log2(&p
, status
, &float32_params
);
4313 return float32_round_pack_canonical(&p
, status
);
4316 float64
float64_log2(float64 a
, float_status
*status
)
4320 float64_unpack_canonical(&p
, a
, status
);
4321 parts_log2(&p
, status
, &float64_params
);
4322 return float64_round_pack_canonical(&p
, status
);
4325 /*----------------------------------------------------------------------------
4326 | The pattern for a default generated NaN.
4327 *----------------------------------------------------------------------------*/
4329 float16
float16_default_nan(float_status
*status
)
4333 parts_default_nan(&p
, status
);
4334 p
.frac
>>= float16_params
.frac_shift
;
4335 return float16_pack_raw(&p
);
4338 float32
float32_default_nan(float_status
*status
)
4342 parts_default_nan(&p
, status
);
4343 p
.frac
>>= float32_params
.frac_shift
;
4344 return float32_pack_raw(&p
);
4347 float64
float64_default_nan(float_status
*status
)
4351 parts_default_nan(&p
, status
);
4352 p
.frac
>>= float64_params
.frac_shift
;
4353 return float64_pack_raw(&p
);
4356 float128
float128_default_nan(float_status
*status
)
4360 parts_default_nan(&p
, status
);
4361 frac_shr(&p
, float128_params
.frac_shift
);
4362 return float128_pack_raw(&p
);
4365 bfloat16
bfloat16_default_nan(float_status
*status
)
4369 parts_default_nan(&p
, status
);
4370 p
.frac
>>= bfloat16_params
.frac_shift
;
4371 return bfloat16_pack_raw(&p
);
4374 /*----------------------------------------------------------------------------
4375 | Returns a quiet NaN from a signalling NaN for the floating point value `a'.
4376 *----------------------------------------------------------------------------*/
4378 float16
float16_silence_nan(float16 a
, float_status
*status
)
4382 float16_unpack_raw(&p
, a
);
4383 p
.frac
<<= float16_params
.frac_shift
;
4384 parts_silence_nan(&p
, status
);
4385 p
.frac
>>= float16_params
.frac_shift
;
4386 return float16_pack_raw(&p
);
4389 float32
float32_silence_nan(float32 a
, float_status
*status
)
4393 float32_unpack_raw(&p
, a
);
4394 p
.frac
<<= float32_params
.frac_shift
;
4395 parts_silence_nan(&p
, status
);
4396 p
.frac
>>= float32_params
.frac_shift
;
4397 return float32_pack_raw(&p
);
4400 float64
float64_silence_nan(float64 a
, float_status
*status
)
4404 float64_unpack_raw(&p
, a
);
4405 p
.frac
<<= float64_params
.frac_shift
;
4406 parts_silence_nan(&p
, status
);
4407 p
.frac
>>= float64_params
.frac_shift
;
4408 return float64_pack_raw(&p
);
4411 bfloat16
bfloat16_silence_nan(bfloat16 a
, float_status
*status
)
4415 bfloat16_unpack_raw(&p
, a
);
4416 p
.frac
<<= bfloat16_params
.frac_shift
;
4417 parts_silence_nan(&p
, status
);
4418 p
.frac
>>= bfloat16_params
.frac_shift
;
4419 return bfloat16_pack_raw(&p
);
4422 float128
float128_silence_nan(float128 a
, float_status
*status
)
4426 float128_unpack_raw(&p
, a
);
4427 frac_shl(&p
, float128_params
.frac_shift
);
4428 parts_silence_nan(&p
, status
);
4429 frac_shr(&p
, float128_params
.frac_shift
);
4430 return float128_pack_raw(&p
);
4433 /*----------------------------------------------------------------------------
4434 | If `a' is denormal and we are in flush-to-zero mode then set the
4435 | input-denormal exception and return zero. Otherwise just return the value.
4436 *----------------------------------------------------------------------------*/
4438 static bool parts_squash_denormal(FloatParts64 p
, float_status
*status
)
4440 if (p
.exp
== 0 && p
.frac
!= 0) {
4441 float_raise(float_flag_input_denormal
, status
);
4448 float16
float16_squash_input_denormal(float16 a
, float_status
*status
)
4450 if (status
->flush_inputs_to_zero
) {
4453 float16_unpack_raw(&p
, a
);
4454 if (parts_squash_denormal(p
, status
)) {
4455 return float16_set_sign(float16_zero
, p
.sign
);
4461 float32
float32_squash_input_denormal(float32 a
, float_status
*status
)
4463 if (status
->flush_inputs_to_zero
) {
4466 float32_unpack_raw(&p
, a
);
4467 if (parts_squash_denormal(p
, status
)) {
4468 return float32_set_sign(float32_zero
, p
.sign
);
4474 float64
float64_squash_input_denormal(float64 a
, float_status
*status
)
4476 if (status
->flush_inputs_to_zero
) {
4479 float64_unpack_raw(&p
, a
);
4480 if (parts_squash_denormal(p
, status
)) {
4481 return float64_set_sign(float64_zero
, p
.sign
);
4487 bfloat16
bfloat16_squash_input_denormal(bfloat16 a
, float_status
*status
)
4489 if (status
->flush_inputs_to_zero
) {
4492 bfloat16_unpack_raw(&p
, a
);
4493 if (parts_squash_denormal(p
, status
)) {
4494 return bfloat16_set_sign(bfloat16_zero
, p
.sign
);
4500 /*----------------------------------------------------------------------------
4501 | Normalizes the subnormal extended double-precision floating-point value
4502 | represented by the denormalized significand `aSig'. The normalized exponent
4503 | and significand are stored at the locations pointed to by `zExpPtr' and
4504 | `zSigPtr', respectively.
4505 *----------------------------------------------------------------------------*/
4507 void normalizeFloatx80Subnormal(uint64_t aSig
, int32_t *zExpPtr
,
4512 shiftCount
= clz64(aSig
);
4513 *zSigPtr
= aSig
<<shiftCount
;
4514 *zExpPtr
= 1 - shiftCount
;
4517 /*----------------------------------------------------------------------------
4518 | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
4519 | and extended significand formed by the concatenation of `zSig0' and `zSig1',
4520 | and returns the proper extended double-precision floating-point value
4521 | corresponding to the abstract input. Ordinarily, the abstract value is
4522 | rounded and packed into the extended double-precision format, with the
4523 | inexact exception raised if the abstract input cannot be represented
4524 | exactly. However, if the abstract value is too large, the overflow and
4525 | inexact exceptions are raised and an infinity or maximal finite value is
4526 | returned. If the abstract value is too small, the input value is rounded to
4527 | a subnormal number, and the underflow and inexact exceptions are raised if
4528 | the abstract input cannot be represented exactly as a subnormal extended
4529 | double-precision floating-point number.
4530 | If `roundingPrecision' is floatx80_precision_s or floatx80_precision_d,
4531 | the result is rounded to the same number of bits as single or double
4532 | precision, respectively. Otherwise, the result is rounded to the full
4533 | precision of the extended double-precision format.
4534 | The input significand must be normalized or smaller. If the input
4535 | significand is not normalized, `zExp' must be 0; in that case, the result
4536 | returned is a subnormal number, and it must not require rounding. The
4537 | handling of underflow and overflow follows the IEC/IEEE Standard for Binary
4538 | Floating-Point Arithmetic.
4539 *----------------------------------------------------------------------------*/
4541 floatx80
roundAndPackFloatx80(FloatX80RoundPrec roundingPrecision
, bool zSign
,
4542 int32_t zExp
, uint64_t zSig0
, uint64_t zSig1
,
4543 float_status
*status
)
4545 FloatRoundMode roundingMode
;
4546 bool roundNearestEven
, increment
, isTiny
;
4547 int64_t roundIncrement
, roundMask
, roundBits
;
4549 roundingMode
= status
->float_rounding_mode
;
4550 roundNearestEven
= ( roundingMode
== float_round_nearest_even
);
4551 switch (roundingPrecision
) {
4552 case floatx80_precision_x
:
4554 case floatx80_precision_d
:
4555 roundIncrement
= UINT64_C(0x0000000000000400);
4556 roundMask
= UINT64_C(0x00000000000007FF);
4558 case floatx80_precision_s
:
4559 roundIncrement
= UINT64_C(0x0000008000000000);
4560 roundMask
= UINT64_C(0x000000FFFFFFFFFF);
4563 g_assert_not_reached();
4565 zSig0
|= ( zSig1
!= 0 );
4566 switch (roundingMode
) {
4567 case float_round_nearest_even
:
4568 case float_round_ties_away
:
4570 case float_round_to_zero
:
4573 case float_round_up
:
4574 roundIncrement
= zSign
? 0 : roundMask
;
4576 case float_round_down
:
4577 roundIncrement
= zSign
? roundMask
: 0;
4582 roundBits
= zSig0
& roundMask
;
4583 if ( 0x7FFD <= (uint32_t) ( zExp
- 1 ) ) {
4584 if ( ( 0x7FFE < zExp
)
4585 || ( ( zExp
== 0x7FFE ) && ( zSig0
+ roundIncrement
< zSig0
) )
4590 if (status
->flush_to_zero
) {
4591 float_raise(float_flag_output_denormal
, status
);
4592 return packFloatx80(zSign
, 0, 0);
4594 isTiny
= status
->tininess_before_rounding
4596 || (zSig0
<= zSig0
+ roundIncrement
);
4597 shift64RightJamming( zSig0
, 1 - zExp
, &zSig0
);
4599 roundBits
= zSig0
& roundMask
;
4600 if (isTiny
&& roundBits
) {
4601 float_raise(float_flag_underflow
, status
);
4604 float_raise(float_flag_inexact
, status
);
4606 zSig0
+= roundIncrement
;
4607 if ( (int64_t) zSig0
< 0 ) zExp
= 1;
4608 roundIncrement
= roundMask
+ 1;
4609 if ( roundNearestEven
&& ( roundBits
<<1 == roundIncrement
) ) {
4610 roundMask
|= roundIncrement
;
4612 zSig0
&= ~ roundMask
;
4613 return packFloatx80( zSign
, zExp
, zSig0
);
4617 float_raise(float_flag_inexact
, status
);
4619 zSig0
+= roundIncrement
;
4620 if ( zSig0
< roundIncrement
) {
4622 zSig0
= UINT64_C(0x8000000000000000);
4624 roundIncrement
= roundMask
+ 1;
4625 if ( roundNearestEven
&& ( roundBits
<<1 == roundIncrement
) ) {
4626 roundMask
|= roundIncrement
;
4628 zSig0
&= ~ roundMask
;
4629 if ( zSig0
== 0 ) zExp
= 0;
4630 return packFloatx80( zSign
, zExp
, zSig0
);
4632 switch (roundingMode
) {
4633 case float_round_nearest_even
:
4634 case float_round_ties_away
:
4635 increment
= ((int64_t)zSig1
< 0);
4637 case float_round_to_zero
:
4640 case float_round_up
:
4641 increment
= !zSign
&& zSig1
;
4643 case float_round_down
:
4644 increment
= zSign
&& zSig1
;
4649 if ( 0x7FFD <= (uint32_t) ( zExp
- 1 ) ) {
4650 if ( ( 0x7FFE < zExp
)
4651 || ( ( zExp
== 0x7FFE )
4652 && ( zSig0
== UINT64_C(0xFFFFFFFFFFFFFFFF) )
4658 float_raise(float_flag_overflow
| float_flag_inexact
, status
);
4659 if ( ( roundingMode
== float_round_to_zero
)
4660 || ( zSign
&& ( roundingMode
== float_round_up
) )
4661 || ( ! zSign
&& ( roundingMode
== float_round_down
) )
4663 return packFloatx80( zSign
, 0x7FFE, ~ roundMask
);
4665 return packFloatx80(zSign
,
4666 floatx80_infinity_high
,
4667 floatx80_infinity_low
);
4670 isTiny
= status
->tininess_before_rounding
4673 || (zSig0
< UINT64_C(0xFFFFFFFFFFFFFFFF));
4674 shift64ExtraRightJamming( zSig0
, zSig1
, 1 - zExp
, &zSig0
, &zSig1
);
4676 if (isTiny
&& zSig1
) {
4677 float_raise(float_flag_underflow
, status
);
4680 float_raise(float_flag_inexact
, status
);
4682 switch (roundingMode
) {
4683 case float_round_nearest_even
:
4684 case float_round_ties_away
:
4685 increment
= ((int64_t)zSig1
< 0);
4687 case float_round_to_zero
:
4690 case float_round_up
:
4691 increment
= !zSign
&& zSig1
;
4693 case float_round_down
:
4694 increment
= zSign
&& zSig1
;
4701 if (!(zSig1
<< 1) && roundNearestEven
) {
4704 if ( (int64_t) zSig0
< 0 ) zExp
= 1;
4706 return packFloatx80( zSign
, zExp
, zSig0
);
4710 float_raise(float_flag_inexact
, status
);
4716 zSig0
= UINT64_C(0x8000000000000000);
4719 if (!(zSig1
<< 1) && roundNearestEven
) {
4725 if ( zSig0
== 0 ) zExp
= 0;
4727 return packFloatx80( zSign
, zExp
, zSig0
);
4731 /*----------------------------------------------------------------------------
4732 | Takes an abstract floating-point value having sign `zSign', exponent
4733 | `zExp', and significand formed by the concatenation of `zSig0' and `zSig1',
4734 | and returns the proper extended double-precision floating-point value
4735 | corresponding to the abstract input. This routine is just like
4736 | `roundAndPackFloatx80' except that the input significand does not have to be
4738 *----------------------------------------------------------------------------*/
4740 floatx80
normalizeRoundAndPackFloatx80(FloatX80RoundPrec roundingPrecision
,
4741 bool zSign
, int32_t zExp
,
4742 uint64_t zSig0
, uint64_t zSig1
,
4743 float_status
*status
)
4752 shiftCount
= clz64(zSig0
);
4753 shortShift128Left( zSig0
, zSig1
, shiftCount
, &zSig0
, &zSig1
);
4755 return roundAndPackFloatx80(roundingPrecision
, zSign
, zExp
,
4756 zSig0
, zSig1
, status
);
4760 /*----------------------------------------------------------------------------
4761 | Returns the binary exponential of the single-precision floating-point value
4762 | `a'. The operation is performed according to the IEC/IEEE Standard for
4763 | Binary Floating-Point Arithmetic.
4765 | Uses the following identities:
4767 | 1. -------------------------------------------------------------------------
4771 | 2. -------------------------------------------------------------------------
4774 | e = 1 + --- + --- + --- + --- + --- + ... + --- + ...
4776 *----------------------------------------------------------------------------*/
4778 static const float64 float32_exp2_coefficients
[15] =
4780 const_float64( 0x3ff0000000000000ll
), /* 1 */
4781 const_float64( 0x3fe0000000000000ll
), /* 2 */
4782 const_float64( 0x3fc5555555555555ll
), /* 3 */
4783 const_float64( 0x3fa5555555555555ll
), /* 4 */
4784 const_float64( 0x3f81111111111111ll
), /* 5 */
4785 const_float64( 0x3f56c16c16c16c17ll
), /* 6 */
4786 const_float64( 0x3f2a01a01a01a01all
), /* 7 */
4787 const_float64( 0x3efa01a01a01a01all
), /* 8 */
4788 const_float64( 0x3ec71de3a556c734ll
), /* 9 */
4789 const_float64( 0x3e927e4fb7789f5cll
), /* 10 */
4790 const_float64( 0x3e5ae64567f544e4ll
), /* 11 */
4791 const_float64( 0x3e21eed8eff8d898ll
), /* 12 */
4792 const_float64( 0x3de6124613a86d09ll
), /* 13 */
4793 const_float64( 0x3da93974a8c07c9dll
), /* 14 */
4794 const_float64( 0x3d6ae7f3e733b81fll
), /* 15 */
4797 float32
float32_exp2(float32 a
, float_status
*status
)
4799 FloatParts64 xp
, xnp
, tp
, rp
;
4802 float32_unpack_canonical(&xp
, a
, status
);
4803 if (unlikely(xp
.cls
!= float_class_normal
)) {
4805 case float_class_snan
:
4806 case float_class_qnan
:
4807 parts_return_nan(&xp
, status
);
4808 return float32_round_pack_canonical(&xp
, status
);
4809 case float_class_inf
:
4810 return xp
.sign
? float32_zero
: a
;
4811 case float_class_zero
:
4816 g_assert_not_reached();
4819 float_raise(float_flag_inexact
, status
);
4821 float64_unpack_canonical(&tp
, float64_ln2
, status
);
4822 xp
= *parts_mul(&xp
, &tp
, status
);
4825 float64_unpack_canonical(&rp
, float64_one
, status
);
4826 for (i
= 0 ; i
< 15 ; i
++) {
4827 float64_unpack_canonical(&tp
, float32_exp2_coefficients
[i
], status
);
4828 rp
= *parts_muladd(&tp
, &xp
, &rp
, 0, status
);
4829 xnp
= *parts_mul(&xnp
, &xp
, status
);
4832 return float32_round_pack_canonical(&rp
, status
);
4835 /*----------------------------------------------------------------------------
4836 | Rounds the extended double-precision floating-point value `a'
4837 | to the precision provided by floatx80_rounding_precision and returns the
4838 | result as an extended double-precision floating-point value.
4839 | The operation is performed according to the IEC/IEEE Standard for Binary
4840 | Floating-Point Arithmetic.
4841 *----------------------------------------------------------------------------*/
4843 floatx80
floatx80_round(floatx80 a
, float_status
*status
)
4847 if (!floatx80_unpack_canonical(&p
, a
, status
)) {
4848 return floatx80_default_nan(status
);
4850 return floatx80_round_pack_canonical(&p
, status
);
4853 static void __attribute__((constructor
)) softfloat_init(void)
4855 union_float64 ua
, ub
, uc
, ur
;
4857 if (QEMU_NO_HARDFLOAT
) {
4861 * Test that the host's FMA is not obviously broken. For example,
4862 * glibc < 2.23 can perform an incorrect FMA on certain hosts; see
4863 * https://sourceware.org/bugzilla/show_bug.cgi?id=13304
4865 ua
.s
= 0x0020000000000001ULL
;
4866 ub
.s
= 0x3ca0000000000000ULL
;
4867 uc
.s
= 0x0020000000000000ULL
;
4868 ur
.h
= fma(ua
.h
, ub
.h
, uc
.h
);
4869 if (ur
.s
!= 0x0020000000000001ULL
) {
4870 force_soft_fma
= true;