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