xref: /openbmc/qemu/include/fpu/softfloat.h (revision f279852b)
1 /*
2  * QEMU float support
3  *
4  * The code in this source file is derived from release 2a of the SoftFloat
5  * IEC/IEEE Floating-point Arithmetic Package. Those parts of the code (and
6  * some later contributions) are provided under that license, as detailed below.
7  * It has subsequently been modified by contributors to the QEMU Project,
8  * so some portions are provided under:
9  *  the SoftFloat-2a license
10  *  the BSD license
11  *  GPL-v2-or-later
12  *
13  * Any future contributions to this file after December 1st 2014 will be
14  * taken to be licensed under the Softfloat-2a license unless specifically
15  * indicated otherwise.
16  */
17 
18 /*
19 ===============================================================================
20 This C header file is part of the SoftFloat IEC/IEEE Floating-point
21 Arithmetic Package, Release 2a.
22 
23 Written by John R. Hauser.  This work was made possible in part by the
24 International Computer Science Institute, located at Suite 600, 1947 Center
25 Street, Berkeley, California 94704.  Funding was partially provided by the
26 National Science Foundation under grant MIP-9311980.  The original version
27 of this code was written as part of a project to build a fixed-point vector
28 processor in collaboration with the University of California at Berkeley,
29 overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
30 is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
31 arithmetic/SoftFloat.html'.
32 
33 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
34 has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
35 TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
36 PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
37 AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
38 
39 Derivative works are acceptable, even for commercial purposes, so long as
40 (1) they include prominent notice that the work is derivative, and (2) they
41 include prominent notice akin to these four paragraphs for those parts of
42 this code that are retained.
43 
44 ===============================================================================
45 */
46 
47 /* BSD licensing:
48  * Copyright (c) 2006, Fabrice Bellard
49  * All rights reserved.
50  *
51  * Redistribution and use in source and binary forms, with or without
52  * modification, are permitted provided that the following conditions are met:
53  *
54  * 1. Redistributions of source code must retain the above copyright notice,
55  * this list of conditions and the following disclaimer.
56  *
57  * 2. Redistributions in binary form must reproduce the above copyright notice,
58  * this list of conditions and the following disclaimer in the documentation
59  * and/or other materials provided with the distribution.
60  *
61  * 3. Neither the name of the copyright holder nor the names of its contributors
62  * may be used to endorse or promote products derived from this software without
63  * specific prior written permission.
64  *
65  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
66  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
67  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
68  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
69  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
70  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
71  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
72  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
73  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
74  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
75  * THE POSSIBILITY OF SUCH DAMAGE.
76  */
77 
78 /* Portions of this work are licensed under the terms of the GNU GPL,
79  * version 2 or later. See the COPYING file in the top-level directory.
80  */
81 
82 #ifndef SOFTFLOAT_H
83 #define SOFTFLOAT_H
84 
85 /*----------------------------------------------------------------------------
86 | Software IEC/IEEE floating-point ordering relations
87 *----------------------------------------------------------------------------*/
88 
89 typedef enum {
90     float_relation_less      = -1,
91     float_relation_equal     =  0,
92     float_relation_greater   =  1,
93     float_relation_unordered =  2
94 } FloatRelation;
95 
96 #include "fpu/softfloat-types.h"
97 #include "fpu/softfloat-helpers.h"
98 #include "qemu/int128.h"
99 
100 /*----------------------------------------------------------------------------
101 | Routine to raise any or all of the software IEC/IEEE floating-point
102 | exception flags.
103 *----------------------------------------------------------------------------*/
104 static inline void float_raise(uint16_t flags, float_status *status)
105 {
106     status->float_exception_flags |= flags;
107 }
108 
109 /*----------------------------------------------------------------------------
110 | If `a' is denormal and we are in flush-to-zero mode then set the
111 | input-denormal exception and return zero. Otherwise just return the value.
112 *----------------------------------------------------------------------------*/
113 float16 float16_squash_input_denormal(float16 a, float_status *status);
114 float32 float32_squash_input_denormal(float32 a, float_status *status);
115 float64 float64_squash_input_denormal(float64 a, float_status *status);
116 bfloat16 bfloat16_squash_input_denormal(bfloat16 a, float_status *status);
117 
118 /*----------------------------------------------------------------------------
119 | 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.
123 | We also support halving the result before rounding, as a special
124 | case to support the ARM fused-sqrt-step instruction FRSQRTS.
125 *----------------------------------------------------------------------------*/
126 enum {
127     float_muladd_negate_c = 1,
128     float_muladd_negate_product = 2,
129     float_muladd_negate_result = 4,
130     float_muladd_halve_result = 8,
131 };
132 
133 /*----------------------------------------------------------------------------
134 | Software IEC/IEEE integer-to-floating-point conversion routines.
135 *----------------------------------------------------------------------------*/
136 
137 float16 int16_to_float16_scalbn(int16_t a, int, float_status *status);
138 float16 int32_to_float16_scalbn(int32_t a, int, float_status *status);
139 float16 int64_to_float16_scalbn(int64_t a, int, float_status *status);
140 float16 uint16_to_float16_scalbn(uint16_t a, int, float_status *status);
141 float16 uint32_to_float16_scalbn(uint32_t a, int, float_status *status);
142 float16 uint64_to_float16_scalbn(uint64_t a, int, float_status *status);
143 
144 float16 int8_to_float16(int8_t a, float_status *status);
145 float16 int16_to_float16(int16_t a, float_status *status);
146 float16 int32_to_float16(int32_t a, float_status *status);
147 float16 int64_to_float16(int64_t a, float_status *status);
148 float16 uint8_to_float16(uint8_t a, float_status *status);
149 float16 uint16_to_float16(uint16_t a, float_status *status);
150 float16 uint32_to_float16(uint32_t a, float_status *status);
151 float16 uint64_to_float16(uint64_t a, float_status *status);
152 
153 float32 int16_to_float32_scalbn(int16_t, int, float_status *status);
154 float32 int32_to_float32_scalbn(int32_t, int, float_status *status);
155 float32 int64_to_float32_scalbn(int64_t, int, float_status *status);
156 float32 uint16_to_float32_scalbn(uint16_t, int, float_status *status);
157 float32 uint32_to_float32_scalbn(uint32_t, int, float_status *status);
158 float32 uint64_to_float32_scalbn(uint64_t, int, float_status *status);
159 
160 float32 int16_to_float32(int16_t, float_status *status);
161 float32 int32_to_float32(int32_t, float_status *status);
162 float32 int64_to_float32(int64_t, float_status *status);
163 float32 uint16_to_float32(uint16_t, float_status *status);
164 float32 uint32_to_float32(uint32_t, float_status *status);
165 float32 uint64_to_float32(uint64_t, float_status *status);
166 
167 float64 int16_to_float64_scalbn(int16_t, int, float_status *status);
168 float64 int32_to_float64_scalbn(int32_t, int, float_status *status);
169 float64 int64_to_float64_scalbn(int64_t, int, float_status *status);
170 float64 uint16_to_float64_scalbn(uint16_t, int, float_status *status);
171 float64 uint32_to_float64_scalbn(uint32_t, int, float_status *status);
172 float64 uint64_to_float64_scalbn(uint64_t, int, float_status *status);
173 
174 float64 int16_to_float64(int16_t, float_status *status);
175 float64 int32_to_float64(int32_t, float_status *status);
176 float64 int64_to_float64(int64_t, float_status *status);
177 float64 uint16_to_float64(uint16_t, float_status *status);
178 float64 uint32_to_float64(uint32_t, float_status *status);
179 float64 uint64_to_float64(uint64_t, float_status *status);
180 
181 floatx80 int32_to_floatx80(int32_t, float_status *status);
182 floatx80 int64_to_floatx80(int64_t, float_status *status);
183 
184 float128 int32_to_float128(int32_t, float_status *status);
185 float128 int64_to_float128(int64_t, float_status *status);
186 float128 uint64_to_float128(uint64_t, float_status *status);
187 float128 uint128_to_float128(Int128, float_status *status);
188 
189 /*----------------------------------------------------------------------------
190 | Software half-precision conversion routines.
191 *----------------------------------------------------------------------------*/
192 
193 float16 float32_to_float16(float32, bool ieee, float_status *status);
194 float32 float16_to_float32(float16, bool ieee, float_status *status);
195 float16 float64_to_float16(float64 a, bool ieee, float_status *status);
196 float64 float16_to_float64(float16 a, bool ieee, float_status *status);
197 
198 int8_t  float16_to_int8_scalbn(float16, FloatRoundMode, int,
199                                float_status *status);
200 int16_t float16_to_int16_scalbn(float16, FloatRoundMode, int, float_status *);
201 int32_t float16_to_int32_scalbn(float16, FloatRoundMode, int, float_status *);
202 int64_t float16_to_int64_scalbn(float16, FloatRoundMode, int, float_status *);
203 
204 int8_t  float16_to_int8(float16, float_status *status);
205 int16_t float16_to_int16(float16, float_status *status);
206 int32_t float16_to_int32(float16, float_status *status);
207 int64_t float16_to_int64(float16, float_status *status);
208 
209 int16_t float16_to_int16_round_to_zero(float16, float_status *status);
210 int32_t float16_to_int32_round_to_zero(float16, float_status *status);
211 int64_t float16_to_int64_round_to_zero(float16, float_status *status);
212 
213 uint8_t float16_to_uint8_scalbn(float16 a, FloatRoundMode,
214                                 int, float_status *status);
215 uint16_t float16_to_uint16_scalbn(float16 a, FloatRoundMode,
216                                   int, float_status *status);
217 uint32_t float16_to_uint32_scalbn(float16 a, FloatRoundMode,
218                                   int, float_status *status);
219 uint64_t float16_to_uint64_scalbn(float16 a, FloatRoundMode,
220                                   int, float_status *status);
221 
222 uint8_t  float16_to_uint8(float16 a, float_status *status);
223 uint16_t float16_to_uint16(float16 a, float_status *status);
224 uint32_t float16_to_uint32(float16 a, float_status *status);
225 uint64_t float16_to_uint64(float16 a, float_status *status);
226 
227 uint16_t float16_to_uint16_round_to_zero(float16 a, float_status *status);
228 uint32_t float16_to_uint32_round_to_zero(float16 a, float_status *status);
229 uint64_t float16_to_uint64_round_to_zero(float16 a, float_status *status);
230 
231 /*----------------------------------------------------------------------------
232 | Software half-precision operations.
233 *----------------------------------------------------------------------------*/
234 
235 float16 float16_round_to_int(float16, float_status *status);
236 float16 float16_add(float16, float16, float_status *status);
237 float16 float16_sub(float16, float16, float_status *status);
238 float16 float16_mul(float16, float16, float_status *status);
239 float16 float16_muladd(float16, float16, float16, int, float_status *status);
240 float16 float16_div(float16, float16, float_status *status);
241 float16 float16_scalbn(float16, int, float_status *status);
242 float16 float16_min(float16, float16, float_status *status);
243 float16 float16_max(float16, float16, float_status *status);
244 float16 float16_minnum(float16, float16, float_status *status);
245 float16 float16_maxnum(float16, float16, float_status *status);
246 float16 float16_minnummag(float16, float16, float_status *status);
247 float16 float16_maxnummag(float16, float16, float_status *status);
248 float16 float16_minimum_number(float16, float16, float_status *status);
249 float16 float16_maximum_number(float16, float16, float_status *status);
250 float16 float16_sqrt(float16, float_status *status);
251 FloatRelation float16_compare(float16, float16, float_status *status);
252 FloatRelation float16_compare_quiet(float16, float16, float_status *status);
253 
254 bool float16_is_quiet_nan(float16, float_status *status);
255 bool float16_is_signaling_nan(float16, float_status *status);
256 float16 float16_silence_nan(float16, float_status *status);
257 
258 static inline bool float16_is_any_nan(float16 a)
259 {
260     return ((float16_val(a) & ~0x8000) > 0x7c00);
261 }
262 
263 static inline bool float16_is_neg(float16 a)
264 {
265     return float16_val(a) >> 15;
266 }
267 
268 static inline bool float16_is_infinity(float16 a)
269 {
270     return (float16_val(a) & 0x7fff) == 0x7c00;
271 }
272 
273 static inline bool float16_is_zero(float16 a)
274 {
275     return (float16_val(a) & 0x7fff) == 0;
276 }
277 
278 static inline bool float16_is_zero_or_denormal(float16 a)
279 {
280     return (float16_val(a) & 0x7c00) == 0;
281 }
282 
283 static inline bool float16_is_normal(float16 a)
284 {
285     return (((float16_val(a) >> 10) + 1) & 0x1f) >= 2;
286 }
287 
288 static inline float16 float16_abs(float16 a)
289 {
290     /* Note that abs does *not* handle NaN specially, nor does
291      * it flush denormal inputs to zero.
292      */
293     return make_float16(float16_val(a) & 0x7fff);
294 }
295 
296 static inline float16 float16_chs(float16 a)
297 {
298     /* Note that chs does *not* handle NaN specially, nor does
299      * it flush denormal inputs to zero.
300      */
301     return make_float16(float16_val(a) ^ 0x8000);
302 }
303 
304 static inline float16 float16_set_sign(float16 a, int sign)
305 {
306     return make_float16((float16_val(a) & 0x7fff) | (sign << 15));
307 }
308 
309 static inline bool float16_eq(float16 a, float16 b, float_status *s)
310 {
311     return float16_compare(a, b, s) == float_relation_equal;
312 }
313 
314 static inline bool float16_le(float16 a, float16 b, float_status *s)
315 {
316     return float16_compare(a, b, s) <= float_relation_equal;
317 }
318 
319 static inline bool float16_lt(float16 a, float16 b, float_status *s)
320 {
321     return float16_compare(a, b, s) < float_relation_equal;
322 }
323 
324 static inline bool float16_unordered(float16 a, float16 b, float_status *s)
325 {
326     return float16_compare(a, b, s) == float_relation_unordered;
327 }
328 
329 static inline bool float16_eq_quiet(float16 a, float16 b, float_status *s)
330 {
331     return float16_compare_quiet(a, b, s) == float_relation_equal;
332 }
333 
334 static inline bool float16_le_quiet(float16 a, float16 b, float_status *s)
335 {
336     return float16_compare_quiet(a, b, s) <= float_relation_equal;
337 }
338 
339 static inline bool float16_lt_quiet(float16 a, float16 b, float_status *s)
340 {
341     return float16_compare_quiet(a, b, s) < float_relation_equal;
342 }
343 
344 static inline bool float16_unordered_quiet(float16 a, float16 b,
345                                            float_status *s)
346 {
347     return float16_compare_quiet(a, b, s) == float_relation_unordered;
348 }
349 
350 #define float16_zero make_float16(0)
351 #define float16_half make_float16(0x3800)
352 #define float16_one make_float16(0x3c00)
353 #define float16_one_point_five make_float16(0x3e00)
354 #define float16_two make_float16(0x4000)
355 #define float16_three make_float16(0x4200)
356 #define float16_infinity make_float16(0x7c00)
357 
358 /*----------------------------------------------------------------------------
359 | Software bfloat16 conversion routines.
360 *----------------------------------------------------------------------------*/
361 
362 bfloat16 bfloat16_round_to_int(bfloat16, float_status *status);
363 bfloat16 float32_to_bfloat16(float32, float_status *status);
364 float32 bfloat16_to_float32(bfloat16, float_status *status);
365 bfloat16 float64_to_bfloat16(float64 a, float_status *status);
366 float64 bfloat16_to_float64(bfloat16 a, float_status *status);
367 
368 int16_t bfloat16_to_int16_scalbn(bfloat16, FloatRoundMode,
369                                  int, float_status *status);
370 int32_t bfloat16_to_int32_scalbn(bfloat16, FloatRoundMode,
371                                  int, float_status *status);
372 int64_t bfloat16_to_int64_scalbn(bfloat16, FloatRoundMode,
373                                  int, float_status *status);
374 
375 int16_t bfloat16_to_int16(bfloat16, float_status *status);
376 int32_t bfloat16_to_int32(bfloat16, float_status *status);
377 int64_t bfloat16_to_int64(bfloat16, float_status *status);
378 
379 int16_t bfloat16_to_int16_round_to_zero(bfloat16, float_status *status);
380 int32_t bfloat16_to_int32_round_to_zero(bfloat16, float_status *status);
381 int64_t bfloat16_to_int64_round_to_zero(bfloat16, float_status *status);
382 
383 uint16_t bfloat16_to_uint16_scalbn(bfloat16 a, FloatRoundMode,
384                                    int, float_status *status);
385 uint32_t bfloat16_to_uint32_scalbn(bfloat16 a, FloatRoundMode,
386                                    int, float_status *status);
387 uint64_t bfloat16_to_uint64_scalbn(bfloat16 a, FloatRoundMode,
388                                    int, float_status *status);
389 
390 uint16_t bfloat16_to_uint16(bfloat16 a, float_status *status);
391 uint32_t bfloat16_to_uint32(bfloat16 a, float_status *status);
392 uint64_t bfloat16_to_uint64(bfloat16 a, float_status *status);
393 
394 uint16_t bfloat16_to_uint16_round_to_zero(bfloat16 a, float_status *status);
395 uint32_t bfloat16_to_uint32_round_to_zero(bfloat16 a, float_status *status);
396 uint64_t bfloat16_to_uint64_round_to_zero(bfloat16 a, float_status *status);
397 
398 bfloat16 int16_to_bfloat16_scalbn(int16_t a, int, float_status *status);
399 bfloat16 int32_to_bfloat16_scalbn(int32_t a, int, float_status *status);
400 bfloat16 int64_to_bfloat16_scalbn(int64_t a, int, float_status *status);
401 bfloat16 uint16_to_bfloat16_scalbn(uint16_t a, int, float_status *status);
402 bfloat16 uint32_to_bfloat16_scalbn(uint32_t a, int, float_status *status);
403 bfloat16 uint64_to_bfloat16_scalbn(uint64_t a, int, float_status *status);
404 
405 bfloat16 int16_to_bfloat16(int16_t a, float_status *status);
406 bfloat16 int32_to_bfloat16(int32_t a, float_status *status);
407 bfloat16 int64_to_bfloat16(int64_t a, float_status *status);
408 bfloat16 uint16_to_bfloat16(uint16_t a, float_status *status);
409 bfloat16 uint32_to_bfloat16(uint32_t a, float_status *status);
410 bfloat16 uint64_to_bfloat16(uint64_t a, float_status *status);
411 
412 /*----------------------------------------------------------------------------
413 | Software bfloat16 operations.
414 *----------------------------------------------------------------------------*/
415 
416 bfloat16 bfloat16_add(bfloat16, bfloat16, float_status *status);
417 bfloat16 bfloat16_sub(bfloat16, bfloat16, float_status *status);
418 bfloat16 bfloat16_mul(bfloat16, bfloat16, float_status *status);
419 bfloat16 bfloat16_div(bfloat16, bfloat16, float_status *status);
420 bfloat16 bfloat16_muladd(bfloat16, bfloat16, bfloat16, int,
421                          float_status *status);
422 float16 bfloat16_scalbn(bfloat16, int, float_status *status);
423 bfloat16 bfloat16_min(bfloat16, bfloat16, float_status *status);
424 bfloat16 bfloat16_max(bfloat16, bfloat16, float_status *status);
425 bfloat16 bfloat16_minnum(bfloat16, bfloat16, float_status *status);
426 bfloat16 bfloat16_maxnum(bfloat16, bfloat16, float_status *status);
427 bfloat16 bfloat16_minnummag(bfloat16, bfloat16, float_status *status);
428 bfloat16 bfloat16_maxnummag(bfloat16, bfloat16, float_status *status);
429 bfloat16 bfloat16_minimum_number(bfloat16, bfloat16, float_status *status);
430 bfloat16 bfloat16_maximum_number(bfloat16, bfloat16, float_status *status);
431 bfloat16 bfloat16_sqrt(bfloat16, float_status *status);
432 FloatRelation bfloat16_compare(bfloat16, bfloat16, float_status *status);
433 FloatRelation bfloat16_compare_quiet(bfloat16, bfloat16, float_status *status);
434 
435 bool bfloat16_is_quiet_nan(bfloat16, float_status *status);
436 bool bfloat16_is_signaling_nan(bfloat16, float_status *status);
437 bfloat16 bfloat16_silence_nan(bfloat16, float_status *status);
438 bfloat16 bfloat16_default_nan(float_status *status);
439 
440 static inline bool bfloat16_is_any_nan(bfloat16 a)
441 {
442     return ((a & ~0x8000) > 0x7F80);
443 }
444 
445 static inline bool bfloat16_is_neg(bfloat16 a)
446 {
447     return a >> 15;
448 }
449 
450 static inline bool bfloat16_is_infinity(bfloat16 a)
451 {
452     return (a & 0x7fff) == 0x7F80;
453 }
454 
455 static inline bool bfloat16_is_zero(bfloat16 a)
456 {
457     return (a & 0x7fff) == 0;
458 }
459 
460 static inline bool bfloat16_is_zero_or_denormal(bfloat16 a)
461 {
462     return (a & 0x7F80) == 0;
463 }
464 
465 static inline bool bfloat16_is_normal(bfloat16 a)
466 {
467     return (((a >> 7) + 1) & 0xff) >= 2;
468 }
469 
470 static inline bfloat16 bfloat16_abs(bfloat16 a)
471 {
472     /* Note that abs does *not* handle NaN specially, nor does
473      * it flush denormal inputs to zero.
474      */
475     return a & 0x7fff;
476 }
477 
478 static inline bfloat16 bfloat16_chs(bfloat16 a)
479 {
480     /* Note that chs does *not* handle NaN specially, nor does
481      * it flush denormal inputs to zero.
482      */
483     return a ^ 0x8000;
484 }
485 
486 static inline bfloat16 bfloat16_set_sign(bfloat16 a, int sign)
487 {
488     return (a & 0x7fff) | (sign << 15);
489 }
490 
491 static inline bool bfloat16_eq(bfloat16 a, bfloat16 b, float_status *s)
492 {
493     return bfloat16_compare(a, b, s) == float_relation_equal;
494 }
495 
496 static inline bool bfloat16_le(bfloat16 a, bfloat16 b, float_status *s)
497 {
498     return bfloat16_compare(a, b, s) <= float_relation_equal;
499 }
500 
501 static inline bool bfloat16_lt(bfloat16 a, bfloat16 b, float_status *s)
502 {
503     return bfloat16_compare(a, b, s) < float_relation_equal;
504 }
505 
506 static inline bool bfloat16_unordered(bfloat16 a, bfloat16 b, float_status *s)
507 {
508     return bfloat16_compare(a, b, s) == float_relation_unordered;
509 }
510 
511 static inline bool bfloat16_eq_quiet(bfloat16 a, bfloat16 b, float_status *s)
512 {
513     return bfloat16_compare_quiet(a, b, s) == float_relation_equal;
514 }
515 
516 static inline bool bfloat16_le_quiet(bfloat16 a, bfloat16 b, float_status *s)
517 {
518     return bfloat16_compare_quiet(a, b, s) <= float_relation_equal;
519 }
520 
521 static inline bool bfloat16_lt_quiet(bfloat16 a, bfloat16 b, float_status *s)
522 {
523     return bfloat16_compare_quiet(a, b, s) < float_relation_equal;
524 }
525 
526 static inline bool bfloat16_unordered_quiet(bfloat16 a, bfloat16 b,
527                                            float_status *s)
528 {
529     return bfloat16_compare_quiet(a, b, s) == float_relation_unordered;
530 }
531 
532 #define bfloat16_zero 0
533 #define bfloat16_half 0x3f00
534 #define bfloat16_one 0x3f80
535 #define bfloat16_one_point_five 0x3fc0
536 #define bfloat16_two 0x4000
537 #define bfloat16_three 0x4040
538 #define bfloat16_infinity 0x7f80
539 
540 /*----------------------------------------------------------------------------
541 | The pattern for a default generated half-precision NaN.
542 *----------------------------------------------------------------------------*/
543 float16 float16_default_nan(float_status *status);
544 
545 /*----------------------------------------------------------------------------
546 | Software IEC/IEEE single-precision conversion routines.
547 *----------------------------------------------------------------------------*/
548 
549 int16_t float32_to_int16_scalbn(float32, FloatRoundMode, int, float_status *);
550 int32_t float32_to_int32_scalbn(float32, FloatRoundMode, int, float_status *);
551 int64_t float32_to_int64_scalbn(float32, FloatRoundMode, int, float_status *);
552 
553 int16_t float32_to_int16(float32, float_status *status);
554 int32_t float32_to_int32(float32, float_status *status);
555 int64_t float32_to_int64(float32, float_status *status);
556 
557 int16_t float32_to_int16_round_to_zero(float32, float_status *status);
558 int32_t float32_to_int32_round_to_zero(float32, float_status *status);
559 int64_t float32_to_int64_round_to_zero(float32, float_status *status);
560 
561 uint16_t float32_to_uint16_scalbn(float32, FloatRoundMode, int, float_status *);
562 uint32_t float32_to_uint32_scalbn(float32, FloatRoundMode, int, float_status *);
563 uint64_t float32_to_uint64_scalbn(float32, FloatRoundMode, int, float_status *);
564 
565 uint16_t float32_to_uint16(float32, float_status *status);
566 uint32_t float32_to_uint32(float32, float_status *status);
567 uint64_t float32_to_uint64(float32, float_status *status);
568 
569 uint16_t float32_to_uint16_round_to_zero(float32, float_status *status);
570 uint32_t float32_to_uint32_round_to_zero(float32, float_status *status);
571 uint64_t float32_to_uint64_round_to_zero(float32, float_status *status);
572 
573 float64 float32_to_float64(float32, float_status *status);
574 floatx80 float32_to_floatx80(float32, float_status *status);
575 float128 float32_to_float128(float32, float_status *status);
576 
577 /*----------------------------------------------------------------------------
578 | Software IEC/IEEE single-precision operations.
579 *----------------------------------------------------------------------------*/
580 float32 float32_round_to_int(float32, float_status *status);
581 float32 float32_add(float32, float32, float_status *status);
582 float32 float32_sub(float32, float32, float_status *status);
583 float32 float32_mul(float32, float32, float_status *status);
584 float32 float32_div(float32, float32, float_status *status);
585 float32 float32_rem(float32, float32, float_status *status);
586 float32 float32_muladd(float32, float32, float32, int, float_status *status);
587 float32 float32_sqrt(float32, float_status *status);
588 float32 float32_exp2(float32, float_status *status);
589 float32 float32_log2(float32, float_status *status);
590 FloatRelation float32_compare(float32, float32, float_status *status);
591 FloatRelation float32_compare_quiet(float32, float32, float_status *status);
592 float32 float32_min(float32, float32, float_status *status);
593 float32 float32_max(float32, float32, float_status *status);
594 float32 float32_minnum(float32, float32, float_status *status);
595 float32 float32_maxnum(float32, float32, float_status *status);
596 float32 float32_minnummag(float32, float32, float_status *status);
597 float32 float32_maxnummag(float32, float32, float_status *status);
598 float32 float32_minimum_number(float32, float32, float_status *status);
599 float32 float32_maximum_number(float32, float32, float_status *status);
600 bool float32_is_quiet_nan(float32, float_status *status);
601 bool float32_is_signaling_nan(float32, float_status *status);
602 float32 float32_silence_nan(float32, float_status *status);
603 float32 float32_scalbn(float32, int, float_status *status);
604 
605 static inline float32 float32_abs(float32 a)
606 {
607     /* Note that abs does *not* handle NaN specially, nor does
608      * it flush denormal inputs to zero.
609      */
610     return make_float32(float32_val(a) & 0x7fffffff);
611 }
612 
613 static inline float32 float32_chs(float32 a)
614 {
615     /* Note that chs does *not* handle NaN specially, nor does
616      * it flush denormal inputs to zero.
617      */
618     return make_float32(float32_val(a) ^ 0x80000000);
619 }
620 
621 static inline bool float32_is_infinity(float32 a)
622 {
623     return (float32_val(a) & 0x7fffffff) == 0x7f800000;
624 }
625 
626 static inline bool float32_is_neg(float32 a)
627 {
628     return float32_val(a) >> 31;
629 }
630 
631 static inline bool float32_is_zero(float32 a)
632 {
633     return (float32_val(a) & 0x7fffffff) == 0;
634 }
635 
636 static inline bool float32_is_any_nan(float32 a)
637 {
638     return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL);
639 }
640 
641 static inline bool float32_is_zero_or_denormal(float32 a)
642 {
643     return (float32_val(a) & 0x7f800000) == 0;
644 }
645 
646 static inline bool float32_is_normal(float32 a)
647 {
648     return (((float32_val(a) >> 23) + 1) & 0xff) >= 2;
649 }
650 
651 static inline bool float32_is_denormal(float32 a)
652 {
653     return float32_is_zero_or_denormal(a) && !float32_is_zero(a);
654 }
655 
656 static inline bool float32_is_zero_or_normal(float32 a)
657 {
658     return float32_is_normal(a) || float32_is_zero(a);
659 }
660 
661 static inline float32 float32_set_sign(float32 a, int sign)
662 {
663     return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31));
664 }
665 
666 static inline bool float32_eq(float32 a, float32 b, float_status *s)
667 {
668     return float32_compare(a, b, s) == float_relation_equal;
669 }
670 
671 static inline bool float32_le(float32 a, float32 b, float_status *s)
672 {
673     return float32_compare(a, b, s) <= float_relation_equal;
674 }
675 
676 static inline bool float32_lt(float32 a, float32 b, float_status *s)
677 {
678     return float32_compare(a, b, s) < float_relation_equal;
679 }
680 
681 static inline bool float32_unordered(float32 a, float32 b, float_status *s)
682 {
683     return float32_compare(a, b, s) == float_relation_unordered;
684 }
685 
686 static inline bool float32_eq_quiet(float32 a, float32 b, float_status *s)
687 {
688     return float32_compare_quiet(a, b, s) == float_relation_equal;
689 }
690 
691 static inline bool float32_le_quiet(float32 a, float32 b, float_status *s)
692 {
693     return float32_compare_quiet(a, b, s) <= float_relation_equal;
694 }
695 
696 static inline bool float32_lt_quiet(float32 a, float32 b, float_status *s)
697 {
698     return float32_compare_quiet(a, b, s) < float_relation_equal;
699 }
700 
701 static inline bool float32_unordered_quiet(float32 a, float32 b,
702                                            float_status *s)
703 {
704     return float32_compare_quiet(a, b, s) == float_relation_unordered;
705 }
706 
707 #define float32_zero make_float32(0)
708 #define float32_half make_float32(0x3f000000)
709 #define float32_one make_float32(0x3f800000)
710 #define float32_one_point_five make_float32(0x3fc00000)
711 #define float32_two make_float32(0x40000000)
712 #define float32_three make_float32(0x40400000)
713 #define float32_infinity make_float32(0x7f800000)
714 
715 /*----------------------------------------------------------------------------
716 | Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
717 | single-precision floating-point value, returning the result.  After being
718 | shifted into the proper positions, the three fields are simply added
719 | together to form the result.  This means that any integer portion of `zSig'
720 | will be added into the exponent.  Since a properly normalized significand
721 | will have an integer portion equal to 1, the `zExp' input should be 1 less
722 | than the desired result exponent whenever `zSig' is a complete, normalized
723 | significand.
724 *----------------------------------------------------------------------------*/
725 
726 static inline float32 packFloat32(bool zSign, int zExp, uint32_t zSig)
727 {
728     return make_float32(
729           (((uint32_t)zSign) << 31) + (((uint32_t)zExp) << 23) + zSig);
730 }
731 
732 /*----------------------------------------------------------------------------
733 | The pattern for a default generated single-precision NaN.
734 *----------------------------------------------------------------------------*/
735 float32 float32_default_nan(float_status *status);
736 
737 /*----------------------------------------------------------------------------
738 | Software IEC/IEEE double-precision conversion routines.
739 *----------------------------------------------------------------------------*/
740 
741 int16_t float64_to_int16_scalbn(float64, FloatRoundMode, int, float_status *);
742 int32_t float64_to_int32_scalbn(float64, FloatRoundMode, int, float_status *);
743 int64_t float64_to_int64_scalbn(float64, FloatRoundMode, int, float_status *);
744 
745 int16_t float64_to_int16(float64, float_status *status);
746 int32_t float64_to_int32(float64, float_status *status);
747 int64_t float64_to_int64(float64, float_status *status);
748 
749 int16_t float64_to_int16_round_to_zero(float64, float_status *status);
750 int32_t float64_to_int32_round_to_zero(float64, float_status *status);
751 int64_t float64_to_int64_round_to_zero(float64, float_status *status);
752 
753 uint16_t float64_to_uint16_scalbn(float64, FloatRoundMode, int, float_status *);
754 uint32_t float64_to_uint32_scalbn(float64, FloatRoundMode, int, float_status *);
755 uint64_t float64_to_uint64_scalbn(float64, FloatRoundMode, int, float_status *);
756 
757 uint16_t float64_to_uint16(float64, float_status *status);
758 uint32_t float64_to_uint32(float64, float_status *status);
759 uint64_t float64_to_uint64(float64, float_status *status);
760 
761 uint16_t float64_to_uint16_round_to_zero(float64, float_status *status);
762 uint32_t float64_to_uint32_round_to_zero(float64, float_status *status);
763 uint64_t float64_to_uint64_round_to_zero(float64, float_status *status);
764 
765 float32 float64_to_float32(float64, float_status *status);
766 floatx80 float64_to_floatx80(float64, float_status *status);
767 float128 float64_to_float128(float64, float_status *status);
768 
769 /*----------------------------------------------------------------------------
770 | Software IEC/IEEE double-precision operations.
771 *----------------------------------------------------------------------------*/
772 float64 float64_round_to_int(float64, float_status *status);
773 float64 float64_add(float64, float64, float_status *status);
774 float64 float64_sub(float64, float64, float_status *status);
775 float64 float64_mul(float64, float64, float_status *status);
776 float64 float64_div(float64, float64, float_status *status);
777 float64 float64_rem(float64, float64, float_status *status);
778 float64 float64_muladd(float64, float64, float64, int, float_status *status);
779 float64 float64_sqrt(float64, float_status *status);
780 float64 float64_log2(float64, float_status *status);
781 FloatRelation float64_compare(float64, float64, float_status *status);
782 FloatRelation float64_compare_quiet(float64, float64, float_status *status);
783 float64 float64_min(float64, float64, float_status *status);
784 float64 float64_max(float64, float64, float_status *status);
785 float64 float64_minnum(float64, float64, float_status *status);
786 float64 float64_maxnum(float64, float64, float_status *status);
787 float64 float64_minnummag(float64, float64, float_status *status);
788 float64 float64_maxnummag(float64, float64, float_status *status);
789 float64 float64_minimum_number(float64, float64, float_status *status);
790 float64 float64_maximum_number(float64, float64, float_status *status);
791 bool float64_is_quiet_nan(float64 a, float_status *status);
792 bool float64_is_signaling_nan(float64, float_status *status);
793 float64 float64_silence_nan(float64, float_status *status);
794 float64 float64_scalbn(float64, int, float_status *status);
795 
796 static inline float64 float64_abs(float64 a)
797 {
798     /* Note that abs does *not* handle NaN specially, nor does
799      * it flush denormal inputs to zero.
800      */
801     return make_float64(float64_val(a) & 0x7fffffffffffffffLL);
802 }
803 
804 static inline float64 float64_chs(float64 a)
805 {
806     /* Note that chs does *not* handle NaN specially, nor does
807      * it flush denormal inputs to zero.
808      */
809     return make_float64(float64_val(a) ^ 0x8000000000000000LL);
810 }
811 
812 static inline bool float64_is_infinity(float64 a)
813 {
814     return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL;
815 }
816 
817 static inline bool float64_is_neg(float64 a)
818 {
819     return float64_val(a) >> 63;
820 }
821 
822 static inline bool float64_is_zero(float64 a)
823 {
824     return (float64_val(a) & 0x7fffffffffffffffLL) == 0;
825 }
826 
827 static inline bool float64_is_any_nan(float64 a)
828 {
829     return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL);
830 }
831 
832 static inline bool float64_is_zero_or_denormal(float64 a)
833 {
834     return (float64_val(a) & 0x7ff0000000000000LL) == 0;
835 }
836 
837 static inline bool float64_is_normal(float64 a)
838 {
839     return (((float64_val(a) >> 52) + 1) & 0x7ff) >= 2;
840 }
841 
842 static inline bool float64_is_denormal(float64 a)
843 {
844     return float64_is_zero_or_denormal(a) && !float64_is_zero(a);
845 }
846 
847 static inline bool float64_is_zero_or_normal(float64 a)
848 {
849     return float64_is_normal(a) || float64_is_zero(a);
850 }
851 
852 static inline float64 float64_set_sign(float64 a, int sign)
853 {
854     return make_float64((float64_val(a) & 0x7fffffffffffffffULL)
855                         | ((int64_t)sign << 63));
856 }
857 
858 static inline bool float64_eq(float64 a, float64 b, float_status *s)
859 {
860     return float64_compare(a, b, s) == float_relation_equal;
861 }
862 
863 static inline bool float64_le(float64 a, float64 b, float_status *s)
864 {
865     return float64_compare(a, b, s) <= float_relation_equal;
866 }
867 
868 static inline bool float64_lt(float64 a, float64 b, float_status *s)
869 {
870     return float64_compare(a, b, s) < float_relation_equal;
871 }
872 
873 static inline bool float64_unordered(float64 a, float64 b, float_status *s)
874 {
875     return float64_compare(a, b, s) == float_relation_unordered;
876 }
877 
878 static inline bool float64_eq_quiet(float64 a, float64 b, float_status *s)
879 {
880     return float64_compare_quiet(a, b, s) == float_relation_equal;
881 }
882 
883 static inline bool float64_le_quiet(float64 a, float64 b, float_status *s)
884 {
885     return float64_compare_quiet(a, b, s) <= float_relation_equal;
886 }
887 
888 static inline bool float64_lt_quiet(float64 a, float64 b, float_status *s)
889 {
890     return float64_compare_quiet(a, b, s) < float_relation_equal;
891 }
892 
893 static inline bool float64_unordered_quiet(float64 a, float64 b,
894                                            float_status *s)
895 {
896     return float64_compare_quiet(a, b, s) == float_relation_unordered;
897 }
898 
899 #define float64_zero make_float64(0)
900 #define float64_half make_float64(0x3fe0000000000000LL)
901 #define float64_one make_float64(0x3ff0000000000000LL)
902 #define float64_one_point_five make_float64(0x3FF8000000000000ULL)
903 #define float64_two make_float64(0x4000000000000000ULL)
904 #define float64_three make_float64(0x4008000000000000ULL)
905 #define float64_ln2 make_float64(0x3fe62e42fefa39efLL)
906 #define float64_infinity make_float64(0x7ff0000000000000LL)
907 
908 /*----------------------------------------------------------------------------
909 | The pattern for a default generated double-precision NaN.
910 *----------------------------------------------------------------------------*/
911 float64 float64_default_nan(float_status *status);
912 
913 /*----------------------------------------------------------------------------
914 | Software IEC/IEEE double-precision operations, rounding to single precision,
915 | returning a result in double precision, with only one rounding step.
916 *----------------------------------------------------------------------------*/
917 
918 float64 float64r32_add(float64, float64, float_status *status);
919 float64 float64r32_sub(float64, float64, float_status *status);
920 float64 float64r32_mul(float64, float64, float_status *status);
921 float64 float64r32_div(float64, float64, float_status *status);
922 float64 float64r32_muladd(float64, float64, float64, int, float_status *status);
923 float64 float64r32_sqrt(float64, float_status *status);
924 
925 /*----------------------------------------------------------------------------
926 | Software IEC/IEEE extended double-precision conversion routines.
927 *----------------------------------------------------------------------------*/
928 int32_t floatx80_to_int32(floatx80, float_status *status);
929 int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status);
930 int64_t floatx80_to_int64(floatx80, float_status *status);
931 int64_t floatx80_to_int64_round_to_zero(floatx80, float_status *status);
932 float32 floatx80_to_float32(floatx80, float_status *status);
933 float64 floatx80_to_float64(floatx80, float_status *status);
934 float128 floatx80_to_float128(floatx80, float_status *status);
935 
936 /*----------------------------------------------------------------------------
937 | The pattern for an extended double-precision inf.
938 *----------------------------------------------------------------------------*/
939 extern const floatx80 floatx80_infinity;
940 
941 /*----------------------------------------------------------------------------
942 | Software IEC/IEEE extended double-precision operations.
943 *----------------------------------------------------------------------------*/
944 floatx80 floatx80_round(floatx80 a, float_status *status);
945 floatx80 floatx80_round_to_int(floatx80, float_status *status);
946 floatx80 floatx80_add(floatx80, floatx80, float_status *status);
947 floatx80 floatx80_sub(floatx80, floatx80, float_status *status);
948 floatx80 floatx80_mul(floatx80, floatx80, float_status *status);
949 floatx80 floatx80_div(floatx80, floatx80, float_status *status);
950 floatx80 floatx80_modrem(floatx80, floatx80, bool, uint64_t *,
951                          float_status *status);
952 floatx80 floatx80_mod(floatx80, floatx80, float_status *status);
953 floatx80 floatx80_rem(floatx80, floatx80, float_status *status);
954 floatx80 floatx80_sqrt(floatx80, float_status *status);
955 FloatRelation floatx80_compare(floatx80, floatx80, float_status *status);
956 FloatRelation floatx80_compare_quiet(floatx80, floatx80, float_status *status);
957 int floatx80_is_quiet_nan(floatx80, float_status *status);
958 int floatx80_is_signaling_nan(floatx80, float_status *status);
959 floatx80 floatx80_silence_nan(floatx80, float_status *status);
960 floatx80 floatx80_scalbn(floatx80, int, float_status *status);
961 
962 static inline floatx80 floatx80_abs(floatx80 a)
963 {
964     a.high &= 0x7fff;
965     return a;
966 }
967 
968 static inline floatx80 floatx80_chs(floatx80 a)
969 {
970     a.high ^= 0x8000;
971     return a;
972 }
973 
974 static inline bool floatx80_is_infinity(floatx80 a)
975 {
976 #if defined(TARGET_M68K)
977     return (a.high & 0x7fff) == floatx80_infinity.high && !(a.low << 1);
978 #else
979     return (a.high & 0x7fff) == floatx80_infinity.high &&
980                        a.low == floatx80_infinity.low;
981 #endif
982 }
983 
984 static inline bool floatx80_is_neg(floatx80 a)
985 {
986     return a.high >> 15;
987 }
988 
989 static inline bool floatx80_is_zero(floatx80 a)
990 {
991     return (a.high & 0x7fff) == 0 && a.low == 0;
992 }
993 
994 static inline bool floatx80_is_zero_or_denormal(floatx80 a)
995 {
996     return (a.high & 0x7fff) == 0;
997 }
998 
999 static inline bool floatx80_is_any_nan(floatx80 a)
1000 {
1001     return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1);
1002 }
1003 
1004 static inline bool floatx80_eq(floatx80 a, floatx80 b, float_status *s)
1005 {
1006     return floatx80_compare(a, b, s) == float_relation_equal;
1007 }
1008 
1009 static inline bool floatx80_le(floatx80 a, floatx80 b, float_status *s)
1010 {
1011     return floatx80_compare(a, b, s) <= float_relation_equal;
1012 }
1013 
1014 static inline bool floatx80_lt(floatx80 a, floatx80 b, float_status *s)
1015 {
1016     return floatx80_compare(a, b, s) < float_relation_equal;
1017 }
1018 
1019 static inline bool floatx80_unordered(floatx80 a, floatx80 b, float_status *s)
1020 {
1021     return floatx80_compare(a, b, s) == float_relation_unordered;
1022 }
1023 
1024 static inline bool floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *s)
1025 {
1026     return floatx80_compare_quiet(a, b, s) == float_relation_equal;
1027 }
1028 
1029 static inline bool floatx80_le_quiet(floatx80 a, floatx80 b, float_status *s)
1030 {
1031     return floatx80_compare_quiet(a, b, s) <= float_relation_equal;
1032 }
1033 
1034 static inline bool floatx80_lt_quiet(floatx80 a, floatx80 b, float_status *s)
1035 {
1036     return floatx80_compare_quiet(a, b, s) < float_relation_equal;
1037 }
1038 
1039 static inline bool floatx80_unordered_quiet(floatx80 a, floatx80 b,
1040                                            float_status *s)
1041 {
1042     return floatx80_compare_quiet(a, b, s) == float_relation_unordered;
1043 }
1044 
1045 /*----------------------------------------------------------------------------
1046 | Return whether the given value is an invalid floatx80 encoding.
1047 | Invalid floatx80 encodings arise when the integer bit is not set, but
1048 | the exponent is not zero. The only times the integer bit is permitted to
1049 | be zero is in subnormal numbers and the value zero.
1050 | This includes what the Intel software developer's manual calls pseudo-NaNs,
1051 | pseudo-infinities and un-normal numbers. It does not include
1052 | pseudo-denormals, which must still be correctly handled as inputs even
1053 | if they are never generated as outputs.
1054 *----------------------------------------------------------------------------*/
1055 static inline bool floatx80_invalid_encoding(floatx80 a)
1056 {
1057 #if defined(TARGET_M68K)
1058     /*-------------------------------------------------------------------------
1059     | With m68k, the explicit integer bit can be zero in the case of:
1060     | - zeros                (exp == 0, mantissa == 0)
1061     | - denormalized numbers (exp == 0, mantissa != 0)
1062     | - unnormalized numbers (exp != 0, exp < 0x7FFF)
1063     | - infinities           (exp == 0x7FFF, mantissa == 0)
1064     | - not-a-numbers        (exp == 0x7FFF, mantissa != 0)
1065     |
1066     | For infinities and NaNs, the explicit integer bit can be either one or
1067     | zero.
1068     |
1069     | The IEEE 754 standard does not define a zero integer bit. Such a number
1070     | is an unnormalized number. Hardware does not directly support
1071     | denormalized and unnormalized numbers, but implicitly supports them by
1072     | trapping them as unimplemented data types, allowing efficient conversion
1073     | in software.
1074     |
1075     | See "M68000 FAMILY PROGRAMMER’S REFERENCE MANUAL",
1076     |     "1.6 FLOATING-POINT DATA TYPES"
1077     *------------------------------------------------------------------------*/
1078     return false;
1079 #else
1080     return (a.low & (1ULL << 63)) == 0 && (a.high & 0x7FFF) != 0;
1081 #endif
1082 }
1083 
1084 #define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL)
1085 #define floatx80_zero_init make_floatx80_init(0x0000, 0x0000000000000000LL)
1086 #define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL)
1087 #define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL)
1088 #define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL)
1089 #define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL)
1090 
1091 /*----------------------------------------------------------------------------
1092 | Returns the fraction bits of the extended double-precision floating-point
1093 | value `a'.
1094 *----------------------------------------------------------------------------*/
1095 
1096 static inline uint64_t extractFloatx80Frac(floatx80 a)
1097 {
1098     return a.low;
1099 }
1100 
1101 /*----------------------------------------------------------------------------
1102 | Returns the exponent bits of the extended double-precision floating-point
1103 | value `a'.
1104 *----------------------------------------------------------------------------*/
1105 
1106 static inline int32_t extractFloatx80Exp(floatx80 a)
1107 {
1108     return a.high & 0x7FFF;
1109 }
1110 
1111 /*----------------------------------------------------------------------------
1112 | Returns the sign bit of the extended double-precision floating-point value
1113 | `a'.
1114 *----------------------------------------------------------------------------*/
1115 
1116 static inline bool extractFloatx80Sign(floatx80 a)
1117 {
1118     return a.high >> 15;
1119 }
1120 
1121 /*----------------------------------------------------------------------------
1122 | Packs the sign `zSign', exponent `zExp', and significand `zSig' into an
1123 | extended double-precision floating-point value, returning the result.
1124 *----------------------------------------------------------------------------*/
1125 
1126 static inline floatx80 packFloatx80(bool zSign, int32_t zExp, uint64_t zSig)
1127 {
1128     floatx80 z;
1129 
1130     z.low = zSig;
1131     z.high = (((uint16_t)zSign) << 15) + zExp;
1132     return z;
1133 }
1134 
1135 /*----------------------------------------------------------------------------
1136 | Normalizes the subnormal extended double-precision floating-point value
1137 | represented by the denormalized significand `aSig'.  The normalized exponent
1138 | and significand are stored at the locations pointed to by `zExpPtr' and
1139 | `zSigPtr', respectively.
1140 *----------------------------------------------------------------------------*/
1141 
1142 void normalizeFloatx80Subnormal(uint64_t aSig, int32_t *zExpPtr,
1143                                 uint64_t *zSigPtr);
1144 
1145 /*----------------------------------------------------------------------------
1146 | Takes two extended double-precision floating-point values `a' and `b', one
1147 | of which is a NaN, and returns the appropriate NaN result.  If either `a' or
1148 | `b' is a signaling NaN, the invalid exception is raised.
1149 *----------------------------------------------------------------------------*/
1150 
1151 floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b, float_status *status);
1152 
1153 /*----------------------------------------------------------------------------
1154 | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
1155 | and extended significand formed by the concatenation of `zSig0' and `zSig1',
1156 | and returns the proper extended double-precision floating-point value
1157 | corresponding to the abstract input.  Ordinarily, the abstract value is
1158 | rounded and packed into the extended double-precision format, with the
1159 | inexact exception raised if the abstract input cannot be represented
1160 | exactly.  However, if the abstract value is too large, the overflow and
1161 | inexact exceptions are raised and an infinity or maximal finite value is
1162 | returned.  If the abstract value is too small, the input value is rounded to
1163 | a subnormal number, and the underflow and inexact exceptions are raised if
1164 | the abstract input cannot be represented exactly as a subnormal extended
1165 | double-precision floating-point number.
1166 |     If `roundingPrecision' is 32 or 64, the result is rounded to the same
1167 | number of bits as single or double precision, respectively.  Otherwise, the
1168 | result is rounded to the full precision of the extended double-precision
1169 | format.
1170 |     The input significand must be normalized or smaller.  If the input
1171 | significand is not normalized, `zExp' must be 0; in that case, the result
1172 | returned is a subnormal number, and it must not require rounding.  The
1173 | handling of underflow and overflow follows the IEC/IEEE Standard for Binary
1174 | Floating-Point Arithmetic.
1175 *----------------------------------------------------------------------------*/
1176 
1177 floatx80 roundAndPackFloatx80(FloatX80RoundPrec roundingPrecision, bool zSign,
1178                               int32_t zExp, uint64_t zSig0, uint64_t zSig1,
1179                               float_status *status);
1180 
1181 /*----------------------------------------------------------------------------
1182 | Takes an abstract floating-point value having sign `zSign', exponent
1183 | `zExp', and significand formed by the concatenation of `zSig0' and `zSig1',
1184 | and returns the proper extended double-precision floating-point value
1185 | corresponding to the abstract input.  This routine is just like
1186 | `roundAndPackFloatx80' except that the input significand does not have to be
1187 | normalized.
1188 *----------------------------------------------------------------------------*/
1189 
1190 floatx80 normalizeRoundAndPackFloatx80(FloatX80RoundPrec roundingPrecision,
1191                                        bool zSign, int32_t zExp,
1192                                        uint64_t zSig0, uint64_t zSig1,
1193                                        float_status *status);
1194 
1195 /*----------------------------------------------------------------------------
1196 | The pattern for a default generated extended double-precision NaN.
1197 *----------------------------------------------------------------------------*/
1198 floatx80 floatx80_default_nan(float_status *status);
1199 
1200 /*----------------------------------------------------------------------------
1201 | Software IEC/IEEE quadruple-precision conversion routines.
1202 *----------------------------------------------------------------------------*/
1203 int32_t float128_to_int32(float128, float_status *status);
1204 int32_t float128_to_int32_round_to_zero(float128, float_status *status);
1205 int64_t float128_to_int64(float128, float_status *status);
1206 int64_t float128_to_int64_round_to_zero(float128, float_status *status);
1207 uint64_t float128_to_uint64(float128, float_status *status);
1208 uint64_t float128_to_uint64_round_to_zero(float128, float_status *status);
1209 uint32_t float128_to_uint32(float128, float_status *status);
1210 uint32_t float128_to_uint32_round_to_zero(float128, float_status *status);
1211 float32 float128_to_float32(float128, float_status *status);
1212 float64 float128_to_float64(float128, float_status *status);
1213 floatx80 float128_to_floatx80(float128, float_status *status);
1214 
1215 /*----------------------------------------------------------------------------
1216 | Software IEC/IEEE quadruple-precision operations.
1217 *----------------------------------------------------------------------------*/
1218 float128 float128_round_to_int(float128, float_status *status);
1219 float128 float128_add(float128, float128, float_status *status);
1220 float128 float128_sub(float128, float128, float_status *status);
1221 float128 float128_mul(float128, float128, float_status *status);
1222 float128 float128_muladd(float128, float128, float128, int,
1223                          float_status *status);
1224 float128 float128_div(float128, float128, float_status *status);
1225 float128 float128_rem(float128, float128, float_status *status);
1226 float128 float128_sqrt(float128, float_status *status);
1227 FloatRelation float128_compare(float128, float128, float_status *status);
1228 FloatRelation float128_compare_quiet(float128, float128, float_status *status);
1229 float128 float128_min(float128, float128, float_status *status);
1230 float128 float128_max(float128, float128, float_status *status);
1231 float128 float128_minnum(float128, float128, float_status *status);
1232 float128 float128_maxnum(float128, float128, float_status *status);
1233 float128 float128_minnummag(float128, float128, float_status *status);
1234 float128 float128_maxnummag(float128, float128, float_status *status);
1235 float128 float128_minimum_number(float128, float128, float_status *status);
1236 float128 float128_maximum_number(float128, float128, float_status *status);
1237 bool float128_is_quiet_nan(float128, float_status *status);
1238 bool float128_is_signaling_nan(float128, float_status *status);
1239 float128 float128_silence_nan(float128, float_status *status);
1240 float128 float128_scalbn(float128, int, float_status *status);
1241 
1242 static inline float128 float128_abs(float128 a)
1243 {
1244     a.high &= 0x7fffffffffffffffLL;
1245     return a;
1246 }
1247 
1248 static inline float128 float128_chs(float128 a)
1249 {
1250     a.high ^= 0x8000000000000000LL;
1251     return a;
1252 }
1253 
1254 static inline bool float128_is_infinity(float128 a)
1255 {
1256     return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0;
1257 }
1258 
1259 static inline bool float128_is_neg(float128 a)
1260 {
1261     return a.high >> 63;
1262 }
1263 
1264 static inline bool float128_is_zero(float128 a)
1265 {
1266     return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0;
1267 }
1268 
1269 static inline bool float128_is_zero_or_denormal(float128 a)
1270 {
1271     return (a.high & 0x7fff000000000000LL) == 0;
1272 }
1273 
1274 static inline bool float128_is_normal(float128 a)
1275 {
1276     return (((a.high >> 48) + 1) & 0x7fff) >= 2;
1277 }
1278 
1279 static inline bool float128_is_denormal(float128 a)
1280 {
1281     return float128_is_zero_or_denormal(a) && !float128_is_zero(a);
1282 }
1283 
1284 static inline bool float128_is_any_nan(float128 a)
1285 {
1286     return ((a.high >> 48) & 0x7fff) == 0x7fff &&
1287         ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));
1288 }
1289 
1290 static inline bool float128_eq(float128 a, float128 b, float_status *s)
1291 {
1292     return float128_compare(a, b, s) == float_relation_equal;
1293 }
1294 
1295 static inline bool float128_le(float128 a, float128 b, float_status *s)
1296 {
1297     return float128_compare(a, b, s) <= float_relation_equal;
1298 }
1299 
1300 static inline bool float128_lt(float128 a, float128 b, float_status *s)
1301 {
1302     return float128_compare(a, b, s) < float_relation_equal;
1303 }
1304 
1305 static inline bool float128_unordered(float128 a, float128 b, float_status *s)
1306 {
1307     return float128_compare(a, b, s) == float_relation_unordered;
1308 }
1309 
1310 static inline bool float128_eq_quiet(float128 a, float128 b, float_status *s)
1311 {
1312     return float128_compare_quiet(a, b, s) == float_relation_equal;
1313 }
1314 
1315 static inline bool float128_le_quiet(float128 a, float128 b, float_status *s)
1316 {
1317     return float128_compare_quiet(a, b, s) <= float_relation_equal;
1318 }
1319 
1320 static inline bool float128_lt_quiet(float128 a, float128 b, float_status *s)
1321 {
1322     return float128_compare_quiet(a, b, s) < float_relation_equal;
1323 }
1324 
1325 static inline bool float128_unordered_quiet(float128 a, float128 b,
1326                                            float_status *s)
1327 {
1328     return float128_compare_quiet(a, b, s) == float_relation_unordered;
1329 }
1330 
1331 #define float128_zero make_float128(0, 0)
1332 
1333 /*----------------------------------------------------------------------------
1334 | The pattern for a default generated quadruple-precision NaN.
1335 *----------------------------------------------------------------------------*/
1336 float128 float128_default_nan(float_status *status);
1337 
1338 #endif /* SOFTFLOAT_H */
1339