blob: 3dcf20e3a212708203c65ef64b4e16bd97e2a965 [file] [log] [blame]
Andreas Färber8d725fa2011-03-07 01:34:04 +01001/*
2 * QEMU float support
3 *
Peter Maydell16017c42015-01-12 14:38:28 +00004 * The code in this source file is derived from release 2a of the SoftFloat
5 * IEC/IEEE Floating-point Arithmetic Package. Those parts of the code (and
6 * some later contributions) are provided under that license, as detailed below.
7 * It has subsequently been modified by contributors to the QEMU Project,
8 * so some portions are provided under:
9 * the SoftFloat-2a license
10 * the BSD license
11 * GPL-v2-or-later
12 *
13 * Any future contributions to this file after December 1st 2014 will be
14 * taken to be licensed under the Softfloat-2a license unless specifically
15 * indicated otherwise.
Andreas Färber8d725fa2011-03-07 01:34:04 +010016 */
17
Peter Maydella7d1ac72015-01-12 14:38:25 +000018/*
19===============================================================================
20This C header file is part of the SoftFloat IEC/IEEE Floating-point
21Arithmetic Package, Release 2a.
bellard158142c2005-03-13 16:54:06 +000022
23Written by John R. Hauser. This work was made possible in part by the
24International Computer Science Institute, located at Suite 600, 1947 Center
25Street, Berkeley, California 94704. Funding was partially provided by the
26National Science Foundation under grant MIP-9311980. The original version
27of this code was written as part of a project to build a fixed-point vector
28processor in collaboration with the University of California at Berkeley,
29overseen by Profs. Nelson Morgan and John Wawrzynek. More information
Peter Maydella7d1ac72015-01-12 14:38:25 +000030is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
bellard158142c2005-03-13 16:54:06 +000031arithmetic/SoftFloat.html'.
32
Peter Maydella7d1ac72015-01-12 14:38:25 +000033THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
34has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
35TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
36PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
37AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
bellard158142c2005-03-13 16:54:06 +000038
39Derivative works are acceptable, even for commercial purposes, so long as
Peter Maydella7d1ac72015-01-12 14:38:25 +000040(1) they include prominent notice that the work is derivative, and (2) they
41include prominent notice akin to these four paragraphs for those parts of
42this code that are retained.
bellard158142c2005-03-13 16:54:06 +000043
Peter Maydella7d1ac72015-01-12 14:38:25 +000044===============================================================================
45*/
bellard158142c2005-03-13 16:54:06 +000046
Peter Maydell16017c42015-01-12 14:38:28 +000047/* BSD licensing:
48 * Copyright (c) 2006, Fabrice Bellard
49 * All rights reserved.
50 *
51 * Redistribution and use in source and binary forms, with or without
52 * modification, are permitted provided that the following conditions are met:
53 *
54 * 1. Redistributions of source code must retain the above copyright notice,
55 * this list of conditions and the following disclaimer.
56 *
57 * 2. Redistributions in binary form must reproduce the above copyright notice,
58 * this list of conditions and the following disclaimer in the documentation
59 * and/or other materials provided with the distribution.
60 *
61 * 3. Neither the name of the copyright holder nor the names of its contributors
62 * may be used to endorse or promote products derived from this software without
63 * specific prior written permission.
64 *
65 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
66 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
67 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
68 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
69 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
70 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
71 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
72 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
73 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
74 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
75 * THE POSSIBILITY OF SUCH DAMAGE.
76 */
77
78/* Portions of this work are licensed under the terms of the GNU GPL,
79 * version 2 or later. See the COPYING file in the top-level directory.
80 */
81
bellard158142c2005-03-13 16:54:06 +000082#ifndef SOFTFLOAT_H
83#define SOFTFLOAT_H
84
bellard1d6bda32005-03-13 18:52:29 +000085/*----------------------------------------------------------------------------
86| Software IEC/IEEE floating-point ordering relations
87*----------------------------------------------------------------------------*/
Richard Henderson71bfd652020-05-05 10:22:05 -070088
89typedef enum {
bellard1d6bda32005-03-13 18:52:29 +000090 float_relation_less = -1,
91 float_relation_equal = 0,
92 float_relation_greater = 1,
93 float_relation_unordered = 2
Richard Henderson71bfd652020-05-05 10:22:05 -070094} FloatRelation;
bellard1d6bda32005-03-13 18:52:29 +000095
Alex Bennéecfd88fc2018-01-19 16:36:40 +000096#include "fpu/softfloat-types.h"
Alex Bennéee34c47e2019-08-08 15:11:08 +010097#include "fpu/softfloat-helpers.h"
Matheus Ferstf2798522022-03-30 14:59:27 -030098#include "qemu/int128.h"
bellard158142c2005-03-13 16:54:06 +000099
100/*----------------------------------------------------------------------------
101| Routine to raise any or all of the software IEC/IEEE floating-point
102| exception flags.
103*----------------------------------------------------------------------------*/
Richard Henderson149a48f2021-12-17 17:57:14 +0100104static inline void float_raise(uint16_t flags, float_status *status)
Richard Henderson622090a2020-10-20 20:05:57 -0700105{
106 status->float_exception_flags |= flags;
107}
bellard158142c2005-03-13 16:54:06 +0000108
109/*----------------------------------------------------------------------------
Alex Bennée7baeabc2014-03-17 16:31:51 +0000110| If `a' is denormal and we are in flush-to-zero mode then set the
111| input-denormal exception and return zero. Otherwise just return the value.
112*----------------------------------------------------------------------------*/
Alex Bennée210cbd42017-07-03 14:30:06 +0100113float16 float16_squash_input_denormal(float16 a, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000114float32 float32_squash_input_denormal(float32 a, float_status *status);
115float64 float64_squash_input_denormal(float64 a, float_status *status);
LIU Zhiwei82823102020-08-13 15:14:19 +0800116bfloat16 bfloat16_squash_input_denormal(bfloat16 a, float_status *status);
Alex Bennée7baeabc2014-03-17 16:31:51 +0000117
118/*----------------------------------------------------------------------------
Peter Maydell369be8f2011-10-19 16:14:06 +0000119| Options to indicate which negations to perform in float*_muladd()
120| Using these differs from negating an input or output before calling
121| the muladd function in that this means that a NaN doesn't have its
122| sign bit inverted before it is propagated.
Peter Maydell67d43532014-02-20 10:35:50 +0000123| We also support halving the result before rounding, as a special
124| case to support the ARM fused-sqrt-step instruction FRSQRTS.
Peter Maydell369be8f2011-10-19 16:14:06 +0000125*----------------------------------------------------------------------------*/
126enum {
127 float_muladd_negate_c = 1,
128 float_muladd_negate_product = 2,
Max Filippov66176802012-09-19 04:23:50 +0400129 float_muladd_negate_result = 4,
Peter Maydell67d43532014-02-20 10:35:50 +0000130 float_muladd_halve_result = 8,
Peter Maydell369be8f2011-10-19 16:14:06 +0000131};
132
133/*----------------------------------------------------------------------------
bellard158142c2005-03-13 16:54:06 +0000134| Software IEC/IEEE integer-to-floating-point conversion routines.
135*----------------------------------------------------------------------------*/
Richard Henderson2abdfe22018-08-24 13:17:29 +0100136
137float16 int16_to_float16_scalbn(int16_t a, int, float_status *status);
138float16 int32_to_float16_scalbn(int32_t a, int, float_status *status);
139float16 int64_to_float16_scalbn(int64_t a, int, float_status *status);
140float16 uint16_to_float16_scalbn(uint16_t a, int, float_status *status);
141float16 uint32_to_float16_scalbn(uint32_t a, int, float_status *status);
142float16 uint64_to_float16_scalbn(uint64_t a, int, float_status *status);
143
Frank Chang0d93d8e2020-07-30 02:52:24 -0700144float16 int8_to_float16(int8_t a, float_status *status);
Richard Henderson2abdfe22018-08-24 13:17:29 +0100145float16 int16_to_float16(int16_t a, float_status *status);
146float16 int32_to_float16(int32_t a, float_status *status);
147float16 int64_to_float16(int64_t a, float_status *status);
Frank Chang0d93d8e2020-07-30 02:52:24 -0700148float16 uint8_to_float16(uint8_t a, float_status *status);
Richard Henderson2abdfe22018-08-24 13:17:29 +0100149float16 uint16_to_float16(uint16_t a, float_status *status);
150float16 uint32_to_float16(uint32_t a, float_status *status);
151float16 uint64_to_float16(uint64_t a, float_status *status);
152
153float32 int16_to_float32_scalbn(int16_t, int, float_status *status);
154float32 int32_to_float32_scalbn(int32_t, int, float_status *status);
155float32 int64_to_float32_scalbn(int64_t, int, float_status *status);
156float32 uint16_to_float32_scalbn(uint16_t, int, float_status *status);
157float32 uint32_to_float32_scalbn(uint32_t, int, float_status *status);
158float32 uint64_to_float32_scalbn(uint64_t, int, float_status *status);
159
Alex Bennéec02e1fb2017-11-30 10:57:08 +0000160float32 int16_to_float32(int16_t, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000161float32 int32_to_float32(int32_t, float_status *status);
Richard Henderson2abdfe22018-08-24 13:17:29 +0100162float32 int64_to_float32(int64_t, float_status *status);
Alex Bennéec02e1fb2017-11-30 10:57:08 +0000163float32 uint16_to_float32(uint16_t, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000164float32 uint32_to_float32(uint32_t, float_status *status);
Richard Henderson2abdfe22018-08-24 13:17:29 +0100165float32 uint64_to_float32(uint64_t, float_status *status);
166
167float64 int16_to_float64_scalbn(int16_t, int, float_status *status);
168float64 int32_to_float64_scalbn(int32_t, int, float_status *status);
169float64 int64_to_float64_scalbn(int64_t, int, float_status *status);
170float64 uint16_to_float64_scalbn(uint16_t, int, float_status *status);
171float64 uint32_to_float64_scalbn(uint32_t, int, float_status *status);
172float64 uint64_to_float64_scalbn(uint64_t, int, float_status *status);
173
174float64 int16_to_float64(int16_t, float_status *status);
175float64 int32_to_float64(int32_t, float_status *status);
176float64 int64_to_float64(int64_t, float_status *status);
Alex Bennéec02e1fb2017-11-30 10:57:08 +0000177float64 uint16_to_float64(uint16_t, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000178float64 uint32_to_float64(uint32_t, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000179float64 uint64_to_float64(uint64_t, float_status *status);
Richard Henderson2abdfe22018-08-24 13:17:29 +0100180
181floatx80 int32_to_floatx80(int32_t, float_status *status);
182floatx80 int64_to_floatx80(int64_t, float_status *status);
183
184float128 int32_to_float128(int32_t, float_status *status);
185float128 int64_to_float128(int64_t, float_status *status);
Matheus Ferst95c1b712022-03-30 14:59:28 -0300186float128 int128_to_float128(Int128, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000187float128 uint64_to_float128(uint64_t, float_status *status);
Matheus Ferstf2798522022-03-30 14:59:27 -0300188float128 uint128_to_float128(Int128, float_status *status);
bellard158142c2005-03-13 16:54:06 +0000189
190/*----------------------------------------------------------------------------
Paul Brook60011492009-11-19 16:45:20 +0000191| Software half-precision conversion routines.
192*----------------------------------------------------------------------------*/
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100193
Alex Bennée6fed16b2018-03-16 16:45:02 +0000194float16 float32_to_float16(float32, bool ieee, float_status *status);
195float32 float16_to_float32(float16, bool ieee, float_status *status);
196float16 float64_to_float16(float64 a, bool ieee, float_status *status);
197float64 float16_to_float64(float16 a, bool ieee, float_status *status);
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100198
Frank Chang0d93d8e2020-07-30 02:52:24 -0700199int8_t float16_to_int8_scalbn(float16, FloatRoundMode, int,
200 float_status *status);
Richard Henderson3dede402020-05-05 09:01:49 -0700201int16_t float16_to_int16_scalbn(float16, FloatRoundMode, int, float_status *);
202int32_t float16_to_int32_scalbn(float16, FloatRoundMode, int, float_status *);
203int64_t float16_to_int64_scalbn(float16, FloatRoundMode, int, float_status *);
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100204
Frank Chang0d93d8e2020-07-30 02:52:24 -0700205int8_t float16_to_int8(float16, float_status *status);
Alex Bennéeab52f972017-11-29 10:56:06 +0000206int16_t float16_to_int16(float16, float_status *status);
Alex Bennéeab52f972017-11-29 10:56:06 +0000207int32_t float16_to_int32(float16, float_status *status);
Alex Bennéeab52f972017-11-29 10:56:06 +0000208int64_t float16_to_int64(float16, float_status *status);
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100209
210int16_t float16_to_int16_round_to_zero(float16, float_status *status);
211int32_t float16_to_int32_round_to_zero(float16, float_status *status);
Alex Bennéeab52f972017-11-29 10:56:06 +0000212int64_t float16_to_int64_round_to_zero(float16, float_status *status);
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100213
Frank Chang0d93d8e2020-07-30 02:52:24 -0700214uint8_t float16_to_uint8_scalbn(float16 a, FloatRoundMode,
215 int, float_status *status);
Richard Henderson3dede402020-05-05 09:01:49 -0700216uint16_t float16_to_uint16_scalbn(float16 a, FloatRoundMode,
217 int, float_status *status);
218uint32_t float16_to_uint32_scalbn(float16 a, FloatRoundMode,
219 int, float_status *status);
220uint64_t float16_to_uint64_scalbn(float16 a, FloatRoundMode,
221 int, float_status *status);
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100222
Frank Chang0d93d8e2020-07-30 02:52:24 -0700223uint8_t float16_to_uint8(float16 a, float_status *status);
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100224uint16_t float16_to_uint16(float16 a, float_status *status);
225uint32_t float16_to_uint32(float16 a, float_status *status);
226uint64_t float16_to_uint64(float16 a, float_status *status);
227
228uint16_t float16_to_uint16_round_to_zero(float16 a, float_status *status);
229uint32_t float16_to_uint32_round_to_zero(float16 a, float_status *status);
Alex Bennéeab52f972017-11-29 10:56:06 +0000230uint64_t float16_to_uint64_round_to_zero(float16 a, float_status *status);
Peter Maydellbb4d4bb2011-02-10 11:28:56 +0000231
232/*----------------------------------------------------------------------------
233| Software half-precision operations.
234*----------------------------------------------------------------------------*/
Alex Bennée6fff2162017-11-27 14:15:17 +0000235
Alex Bennéedbe4d532017-11-29 10:21:25 +0000236float16 float16_round_to_int(float16, float_status *status);
Alex Bennée6fff2162017-11-27 14:15:17 +0000237float16 float16_add(float16, float16, float_status *status);
238float16 float16_sub(float16, float16, float_status *status);
Alex Bennée74d707e2017-12-07 18:56:50 +0000239float16 float16_mul(float16, float16, float_status *status);
Alex Bennéed4468302017-11-28 17:04:44 +0000240float16 float16_muladd(float16, float16, float16, int, float_status *status);
Alex Bennéecf073232017-11-27 16:13:36 +0000241float16 float16_div(float16, float16, float_status *status);
Alex Bennée0bfc9f12017-11-30 11:31:40 +0000242float16 float16_scalbn(float16, int, float_status *status);
Alex Bennée89360062017-12-05 12:36:01 +0000243float16 float16_min(float16, float16, float_status *status);
244float16 float16_max(float16, float16, float_status *status);
245float16 float16_minnum(float16, float16, float_status *status);
246float16 float16_maxnum(float16, float16, float_status *status);
247float16 float16_minnummag(float16, float16, float_status *status);
248float16 float16_maxnummag(float16, float16, float_status *status);
Chih-Min Chao0e903032021-10-22 00:08:45 +0800249float16 float16_minimum_number(float16, float16, float_status *status);
250float16 float16_maximum_number(float16, float16, float_status *status);
Alex Bennéec13bb2d2018-01-12 11:24:02 +0000251float16 float16_sqrt(float16, float_status *status);
Richard Henderson71bfd652020-05-05 10:22:05 -0700252FloatRelation float16_compare(float16, float16, float_status *status);
253FloatRelation float16_compare_quiet(float16, float16, float_status *status);
Alex Bennée6fff2162017-11-27 14:15:17 +0000254
Richard Henderson150c7a92020-05-05 12:16:24 -0700255bool float16_is_quiet_nan(float16, float_status *status);
256bool float16_is_signaling_nan(float16, float_status *status);
Richard Hendersond619bb92018-05-10 11:39:48 -0700257float16 float16_silence_nan(float16, float_status *status);
Paul Brook60011492009-11-19 16:45:20 +0000258
Richard Henderson150c7a92020-05-05 12:16:24 -0700259static inline bool float16_is_any_nan(float16 a)
Max Filippov213ff4e2012-09-19 04:23:51 +0400260{
261 return ((float16_val(a) & ~0x8000) > 0x7c00);
262}
263
Richard Henderson150c7a92020-05-05 12:16:24 -0700264static inline bool float16_is_neg(float16 a)
Bharata B Raof566c042017-01-06 11:44:49 +0530265{
266 return float16_val(a) >> 15;
267}
268
Richard Henderson150c7a92020-05-05 12:16:24 -0700269static inline bool float16_is_infinity(float16 a)
Bharata B Raof566c042017-01-06 11:44:49 +0530270{
271 return (float16_val(a) & 0x7fff) == 0x7c00;
272}
273
Richard Henderson150c7a92020-05-05 12:16:24 -0700274static inline bool float16_is_zero(float16 a)
Bharata B Raof566c042017-01-06 11:44:49 +0530275{
276 return (float16_val(a) & 0x7fff) == 0;
277}
278
Richard Henderson150c7a92020-05-05 12:16:24 -0700279static inline bool float16_is_zero_or_denormal(float16 a)
Bharata B Raof566c042017-01-06 11:44:49 +0530280{
281 return (float16_val(a) & 0x7c00) == 0;
282}
283
Stephen Longa03e9242020-06-16 12:17:43 -0700284static inline bool float16_is_normal(float16 a)
285{
286 return (((float16_val(a) >> 10) + 1) & 0x1f) >= 2;
287}
288
Alex Bennée28136772017-07-03 14:33:08 +0100289static inline float16 float16_abs(float16 a)
290{
291 /* Note that abs does *not* handle NaN specially, nor does
292 * it flush denormal inputs to zero.
293 */
294 return make_float16(float16_val(a) & 0x7fff);
295}
Alex Bennée5f10aef2017-12-07 19:09:24 +0000296
297static inline float16 float16_chs(float16 a)
298{
299 /* Note that chs does *not* handle NaN specially, nor does
300 * it flush denormal inputs to zero.
301 */
302 return make_float16(float16_val(a) ^ 0x8000);
303}
304
Alex Bennée78b5a3e2017-12-08 17:03:13 +0000305static inline float16 float16_set_sign(float16 a, int sign)
306{
307 return make_float16((float16_val(a) & 0x7fff) | (sign << 15));
308}
309
Kito Chengdd205022020-07-30 02:52:22 -0700310static inline bool float16_eq(float16 a, float16 b, float_status *s)
311{
312 return float16_compare(a, b, s) == float_relation_equal;
313}
314
315static inline bool float16_le(float16 a, float16 b, float_status *s)
316{
317 return float16_compare(a, b, s) <= float_relation_equal;
318}
319
320static inline bool float16_lt(float16 a, float16 b, float_status *s)
321{
322 return float16_compare(a, b, s) < float_relation_equal;
323}
324
325static inline bool float16_unordered(float16 a, float16 b, float_status *s)
326{
327 return float16_compare(a, b, s) == float_relation_unordered;
328}
329
330static inline bool float16_eq_quiet(float16 a, float16 b, float_status *s)
331{
332 return float16_compare_quiet(a, b, s) == float_relation_equal;
333}
334
335static inline bool float16_le_quiet(float16 a, float16 b, float_status *s)
336{
337 return float16_compare_quiet(a, b, s) <= float_relation_equal;
338}
339
340static inline bool float16_lt_quiet(float16 a, float16 b, float_status *s)
341{
342 return float16_compare_quiet(a, b, s) < float_relation_equal;
343}
344
345static inline bool float16_unordered_quiet(float16 a, float16 b,
346 float_status *s)
347{
348 return float16_compare_quiet(a, b, s) == float_relation_unordered;
349}
350
Alex Bennéeefd48292017-12-08 17:13:19 +0000351#define float16_zero make_float16(0)
Alex Bennéeefd48292017-12-08 17:13:19 +0000352#define float16_half make_float16(0x3800)
Alex Bennée026e2d62018-03-01 11:05:50 +0000353#define float16_one make_float16(0x3c00)
354#define float16_one_point_five make_float16(0x3e00)
355#define float16_two make_float16(0x4000)
356#define float16_three make_float16(0x4200)
Alex Bennéeefd48292017-12-08 17:13:19 +0000357#define float16_infinity make_float16(0x7c00)
358
Paul Brook60011492009-11-19 16:45:20 +0000359/*----------------------------------------------------------------------------
LIU Zhiwei34f0c0a2020-08-13 15:14:20 +0800360| Software bfloat16 conversion routines.
361*----------------------------------------------------------------------------*/
362
363bfloat16 bfloat16_round_to_int(bfloat16, float_status *status);
364bfloat16 float32_to_bfloat16(float32, float_status *status);
365float32 bfloat16_to_float32(bfloat16, float_status *status);
366bfloat16 float64_to_bfloat16(float64 a, float_status *status);
367float64 bfloat16_to_float64(bfloat16 a, float_status *status);
368
369int16_t bfloat16_to_int16_scalbn(bfloat16, FloatRoundMode,
370 int, float_status *status);
371int32_t bfloat16_to_int32_scalbn(bfloat16, FloatRoundMode,
372 int, float_status *status);
373int64_t bfloat16_to_int64_scalbn(bfloat16, FloatRoundMode,
374 int, float_status *status);
375
376int16_t bfloat16_to_int16(bfloat16, float_status *status);
377int32_t bfloat16_to_int32(bfloat16, float_status *status);
378int64_t bfloat16_to_int64(bfloat16, float_status *status);
379
380int16_t bfloat16_to_int16_round_to_zero(bfloat16, float_status *status);
381int32_t bfloat16_to_int32_round_to_zero(bfloat16, float_status *status);
382int64_t bfloat16_to_int64_round_to_zero(bfloat16, float_status *status);
383
384uint16_t bfloat16_to_uint16_scalbn(bfloat16 a, FloatRoundMode,
385 int, float_status *status);
386uint32_t bfloat16_to_uint32_scalbn(bfloat16 a, FloatRoundMode,
387 int, float_status *status);
388uint64_t bfloat16_to_uint64_scalbn(bfloat16 a, FloatRoundMode,
389 int, float_status *status);
390
391uint16_t bfloat16_to_uint16(bfloat16 a, float_status *status);
392uint32_t bfloat16_to_uint32(bfloat16 a, float_status *status);
393uint64_t bfloat16_to_uint64(bfloat16 a, float_status *status);
394
395uint16_t bfloat16_to_uint16_round_to_zero(bfloat16 a, float_status *status);
396uint32_t bfloat16_to_uint32_round_to_zero(bfloat16 a, float_status *status);
397uint64_t bfloat16_to_uint64_round_to_zero(bfloat16 a, float_status *status);
398
399bfloat16 int16_to_bfloat16_scalbn(int16_t a, int, float_status *status);
400bfloat16 int32_to_bfloat16_scalbn(int32_t a, int, float_status *status);
401bfloat16 int64_to_bfloat16_scalbn(int64_t a, int, float_status *status);
402bfloat16 uint16_to_bfloat16_scalbn(uint16_t a, int, float_status *status);
403bfloat16 uint32_to_bfloat16_scalbn(uint32_t a, int, float_status *status);
404bfloat16 uint64_to_bfloat16_scalbn(uint64_t a, int, float_status *status);
405
406bfloat16 int16_to_bfloat16(int16_t a, float_status *status);
407bfloat16 int32_to_bfloat16(int32_t a, float_status *status);
408bfloat16 int64_to_bfloat16(int64_t a, float_status *status);
409bfloat16 uint16_to_bfloat16(uint16_t a, float_status *status);
410bfloat16 uint32_to_bfloat16(uint32_t a, float_status *status);
411bfloat16 uint64_to_bfloat16(uint64_t a, float_status *status);
412
413/*----------------------------------------------------------------------------
LIU Zhiwei82823102020-08-13 15:14:19 +0800414| Software bfloat16 operations.
415*----------------------------------------------------------------------------*/
416
417bfloat16 bfloat16_add(bfloat16, bfloat16, float_status *status);
418bfloat16 bfloat16_sub(bfloat16, bfloat16, float_status *status);
419bfloat16 bfloat16_mul(bfloat16, bfloat16, float_status *status);
420bfloat16 bfloat16_div(bfloat16, bfloat16, float_status *status);
421bfloat16 bfloat16_muladd(bfloat16, bfloat16, bfloat16, int,
422 float_status *status);
423float16 bfloat16_scalbn(bfloat16, int, float_status *status);
424bfloat16 bfloat16_min(bfloat16, bfloat16, float_status *status);
425bfloat16 bfloat16_max(bfloat16, bfloat16, float_status *status);
426bfloat16 bfloat16_minnum(bfloat16, bfloat16, float_status *status);
427bfloat16 bfloat16_maxnum(bfloat16, bfloat16, float_status *status);
428bfloat16 bfloat16_minnummag(bfloat16, bfloat16, float_status *status);
429bfloat16 bfloat16_maxnummag(bfloat16, bfloat16, float_status *status);
Chih-Min Chao0e903032021-10-22 00:08:45 +0800430bfloat16 bfloat16_minimum_number(bfloat16, bfloat16, float_status *status);
431bfloat16 bfloat16_maximum_number(bfloat16, bfloat16, float_status *status);
LIU Zhiwei82823102020-08-13 15:14:19 +0800432bfloat16 bfloat16_sqrt(bfloat16, float_status *status);
433FloatRelation bfloat16_compare(bfloat16, bfloat16, float_status *status);
434FloatRelation bfloat16_compare_quiet(bfloat16, bfloat16, float_status *status);
435
LIU Zhiwei5ebf5f42020-08-13 15:14:21 +0800436bool bfloat16_is_quiet_nan(bfloat16, float_status *status);
437bool bfloat16_is_signaling_nan(bfloat16, float_status *status);
LIU Zhiwei82823102020-08-13 15:14:19 +0800438bfloat16 bfloat16_silence_nan(bfloat16, float_status *status);
439bfloat16 bfloat16_default_nan(float_status *status);
440
LIU Zhiwei5ebf5f42020-08-13 15:14:21 +0800441static inline bool bfloat16_is_any_nan(bfloat16 a)
442{
443 return ((a & ~0x8000) > 0x7F80);
444}
445
446static inline bool bfloat16_is_neg(bfloat16 a)
447{
448 return a >> 15;
449}
450
451static inline bool bfloat16_is_infinity(bfloat16 a)
452{
453 return (a & 0x7fff) == 0x7F80;
454}
455
456static inline bool bfloat16_is_zero(bfloat16 a)
457{
458 return (a & 0x7fff) == 0;
459}
460
461static inline bool bfloat16_is_zero_or_denormal(bfloat16 a)
462{
463 return (a & 0x7F80) == 0;
464}
465
466static inline bool bfloat16_is_normal(bfloat16 a)
467{
468 return (((a >> 7) + 1) & 0xff) >= 2;
469}
470
471static inline bfloat16 bfloat16_abs(bfloat16 a)
472{
473 /* Note that abs does *not* handle NaN specially, nor does
474 * it flush denormal inputs to zero.
475 */
476 return a & 0x7fff;
477}
478
479static inline bfloat16 bfloat16_chs(bfloat16 a)
480{
481 /* Note that chs does *not* handle NaN specially, nor does
482 * it flush denormal inputs to zero.
483 */
484 return a ^ 0x8000;
485}
486
LIU Zhiwei82823102020-08-13 15:14:19 +0800487static inline bfloat16 bfloat16_set_sign(bfloat16 a, int sign)
488{
489 return (a & 0x7fff) | (sign << 15);
490}
491
Richard Hendersonc53b1072020-08-16 14:46:58 -0700492static inline bool bfloat16_eq(bfloat16 a, bfloat16 b, float_status *s)
493{
494 return bfloat16_compare(a, b, s) == float_relation_equal;
495}
496
497static inline bool bfloat16_le(bfloat16 a, bfloat16 b, float_status *s)
498{
499 return bfloat16_compare(a, b, s) <= float_relation_equal;
500}
501
502static inline bool bfloat16_lt(bfloat16 a, bfloat16 b, float_status *s)
503{
504 return bfloat16_compare(a, b, s) < float_relation_equal;
505}
506
507static inline bool bfloat16_unordered(bfloat16 a, bfloat16 b, float_status *s)
508{
509 return bfloat16_compare(a, b, s) == float_relation_unordered;
510}
511
512static inline bool bfloat16_eq_quiet(bfloat16 a, bfloat16 b, float_status *s)
513{
514 return bfloat16_compare_quiet(a, b, s) == float_relation_equal;
515}
516
517static inline bool bfloat16_le_quiet(bfloat16 a, bfloat16 b, float_status *s)
518{
519 return bfloat16_compare_quiet(a, b, s) <= float_relation_equal;
520}
521
522static inline bool bfloat16_lt_quiet(bfloat16 a, bfloat16 b, float_status *s)
523{
524 return bfloat16_compare_quiet(a, b, s) < float_relation_equal;
525}
526
527static inline bool bfloat16_unordered_quiet(bfloat16 a, bfloat16 b,
528 float_status *s)
529{
530 return bfloat16_compare_quiet(a, b, s) == float_relation_unordered;
531}
532
LIU Zhiwei82823102020-08-13 15:14:19 +0800533#define bfloat16_zero 0
534#define bfloat16_half 0x3f00
535#define bfloat16_one 0x3f80
536#define bfloat16_one_point_five 0x3fc0
537#define bfloat16_two 0x4000
538#define bfloat16_three 0x4040
539#define bfloat16_infinity 0x7f80
540
541/*----------------------------------------------------------------------------
Christophe Lyon85596662011-02-21 17:38:44 +0100542| The pattern for a default generated half-precision NaN.
543*----------------------------------------------------------------------------*/
Aleksandar Markovicaf39bc82016-06-10 11:57:28 +0200544float16 float16_default_nan(float_status *status);
Christophe Lyon85596662011-02-21 17:38:44 +0100545
546/*----------------------------------------------------------------------------
bellard158142c2005-03-13 16:54:06 +0000547| Software IEC/IEEE single-precision conversion routines.
548*----------------------------------------------------------------------------*/
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100549
Richard Henderson3dede402020-05-05 09:01:49 -0700550int16_t float32_to_int16_scalbn(float32, FloatRoundMode, int, float_status *);
551int32_t float32_to_int32_scalbn(float32, FloatRoundMode, int, float_status *);
552int64_t float32_to_int64_scalbn(float32, FloatRoundMode, int, float_status *);
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100553
Peter Maydell0bb721d2016-02-19 16:25:00 +0000554int16_t float32_to_int16(float32, float_status *status);
Peter Maydellf4014512016-01-22 15:09:21 +0000555int32_t float32_to_int32(float32, float_status *status);
Peter Maydellf42c2222016-01-22 15:09:20 +0000556int64_t float32_to_int64(float32, float_status *status);
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100557
558int16_t float32_to_int16_round_to_zero(float32, float_status *status);
559int32_t float32_to_int32_round_to_zero(float32, float_status *status);
Peter Maydellf42c2222016-01-22 15:09:20 +0000560int64_t float32_to_int64_round_to_zero(float32, float_status *status);
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100561
Richard Henderson3dede402020-05-05 09:01:49 -0700562uint16_t float32_to_uint16_scalbn(float32, FloatRoundMode, int, float_status *);
563uint32_t float32_to_uint32_scalbn(float32, FloatRoundMode, int, float_status *);
564uint64_t float32_to_uint64_scalbn(float32, FloatRoundMode, int, float_status *);
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100565
566uint16_t float32_to_uint16(float32, float_status *status);
567uint32_t float32_to_uint32(float32, float_status *status);
568uint64_t float32_to_uint64(float32, float_status *status);
569
570uint16_t float32_to_uint16_round_to_zero(float32, float_status *status);
571uint32_t float32_to_uint32_round_to_zero(float32, float_status *status);
572uint64_t float32_to_uint64_round_to_zero(float32, float_status *status);
573
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000574float64 float32_to_float64(float32, float_status *status);
575floatx80 float32_to_floatx80(float32, float_status *status);
576float128 float32_to_float128(float32, float_status *status);
bellard158142c2005-03-13 16:54:06 +0000577
578/*----------------------------------------------------------------------------
579| Software IEC/IEEE single-precision operations.
580*----------------------------------------------------------------------------*/
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000581float32 float32_round_to_int(float32, float_status *status);
582float32 float32_add(float32, float32, float_status *status);
583float32 float32_sub(float32, float32, float_status *status);
584float32 float32_mul(float32, float32, float_status *status);
585float32 float32_div(float32, float32, float_status *status);
586float32 float32_rem(float32, float32, float_status *status);
587float32 float32_muladd(float32, float32, float32, int, float_status *status);
588float32 float32_sqrt(float32, float_status *status);
589float32 float32_exp2(float32, float_status *status);
590float32 float32_log2(float32, float_status *status);
Richard Henderson71bfd652020-05-05 10:22:05 -0700591FloatRelation float32_compare(float32, float32, float_status *status);
592FloatRelation float32_compare_quiet(float32, float32, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000593float32 float32_min(float32, float32, float_status *status);
594float32 float32_max(float32, float32, float_status *status);
595float32 float32_minnum(float32, float32, float_status *status);
596float32 float32_maxnum(float32, float32, float_status *status);
597float32 float32_minnummag(float32, float32, float_status *status);
598float32 float32_maxnummag(float32, float32, float_status *status);
Chih-Min Chao0e903032021-10-22 00:08:45 +0800599float32 float32_minimum_number(float32, float32, float_status *status);
600float32 float32_maximum_number(float32, float32, float_status *status);
Richard Henderson150c7a92020-05-05 12:16:24 -0700601bool float32_is_quiet_nan(float32, float_status *status);
602bool float32_is_signaling_nan(float32, float_status *status);
Richard Hendersond619bb92018-05-10 11:39:48 -0700603float32 float32_silence_nan(float32, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000604float32 float32_scalbn(float32, int, float_status *status);
bellard158142c2005-03-13 16:54:06 +0000605
Luiz Capitulinoa49db982014-06-19 10:13:43 -0400606static inline float32 float32_abs(float32 a)
bellard1d6bda32005-03-13 18:52:29 +0000607{
Peter Maydell37d18662011-01-06 19:37:53 +0000608 /* Note that abs does *not* handle NaN specially, nor does
609 * it flush denormal inputs to zero.
610 */
pbrookf090c9d2007-11-18 14:33:24 +0000611 return make_float32(float32_val(a) & 0x7fffffff);
bellard1d6bda32005-03-13 18:52:29 +0000612}
613
Luiz Capitulinoa49db982014-06-19 10:13:43 -0400614static inline float32 float32_chs(float32 a)
bellard1d6bda32005-03-13 18:52:29 +0000615{
Peter Maydell37d18662011-01-06 19:37:53 +0000616 /* Note that chs does *not* handle NaN specially, nor does
617 * it flush denormal inputs to zero.
618 */
pbrookf090c9d2007-11-18 14:33:24 +0000619 return make_float32(float32_val(a) ^ 0x80000000);
bellard1d6bda32005-03-13 18:52:29 +0000620}
621
Richard Henderson150c7a92020-05-05 12:16:24 -0700622static inline bool float32_is_infinity(float32 a)
aurel32c52ab6f2008-12-15 17:14:20 +0000623{
aurel32dadd71a2008-12-18 22:43:16 +0000624 return (float32_val(a) & 0x7fffffff) == 0x7f800000;
aurel32c52ab6f2008-12-15 17:14:20 +0000625}
626
Richard Henderson150c7a92020-05-05 12:16:24 -0700627static inline bool float32_is_neg(float32 a)
aurel32c52ab6f2008-12-15 17:14:20 +0000628{
629 return float32_val(a) >> 31;
630}
631
Richard Henderson150c7a92020-05-05 12:16:24 -0700632static inline bool float32_is_zero(float32 a)
aurel32c52ab6f2008-12-15 17:14:20 +0000633{
634 return (float32_val(a) & 0x7fffffff) == 0;
635}
636
Richard Henderson150c7a92020-05-05 12:16:24 -0700637static inline bool float32_is_any_nan(float32 a)
Peter Maydell21d6ebd2010-12-07 15:37:34 +0000638{
639 return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL);
640}
641
Richard Henderson150c7a92020-05-05 12:16:24 -0700642static inline bool float32_is_zero_or_denormal(float32 a)
Peter Maydell6f3300a2011-01-14 20:39:18 +0100643{
644 return (float32_val(a) & 0x7f800000) == 0;
645}
646
Emilio G. Cota588e6df2018-03-16 17:58:56 -0400647static inline bool float32_is_normal(float32 a)
648{
David Hildenbrand473931812019-02-06 10:10:43 +0100649 return (((float32_val(a) >> 23) + 1) & 0xff) >= 2;
Emilio G. Cota588e6df2018-03-16 17:58:56 -0400650}
651
652static inline bool float32_is_denormal(float32 a)
653{
654 return float32_is_zero_or_denormal(a) && !float32_is_zero(a);
655}
656
Emilio G. Cota315df0d2018-03-28 20:29:55 -0400657static inline bool float32_is_zero_or_normal(float32 a)
658{
659 return float32_is_normal(a) || float32_is_zero(a);
660}
661
Luiz Capitulinoa49db982014-06-19 10:13:43 -0400662static inline float32 float32_set_sign(float32 a, int sign)
Christophe Lyonc30fe7d2011-02-21 17:38:45 +0100663{
664 return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31));
665}
666
Richard Henderson5da2d2d2020-05-05 10:33:18 -0700667static inline bool float32_eq(float32 a, float32 b, float_status *s)
668{
669 return float32_compare(a, b, s) == float_relation_equal;
670}
671
672static inline bool float32_le(float32 a, float32 b, float_status *s)
673{
674 return float32_compare(a, b, s) <= float_relation_equal;
675}
676
677static inline bool float32_lt(float32 a, float32 b, float_status *s)
678{
679 return float32_compare(a, b, s) < float_relation_equal;
680}
681
682static inline bool float32_unordered(float32 a, float32 b, float_status *s)
683{
684 return float32_compare(a, b, s) == float_relation_unordered;
685}
686
687static inline bool float32_eq_quiet(float32 a, float32 b, float_status *s)
688{
689 return float32_compare_quiet(a, b, s) == float_relation_equal;
690}
691
692static inline bool float32_le_quiet(float32 a, float32 b, float_status *s)
693{
694 return float32_compare_quiet(a, b, s) <= float_relation_equal;
695}
696
697static inline bool float32_lt_quiet(float32 a, float32 b, float_status *s)
698{
699 return float32_compare_quiet(a, b, s) < float_relation_equal;
700}
701
702static inline bool float32_unordered_quiet(float32 a, float32 b,
703 float_status *s)
704{
705 return float32_compare_quiet(a, b, s) == float_relation_unordered;
706}
707
pbrookf090c9d2007-11-18 14:33:24 +0000708#define float32_zero make_float32(0)
Christophe Lyonc30fe7d2011-02-21 17:38:45 +0100709#define float32_half make_float32(0x3f000000)
Alex Bennée026e2d62018-03-01 11:05:50 +0000710#define float32_one make_float32(0x3f800000)
711#define float32_one_point_five make_float32(0x3fc00000)
712#define float32_two make_float32(0x40000000)
713#define float32_three make_float32(0x40400000)
Christophe Lyonc30fe7d2011-02-21 17:38:45 +0100714#define float32_infinity make_float32(0x7f800000)
pbrookf090c9d2007-11-18 14:33:24 +0000715
Christophe Lyon85596662011-02-21 17:38:44 +0100716/*----------------------------------------------------------------------------
Laurent Vivier88857ac2018-02-24 21:17:59 +0100717| Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
718| single-precision floating-point value, returning the result. After being
719| shifted into the proper positions, the three fields are simply added
720| together to form the result. This means that any integer portion of `zSig'
721| will be added into the exponent. Since a properly normalized significand
722| will have an integer portion equal to 1, the `zExp' input should be 1 less
723| than the desired result exponent whenever `zSig' is a complete, normalized
724| significand.
725*----------------------------------------------------------------------------*/
726
Richard Hendersonc1203912020-05-04 19:54:57 -0700727static inline float32 packFloat32(bool zSign, int zExp, uint32_t zSig)
Laurent Vivier88857ac2018-02-24 21:17:59 +0100728{
729 return make_float32(
730 (((uint32_t)zSign) << 31) + (((uint32_t)zExp) << 23) + zSig);
731}
732
733/*----------------------------------------------------------------------------
Christophe Lyon85596662011-02-21 17:38:44 +0100734| The pattern for a default generated single-precision NaN.
735*----------------------------------------------------------------------------*/
Aleksandar Markovicaf39bc82016-06-10 11:57:28 +0200736float32 float32_default_nan(float_status *status);
Christophe Lyon85596662011-02-21 17:38:44 +0100737
bellard158142c2005-03-13 16:54:06 +0000738/*----------------------------------------------------------------------------
739| Software IEC/IEEE double-precision conversion routines.
740*----------------------------------------------------------------------------*/
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100741
Richard Henderson3dede402020-05-05 09:01:49 -0700742int16_t float64_to_int16_scalbn(float64, FloatRoundMode, int, float_status *);
743int32_t float64_to_int32_scalbn(float64, FloatRoundMode, int, float_status *);
744int64_t float64_to_int64_scalbn(float64, FloatRoundMode, int, float_status *);
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100745
Peter Maydell0bb721d2016-02-19 16:25:00 +0000746int16_t float64_to_int16(float64, float_status *status);
Peter Maydellf4014512016-01-22 15:09:21 +0000747int32_t float64_to_int32(float64, float_status *status);
Peter Maydellf42c2222016-01-22 15:09:20 +0000748int64_t float64_to_int64(float64, float_status *status);
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100749
750int16_t float64_to_int16_round_to_zero(float64, float_status *status);
751int32_t float64_to_int32_round_to_zero(float64, float_status *status);
Peter Maydellf42c2222016-01-22 15:09:20 +0000752int64_t float64_to_int64_round_to_zero(float64, float_status *status);
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100753
Richard Henderson3dede402020-05-05 09:01:49 -0700754uint16_t float64_to_uint16_scalbn(float64, FloatRoundMode, int, float_status *);
755uint32_t float64_to_uint32_scalbn(float64, FloatRoundMode, int, float_status *);
756uint64_t float64_to_uint64_scalbn(float64, FloatRoundMode, int, float_status *);
Richard Henderson2f6c74b2018-08-24 13:17:30 +0100757
758uint16_t float64_to_uint16(float64, float_status *status);
759uint32_t float64_to_uint32(float64, float_status *status);
760uint64_t float64_to_uint64(float64, float_status *status);
761
762uint16_t float64_to_uint16_round_to_zero(float64, float_status *status);
763uint32_t float64_to_uint32_round_to_zero(float64, float_status *status);
764uint64_t float64_to_uint64_round_to_zero(float64, float_status *status);
765
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000766float32 float64_to_float32(float64, float_status *status);
767floatx80 float64_to_floatx80(float64, float_status *status);
768float128 float64_to_float128(float64, float_status *status);
bellard158142c2005-03-13 16:54:06 +0000769
770/*----------------------------------------------------------------------------
771| Software IEC/IEEE double-precision operations.
772*----------------------------------------------------------------------------*/
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000773float64 float64_round_to_int(float64, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000774float64 float64_add(float64, float64, float_status *status);
775float64 float64_sub(float64, float64, float_status *status);
776float64 float64_mul(float64, float64, float_status *status);
777float64 float64_div(float64, float64, float_status *status);
778float64 float64_rem(float64, float64, float_status *status);
779float64 float64_muladd(float64, float64, float64, int, float_status *status);
780float64 float64_sqrt(float64, float_status *status);
781float64 float64_log2(float64, float_status *status);
Richard Henderson71bfd652020-05-05 10:22:05 -0700782FloatRelation float64_compare(float64, float64, float_status *status);
783FloatRelation float64_compare_quiet(float64, float64, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000784float64 float64_min(float64, float64, float_status *status);
785float64 float64_max(float64, float64, float_status *status);
786float64 float64_minnum(float64, float64, float_status *status);
787float64 float64_maxnum(float64, float64, float_status *status);
788float64 float64_minnummag(float64, float64, float_status *status);
789float64 float64_maxnummag(float64, float64, float_status *status);
Chih-Min Chao0e903032021-10-22 00:08:45 +0800790float64 float64_minimum_number(float64, float64, float_status *status);
791float64 float64_maximum_number(float64, float64, float_status *status);
Richard Henderson150c7a92020-05-05 12:16:24 -0700792bool float64_is_quiet_nan(float64 a, float_status *status);
793bool float64_is_signaling_nan(float64, float_status *status);
Richard Hendersond619bb92018-05-10 11:39:48 -0700794float64 float64_silence_nan(float64, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000795float64 float64_scalbn(float64, int, float_status *status);
bellard158142c2005-03-13 16:54:06 +0000796
Luiz Capitulinoa49db982014-06-19 10:13:43 -0400797static inline float64 float64_abs(float64 a)
bellard1d6bda32005-03-13 18:52:29 +0000798{
Peter Maydell37d18662011-01-06 19:37:53 +0000799 /* Note that abs does *not* handle NaN specially, nor does
800 * it flush denormal inputs to zero.
801 */
pbrookf090c9d2007-11-18 14:33:24 +0000802 return make_float64(float64_val(a) & 0x7fffffffffffffffLL);
bellard1d6bda32005-03-13 18:52:29 +0000803}
804
Luiz Capitulinoa49db982014-06-19 10:13:43 -0400805static inline float64 float64_chs(float64 a)
bellard1d6bda32005-03-13 18:52:29 +0000806{
Peter Maydell37d18662011-01-06 19:37:53 +0000807 /* Note that chs does *not* handle NaN specially, nor does
808 * it flush denormal inputs to zero.
809 */
pbrookf090c9d2007-11-18 14:33:24 +0000810 return make_float64(float64_val(a) ^ 0x8000000000000000LL);
bellard1d6bda32005-03-13 18:52:29 +0000811}
812
Richard Henderson150c7a92020-05-05 12:16:24 -0700813static inline bool float64_is_infinity(float64 a)
aurel32c52ab6f2008-12-15 17:14:20 +0000814{
815 return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL;
816}
817
Richard Henderson150c7a92020-05-05 12:16:24 -0700818static inline bool float64_is_neg(float64 a)
aurel32c52ab6f2008-12-15 17:14:20 +0000819{
820 return float64_val(a) >> 63;
821}
822
Richard Henderson150c7a92020-05-05 12:16:24 -0700823static inline bool float64_is_zero(float64 a)
aurel32c52ab6f2008-12-15 17:14:20 +0000824{
825 return (float64_val(a) & 0x7fffffffffffffffLL) == 0;
826}
827
Richard Henderson150c7a92020-05-05 12:16:24 -0700828static inline bool float64_is_any_nan(float64 a)
Peter Maydell21d6ebd2010-12-07 15:37:34 +0000829{
830 return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL);
831}
832
Richard Henderson150c7a92020-05-05 12:16:24 -0700833static inline bool float64_is_zero_or_denormal(float64 a)
Aurelien Jarno587eabf2011-05-15 14:09:18 +0200834{
835 return (float64_val(a) & 0x7ff0000000000000LL) == 0;
836}
837
Emilio G. Cota588e6df2018-03-16 17:58:56 -0400838static inline bool float64_is_normal(float64 a)
839{
David Hildenbrand473931812019-02-06 10:10:43 +0100840 return (((float64_val(a) >> 52) + 1) & 0x7ff) >= 2;
Emilio G. Cota588e6df2018-03-16 17:58:56 -0400841}
842
843static inline bool float64_is_denormal(float64 a)
844{
845 return float64_is_zero_or_denormal(a) && !float64_is_zero(a);
846}
847
Emilio G. Cota315df0d2018-03-28 20:29:55 -0400848static inline bool float64_is_zero_or_normal(float64 a)
849{
850 return float64_is_normal(a) || float64_is_zero(a);
851}
852
Luiz Capitulinoa49db982014-06-19 10:13:43 -0400853static inline float64 float64_set_sign(float64 a, int sign)
Christophe Lyonc30fe7d2011-02-21 17:38:45 +0100854{
855 return make_float64((float64_val(a) & 0x7fffffffffffffffULL)
856 | ((int64_t)sign << 63));
857}
858
Richard Henderson0673ecd2020-05-05 10:40:23 -0700859static inline bool float64_eq(float64 a, float64 b, float_status *s)
860{
861 return float64_compare(a, b, s) == float_relation_equal;
862}
863
864static inline bool float64_le(float64 a, float64 b, float_status *s)
865{
866 return float64_compare(a, b, s) <= float_relation_equal;
867}
868
869static inline bool float64_lt(float64 a, float64 b, float_status *s)
870{
871 return float64_compare(a, b, s) < float_relation_equal;
872}
873
874static inline bool float64_unordered(float64 a, float64 b, float_status *s)
875{
876 return float64_compare(a, b, s) == float_relation_unordered;
877}
878
879static inline bool float64_eq_quiet(float64 a, float64 b, float_status *s)
880{
881 return float64_compare_quiet(a, b, s) == float_relation_equal;
882}
883
884static inline bool float64_le_quiet(float64 a, float64 b, float_status *s)
885{
886 return float64_compare_quiet(a, b, s) <= float_relation_equal;
887}
888
889static inline bool float64_lt_quiet(float64 a, float64 b, float_status *s)
890{
891 return float64_compare_quiet(a, b, s) < float_relation_equal;
892}
893
894static inline bool float64_unordered_quiet(float64 a, float64 b,
895 float_status *s)
896{
897 return float64_compare_quiet(a, b, s) == float_relation_unordered;
898}
899
pbrookf090c9d2007-11-18 14:33:24 +0000900#define float64_zero make_float64(0)
Christophe Lyonc30fe7d2011-02-21 17:38:45 +0100901#define float64_half make_float64(0x3fe0000000000000LL)
Alex Bennée026e2d62018-03-01 11:05:50 +0000902#define float64_one make_float64(0x3ff0000000000000LL)
903#define float64_one_point_five make_float64(0x3FF8000000000000ULL)
904#define float64_two make_float64(0x4000000000000000ULL)
905#define float64_three make_float64(0x4008000000000000ULL)
906#define float64_ln2 make_float64(0x3fe62e42fefa39efLL)
Christophe Lyonc30fe7d2011-02-21 17:38:45 +0100907#define float64_infinity make_float64(0x7ff0000000000000LL)
pbrookf090c9d2007-11-18 14:33:24 +0000908
Christophe Lyon85596662011-02-21 17:38:44 +0100909/*----------------------------------------------------------------------------
910| The pattern for a default generated double-precision NaN.
911*----------------------------------------------------------------------------*/
Aleksandar Markovicaf39bc82016-06-10 11:57:28 +0200912float64 float64_default_nan(float_status *status);
Christophe Lyon85596662011-02-21 17:38:44 +0100913
bellard158142c2005-03-13 16:54:06 +0000914/*----------------------------------------------------------------------------
Richard Henderson42636fb2021-12-17 17:57:15 +0100915| Software IEC/IEEE double-precision operations, rounding to single precision,
916| returning a result in double precision, with only one rounding step.
917*----------------------------------------------------------------------------*/
918
919float64 float64r32_add(float64, float64, float_status *status);
920float64 float64r32_sub(float64, float64, float_status *status);
921float64 float64r32_mul(float64, float64, float_status *status);
922float64 float64r32_div(float64, float64, float_status *status);
923float64 float64r32_muladd(float64, float64, float64, int, float_status *status);
924float64 float64r32_sqrt(float64, float_status *status);
925
926/*----------------------------------------------------------------------------
bellard158142c2005-03-13 16:54:06 +0000927| Software IEC/IEEE extended double-precision conversion routines.
928*----------------------------------------------------------------------------*/
Peter Maydellf4014512016-01-22 15:09:21 +0000929int32_t floatx80_to_int32(floatx80, float_status *status);
930int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status);
Peter Maydellf42c2222016-01-22 15:09:20 +0000931int64_t floatx80_to_int64(floatx80, float_status *status);
932int64_t floatx80_to_int64_round_to_zero(floatx80, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000933float32 floatx80_to_float32(floatx80, float_status *status);
934float64 floatx80_to_float64(floatx80, float_status *status);
935float128 floatx80_to_float128(floatx80, float_status *status);
bellard158142c2005-03-13 16:54:06 +0000936
937/*----------------------------------------------------------------------------
Laurent Vivier0f605c82018-02-24 21:18:01 +0100938| The pattern for an extended double-precision inf.
939*----------------------------------------------------------------------------*/
940extern const floatx80 floatx80_infinity;
941
942/*----------------------------------------------------------------------------
bellard158142c2005-03-13 16:54:06 +0000943| Software IEC/IEEE extended double-precision operations.
944*----------------------------------------------------------------------------*/
Laurent Vivier0f721292017-06-28 22:42:38 +0200945floatx80 floatx80_round(floatx80 a, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000946floatx80 floatx80_round_to_int(floatx80, float_status *status);
947floatx80 floatx80_add(floatx80, floatx80, float_status *status);
948floatx80 floatx80_sub(floatx80, floatx80, float_status *status);
949floatx80 floatx80_mul(floatx80, floatx80, float_status *status);
950floatx80 floatx80_div(floatx80, floatx80, float_status *status);
Joseph Myers445810e2020-06-08 16:57:16 +0000951floatx80 floatx80_modrem(floatx80, floatx80, bool, uint64_t *,
952 float_status *status);
Joseph Myers6b8b0132020-06-08 16:55:11 +0000953floatx80 floatx80_mod(floatx80, floatx80, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000954floatx80 floatx80_rem(floatx80, floatx80, float_status *status);
955floatx80 floatx80_sqrt(floatx80, float_status *status);
Richard Henderson71bfd652020-05-05 10:22:05 -0700956FloatRelation floatx80_compare(floatx80, floatx80, float_status *status);
957FloatRelation floatx80_compare_quiet(floatx80, floatx80, float_status *status);
Aleksandar Markovicaf39bc82016-06-10 11:57:28 +0200958int floatx80_is_quiet_nan(floatx80, float_status *status);
959int floatx80_is_signaling_nan(floatx80, float_status *status);
Richard Hendersond619bb92018-05-10 11:39:48 -0700960floatx80 floatx80_silence_nan(floatx80, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +0000961floatx80 floatx80_scalbn(floatx80, int, float_status *status);
bellard158142c2005-03-13 16:54:06 +0000962
Luiz Capitulinoa49db982014-06-19 10:13:43 -0400963static inline floatx80 floatx80_abs(floatx80 a)
bellard1d6bda32005-03-13 18:52:29 +0000964{
965 a.high &= 0x7fff;
966 return a;
967}
968
Luiz Capitulinoa49db982014-06-19 10:13:43 -0400969static inline floatx80 floatx80_chs(floatx80 a)
bellard1d6bda32005-03-13 18:52:29 +0000970{
971 a.high ^= 0x8000;
972 return a;
973}
974
Richard Henderson150c7a92020-05-05 12:16:24 -0700975static inline bool floatx80_is_infinity(floatx80 a)
aurel32c52ab6f2008-12-15 17:14:20 +0000976{
Laurent Vivier0f605c82018-02-24 21:18:01 +0100977#if defined(TARGET_M68K)
978 return (a.high & 0x7fff) == floatx80_infinity.high && !(a.low << 1);
979#else
980 return (a.high & 0x7fff) == floatx80_infinity.high &&
981 a.low == floatx80_infinity.low;
982#endif
aurel32c52ab6f2008-12-15 17:14:20 +0000983}
984
Richard Henderson150c7a92020-05-05 12:16:24 -0700985static inline bool floatx80_is_neg(floatx80 a)
aurel32c52ab6f2008-12-15 17:14:20 +0000986{
987 return a.high >> 15;
988}
989
Richard Henderson150c7a92020-05-05 12:16:24 -0700990static inline bool floatx80_is_zero(floatx80 a)
aurel32c52ab6f2008-12-15 17:14:20 +0000991{
992 return (a.high & 0x7fff) == 0 && a.low == 0;
993}
994
Richard Henderson150c7a92020-05-05 12:16:24 -0700995static inline bool floatx80_is_zero_or_denormal(floatx80 a)
Aurelien Jarno587eabf2011-05-15 14:09:18 +0200996{
997 return (a.high & 0x7fff) == 0;
998}
999
Richard Henderson150c7a92020-05-05 12:16:24 -07001000static inline bool floatx80_is_any_nan(floatx80 a)
Peter Maydell2bed6522011-01-06 18:34:43 +00001001{
1002 return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1);
1003}
1004
Richard Hendersonc6baf652020-05-05 10:53:15 -07001005static inline bool floatx80_eq(floatx80 a, floatx80 b, float_status *s)
1006{
1007 return floatx80_compare(a, b, s) == float_relation_equal;
1008}
1009
1010static inline bool floatx80_le(floatx80 a, floatx80 b, float_status *s)
1011{
1012 return floatx80_compare(a, b, s) <= float_relation_equal;
1013}
1014
1015static inline bool floatx80_lt(floatx80 a, floatx80 b, float_status *s)
1016{
1017 return floatx80_compare(a, b, s) < float_relation_equal;
1018}
1019
1020static inline bool floatx80_unordered(floatx80 a, floatx80 b, float_status *s)
1021{
1022 return floatx80_compare(a, b, s) == float_relation_unordered;
1023}
1024
1025static inline bool floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *s)
1026{
1027 return floatx80_compare_quiet(a, b, s) == float_relation_equal;
1028}
1029
1030static inline bool floatx80_le_quiet(floatx80 a, floatx80 b, float_status *s)
1031{
1032 return floatx80_compare_quiet(a, b, s) <= float_relation_equal;
1033}
1034
1035static inline bool floatx80_lt_quiet(floatx80 a, floatx80 b, float_status *s)
1036{
1037 return floatx80_compare_quiet(a, b, s) < float_relation_equal;
1038}
1039
1040static inline bool floatx80_unordered_quiet(floatx80 a, floatx80 b,
1041 float_status *s)
1042{
1043 return floatx80_compare_quiet(a, b, s) == float_relation_unordered;
1044}
1045
Andrew Dutcherd1eb8f22016-08-16 17:14:55 -07001046/*----------------------------------------------------------------------------
1047| Return whether the given value is an invalid floatx80 encoding.
1048| Invalid floatx80 encodings arise when the integer bit is not set, but
1049| the exponent is not zero. The only times the integer bit is permitted to
1050| be zero is in subnormal numbers and the value zero.
1051| This includes what the Intel software developer's manual calls pseudo-NaNs,
1052| pseudo-infinities and un-normal numbers. It does not include
1053| pseudo-denormals, which must still be correctly handled as inputs even
1054| if they are never generated as outputs.
1055*----------------------------------------------------------------------------*/
1056static inline bool floatx80_invalid_encoding(floatx80 a)
1057{
Laurent Vivierd159dd02020-06-12 16:04:00 +02001058#if defined(TARGET_M68K)
1059 /*-------------------------------------------------------------------------
1060 | With m68k, the explicit integer bit can be zero in the case of:
1061 | - zeros (exp == 0, mantissa == 0)
1062 | - denormalized numbers (exp == 0, mantissa != 0)
1063 | - unnormalized numbers (exp != 0, exp < 0x7FFF)
1064 | - infinities (exp == 0x7FFF, mantissa == 0)
1065 | - not-a-numbers (exp == 0x7FFF, mantissa != 0)
1066 |
1067 | For infinities and NaNs, the explicit integer bit can be either one or
1068 | zero.
1069 |
1070 | The IEEE 754 standard does not define a zero integer bit. Such a number
1071 | is an unnormalized number. Hardware does not directly support
1072 | denormalized and unnormalized numbers, but implicitly supports them by
1073 | trapping them as unimplemented data types, allowing efficient conversion
1074 | in software.
1075 |
1076 | See "M68000 FAMILY PROGRAMMER’S REFERENCE MANUAL",
1077 | "1.6 FLOATING-POINT DATA TYPES"
1078 *------------------------------------------------------------------------*/
1079 return false;
1080#else
Andrew Dutcherd1eb8f22016-08-16 17:14:55 -07001081 return (a.low & (1ULL << 63)) == 0 && (a.high & 0x7FFF) != 0;
Laurent Vivierd159dd02020-06-12 16:04:00 +02001082#endif
Andrew Dutcherd1eb8f22016-08-16 17:14:55 -07001083}
1084
Aurelien Jarnof3218a82011-04-20 13:04:22 +02001085#define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL)
Laszlo Ersek163b3d12020-07-24 07:45:00 +01001086#define floatx80_zero_init make_floatx80_init(0x0000, 0x0000000000000000LL)
Aurelien Jarnof3218a82011-04-20 13:04:22 +02001087#define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL)
1088#define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL)
Aurelien Jarnoc4b4c772011-04-20 13:04:22 +02001089#define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL)
Aurelien Jarnof3218a82011-04-20 13:04:22 +02001090#define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL)
Aurelien Jarnof3218a82011-04-20 13:04:22 +02001091
Christophe Lyon85596662011-02-21 17:38:44 +01001092/*----------------------------------------------------------------------------
Laurent Vivier88857ac2018-02-24 21:17:59 +01001093| Returns the fraction bits of the extended double-precision floating-point
1094| value `a'.
1095*----------------------------------------------------------------------------*/
1096
1097static inline uint64_t extractFloatx80Frac(floatx80 a)
1098{
1099 return a.low;
1100}
1101
1102/*----------------------------------------------------------------------------
1103| Returns the exponent bits of the extended double-precision floating-point
1104| value `a'.
1105*----------------------------------------------------------------------------*/
1106
1107static inline int32_t extractFloatx80Exp(floatx80 a)
1108{
1109 return a.high & 0x7FFF;
1110}
1111
1112/*----------------------------------------------------------------------------
1113| Returns the sign bit of the extended double-precision floating-point value
1114| `a'.
1115*----------------------------------------------------------------------------*/
1116
Richard Hendersonc1203912020-05-04 19:54:57 -07001117static inline bool extractFloatx80Sign(floatx80 a)
Laurent Vivier88857ac2018-02-24 21:17:59 +01001118{
1119 return a.high >> 15;
1120}
1121
1122/*----------------------------------------------------------------------------
1123| Packs the sign `zSign', exponent `zExp', and significand `zSig' into an
1124| extended double-precision floating-point value, returning the result.
1125*----------------------------------------------------------------------------*/
1126
Richard Hendersonc1203912020-05-04 19:54:57 -07001127static inline floatx80 packFloatx80(bool zSign, int32_t zExp, uint64_t zSig)
Laurent Vivier88857ac2018-02-24 21:17:59 +01001128{
1129 floatx80 z;
1130
1131 z.low = zSig;
1132 z.high = (((uint16_t)zSign) << 15) + zExp;
1133 return z;
1134}
1135
1136/*----------------------------------------------------------------------------
1137| Normalizes the subnormal extended double-precision floating-point value
1138| represented by the denormalized significand `aSig'. The normalized exponent
1139| and significand are stored at the locations pointed to by `zExpPtr' and
1140| `zSigPtr', respectively.
1141*----------------------------------------------------------------------------*/
1142
1143void normalizeFloatx80Subnormal(uint64_t aSig, int32_t *zExpPtr,
1144 uint64_t *zSigPtr);
1145
1146/*----------------------------------------------------------------------------
1147| Takes two extended double-precision floating-point values `a' and `b', one
1148| of which is a NaN, and returns the appropriate NaN result. If either `a' or
1149| `b' is a signaling NaN, the invalid exception is raised.
1150*----------------------------------------------------------------------------*/
1151
1152floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b, float_status *status);
1153
1154/*----------------------------------------------------------------------------
1155| Takes an abstract floating-point value having sign `zSign', exponent `zExp',
1156| and extended significand formed by the concatenation of `zSig0' and `zSig1',
1157| and returns the proper extended double-precision floating-point value
1158| corresponding to the abstract input. Ordinarily, the abstract value is
1159| rounded and packed into the extended double-precision format, with the
1160| inexact exception raised if the abstract input cannot be represented
1161| exactly. However, if the abstract value is too large, the overflow and
1162| inexact exceptions are raised and an infinity or maximal finite value is
1163| returned. If the abstract value is too small, the input value is rounded to
1164| a subnormal number, and the underflow and inexact exceptions are raised if
1165| the abstract input cannot be represented exactly as a subnormal extended
1166| double-precision floating-point number.
1167| If `roundingPrecision' is 32 or 64, the result is rounded to the same
1168| number of bits as single or double precision, respectively. Otherwise, the
1169| result is rounded to the full precision of the extended double-precision
1170| format.
1171| The input significand must be normalized or smaller. If the input
1172| significand is not normalized, `zExp' must be 0; in that case, the result
1173| returned is a subnormal number, and it must not require rounding. The
1174| handling of underflow and overflow follows the IEC/IEEE Standard for Binary
1175| Floating-Point Arithmetic.
1176*----------------------------------------------------------------------------*/
1177
Richard Henderson8da5f1d2020-11-21 09:33:36 -08001178floatx80 roundAndPackFloatx80(FloatX80RoundPrec roundingPrecision, bool zSign,
Laurent Vivier88857ac2018-02-24 21:17:59 +01001179 int32_t zExp, uint64_t zSig0, uint64_t zSig1,
1180 float_status *status);
1181
1182/*----------------------------------------------------------------------------
1183| Takes an abstract floating-point value having sign `zSign', exponent
1184| `zExp', and significand formed by the concatenation of `zSig0' and `zSig1',
1185| and returns the proper extended double-precision floating-point value
1186| corresponding to the abstract input. This routine is just like
1187| `roundAndPackFloatx80' except that the input significand does not have to be
1188| normalized.
1189*----------------------------------------------------------------------------*/
1190
Richard Henderson8da5f1d2020-11-21 09:33:36 -08001191floatx80 normalizeRoundAndPackFloatx80(FloatX80RoundPrec roundingPrecision,
Richard Hendersonc1203912020-05-04 19:54:57 -07001192 bool zSign, int32_t zExp,
Laurent Vivier88857ac2018-02-24 21:17:59 +01001193 uint64_t zSig0, uint64_t zSig1,
1194 float_status *status);
1195
1196/*----------------------------------------------------------------------------
Paolo Bonzini789ec7c2011-07-28 12:10:29 +02001197| The pattern for a default generated extended double-precision NaN.
Christophe Lyon85596662011-02-21 17:38:44 +01001198*----------------------------------------------------------------------------*/
Aleksandar Markovicaf39bc82016-06-10 11:57:28 +02001199floatx80 floatx80_default_nan(float_status *status);
Christophe Lyon85596662011-02-21 17:38:44 +01001200
bellard158142c2005-03-13 16:54:06 +00001201/*----------------------------------------------------------------------------
1202| Software IEC/IEEE quadruple-precision conversion routines.
1203*----------------------------------------------------------------------------*/
Peter Maydellf4014512016-01-22 15:09:21 +00001204int32_t float128_to_int32(float128, float_status *status);
1205int32_t float128_to_int32_round_to_zero(float128, float_status *status);
Peter Maydellf42c2222016-01-22 15:09:20 +00001206int64_t float128_to_int64(float128, float_status *status);
Matheus Ferstbea59232022-03-30 14:59:30 -03001207Int128 float128_to_int128(float128, float_status *status);
Peter Maydellf42c2222016-01-22 15:09:20 +00001208int64_t float128_to_int64_round_to_zero(float128, float_status *status);
Matheus Ferstbea59232022-03-30 14:59:30 -03001209Int128 float128_to_int128_round_to_zero(float128, float_status *status);
Bharata B Rao2e6d8562017-02-10 12:53:06 +05301210uint64_t float128_to_uint64(float128, float_status *status);
Matheus Ferst4de49dd2022-03-30 14:59:29 -03001211Int128 float128_to_uint128(float128, float_status *status);
Bharata B Rao2e6d8562017-02-10 12:53:06 +05301212uint64_t float128_to_uint64_round_to_zero(float128, float_status *status);
Matheus Ferst4de49dd2022-03-30 14:59:29 -03001213Int128 float128_to_uint128_round_to_zero(float128, float_status *status);
David Hildenbrande45de992019-02-06 11:53:39 +01001214uint32_t float128_to_uint32(float128, float_status *status);
Bharata B Raofd425032017-02-10 12:53:07 +05301215uint32_t float128_to_uint32_round_to_zero(float128, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +00001216float32 float128_to_float32(float128, float_status *status);
1217float64 float128_to_float64(float128, float_status *status);
1218floatx80 float128_to_floatx80(float128, float_status *status);
bellard158142c2005-03-13 16:54:06 +00001219
1220/*----------------------------------------------------------------------------
1221| Software IEC/IEEE quadruple-precision operations.
1222*----------------------------------------------------------------------------*/
Peter Maydelle5a41ff2015-01-30 12:04:16 +00001223float128 float128_round_to_int(float128, float_status *status);
1224float128 float128_add(float128, float128, float_status *status);
1225float128 float128_sub(float128, float128, float_status *status);
1226float128 float128_mul(float128, float128, float_status *status);
Richard Hendersondedd1232020-10-24 06:04:19 -07001227float128 float128_muladd(float128, float128, float128, int,
1228 float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +00001229float128 float128_div(float128, float128, float_status *status);
1230float128 float128_rem(float128, float128, float_status *status);
1231float128 float128_sqrt(float128, float_status *status);
Richard Henderson71bfd652020-05-05 10:22:05 -07001232FloatRelation float128_compare(float128, float128, float_status *status);
1233FloatRelation float128_compare_quiet(float128, float128, float_status *status);
David Hildenbrandceebc122021-05-17 16:27:36 +02001234float128 float128_min(float128, float128, float_status *status);
1235float128 float128_max(float128, float128, float_status *status);
1236float128 float128_minnum(float128, float128, float_status *status);
1237float128 float128_maxnum(float128, float128, float_status *status);
1238float128 float128_minnummag(float128, float128, float_status *status);
1239float128 float128_maxnummag(float128, float128, float_status *status);
Chih-Min Chao0e903032021-10-22 00:08:45 +08001240float128 float128_minimum_number(float128, float128, float_status *status);
1241float128 float128_maximum_number(float128, float128, float_status *status);
Richard Henderson150c7a92020-05-05 12:16:24 -07001242bool float128_is_quiet_nan(float128, float_status *status);
1243bool float128_is_signaling_nan(float128, float_status *status);
Richard Hendersond619bb92018-05-10 11:39:48 -07001244float128 float128_silence_nan(float128, float_status *status);
Peter Maydelle5a41ff2015-01-30 12:04:16 +00001245float128 float128_scalbn(float128, int, float_status *status);
bellard158142c2005-03-13 16:54:06 +00001246
Luiz Capitulinoa49db982014-06-19 10:13:43 -04001247static inline float128 float128_abs(float128 a)
bellard1d6bda32005-03-13 18:52:29 +00001248{
1249 a.high &= 0x7fffffffffffffffLL;
1250 return a;
1251}
1252
Luiz Capitulinoa49db982014-06-19 10:13:43 -04001253static inline float128 float128_chs(float128 a)
bellard1d6bda32005-03-13 18:52:29 +00001254{
1255 a.high ^= 0x8000000000000000LL;
1256 return a;
1257}
1258
Richard Henderson150c7a92020-05-05 12:16:24 -07001259static inline bool float128_is_infinity(float128 a)
aurel32c52ab6f2008-12-15 17:14:20 +00001260{
1261 return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0;
1262}
1263
Richard Henderson150c7a92020-05-05 12:16:24 -07001264static inline bool float128_is_neg(float128 a)
aurel32c52ab6f2008-12-15 17:14:20 +00001265{
1266 return a.high >> 63;
1267}
1268
Richard Henderson150c7a92020-05-05 12:16:24 -07001269static inline bool float128_is_zero(float128 a)
aurel32c52ab6f2008-12-15 17:14:20 +00001270{
1271 return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0;
1272}
1273
Richard Henderson150c7a92020-05-05 12:16:24 -07001274static inline bool float128_is_zero_or_denormal(float128 a)
Aurelien Jarno587eabf2011-05-15 14:09:18 +02001275{
1276 return (a.high & 0x7fff000000000000LL) == 0;
1277}
1278
David Hildenbrand473931812019-02-06 10:10:43 +01001279static inline bool float128_is_normal(float128 a)
1280{
1281 return (((a.high >> 48) + 1) & 0x7fff) >= 2;
1282}
1283
1284static inline bool float128_is_denormal(float128 a)
1285{
1286 return float128_is_zero_or_denormal(a) && !float128_is_zero(a);
1287}
1288
Richard Henderson150c7a92020-05-05 12:16:24 -07001289static inline bool float128_is_any_nan(float128 a)
Peter Maydell2bed6522011-01-06 18:34:43 +00001290{
1291 return ((a.high >> 48) & 0x7fff) == 0x7fff &&
1292 ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));
1293}
1294
Richard Hendersonb7b1ac62020-05-05 10:50:32 -07001295static inline bool float128_eq(float128 a, float128 b, float_status *s)
1296{
1297 return float128_compare(a, b, s) == float_relation_equal;
1298}
1299
1300static inline bool float128_le(float128 a, float128 b, float_status *s)
1301{
1302 return float128_compare(a, b, s) <= float_relation_equal;
1303}
1304
1305static inline bool float128_lt(float128 a, float128 b, float_status *s)
1306{
1307 return float128_compare(a, b, s) < float_relation_equal;
1308}
1309
1310static inline bool float128_unordered(float128 a, float128 b, float_status *s)
1311{
1312 return float128_compare(a, b, s) == float_relation_unordered;
1313}
1314
1315static inline bool float128_eq_quiet(float128 a, float128 b, float_status *s)
1316{
1317 return float128_compare_quiet(a, b, s) == float_relation_equal;
1318}
1319
1320static inline bool float128_le_quiet(float128 a, float128 b, float_status *s)
1321{
1322 return float128_compare_quiet(a, b, s) <= float_relation_equal;
1323}
1324
1325static inline bool float128_lt_quiet(float128 a, float128 b, float_status *s)
1326{
1327 return float128_compare_quiet(a, b, s) < float_relation_equal;
1328}
1329
1330static inline bool float128_unordered_quiet(float128 a, float128 b,
1331 float_status *s)
1332{
1333 return float128_compare_quiet(a, b, s) == float_relation_unordered;
1334}
1335
Richard Henderson1e397ea2012-12-31 10:09:04 -08001336#define float128_zero make_float128(0, 0)
1337
Christophe Lyon85596662011-02-21 17:38:44 +01001338/*----------------------------------------------------------------------------
Paolo Bonzini789ec7c2011-07-28 12:10:29 +02001339| The pattern for a default generated quadruple-precision NaN.
Christophe Lyon85596662011-02-21 17:38:44 +01001340*----------------------------------------------------------------------------*/
Aleksandar Markovicaf39bc82016-06-10 11:57:28 +02001341float128 float128_default_nan(float_status *status);
Christophe Lyon85596662011-02-21 17:38:44 +01001342
Markus Armbruster175de522016-06-29 15:29:06 +02001343#endif /* SOFTFLOAT_H */