xref: /openbmc/qemu/include/fpu/softfloat.h (revision 00f9ef8f)
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 *----------------------------------------------------------------------------*/
float_raise(uint16_t flags,float_status * status)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 int128_to_float128(Int128, float_status *status);
187 float128 uint64_to_float128(uint64_t, float_status *status);
188 float128 uint128_to_float128(Int128, float_status *status);
189 
190 /*----------------------------------------------------------------------------
191 | Software half-precision conversion routines.
192 *----------------------------------------------------------------------------*/
193 
194 float16 float32_to_float16(float32, bool ieee, float_status *status);
195 float32 float16_to_float32(float16, bool ieee, float_status *status);
196 float16 float64_to_float16(float64 a, bool ieee, float_status *status);
197 float64 float16_to_float64(float16 a, bool ieee, float_status *status);
198 
199 int8_t  float16_to_int8_scalbn(float16, FloatRoundMode, int,
200                                float_status *status);
201 int16_t float16_to_int16_scalbn(float16, FloatRoundMode, int, float_status *);
202 int32_t float16_to_int32_scalbn(float16, FloatRoundMode, int, float_status *);
203 int64_t float16_to_int64_scalbn(float16, FloatRoundMode, int, float_status *);
204 
205 int8_t  float16_to_int8(float16, float_status *status);
206 int16_t float16_to_int16(float16, float_status *status);
207 int32_t float16_to_int32(float16, float_status *status);
208 int64_t float16_to_int64(float16, float_status *status);
209 
210 int16_t float16_to_int16_round_to_zero(float16, float_status *status);
211 int32_t float16_to_int32_round_to_zero(float16, float_status *status);
212 int64_t float16_to_int64_round_to_zero(float16, float_status *status);
213 
214 uint8_t float16_to_uint8_scalbn(float16 a, FloatRoundMode,
215                                 int, float_status *status);
216 uint16_t float16_to_uint16_scalbn(float16 a, FloatRoundMode,
217                                   int, float_status *status);
218 uint32_t float16_to_uint32_scalbn(float16 a, FloatRoundMode,
219                                   int, float_status *status);
220 uint64_t float16_to_uint64_scalbn(float16 a, FloatRoundMode,
221                                   int, float_status *status);
222 
223 uint8_t  float16_to_uint8(float16 a, float_status *status);
224 uint16_t float16_to_uint16(float16 a, float_status *status);
225 uint32_t float16_to_uint32(float16 a, float_status *status);
226 uint64_t float16_to_uint64(float16 a, float_status *status);
227 
228 uint16_t float16_to_uint16_round_to_zero(float16 a, float_status *status);
229 uint32_t float16_to_uint32_round_to_zero(float16 a, float_status *status);
230 uint64_t float16_to_uint64_round_to_zero(float16 a, float_status *status);
231 
232 /*----------------------------------------------------------------------------
233 | Software half-precision operations.
234 *----------------------------------------------------------------------------*/
235 
236 float16 float16_round_to_int(float16, float_status *status);
237 float16 float16_add(float16, float16, float_status *status);
238 float16 float16_sub(float16, float16, float_status *status);
239 float16 float16_mul(float16, float16, float_status *status);
240 float16 float16_muladd(float16, float16, float16, int, float_status *status);
241 float16 float16_div(float16, float16, float_status *status);
242 float16 float16_scalbn(float16, int, float_status *status);
243 float16 float16_min(float16, float16, float_status *status);
244 float16 float16_max(float16, float16, float_status *status);
245 float16 float16_minnum(float16, float16, float_status *status);
246 float16 float16_maxnum(float16, float16, float_status *status);
247 float16 float16_minnummag(float16, float16, float_status *status);
248 float16 float16_maxnummag(float16, float16, float_status *status);
249 float16 float16_minimum_number(float16, float16, float_status *status);
250 float16 float16_maximum_number(float16, float16, float_status *status);
251 float16 float16_sqrt(float16, float_status *status);
252 FloatRelation float16_compare(float16, float16, float_status *status);
253 FloatRelation float16_compare_quiet(float16, float16, float_status *status);
254 
255 bool float16_is_quiet_nan(float16, float_status *status);
256 bool float16_is_signaling_nan(float16, float_status *status);
257 float16 float16_silence_nan(float16, float_status *status);
258 
float16_is_any_nan(float16 a)259 static inline bool float16_is_any_nan(float16 a)
260 {
261     return ((float16_val(a) & ~0x8000) > 0x7c00);
262 }
263 
float16_is_neg(float16 a)264 static inline bool float16_is_neg(float16 a)
265 {
266     return float16_val(a) >> 15;
267 }
268 
float16_is_infinity(float16 a)269 static inline bool float16_is_infinity(float16 a)
270 {
271     return (float16_val(a) & 0x7fff) == 0x7c00;
272 }
273 
float16_is_zero(float16 a)274 static inline bool float16_is_zero(float16 a)
275 {
276     return (float16_val(a) & 0x7fff) == 0;
277 }
278 
float16_is_zero_or_denormal(float16 a)279 static inline bool float16_is_zero_or_denormal(float16 a)
280 {
281     return (float16_val(a) & 0x7c00) == 0;
282 }
283 
float16_is_normal(float16 a)284 static inline bool float16_is_normal(float16 a)
285 {
286     return (((float16_val(a) >> 10) + 1) & 0x1f) >= 2;
287 }
288 
float16_abs(float16 a)289 static 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 }
296 
float16_chs(float16 a)297 static 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 
float16_set_sign(float16 a,int sign)305 static inline float16 float16_set_sign(float16 a, int sign)
306 {
307     return make_float16((float16_val(a) & 0x7fff) | (sign << 15));
308 }
309 
float16_eq(float16 a,float16 b,float_status * s)310 static inline bool float16_eq(float16 a, float16 b, float_status *s)
311 {
312     return float16_compare(a, b, s) == float_relation_equal;
313 }
314 
float16_le(float16 a,float16 b,float_status * s)315 static inline bool float16_le(float16 a, float16 b, float_status *s)
316 {
317     return float16_compare(a, b, s) <= float_relation_equal;
318 }
319 
float16_lt(float16 a,float16 b,float_status * s)320 static inline bool float16_lt(float16 a, float16 b, float_status *s)
321 {
322     return float16_compare(a, b, s) < float_relation_equal;
323 }
324 
float16_unordered(float16 a,float16 b,float_status * s)325 static inline bool float16_unordered(float16 a, float16 b, float_status *s)
326 {
327     return float16_compare(a, b, s) == float_relation_unordered;
328 }
329 
float16_eq_quiet(float16 a,float16 b,float_status * s)330 static 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 
float16_le_quiet(float16 a,float16 b,float_status * s)335 static 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 
float16_lt_quiet(float16 a,float16 b,float_status * s)340 static 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 
float16_unordered_quiet(float16 a,float16 b,float_status * s)345 static 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 
351 #define float16_zero make_float16(0)
352 #define float16_half make_float16(0x3800)
353 #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)
357 #define float16_infinity make_float16(0x7c00)
358 
359 /*----------------------------------------------------------------------------
360 | Software bfloat16 conversion routines.
361 *----------------------------------------------------------------------------*/
362 
363 bfloat16 bfloat16_round_to_int(bfloat16, float_status *status);
364 bfloat16 float32_to_bfloat16(float32, float_status *status);
365 float32 bfloat16_to_float32(bfloat16, float_status *status);
366 bfloat16 float64_to_bfloat16(float64 a, float_status *status);
367 float64 bfloat16_to_float64(bfloat16 a, float_status *status);
368 
369 int8_t bfloat16_to_int8_scalbn(bfloat16, FloatRoundMode,
370                                int, float_status *status);
371 int16_t bfloat16_to_int16_scalbn(bfloat16, FloatRoundMode,
372                                  int, float_status *status);
373 int32_t bfloat16_to_int32_scalbn(bfloat16, FloatRoundMode,
374                                  int, float_status *status);
375 int64_t bfloat16_to_int64_scalbn(bfloat16, FloatRoundMode,
376                                  int, float_status *status);
377 
378 int8_t bfloat16_to_int8(bfloat16, float_status *status);
379 int16_t bfloat16_to_int16(bfloat16, float_status *status);
380 int32_t bfloat16_to_int32(bfloat16, float_status *status);
381 int64_t bfloat16_to_int64(bfloat16, float_status *status);
382 
383 int8_t bfloat16_to_int8_round_to_zero(bfloat16, float_status *status);
384 int16_t bfloat16_to_int16_round_to_zero(bfloat16, float_status *status);
385 int32_t bfloat16_to_int32_round_to_zero(bfloat16, float_status *status);
386 int64_t bfloat16_to_int64_round_to_zero(bfloat16, float_status *status);
387 
388 uint8_t bfloat16_to_uint8_scalbn(bfloat16 a, FloatRoundMode,
389                                  int, float_status *status);
390 uint16_t bfloat16_to_uint16_scalbn(bfloat16 a, FloatRoundMode,
391                                    int, float_status *status);
392 uint32_t bfloat16_to_uint32_scalbn(bfloat16 a, FloatRoundMode,
393                                    int, float_status *status);
394 uint64_t bfloat16_to_uint64_scalbn(bfloat16 a, FloatRoundMode,
395                                    int, float_status *status);
396 
397 uint8_t bfloat16_to_uint8(bfloat16 a, float_status *status);
398 uint16_t bfloat16_to_uint16(bfloat16 a, float_status *status);
399 uint32_t bfloat16_to_uint32(bfloat16 a, float_status *status);
400 uint64_t bfloat16_to_uint64(bfloat16 a, float_status *status);
401 
402 uint8_t bfloat16_to_uint8_round_to_zero(bfloat16 a, float_status *status);
403 uint16_t bfloat16_to_uint16_round_to_zero(bfloat16 a, float_status *status);
404 uint32_t bfloat16_to_uint32_round_to_zero(bfloat16 a, float_status *status);
405 uint64_t bfloat16_to_uint64_round_to_zero(bfloat16 a, float_status *status);
406 
407 bfloat16 int8_to_bfloat16_scalbn(int8_t a, int, float_status *status);
408 bfloat16 int16_to_bfloat16_scalbn(int16_t a, int, float_status *status);
409 bfloat16 int32_to_bfloat16_scalbn(int32_t a, int, float_status *status);
410 bfloat16 int64_to_bfloat16_scalbn(int64_t a, int, float_status *status);
411 bfloat16 uint8_to_bfloat16_scalbn(uint8_t a, int, float_status *status);
412 bfloat16 uint16_to_bfloat16_scalbn(uint16_t a, int, float_status *status);
413 bfloat16 uint32_to_bfloat16_scalbn(uint32_t a, int, float_status *status);
414 bfloat16 uint64_to_bfloat16_scalbn(uint64_t a, int, float_status *status);
415 
416 bfloat16 int8_to_bfloat16(int8_t a, float_status *status);
417 bfloat16 int16_to_bfloat16(int16_t a, float_status *status);
418 bfloat16 int32_to_bfloat16(int32_t a, float_status *status);
419 bfloat16 int64_to_bfloat16(int64_t a, float_status *status);
420 bfloat16 uint8_to_bfloat16(uint8_t a, float_status *status);
421 bfloat16 uint16_to_bfloat16(uint16_t a, float_status *status);
422 bfloat16 uint32_to_bfloat16(uint32_t a, float_status *status);
423 bfloat16 uint64_to_bfloat16(uint64_t a, float_status *status);
424 
425 /*----------------------------------------------------------------------------
426 | Software bfloat16 operations.
427 *----------------------------------------------------------------------------*/
428 
429 bfloat16 bfloat16_add(bfloat16, bfloat16, float_status *status);
430 bfloat16 bfloat16_sub(bfloat16, bfloat16, float_status *status);
431 bfloat16 bfloat16_mul(bfloat16, bfloat16, float_status *status);
432 bfloat16 bfloat16_div(bfloat16, bfloat16, float_status *status);
433 bfloat16 bfloat16_muladd(bfloat16, bfloat16, bfloat16, int,
434                          float_status *status);
435 float16 bfloat16_scalbn(bfloat16, int, float_status *status);
436 bfloat16 bfloat16_min(bfloat16, bfloat16, float_status *status);
437 bfloat16 bfloat16_max(bfloat16, bfloat16, float_status *status);
438 bfloat16 bfloat16_minnum(bfloat16, bfloat16, float_status *status);
439 bfloat16 bfloat16_maxnum(bfloat16, bfloat16, float_status *status);
440 bfloat16 bfloat16_minnummag(bfloat16, bfloat16, float_status *status);
441 bfloat16 bfloat16_maxnummag(bfloat16, bfloat16, float_status *status);
442 bfloat16 bfloat16_minimum_number(bfloat16, bfloat16, float_status *status);
443 bfloat16 bfloat16_maximum_number(bfloat16, bfloat16, float_status *status);
444 bfloat16 bfloat16_sqrt(bfloat16, float_status *status);
445 FloatRelation bfloat16_compare(bfloat16, bfloat16, float_status *status);
446 FloatRelation bfloat16_compare_quiet(bfloat16, bfloat16, float_status *status);
447 
448 bool bfloat16_is_quiet_nan(bfloat16, float_status *status);
449 bool bfloat16_is_signaling_nan(bfloat16, float_status *status);
450 bfloat16 bfloat16_silence_nan(bfloat16, float_status *status);
451 bfloat16 bfloat16_default_nan(float_status *status);
452 
bfloat16_is_any_nan(bfloat16 a)453 static inline bool bfloat16_is_any_nan(bfloat16 a)
454 {
455     return ((a & ~0x8000) > 0x7F80);
456 }
457 
bfloat16_is_neg(bfloat16 a)458 static inline bool bfloat16_is_neg(bfloat16 a)
459 {
460     return a >> 15;
461 }
462 
bfloat16_is_infinity(bfloat16 a)463 static inline bool bfloat16_is_infinity(bfloat16 a)
464 {
465     return (a & 0x7fff) == 0x7F80;
466 }
467 
bfloat16_is_zero(bfloat16 a)468 static inline bool bfloat16_is_zero(bfloat16 a)
469 {
470     return (a & 0x7fff) == 0;
471 }
472 
bfloat16_is_zero_or_denormal(bfloat16 a)473 static inline bool bfloat16_is_zero_or_denormal(bfloat16 a)
474 {
475     return (a & 0x7F80) == 0;
476 }
477 
bfloat16_is_normal(bfloat16 a)478 static inline bool bfloat16_is_normal(bfloat16 a)
479 {
480     return (((a >> 7) + 1) & 0xff) >= 2;
481 }
482 
bfloat16_abs(bfloat16 a)483 static inline bfloat16 bfloat16_abs(bfloat16 a)
484 {
485     /* Note that abs does *not* handle NaN specially, nor does
486      * it flush denormal inputs to zero.
487      */
488     return a & 0x7fff;
489 }
490 
bfloat16_chs(bfloat16 a)491 static inline bfloat16 bfloat16_chs(bfloat16 a)
492 {
493     /* Note that chs does *not* handle NaN specially, nor does
494      * it flush denormal inputs to zero.
495      */
496     return a ^ 0x8000;
497 }
498 
bfloat16_set_sign(bfloat16 a,int sign)499 static inline bfloat16 bfloat16_set_sign(bfloat16 a, int sign)
500 {
501     return (a & 0x7fff) | (sign << 15);
502 }
503 
bfloat16_eq(bfloat16 a,bfloat16 b,float_status * s)504 static inline bool bfloat16_eq(bfloat16 a, bfloat16 b, float_status *s)
505 {
506     return bfloat16_compare(a, b, s) == float_relation_equal;
507 }
508 
bfloat16_le(bfloat16 a,bfloat16 b,float_status * s)509 static inline bool bfloat16_le(bfloat16 a, bfloat16 b, float_status *s)
510 {
511     return bfloat16_compare(a, b, s) <= float_relation_equal;
512 }
513 
bfloat16_lt(bfloat16 a,bfloat16 b,float_status * s)514 static inline bool bfloat16_lt(bfloat16 a, bfloat16 b, float_status *s)
515 {
516     return bfloat16_compare(a, b, s) < float_relation_equal;
517 }
518 
bfloat16_unordered(bfloat16 a,bfloat16 b,float_status * s)519 static inline bool bfloat16_unordered(bfloat16 a, bfloat16 b, float_status *s)
520 {
521     return bfloat16_compare(a, b, s) == float_relation_unordered;
522 }
523 
bfloat16_eq_quiet(bfloat16 a,bfloat16 b,float_status * s)524 static inline bool bfloat16_eq_quiet(bfloat16 a, bfloat16 b, float_status *s)
525 {
526     return bfloat16_compare_quiet(a, b, s) == float_relation_equal;
527 }
528 
bfloat16_le_quiet(bfloat16 a,bfloat16 b,float_status * s)529 static inline bool bfloat16_le_quiet(bfloat16 a, bfloat16 b, float_status *s)
530 {
531     return bfloat16_compare_quiet(a, b, s) <= float_relation_equal;
532 }
533 
bfloat16_lt_quiet(bfloat16 a,bfloat16 b,float_status * s)534 static inline bool bfloat16_lt_quiet(bfloat16 a, bfloat16 b, float_status *s)
535 {
536     return bfloat16_compare_quiet(a, b, s) < float_relation_equal;
537 }
538 
bfloat16_unordered_quiet(bfloat16 a,bfloat16 b,float_status * s)539 static inline bool bfloat16_unordered_quiet(bfloat16 a, bfloat16 b,
540                                            float_status *s)
541 {
542     return bfloat16_compare_quiet(a, b, s) == float_relation_unordered;
543 }
544 
545 #define bfloat16_zero 0
546 #define bfloat16_half 0x3f00
547 #define bfloat16_one 0x3f80
548 #define bfloat16_one_point_five 0x3fc0
549 #define bfloat16_two 0x4000
550 #define bfloat16_three 0x4040
551 #define bfloat16_infinity 0x7f80
552 
553 /*----------------------------------------------------------------------------
554 | The pattern for a default generated half-precision NaN.
555 *----------------------------------------------------------------------------*/
556 float16 float16_default_nan(float_status *status);
557 
558 /*----------------------------------------------------------------------------
559 | Software IEC/IEEE single-precision conversion routines.
560 *----------------------------------------------------------------------------*/
561 
562 int16_t float32_to_int16_scalbn(float32, FloatRoundMode, int, float_status *);
563 int32_t float32_to_int32_scalbn(float32, FloatRoundMode, int, float_status *);
564 int64_t float32_to_int64_scalbn(float32, FloatRoundMode, int, float_status *);
565 
566 int16_t float32_to_int16(float32, float_status *status);
567 int32_t float32_to_int32(float32, float_status *status);
568 int64_t float32_to_int64(float32, float_status *status);
569 
570 int16_t float32_to_int16_round_to_zero(float32, float_status *status);
571 int32_t float32_to_int32_round_to_zero(float32, float_status *status);
572 int64_t float32_to_int64_round_to_zero(float32, float_status *status);
573 
574 uint16_t float32_to_uint16_scalbn(float32, FloatRoundMode, int, float_status *);
575 uint32_t float32_to_uint32_scalbn(float32, FloatRoundMode, int, float_status *);
576 uint64_t float32_to_uint64_scalbn(float32, FloatRoundMode, int, float_status *);
577 
578 uint16_t float32_to_uint16(float32, float_status *status);
579 uint32_t float32_to_uint32(float32, float_status *status);
580 uint64_t float32_to_uint64(float32, float_status *status);
581 
582 uint16_t float32_to_uint16_round_to_zero(float32, float_status *status);
583 uint32_t float32_to_uint32_round_to_zero(float32, float_status *status);
584 uint64_t float32_to_uint64_round_to_zero(float32, float_status *status);
585 
586 float64 float32_to_float64(float32, float_status *status);
587 floatx80 float32_to_floatx80(float32, float_status *status);
588 float128 float32_to_float128(float32, float_status *status);
589 
590 /*----------------------------------------------------------------------------
591 | Software IEC/IEEE single-precision operations.
592 *----------------------------------------------------------------------------*/
593 float32 float32_round_to_int(float32, float_status *status);
594 float32 float32_add(float32, float32, float_status *status);
595 float32 float32_sub(float32, float32, float_status *status);
596 float32 float32_mul(float32, float32, float_status *status);
597 float32 float32_div(float32, float32, float_status *status);
598 float32 float32_rem(float32, float32, float_status *status);
599 float32 float32_muladd(float32, float32, float32, int, float_status *status);
600 float32 float32_sqrt(float32, float_status *status);
601 float32 float32_exp2(float32, float_status *status);
602 float32 float32_log2(float32, float_status *status);
603 FloatRelation float32_compare(float32, float32, float_status *status);
604 FloatRelation float32_compare_quiet(float32, float32, float_status *status);
605 float32 float32_min(float32, float32, float_status *status);
606 float32 float32_max(float32, float32, float_status *status);
607 float32 float32_minnum(float32, float32, float_status *status);
608 float32 float32_maxnum(float32, float32, float_status *status);
609 float32 float32_minnummag(float32, float32, float_status *status);
610 float32 float32_maxnummag(float32, float32, float_status *status);
611 float32 float32_minimum_number(float32, float32, float_status *status);
612 float32 float32_maximum_number(float32, float32, float_status *status);
613 bool float32_is_quiet_nan(float32, float_status *status);
614 bool float32_is_signaling_nan(float32, float_status *status);
615 float32 float32_silence_nan(float32, float_status *status);
616 float32 float32_scalbn(float32, int, float_status *status);
617 
float32_abs(float32 a)618 static inline float32 float32_abs(float32 a)
619 {
620     /* Note that abs does *not* handle NaN specially, nor does
621      * it flush denormal inputs to zero.
622      */
623     return make_float32(float32_val(a) & 0x7fffffff);
624 }
625 
float32_chs(float32 a)626 static inline float32 float32_chs(float32 a)
627 {
628     /* Note that chs does *not* handle NaN specially, nor does
629      * it flush denormal inputs to zero.
630      */
631     return make_float32(float32_val(a) ^ 0x80000000);
632 }
633 
float32_is_infinity(float32 a)634 static inline bool float32_is_infinity(float32 a)
635 {
636     return (float32_val(a) & 0x7fffffff) == 0x7f800000;
637 }
638 
float32_is_neg(float32 a)639 static inline bool float32_is_neg(float32 a)
640 {
641     return float32_val(a) >> 31;
642 }
643 
float32_is_zero(float32 a)644 static inline bool float32_is_zero(float32 a)
645 {
646     return (float32_val(a) & 0x7fffffff) == 0;
647 }
648 
float32_is_any_nan(float32 a)649 static inline bool float32_is_any_nan(float32 a)
650 {
651     return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL);
652 }
653 
float32_is_zero_or_denormal(float32 a)654 static inline bool float32_is_zero_or_denormal(float32 a)
655 {
656     return (float32_val(a) & 0x7f800000) == 0;
657 }
658 
float32_is_normal(float32 a)659 static inline bool float32_is_normal(float32 a)
660 {
661     return (((float32_val(a) >> 23) + 1) & 0xff) >= 2;
662 }
663 
float32_is_denormal(float32 a)664 static inline bool float32_is_denormal(float32 a)
665 {
666     return float32_is_zero_or_denormal(a) && !float32_is_zero(a);
667 }
668 
float32_is_zero_or_normal(float32 a)669 static inline bool float32_is_zero_or_normal(float32 a)
670 {
671     return float32_is_normal(a) || float32_is_zero(a);
672 }
673 
float32_set_sign(float32 a,int sign)674 static inline float32 float32_set_sign(float32 a, int sign)
675 {
676     return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31));
677 }
678 
float32_eq(float32 a,float32 b,float_status * s)679 static inline bool float32_eq(float32 a, float32 b, float_status *s)
680 {
681     return float32_compare(a, b, s) == float_relation_equal;
682 }
683 
float32_le(float32 a,float32 b,float_status * s)684 static inline bool float32_le(float32 a, float32 b, float_status *s)
685 {
686     return float32_compare(a, b, s) <= float_relation_equal;
687 }
688 
float32_lt(float32 a,float32 b,float_status * s)689 static inline bool float32_lt(float32 a, float32 b, float_status *s)
690 {
691     return float32_compare(a, b, s) < float_relation_equal;
692 }
693 
float32_unordered(float32 a,float32 b,float_status * s)694 static inline bool float32_unordered(float32 a, float32 b, float_status *s)
695 {
696     return float32_compare(a, b, s) == float_relation_unordered;
697 }
698 
float32_eq_quiet(float32 a,float32 b,float_status * s)699 static inline bool float32_eq_quiet(float32 a, float32 b, float_status *s)
700 {
701     return float32_compare_quiet(a, b, s) == float_relation_equal;
702 }
703 
float32_le_quiet(float32 a,float32 b,float_status * s)704 static inline bool float32_le_quiet(float32 a, float32 b, float_status *s)
705 {
706     return float32_compare_quiet(a, b, s) <= float_relation_equal;
707 }
708 
float32_lt_quiet(float32 a,float32 b,float_status * s)709 static inline bool float32_lt_quiet(float32 a, float32 b, float_status *s)
710 {
711     return float32_compare_quiet(a, b, s) < float_relation_equal;
712 }
713 
float32_unordered_quiet(float32 a,float32 b,float_status * s)714 static inline bool float32_unordered_quiet(float32 a, float32 b,
715                                            float_status *s)
716 {
717     return float32_compare_quiet(a, b, s) == float_relation_unordered;
718 }
719 
720 #define float32_zero make_float32(0)
721 #define float32_half make_float32(0x3f000000)
722 #define float32_one make_float32(0x3f800000)
723 #define float32_one_point_five make_float32(0x3fc00000)
724 #define float32_two make_float32(0x40000000)
725 #define float32_three make_float32(0x40400000)
726 #define float32_infinity make_float32(0x7f800000)
727 
728 /*----------------------------------------------------------------------------
729 | Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
730 | single-precision floating-point value, returning the result.  After being
731 | shifted into the proper positions, the three fields are simply added
732 | together to form the result.  This means that any integer portion of `zSig'
733 | will be added into the exponent.  Since a properly normalized significand
734 | will have an integer portion equal to 1, the `zExp' input should be 1 less
735 | than the desired result exponent whenever `zSig' is a complete, normalized
736 | significand.
737 *----------------------------------------------------------------------------*/
738 
packFloat32(bool zSign,int zExp,uint32_t zSig)739 static inline float32 packFloat32(bool zSign, int zExp, uint32_t zSig)
740 {
741     return make_float32(
742           (((uint32_t)zSign) << 31) + (((uint32_t)zExp) << 23) + zSig);
743 }
744 
745 /*----------------------------------------------------------------------------
746 | The pattern for a default generated single-precision NaN.
747 *----------------------------------------------------------------------------*/
748 float32 float32_default_nan(float_status *status);
749 
750 /*----------------------------------------------------------------------------
751 | Software IEC/IEEE double-precision conversion routines.
752 *----------------------------------------------------------------------------*/
753 
754 int16_t float64_to_int16_scalbn(float64, FloatRoundMode, int, float_status *);
755 int32_t float64_to_int32_scalbn(float64, FloatRoundMode, int, float_status *);
756 int64_t float64_to_int64_scalbn(float64, FloatRoundMode, int, float_status *);
757 
758 int16_t float64_to_int16(float64, float_status *status);
759 int32_t float64_to_int32(float64, float_status *status);
760 int64_t float64_to_int64(float64, float_status *status);
761 
762 int16_t float64_to_int16_round_to_zero(float64, float_status *status);
763 int32_t float64_to_int32_round_to_zero(float64, float_status *status);
764 int64_t float64_to_int64_round_to_zero(float64, float_status *status);
765 
766 int32_t float64_to_int32_modulo(float64, FloatRoundMode, float_status *status);
767 int64_t float64_to_int64_modulo(float64, FloatRoundMode, float_status *status);
768 
769 uint16_t float64_to_uint16_scalbn(float64, FloatRoundMode, int, float_status *);
770 uint32_t float64_to_uint32_scalbn(float64, FloatRoundMode, int, float_status *);
771 uint64_t float64_to_uint64_scalbn(float64, FloatRoundMode, int, float_status *);
772 
773 uint16_t float64_to_uint16(float64, float_status *status);
774 uint32_t float64_to_uint32(float64, float_status *status);
775 uint64_t float64_to_uint64(float64, float_status *status);
776 
777 uint16_t float64_to_uint16_round_to_zero(float64, float_status *status);
778 uint32_t float64_to_uint32_round_to_zero(float64, float_status *status);
779 uint64_t float64_to_uint64_round_to_zero(float64, float_status *status);
780 
781 float32 float64_to_float32(float64, float_status *status);
782 floatx80 float64_to_floatx80(float64, float_status *status);
783 float128 float64_to_float128(float64, float_status *status);
784 
785 /*----------------------------------------------------------------------------
786 | Software IEC/IEEE double-precision operations.
787 *----------------------------------------------------------------------------*/
788 float64 float64_round_to_int(float64, float_status *status);
789 float64 float64_add(float64, float64, float_status *status);
790 float64 float64_sub(float64, float64, float_status *status);
791 float64 float64_mul(float64, float64, float_status *status);
792 float64 float64_div(float64, float64, float_status *status);
793 float64 float64_rem(float64, float64, float_status *status);
794 float64 float64_muladd(float64, float64, float64, int, float_status *status);
795 float64 float64_sqrt(float64, float_status *status);
796 float64 float64_log2(float64, float_status *status);
797 FloatRelation float64_compare(float64, float64, float_status *status);
798 FloatRelation float64_compare_quiet(float64, float64, float_status *status);
799 float64 float64_min(float64, float64, float_status *status);
800 float64 float64_max(float64, float64, float_status *status);
801 float64 float64_minnum(float64, float64, float_status *status);
802 float64 float64_maxnum(float64, float64, float_status *status);
803 float64 float64_minnummag(float64, float64, float_status *status);
804 float64 float64_maxnummag(float64, float64, float_status *status);
805 float64 float64_minimum_number(float64, float64, float_status *status);
806 float64 float64_maximum_number(float64, float64, float_status *status);
807 bool float64_is_quiet_nan(float64 a, float_status *status);
808 bool float64_is_signaling_nan(float64, float_status *status);
809 float64 float64_silence_nan(float64, float_status *status);
810 float64 float64_scalbn(float64, int, float_status *status);
811 
float64_abs(float64 a)812 static inline float64 float64_abs(float64 a)
813 {
814     /* Note that abs does *not* handle NaN specially, nor does
815      * it flush denormal inputs to zero.
816      */
817     return make_float64(float64_val(a) & 0x7fffffffffffffffLL);
818 }
819 
float64_chs(float64 a)820 static inline float64 float64_chs(float64 a)
821 {
822     /* Note that chs does *not* handle NaN specially, nor does
823      * it flush denormal inputs to zero.
824      */
825     return make_float64(float64_val(a) ^ 0x8000000000000000LL);
826 }
827 
float64_is_infinity(float64 a)828 static inline bool float64_is_infinity(float64 a)
829 {
830     return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL;
831 }
832 
float64_is_neg(float64 a)833 static inline bool float64_is_neg(float64 a)
834 {
835     return float64_val(a) >> 63;
836 }
837 
float64_is_zero(float64 a)838 static inline bool float64_is_zero(float64 a)
839 {
840     return (float64_val(a) & 0x7fffffffffffffffLL) == 0;
841 }
842 
float64_is_any_nan(float64 a)843 static inline bool float64_is_any_nan(float64 a)
844 {
845     return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL);
846 }
847 
float64_is_zero_or_denormal(float64 a)848 static inline bool float64_is_zero_or_denormal(float64 a)
849 {
850     return (float64_val(a) & 0x7ff0000000000000LL) == 0;
851 }
852 
float64_is_normal(float64 a)853 static inline bool float64_is_normal(float64 a)
854 {
855     return (((float64_val(a) >> 52) + 1) & 0x7ff) >= 2;
856 }
857 
float64_is_denormal(float64 a)858 static inline bool float64_is_denormal(float64 a)
859 {
860     return float64_is_zero_or_denormal(a) && !float64_is_zero(a);
861 }
862 
float64_is_zero_or_normal(float64 a)863 static inline bool float64_is_zero_or_normal(float64 a)
864 {
865     return float64_is_normal(a) || float64_is_zero(a);
866 }
867 
float64_set_sign(float64 a,int sign)868 static inline float64 float64_set_sign(float64 a, int sign)
869 {
870     return make_float64((float64_val(a) & 0x7fffffffffffffffULL)
871                         | ((int64_t)sign << 63));
872 }
873 
float64_eq(float64 a,float64 b,float_status * s)874 static inline bool float64_eq(float64 a, float64 b, float_status *s)
875 {
876     return float64_compare(a, b, s) == float_relation_equal;
877 }
878 
float64_le(float64 a,float64 b,float_status * s)879 static inline bool float64_le(float64 a, float64 b, float_status *s)
880 {
881     return float64_compare(a, b, s) <= float_relation_equal;
882 }
883 
float64_lt(float64 a,float64 b,float_status * s)884 static inline bool float64_lt(float64 a, float64 b, float_status *s)
885 {
886     return float64_compare(a, b, s) < float_relation_equal;
887 }
888 
float64_unordered(float64 a,float64 b,float_status * s)889 static inline bool float64_unordered(float64 a, float64 b, float_status *s)
890 {
891     return float64_compare(a, b, s) == float_relation_unordered;
892 }
893 
float64_eq_quiet(float64 a,float64 b,float_status * s)894 static inline bool float64_eq_quiet(float64 a, float64 b, float_status *s)
895 {
896     return float64_compare_quiet(a, b, s) == float_relation_equal;
897 }
898 
float64_le_quiet(float64 a,float64 b,float_status * s)899 static inline bool float64_le_quiet(float64 a, float64 b, float_status *s)
900 {
901     return float64_compare_quiet(a, b, s) <= float_relation_equal;
902 }
903 
float64_lt_quiet(float64 a,float64 b,float_status * s)904 static inline bool float64_lt_quiet(float64 a, float64 b, float_status *s)
905 {
906     return float64_compare_quiet(a, b, s) < float_relation_equal;
907 }
908 
float64_unordered_quiet(float64 a,float64 b,float_status * s)909 static inline bool float64_unordered_quiet(float64 a, float64 b,
910                                            float_status *s)
911 {
912     return float64_compare_quiet(a, b, s) == float_relation_unordered;
913 }
914 
915 #define float64_zero make_float64(0)
916 #define float64_half make_float64(0x3fe0000000000000LL)
917 #define float64_one make_float64(0x3ff0000000000000LL)
918 #define float64_one_point_five make_float64(0x3FF8000000000000ULL)
919 #define float64_two make_float64(0x4000000000000000ULL)
920 #define float64_three make_float64(0x4008000000000000ULL)
921 #define float64_ln2 make_float64(0x3fe62e42fefa39efLL)
922 #define float64_infinity make_float64(0x7ff0000000000000LL)
923 
924 /*----------------------------------------------------------------------------
925 | The pattern for a default generated double-precision NaN.
926 *----------------------------------------------------------------------------*/
927 float64 float64_default_nan(float_status *status);
928 
929 /*----------------------------------------------------------------------------
930 | Software IEC/IEEE double-precision operations, rounding to single precision,
931 | returning a result in double precision, with only one rounding step.
932 *----------------------------------------------------------------------------*/
933 
934 float64 float64r32_add(float64, float64, float_status *status);
935 float64 float64r32_sub(float64, float64, float_status *status);
936 float64 float64r32_mul(float64, float64, float_status *status);
937 float64 float64r32_div(float64, float64, float_status *status);
938 float64 float64r32_muladd(float64, float64, float64, int, float_status *status);
939 float64 float64r32_sqrt(float64, float_status *status);
940 
941 /*----------------------------------------------------------------------------
942 | Software IEC/IEEE extended double-precision conversion routines.
943 *----------------------------------------------------------------------------*/
944 int32_t floatx80_to_int32(floatx80, float_status *status);
945 int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status);
946 int64_t floatx80_to_int64(floatx80, float_status *status);
947 int64_t floatx80_to_int64_round_to_zero(floatx80, float_status *status);
948 float32 floatx80_to_float32(floatx80, float_status *status);
949 float64 floatx80_to_float64(floatx80, float_status *status);
950 float128 floatx80_to_float128(floatx80, float_status *status);
951 
952 /*----------------------------------------------------------------------------
953 | The pattern for an extended double-precision inf.
954 *----------------------------------------------------------------------------*/
955 extern const floatx80 floatx80_infinity;
956 
957 /*----------------------------------------------------------------------------
958 | Software IEC/IEEE extended double-precision operations.
959 *----------------------------------------------------------------------------*/
960 floatx80 floatx80_round(floatx80 a, float_status *status);
961 floatx80 floatx80_round_to_int(floatx80, float_status *status);
962 floatx80 floatx80_add(floatx80, floatx80, float_status *status);
963 floatx80 floatx80_sub(floatx80, floatx80, float_status *status);
964 floatx80 floatx80_mul(floatx80, floatx80, float_status *status);
965 floatx80 floatx80_div(floatx80, floatx80, float_status *status);
966 floatx80 floatx80_modrem(floatx80, floatx80, bool, uint64_t *,
967                          float_status *status);
968 floatx80 floatx80_mod(floatx80, floatx80, float_status *status);
969 floatx80 floatx80_rem(floatx80, floatx80, float_status *status);
970 floatx80 floatx80_sqrt(floatx80, float_status *status);
971 FloatRelation floatx80_compare(floatx80, floatx80, float_status *status);
972 FloatRelation floatx80_compare_quiet(floatx80, floatx80, float_status *status);
973 int floatx80_is_quiet_nan(floatx80, float_status *status);
974 int floatx80_is_signaling_nan(floatx80, float_status *status);
975 floatx80 floatx80_silence_nan(floatx80, float_status *status);
976 floatx80 floatx80_scalbn(floatx80, int, float_status *status);
977 
floatx80_abs(floatx80 a)978 static inline floatx80 floatx80_abs(floatx80 a)
979 {
980     a.high &= 0x7fff;
981     return a;
982 }
983 
floatx80_chs(floatx80 a)984 static inline floatx80 floatx80_chs(floatx80 a)
985 {
986     a.high ^= 0x8000;
987     return a;
988 }
989 
floatx80_is_infinity(floatx80 a)990 static inline bool floatx80_is_infinity(floatx80 a)
991 {
992 #if defined(TARGET_M68K)
993     return (a.high & 0x7fff) == floatx80_infinity.high && !(a.low << 1);
994 #else
995     return (a.high & 0x7fff) == floatx80_infinity.high &&
996                        a.low == floatx80_infinity.low;
997 #endif
998 }
999 
floatx80_is_neg(floatx80 a)1000 static inline bool floatx80_is_neg(floatx80 a)
1001 {
1002     return a.high >> 15;
1003 }
1004 
floatx80_is_zero(floatx80 a)1005 static inline bool floatx80_is_zero(floatx80 a)
1006 {
1007     return (a.high & 0x7fff) == 0 && a.low == 0;
1008 }
1009 
floatx80_is_zero_or_denormal(floatx80 a)1010 static inline bool floatx80_is_zero_or_denormal(floatx80 a)
1011 {
1012     return (a.high & 0x7fff) == 0;
1013 }
1014 
floatx80_is_any_nan(floatx80 a)1015 static inline bool floatx80_is_any_nan(floatx80 a)
1016 {
1017     return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1);
1018 }
1019 
floatx80_eq(floatx80 a,floatx80 b,float_status * s)1020 static inline bool floatx80_eq(floatx80 a, floatx80 b, float_status *s)
1021 {
1022     return floatx80_compare(a, b, s) == float_relation_equal;
1023 }
1024 
floatx80_le(floatx80 a,floatx80 b,float_status * s)1025 static inline bool floatx80_le(floatx80 a, floatx80 b, float_status *s)
1026 {
1027     return floatx80_compare(a, b, s) <= float_relation_equal;
1028 }
1029 
floatx80_lt(floatx80 a,floatx80 b,float_status * s)1030 static inline bool floatx80_lt(floatx80 a, floatx80 b, float_status *s)
1031 {
1032     return floatx80_compare(a, b, s) < float_relation_equal;
1033 }
1034 
floatx80_unordered(floatx80 a,floatx80 b,float_status * s)1035 static inline bool floatx80_unordered(floatx80 a, floatx80 b, float_status *s)
1036 {
1037     return floatx80_compare(a, b, s) == float_relation_unordered;
1038 }
1039 
floatx80_eq_quiet(floatx80 a,floatx80 b,float_status * s)1040 static inline bool floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *s)
1041 {
1042     return floatx80_compare_quiet(a, b, s) == float_relation_equal;
1043 }
1044 
floatx80_le_quiet(floatx80 a,floatx80 b,float_status * s)1045 static inline bool floatx80_le_quiet(floatx80 a, floatx80 b, float_status *s)
1046 {
1047     return floatx80_compare_quiet(a, b, s) <= float_relation_equal;
1048 }
1049 
floatx80_lt_quiet(floatx80 a,floatx80 b,float_status * s)1050 static inline bool floatx80_lt_quiet(floatx80 a, floatx80 b, float_status *s)
1051 {
1052     return floatx80_compare_quiet(a, b, s) < float_relation_equal;
1053 }
1054 
floatx80_unordered_quiet(floatx80 a,floatx80 b,float_status * s)1055 static inline bool floatx80_unordered_quiet(floatx80 a, floatx80 b,
1056                                            float_status *s)
1057 {
1058     return floatx80_compare_quiet(a, b, s) == float_relation_unordered;
1059 }
1060 
1061 /*----------------------------------------------------------------------------
1062 | Return whether the given value is an invalid floatx80 encoding.
1063 | Invalid floatx80 encodings arise when the integer bit is not set, but
1064 | the exponent is not zero. The only times the integer bit is permitted to
1065 | be zero is in subnormal numbers and the value zero.
1066 | This includes what the Intel software developer's manual calls pseudo-NaNs,
1067 | pseudo-infinities and un-normal numbers. It does not include
1068 | pseudo-denormals, which must still be correctly handled as inputs even
1069 | if they are never generated as outputs.
1070 *----------------------------------------------------------------------------*/
floatx80_invalid_encoding(floatx80 a)1071 static inline bool floatx80_invalid_encoding(floatx80 a)
1072 {
1073 #if defined(TARGET_M68K)
1074     /*-------------------------------------------------------------------------
1075     | With m68k, the explicit integer bit can be zero in the case of:
1076     | - zeros                (exp == 0, mantissa == 0)
1077     | - denormalized numbers (exp == 0, mantissa != 0)
1078     | - unnormalized numbers (exp != 0, exp < 0x7FFF)
1079     | - infinities           (exp == 0x7FFF, mantissa == 0)
1080     | - not-a-numbers        (exp == 0x7FFF, mantissa != 0)
1081     |
1082     | For infinities and NaNs, the explicit integer bit can be either one or
1083     | zero.
1084     |
1085     | The IEEE 754 standard does not define a zero integer bit. Such a number
1086     | is an unnormalized number. Hardware does not directly support
1087     | denormalized and unnormalized numbers, but implicitly supports them by
1088     | trapping them as unimplemented data types, allowing efficient conversion
1089     | in software.
1090     |
1091     | See "M68000 FAMILY PROGRAMMER’S REFERENCE MANUAL",
1092     |     "1.6 FLOATING-POINT DATA TYPES"
1093     *------------------------------------------------------------------------*/
1094     return false;
1095 #else
1096     return (a.low & (1ULL << 63)) == 0 && (a.high & 0x7FFF) != 0;
1097 #endif
1098 }
1099 
1100 #define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL)
1101 #define floatx80_zero_init make_floatx80_init(0x0000, 0x0000000000000000LL)
1102 #define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL)
1103 #define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL)
1104 #define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL)
1105 #define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL)
1106 
1107 /*----------------------------------------------------------------------------
1108 | Returns the fraction bits of the extended double-precision floating-point
1109 | value `a'.
1110 *----------------------------------------------------------------------------*/
1111 
extractFloatx80Frac(floatx80 a)1112 static inline uint64_t extractFloatx80Frac(floatx80 a)
1113 {
1114     return a.low;
1115 }
1116 
1117 /*----------------------------------------------------------------------------
1118 | Returns the exponent bits of the extended double-precision floating-point
1119 | value `a'.
1120 *----------------------------------------------------------------------------*/
1121 
extractFloatx80Exp(floatx80 a)1122 static inline int32_t extractFloatx80Exp(floatx80 a)
1123 {
1124     return a.high & 0x7FFF;
1125 }
1126 
1127 /*----------------------------------------------------------------------------
1128 | Returns the sign bit of the extended double-precision floating-point value
1129 | `a'.
1130 *----------------------------------------------------------------------------*/
1131 
extractFloatx80Sign(floatx80 a)1132 static inline bool extractFloatx80Sign(floatx80 a)
1133 {
1134     return a.high >> 15;
1135 }
1136 
1137 /*----------------------------------------------------------------------------
1138 | Packs the sign `zSign', exponent `zExp', and significand `zSig' into an
1139 | extended double-precision floating-point value, returning the result.
1140 *----------------------------------------------------------------------------*/
1141 
packFloatx80(bool zSign,int32_t zExp,uint64_t zSig)1142 static inline floatx80 packFloatx80(bool zSign, int32_t zExp, uint64_t zSig)
1143 {
1144     floatx80 z;
1145 
1146     z.low = zSig;
1147     z.high = (((uint16_t)zSign) << 15) + zExp;
1148     return z;
1149 }
1150 
1151 /*----------------------------------------------------------------------------
1152 | Normalizes the subnormal extended double-precision floating-point value
1153 | represented by the denormalized significand `aSig'.  The normalized exponent
1154 | and significand are stored at the locations pointed to by `zExpPtr' and
1155 | `zSigPtr', respectively.
1156 *----------------------------------------------------------------------------*/
1157 
1158 void normalizeFloatx80Subnormal(uint64_t aSig, int32_t *zExpPtr,
1159                                 uint64_t *zSigPtr);
1160 
1161 /*----------------------------------------------------------------------------
1162 | Takes two extended double-precision floating-point values `a' and `b', one
1163 | of which is a NaN, and returns the appropriate NaN result.  If either `a' or
1164 | `b' is a signaling NaN, the invalid exception is raised.
1165 *----------------------------------------------------------------------------*/
1166 
1167 floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b, float_status *status);
1168 
1169 /*----------------------------------------------------------------------------
1170 | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
1171 | and extended significand formed by the concatenation of `zSig0' and `zSig1',
1172 | and returns the proper extended double-precision floating-point value
1173 | corresponding to the abstract input.  Ordinarily, the abstract value is
1174 | rounded and packed into the extended double-precision format, with the
1175 | inexact exception raised if the abstract input cannot be represented
1176 | exactly.  However, if the abstract value is too large, the overflow and
1177 | inexact exceptions are raised and an infinity or maximal finite value is
1178 | returned.  If the abstract value is too small, the input value is rounded to
1179 | a subnormal number, and the underflow and inexact exceptions are raised if
1180 | the abstract input cannot be represented exactly as a subnormal extended
1181 | double-precision floating-point number.
1182 |     If `roundingPrecision' is 32 or 64, the result is rounded to the same
1183 | number of bits as single or double precision, respectively.  Otherwise, the
1184 | result is rounded to the full precision of the extended double-precision
1185 | format.
1186 |     The input significand must be normalized or smaller.  If the input
1187 | significand is not normalized, `zExp' must be 0; in that case, the result
1188 | returned is a subnormal number, and it must not require rounding.  The
1189 | handling of underflow and overflow follows the IEC/IEEE Standard for Binary
1190 | Floating-Point Arithmetic.
1191 *----------------------------------------------------------------------------*/
1192 
1193 floatx80 roundAndPackFloatx80(FloatX80RoundPrec roundingPrecision, bool zSign,
1194                               int32_t zExp, uint64_t zSig0, uint64_t zSig1,
1195                               float_status *status);
1196 
1197 /*----------------------------------------------------------------------------
1198 | Takes an abstract floating-point value having sign `zSign', exponent
1199 | `zExp', and significand formed by the concatenation of `zSig0' and `zSig1',
1200 | and returns the proper extended double-precision floating-point value
1201 | corresponding to the abstract input.  This routine is just like
1202 | `roundAndPackFloatx80' except that the input significand does not have to be
1203 | normalized.
1204 *----------------------------------------------------------------------------*/
1205 
1206 floatx80 normalizeRoundAndPackFloatx80(FloatX80RoundPrec roundingPrecision,
1207                                        bool zSign, int32_t zExp,
1208                                        uint64_t zSig0, uint64_t zSig1,
1209                                        float_status *status);
1210 
1211 /*----------------------------------------------------------------------------
1212 | The pattern for a default generated extended double-precision NaN.
1213 *----------------------------------------------------------------------------*/
1214 floatx80 floatx80_default_nan(float_status *status);
1215 
1216 /*----------------------------------------------------------------------------
1217 | Software IEC/IEEE quadruple-precision conversion routines.
1218 *----------------------------------------------------------------------------*/
1219 int32_t float128_to_int32(float128, float_status *status);
1220 int32_t float128_to_int32_round_to_zero(float128, float_status *status);
1221 int64_t float128_to_int64(float128, float_status *status);
1222 Int128 float128_to_int128(float128, float_status *status);
1223 int64_t float128_to_int64_round_to_zero(float128, float_status *status);
1224 Int128 float128_to_int128_round_to_zero(float128, float_status *status);
1225 uint64_t float128_to_uint64(float128, float_status *status);
1226 Int128 float128_to_uint128(float128, float_status *status);
1227 uint64_t float128_to_uint64_round_to_zero(float128, float_status *status);
1228 Int128 float128_to_uint128_round_to_zero(float128, float_status *status);
1229 uint32_t float128_to_uint32(float128, float_status *status);
1230 uint32_t float128_to_uint32_round_to_zero(float128, float_status *status);
1231 float32 float128_to_float32(float128, float_status *status);
1232 float64 float128_to_float64(float128, float_status *status);
1233 floatx80 float128_to_floatx80(float128, float_status *status);
1234 
1235 /*----------------------------------------------------------------------------
1236 | Software IEC/IEEE quadruple-precision operations.
1237 *----------------------------------------------------------------------------*/
1238 float128 float128_round_to_int(float128, float_status *status);
1239 float128 float128_add(float128, float128, float_status *status);
1240 float128 float128_sub(float128, float128, float_status *status);
1241 float128 float128_mul(float128, float128, float_status *status);
1242 float128 float128_muladd(float128, float128, float128, int,
1243                          float_status *status);
1244 float128 float128_div(float128, float128, float_status *status);
1245 float128 float128_rem(float128, float128, float_status *status);
1246 float128 float128_sqrt(float128, float_status *status);
1247 FloatRelation float128_compare(float128, float128, float_status *status);
1248 FloatRelation float128_compare_quiet(float128, float128, float_status *status);
1249 float128 float128_min(float128, float128, float_status *status);
1250 float128 float128_max(float128, float128, float_status *status);
1251 float128 float128_minnum(float128, float128, float_status *status);
1252 float128 float128_maxnum(float128, float128, float_status *status);
1253 float128 float128_minnummag(float128, float128, float_status *status);
1254 float128 float128_maxnummag(float128, float128, float_status *status);
1255 float128 float128_minimum_number(float128, float128, float_status *status);
1256 float128 float128_maximum_number(float128, float128, float_status *status);
1257 bool float128_is_quiet_nan(float128, float_status *status);
1258 bool float128_is_signaling_nan(float128, float_status *status);
1259 float128 float128_silence_nan(float128, float_status *status);
1260 float128 float128_scalbn(float128, int, float_status *status);
1261 
float128_abs(float128 a)1262 static inline float128 float128_abs(float128 a)
1263 {
1264     a.high &= 0x7fffffffffffffffLL;
1265     return a;
1266 }
1267 
float128_chs(float128 a)1268 static inline float128 float128_chs(float128 a)
1269 {
1270     a.high ^= 0x8000000000000000LL;
1271     return a;
1272 }
1273 
float128_is_infinity(float128 a)1274 static inline bool float128_is_infinity(float128 a)
1275 {
1276     return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0;
1277 }
1278 
float128_is_neg(float128 a)1279 static inline bool float128_is_neg(float128 a)
1280 {
1281     return a.high >> 63;
1282 }
1283 
float128_is_zero(float128 a)1284 static inline bool float128_is_zero(float128 a)
1285 {
1286     return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0;
1287 }
1288 
float128_is_zero_or_denormal(float128 a)1289 static inline bool float128_is_zero_or_denormal(float128 a)
1290 {
1291     return (a.high & 0x7fff000000000000LL) == 0;
1292 }
1293 
float128_is_normal(float128 a)1294 static inline bool float128_is_normal(float128 a)
1295 {
1296     return (((a.high >> 48) + 1) & 0x7fff) >= 2;
1297 }
1298 
float128_is_denormal(float128 a)1299 static inline bool float128_is_denormal(float128 a)
1300 {
1301     return float128_is_zero_or_denormal(a) && !float128_is_zero(a);
1302 }
1303 
float128_is_any_nan(float128 a)1304 static inline bool float128_is_any_nan(float128 a)
1305 {
1306     return ((a.high >> 48) & 0x7fff) == 0x7fff &&
1307         ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));
1308 }
1309 
float128_eq(float128 a,float128 b,float_status * s)1310 static inline bool float128_eq(float128 a, float128 b, float_status *s)
1311 {
1312     return float128_compare(a, b, s) == float_relation_equal;
1313 }
1314 
float128_le(float128 a,float128 b,float_status * s)1315 static inline bool float128_le(float128 a, float128 b, float_status *s)
1316 {
1317     return float128_compare(a, b, s) <= float_relation_equal;
1318 }
1319 
float128_lt(float128 a,float128 b,float_status * s)1320 static inline bool float128_lt(float128 a, float128 b, float_status *s)
1321 {
1322     return float128_compare(a, b, s) < float_relation_equal;
1323 }
1324 
float128_unordered(float128 a,float128 b,float_status * s)1325 static inline bool float128_unordered(float128 a, float128 b, float_status *s)
1326 {
1327     return float128_compare(a, b, s) == float_relation_unordered;
1328 }
1329 
float128_eq_quiet(float128 a,float128 b,float_status * s)1330 static inline bool float128_eq_quiet(float128 a, float128 b, float_status *s)
1331 {
1332     return float128_compare_quiet(a, b, s) == float_relation_equal;
1333 }
1334 
float128_le_quiet(float128 a,float128 b,float_status * s)1335 static inline bool float128_le_quiet(float128 a, float128 b, float_status *s)
1336 {
1337     return float128_compare_quiet(a, b, s) <= float_relation_equal;
1338 }
1339 
float128_lt_quiet(float128 a,float128 b,float_status * s)1340 static inline bool float128_lt_quiet(float128 a, float128 b, float_status *s)
1341 {
1342     return float128_compare_quiet(a, b, s) < float_relation_equal;
1343 }
1344 
float128_unordered_quiet(float128 a,float128 b,float_status * s)1345 static inline bool float128_unordered_quiet(float128 a, float128 b,
1346                                            float_status *s)
1347 {
1348     return float128_compare_quiet(a, b, s) == float_relation_unordered;
1349 }
1350 
1351 #define float128_zero make_float128(0, 0)
1352 
1353 /*----------------------------------------------------------------------------
1354 | The pattern for a default generated quadruple-precision NaN.
1355 *----------------------------------------------------------------------------*/
1356 float128 float128_default_nan(float_status *status);
1357 
1358 #endif /* SOFTFLOAT_H */
1359