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