jcs.org
qemu with hax to log dma reads & writes
jcs.org/2018/11/12/vfio
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===============================================================================
20This C header file is part of the SoftFloat IEC/IEEE Floating-point
21Arithmetic Package, Release 2a.
22
23Written by John R. Hauser. This work was made possible in part by the
24International Computer Science Institute, located at Suite 600, 1947 Center
25Street, Berkeley, California 94704. Funding was partially provided by the
26National Science Foundation under grant MIP-9311980. The original version
27of this code was written as part of a project to build a fixed-point vector
28processor in collaboration with the University of California at Berkeley,
29overseen by Profs. Nelson Morgan and John Wawrzynek. More information
30is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
31arithmetic/SoftFloat.html'.
32
33THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
34has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
35TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
36PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
37AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
38
39Derivative works are acceptable, even for commercial purposes, so long as
40(1) they include prominent notice that the work is derivative, and (2) they
41include prominent notice akin to these four paragraphs for those parts of
42this code that are retained.
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*----------------------------------------------------------------------------*/
88enum {
89 float_relation_less = -1,
90 float_relation_equal = 0,
91 float_relation_greater = 1,
92 float_relation_unordered = 2
93};
94
95#include "fpu/softfloat-types.h"
96#include "fpu/softfloat-helpers.h"
97
98/*----------------------------------------------------------------------------
99| Routine to raise any or all of the software IEC/IEEE floating-point
100| exception flags.
101*----------------------------------------------------------------------------*/
102void float_raise(uint8_t flags, float_status *status);
103
104/*----------------------------------------------------------------------------
105| If `a' is denormal and we are in flush-to-zero mode then set the
106| input-denormal exception and return zero. Otherwise just return the value.
107*----------------------------------------------------------------------------*/
108float16 float16_squash_input_denormal(float16 a, float_status *status);
109float32 float32_squash_input_denormal(float32 a, float_status *status);
110float64 float64_squash_input_denormal(float64 a, float_status *status);
111
112/*----------------------------------------------------------------------------
113| Options to indicate which negations to perform in float*_muladd()
114| Using these differs from negating an input or output before calling
115| the muladd function in that this means that a NaN doesn't have its
116| sign bit inverted before it is propagated.
117| We also support halving the result before rounding, as a special
118| case to support the ARM fused-sqrt-step instruction FRSQRTS.
119*----------------------------------------------------------------------------*/
120enum {
121 float_muladd_negate_c = 1,
122 float_muladd_negate_product = 2,
123 float_muladd_negate_result = 4,
124 float_muladd_halve_result = 8,
125};
126
127/*----------------------------------------------------------------------------
128| Software IEC/IEEE integer-to-floating-point conversion routines.
129*----------------------------------------------------------------------------*/
130
131float16 int16_to_float16_scalbn(int16_t a, int, float_status *status);
132float16 int32_to_float16_scalbn(int32_t a, int, float_status *status);
133float16 int64_to_float16_scalbn(int64_t a, int, float_status *status);
134float16 uint16_to_float16_scalbn(uint16_t a, int, float_status *status);
135float16 uint32_to_float16_scalbn(uint32_t a, int, float_status *status);
136float16 uint64_to_float16_scalbn(uint64_t a, int, float_status *status);
137
138float16 int16_to_float16(int16_t a, float_status *status);
139float16 int32_to_float16(int32_t a, float_status *status);
140float16 int64_to_float16(int64_t a, float_status *status);
141float16 uint16_to_float16(uint16_t a, float_status *status);
142float16 uint32_to_float16(uint32_t a, float_status *status);
143float16 uint64_to_float16(uint64_t a, float_status *status);
144
145float32 int16_to_float32_scalbn(int16_t, int, float_status *status);
146float32 int32_to_float32_scalbn(int32_t, int, float_status *status);
147float32 int64_to_float32_scalbn(int64_t, int, float_status *status);
148float32 uint16_to_float32_scalbn(uint16_t, int, float_status *status);
149float32 uint32_to_float32_scalbn(uint32_t, int, float_status *status);
150float32 uint64_to_float32_scalbn(uint64_t, int, float_status *status);
151
152float32 int16_to_float32(int16_t, float_status *status);
153float32 int32_to_float32(int32_t, float_status *status);
154float32 int64_to_float32(int64_t, float_status *status);
155float32 uint16_to_float32(uint16_t, float_status *status);
156float32 uint32_to_float32(uint32_t, float_status *status);
157float32 uint64_to_float32(uint64_t, float_status *status);
158
159float64 int16_to_float64_scalbn(int16_t, int, float_status *status);
160float64 int32_to_float64_scalbn(int32_t, int, float_status *status);
161float64 int64_to_float64_scalbn(int64_t, int, float_status *status);
162float64 uint16_to_float64_scalbn(uint16_t, int, float_status *status);
163float64 uint32_to_float64_scalbn(uint32_t, int, float_status *status);
164float64 uint64_to_float64_scalbn(uint64_t, int, float_status *status);
165
166float64 int16_to_float64(int16_t, float_status *status);
167float64 int32_to_float64(int32_t, float_status *status);
168float64 int64_to_float64(int64_t, float_status *status);
169float64 uint16_to_float64(uint16_t, float_status *status);
170float64 uint32_to_float64(uint32_t, float_status *status);
171float64 uint64_to_float64(uint64_t, float_status *status);
172
173floatx80 int32_to_floatx80(int32_t, float_status *status);
174floatx80 int64_to_floatx80(int64_t, float_status *status);
175
176float128 int32_to_float128(int32_t, float_status *status);
177float128 int64_to_float128(int64_t, float_status *status);
178float128 uint64_to_float128(uint64_t, float_status *status);
179
180/*----------------------------------------------------------------------------
181| Software half-precision conversion routines.
182*----------------------------------------------------------------------------*/
183
184float16 float32_to_float16(float32, bool ieee, float_status *status);
185float32 float16_to_float32(float16, bool ieee, float_status *status);
186float16 float64_to_float16(float64 a, bool ieee, float_status *status);
187float64 float16_to_float64(float16 a, bool ieee, float_status *status);
188
189int16_t float16_to_int16_scalbn(float16, int, int, float_status *status);
190int32_t float16_to_int32_scalbn(float16, int, int, float_status *status);
191int64_t float16_to_int64_scalbn(float16, int, int, float_status *status);
192
193int16_t float16_to_int16(float16, float_status *status);
194int32_t float16_to_int32(float16, float_status *status);
195int64_t float16_to_int64(float16, float_status *status);
196
197int16_t float16_to_int16_round_to_zero(float16, float_status *status);
198int32_t float16_to_int32_round_to_zero(float16, float_status *status);
199int64_t float16_to_int64_round_to_zero(float16, float_status *status);
200
201uint16_t float16_to_uint16_scalbn(float16 a, int, int, float_status *status);
202uint32_t float16_to_uint32_scalbn(float16 a, int, int, float_status *status);
203uint64_t float16_to_uint64_scalbn(float16 a, int, int, float_status *status);
204
205uint16_t float16_to_uint16(float16 a, float_status *status);
206uint32_t float16_to_uint32(float16 a, float_status *status);
207uint64_t float16_to_uint64(float16 a, float_status *status);
208
209uint16_t float16_to_uint16_round_to_zero(float16 a, float_status *status);
210uint32_t float16_to_uint32_round_to_zero(float16 a, float_status *status);
211uint64_t float16_to_uint64_round_to_zero(float16 a, float_status *status);
212
213/*----------------------------------------------------------------------------
214| Software half-precision operations.
215*----------------------------------------------------------------------------*/
216
217float16 float16_round_to_int(float16, float_status *status);
218float16 float16_add(float16, float16, float_status *status);
219float16 float16_sub(float16, float16, float_status *status);
220float16 float16_mul(float16, float16, float_status *status);
221float16 float16_muladd(float16, float16, float16, int, float_status *status);
222float16 float16_div(float16, float16, float_status *status);
223float16 float16_scalbn(float16, int, float_status *status);
224float16 float16_min(float16, float16, float_status *status);
225float16 float16_max(float16, float16, float_status *status);
226float16 float16_minnum(float16, float16, float_status *status);
227float16 float16_maxnum(float16, float16, float_status *status);
228float16 float16_minnummag(float16, float16, float_status *status);
229float16 float16_maxnummag(float16, float16, float_status *status);
230float16 float16_sqrt(float16, float_status *status);
231int float16_compare(float16, float16, float_status *status);
232int float16_compare_quiet(float16, float16, float_status *status);
233
234int float16_is_quiet_nan(float16, float_status *status);
235int float16_is_signaling_nan(float16, float_status *status);
236float16 float16_silence_nan(float16, float_status *status);
237
238static inline int float16_is_any_nan(float16 a)
239{
240 return ((float16_val(a) & ~0x8000) > 0x7c00);
241}
242
243static inline int float16_is_neg(float16 a)
244{
245 return float16_val(a) >> 15;
246}
247
248static inline int float16_is_infinity(float16 a)
249{
250 return (float16_val(a) & 0x7fff) == 0x7c00;
251}
252
253static inline int float16_is_zero(float16 a)
254{
255 return (float16_val(a) & 0x7fff) == 0;
256}
257
258static inline int float16_is_zero_or_denormal(float16 a)
259{
260 return (float16_val(a) & 0x7c00) == 0;
261}
262
263static inline float16 float16_abs(float16 a)
264{
265 /* Note that abs does *not* handle NaN specially, nor does
266 * it flush denormal inputs to zero.
267 */
268 return make_float16(float16_val(a) & 0x7fff);
269}
270
271static inline float16 float16_chs(float16 a)
272{
273 /* Note that chs does *not* handle NaN specially, nor does
274 * it flush denormal inputs to zero.
275 */
276 return make_float16(float16_val(a) ^ 0x8000);
277}
278
279static inline float16 float16_set_sign(float16 a, int sign)
280{
281 return make_float16((float16_val(a) & 0x7fff) | (sign << 15));
282}
283
284#define float16_zero make_float16(0)
285#define float16_half make_float16(0x3800)
286#define float16_one make_float16(0x3c00)
287#define float16_one_point_five make_float16(0x3e00)
288#define float16_two make_float16(0x4000)
289#define float16_three make_float16(0x4200)
290#define float16_infinity make_float16(0x7c00)
291
292/*----------------------------------------------------------------------------
293| The pattern for a default generated half-precision NaN.
294*----------------------------------------------------------------------------*/
295float16 float16_default_nan(float_status *status);
296
297/*----------------------------------------------------------------------------
298| Software IEC/IEEE single-precision conversion routines.
299*----------------------------------------------------------------------------*/
300
301int16_t float32_to_int16_scalbn(float32, int, int, float_status *status);
302int32_t float32_to_int32_scalbn(float32, int, int, float_status *status);
303int64_t float32_to_int64_scalbn(float32, int, int, float_status *status);
304
305int16_t float32_to_int16(float32, float_status *status);
306int32_t float32_to_int32(float32, float_status *status);
307int64_t float32_to_int64(float32, float_status *status);
308
309int16_t float32_to_int16_round_to_zero(float32, float_status *status);
310int32_t float32_to_int32_round_to_zero(float32, float_status *status);
311int64_t float32_to_int64_round_to_zero(float32, float_status *status);
312
313uint16_t float32_to_uint16_scalbn(float32, int, int, float_status *status);
314uint32_t float32_to_uint32_scalbn(float32, int, int, float_status *status);
315uint64_t float32_to_uint64_scalbn(float32, int, int, float_status *status);
316
317uint16_t float32_to_uint16(float32, float_status *status);
318uint32_t float32_to_uint32(float32, float_status *status);
319uint64_t float32_to_uint64(float32, float_status *status);
320
321uint16_t float32_to_uint16_round_to_zero(float32, float_status *status);
322uint32_t float32_to_uint32_round_to_zero(float32, float_status *status);
323uint64_t float32_to_uint64_round_to_zero(float32, float_status *status);
324
325float64 float32_to_float64(float32, float_status *status);
326floatx80 float32_to_floatx80(float32, float_status *status);
327float128 float32_to_float128(float32, float_status *status);
328
329/*----------------------------------------------------------------------------
330| Software IEC/IEEE single-precision operations.
331*----------------------------------------------------------------------------*/
332float32 float32_round_to_int(float32, float_status *status);
333float32 float32_add(float32, float32, float_status *status);
334float32 float32_sub(float32, float32, float_status *status);
335float32 float32_mul(float32, float32, float_status *status);
336float32 float32_div(float32, float32, float_status *status);
337float32 float32_rem(float32, float32, float_status *status);
338float32 float32_muladd(float32, float32, float32, int, float_status *status);
339float32 float32_sqrt(float32, float_status *status);
340float32 float32_exp2(float32, float_status *status);
341float32 float32_log2(float32, float_status *status);
342int float32_eq(float32, float32, float_status *status);
343int float32_le(float32, float32, float_status *status);
344int float32_lt(float32, float32, float_status *status);
345int float32_unordered(float32, float32, float_status *status);
346int float32_eq_quiet(float32, float32, float_status *status);
347int float32_le_quiet(float32, float32, float_status *status);
348int float32_lt_quiet(float32, float32, float_status *status);
349int float32_unordered_quiet(float32, float32, float_status *status);
350int float32_compare(float32, float32, float_status *status);
351int float32_compare_quiet(float32, float32, float_status *status);
352float32 float32_min(float32, float32, float_status *status);
353float32 float32_max(float32, float32, float_status *status);
354float32 float32_minnum(float32, float32, float_status *status);
355float32 float32_maxnum(float32, float32, float_status *status);
356float32 float32_minnummag(float32, float32, float_status *status);
357float32 float32_maxnummag(float32, float32, float_status *status);
358int float32_is_quiet_nan(float32, float_status *status);
359int float32_is_signaling_nan(float32, float_status *status);
360float32 float32_silence_nan(float32, float_status *status);
361float32 float32_scalbn(float32, int, float_status *status);
362
363static inline float32 float32_abs(float32 a)
364{
365 /* Note that abs does *not* handle NaN specially, nor does
366 * it flush denormal inputs to zero.
367 */
368 return make_float32(float32_val(a) & 0x7fffffff);
369}
370
371static inline float32 float32_chs(float32 a)
372{
373 /* Note that chs does *not* handle NaN specially, nor does
374 * it flush denormal inputs to zero.
375 */
376 return make_float32(float32_val(a) ^ 0x80000000);
377}
378
379static inline int float32_is_infinity(float32 a)
380{
381 return (float32_val(a) & 0x7fffffff) == 0x7f800000;
382}
383
384static inline int float32_is_neg(float32 a)
385{
386 return float32_val(a) >> 31;
387}
388
389static inline int float32_is_zero(float32 a)
390{
391 return (float32_val(a) & 0x7fffffff) == 0;
392}
393
394static inline int float32_is_any_nan(float32 a)
395{
396 return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL);
397}
398
399static inline int float32_is_zero_or_denormal(float32 a)
400{
401 return (float32_val(a) & 0x7f800000) == 0;
402}
403
404static inline bool float32_is_normal(float32 a)
405{
406 return (((float32_val(a) >> 23) + 1) & 0xff) >= 2;
407}
408
409static inline bool float32_is_denormal(float32 a)
410{
411 return float32_is_zero_or_denormal(a) && !float32_is_zero(a);
412}
413
414static inline bool float32_is_zero_or_normal(float32 a)
415{
416 return float32_is_normal(a) || float32_is_zero(a);
417}
418
419static inline float32 float32_set_sign(float32 a, int sign)
420{
421 return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31));
422}
423
424#define float32_zero make_float32(0)
425#define float32_half make_float32(0x3f000000)
426#define float32_one make_float32(0x3f800000)
427#define float32_one_point_five make_float32(0x3fc00000)
428#define float32_two make_float32(0x40000000)
429#define float32_three make_float32(0x40400000)
430#define float32_infinity make_float32(0x7f800000)
431
432/*----------------------------------------------------------------------------
433| Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
434| single-precision floating-point value, returning the result. After being
435| shifted into the proper positions, the three fields are simply added
436| together to form the result. This means that any integer portion of `zSig'
437| will be added into the exponent. Since a properly normalized significand
438| will have an integer portion equal to 1, the `zExp' input should be 1 less
439| than the desired result exponent whenever `zSig' is a complete, normalized
440| significand.
441*----------------------------------------------------------------------------*/
442
443static inline float32 packFloat32(flag zSign, int zExp, uint32_t zSig)
444{
445 return make_float32(
446 (((uint32_t)zSign) << 31) + (((uint32_t)zExp) << 23) + zSig);
447}
448
449/*----------------------------------------------------------------------------
450| The pattern for a default generated single-precision NaN.
451*----------------------------------------------------------------------------*/
452float32 float32_default_nan(float_status *status);
453
454/*----------------------------------------------------------------------------
455| Software IEC/IEEE double-precision conversion routines.
456*----------------------------------------------------------------------------*/
457
458int16_t float64_to_int16_scalbn(float64, int, int, float_status *status);
459int32_t float64_to_int32_scalbn(float64, int, int, float_status *status);
460int64_t float64_to_int64_scalbn(float64, int, int, float_status *status);
461
462int16_t float64_to_int16(float64, float_status *status);
463int32_t float64_to_int32(float64, float_status *status);
464int64_t float64_to_int64(float64, float_status *status);
465
466int16_t float64_to_int16_round_to_zero(float64, float_status *status);
467int32_t float64_to_int32_round_to_zero(float64, float_status *status);
468int64_t float64_to_int64_round_to_zero(float64, float_status *status);
469
470uint16_t float64_to_uint16_scalbn(float64, int, int, float_status *status);
471uint32_t float64_to_uint32_scalbn(float64, int, int, float_status *status);
472uint64_t float64_to_uint64_scalbn(float64, int, int, float_status *status);
473
474uint16_t float64_to_uint16(float64, float_status *status);
475uint32_t float64_to_uint32(float64, float_status *status);
476uint64_t float64_to_uint64(float64, float_status *status);
477
478uint16_t float64_to_uint16_round_to_zero(float64, float_status *status);
479uint32_t float64_to_uint32_round_to_zero(float64, float_status *status);
480uint64_t float64_to_uint64_round_to_zero(float64, float_status *status);
481
482float32 float64_to_float32(float64, float_status *status);
483floatx80 float64_to_floatx80(float64, float_status *status);
484float128 float64_to_float128(float64, float_status *status);
485
486/*----------------------------------------------------------------------------
487| Software IEC/IEEE double-precision operations.
488*----------------------------------------------------------------------------*/
489float64 float64_round_to_int(float64, float_status *status);
490float64 float64_add(float64, float64, float_status *status);
491float64 float64_sub(float64, float64, float_status *status);
492float64 float64_mul(float64, float64, float_status *status);
493float64 float64_div(float64, float64, float_status *status);
494float64 float64_rem(float64, float64, float_status *status);
495float64 float64_muladd(float64, float64, float64, int, float_status *status);
496float64 float64_sqrt(float64, float_status *status);
497float64 float64_log2(float64, float_status *status);
498int float64_eq(float64, float64, float_status *status);
499int float64_le(float64, float64, float_status *status);
500int float64_lt(float64, float64, float_status *status);
501int float64_unordered(float64, float64, float_status *status);
502int float64_eq_quiet(float64, float64, float_status *status);
503int float64_le_quiet(float64, float64, float_status *status);
504int float64_lt_quiet(float64, float64, float_status *status);
505int float64_unordered_quiet(float64, float64, float_status *status);
506int float64_compare(float64, float64, float_status *status);
507int float64_compare_quiet(float64, float64, float_status *status);
508float64 float64_min(float64, float64, float_status *status);
509float64 float64_max(float64, float64, float_status *status);
510float64 float64_minnum(float64, float64, float_status *status);
511float64 float64_maxnum(float64, float64, float_status *status);
512float64 float64_minnummag(float64, float64, float_status *status);
513float64 float64_maxnummag(float64, float64, float_status *status);
514int float64_is_quiet_nan(float64 a, float_status *status);
515int float64_is_signaling_nan(float64, float_status *status);
516float64 float64_silence_nan(float64, float_status *status);
517float64 float64_scalbn(float64, int, float_status *status);
518
519static inline float64 float64_abs(float64 a)
520{
521 /* Note that abs does *not* handle NaN specially, nor does
522 * it flush denormal inputs to zero.
523 */
524 return make_float64(float64_val(a) & 0x7fffffffffffffffLL);
525}
526
527static inline float64 float64_chs(float64 a)
528{
529 /* Note that chs does *not* handle NaN specially, nor does
530 * it flush denormal inputs to zero.
531 */
532 return make_float64(float64_val(a) ^ 0x8000000000000000LL);
533}
534
535static inline int float64_is_infinity(float64 a)
536{
537 return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL;
538}
539
540static inline int float64_is_neg(float64 a)
541{
542 return float64_val(a) >> 63;
543}
544
545static inline int float64_is_zero(float64 a)
546{
547 return (float64_val(a) & 0x7fffffffffffffffLL) == 0;
548}
549
550static inline int float64_is_any_nan(float64 a)
551{
552 return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL);
553}
554
555static inline int float64_is_zero_or_denormal(float64 a)
556{
557 return (float64_val(a) & 0x7ff0000000000000LL) == 0;
558}
559
560static inline bool float64_is_normal(float64 a)
561{
562 return (((float64_val(a) >> 52) + 1) & 0x7ff) >= 2;
563}
564
565static inline bool float64_is_denormal(float64 a)
566{
567 return float64_is_zero_or_denormal(a) && !float64_is_zero(a);
568}
569
570static inline bool float64_is_zero_or_normal(float64 a)
571{
572 return float64_is_normal(a) || float64_is_zero(a);
573}
574
575static inline float64 float64_set_sign(float64 a, int sign)
576{
577 return make_float64((float64_val(a) & 0x7fffffffffffffffULL)
578 | ((int64_t)sign << 63));
579}
580
581#define float64_zero make_float64(0)
582#define float64_half make_float64(0x3fe0000000000000LL)
583#define float64_one make_float64(0x3ff0000000000000LL)
584#define float64_one_point_five make_float64(0x3FF8000000000000ULL)
585#define float64_two make_float64(0x4000000000000000ULL)
586#define float64_three make_float64(0x4008000000000000ULL)
587#define float64_ln2 make_float64(0x3fe62e42fefa39efLL)
588#define float64_infinity make_float64(0x7ff0000000000000LL)
589
590/*----------------------------------------------------------------------------
591| The pattern for a default generated double-precision NaN.
592*----------------------------------------------------------------------------*/
593float64 float64_default_nan(float_status *status);
594
595/*----------------------------------------------------------------------------
596| Software IEC/IEEE extended double-precision conversion routines.
597*----------------------------------------------------------------------------*/
598int32_t floatx80_to_int32(floatx80, float_status *status);
599int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status);
600int64_t floatx80_to_int64(floatx80, float_status *status);
601int64_t floatx80_to_int64_round_to_zero(floatx80, float_status *status);
602float32 floatx80_to_float32(floatx80, float_status *status);
603float64 floatx80_to_float64(floatx80, float_status *status);
604float128 floatx80_to_float128(floatx80, float_status *status);
605
606/*----------------------------------------------------------------------------
607| The pattern for an extended double-precision inf.
608*----------------------------------------------------------------------------*/
609extern const floatx80 floatx80_infinity;
610
611/*----------------------------------------------------------------------------
612| Software IEC/IEEE extended double-precision operations.
613*----------------------------------------------------------------------------*/
614floatx80 floatx80_round(floatx80 a, float_status *status);
615floatx80 floatx80_round_to_int(floatx80, float_status *status);
616floatx80 floatx80_add(floatx80, floatx80, float_status *status);
617floatx80 floatx80_sub(floatx80, floatx80, float_status *status);
618floatx80 floatx80_mul(floatx80, floatx80, float_status *status);
619floatx80 floatx80_div(floatx80, floatx80, float_status *status);
620floatx80 floatx80_rem(floatx80, floatx80, float_status *status);
621floatx80 floatx80_sqrt(floatx80, float_status *status);
622int floatx80_eq(floatx80, floatx80, float_status *status);
623int floatx80_le(floatx80, floatx80, float_status *status);
624int floatx80_lt(floatx80, floatx80, float_status *status);
625int floatx80_unordered(floatx80, floatx80, float_status *status);
626int floatx80_eq_quiet(floatx80, floatx80, float_status *status);
627int floatx80_le_quiet(floatx80, floatx80, float_status *status);
628int floatx80_lt_quiet(floatx80, floatx80, float_status *status);
629int floatx80_unordered_quiet(floatx80, floatx80, float_status *status);
630int floatx80_compare(floatx80, floatx80, float_status *status);
631int floatx80_compare_quiet(floatx80, floatx80, float_status *status);
632int floatx80_is_quiet_nan(floatx80, float_status *status);
633int floatx80_is_signaling_nan(floatx80, float_status *status);
634floatx80 floatx80_silence_nan(floatx80, float_status *status);
635floatx80 floatx80_scalbn(floatx80, int, float_status *status);
636
637static inline floatx80 floatx80_abs(floatx80 a)
638{
639 a.high &= 0x7fff;
640 return a;
641}
642
643static inline floatx80 floatx80_chs(floatx80 a)
644{
645 a.high ^= 0x8000;
646 return a;
647}
648
649static inline int floatx80_is_infinity(floatx80 a)
650{
651#if defined(TARGET_M68K)
652 return (a.high & 0x7fff) == floatx80_infinity.high && !(a.low << 1);
653#else
654 return (a.high & 0x7fff) == floatx80_infinity.high &&
655 a.low == floatx80_infinity.low;
656#endif
657}
658
659static inline int floatx80_is_neg(floatx80 a)
660{
661 return a.high >> 15;
662}
663
664static inline int floatx80_is_zero(floatx80 a)
665{
666 return (a.high & 0x7fff) == 0 && a.low == 0;
667}
668
669static inline int floatx80_is_zero_or_denormal(floatx80 a)
670{
671 return (a.high & 0x7fff) == 0;
672}
673
674static inline int floatx80_is_any_nan(floatx80 a)
675{
676 return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1);
677}
678
679/*----------------------------------------------------------------------------
680| Return whether the given value is an invalid floatx80 encoding.
681| Invalid floatx80 encodings arise when the integer bit is not set, but
682| the exponent is not zero. The only times the integer bit is permitted to
683| be zero is in subnormal numbers and the value zero.
684| This includes what the Intel software developer's manual calls pseudo-NaNs,
685| pseudo-infinities and un-normal numbers. It does not include
686| pseudo-denormals, which must still be correctly handled as inputs even
687| if they are never generated as outputs.
688*----------------------------------------------------------------------------*/
689static inline bool floatx80_invalid_encoding(floatx80 a)
690{
691 return (a.low & (1ULL << 63)) == 0 && (a.high & 0x7FFF) != 0;
692}
693
694#define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL)
695#define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL)
696#define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL)
697#define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL)
698#define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL)
699
700/*----------------------------------------------------------------------------
701| Returns the fraction bits of the extended double-precision floating-point
702| value `a'.
703*----------------------------------------------------------------------------*/
704
705static inline uint64_t extractFloatx80Frac(floatx80 a)
706{
707 return a.low;
708}
709
710/*----------------------------------------------------------------------------
711| Returns the exponent bits of the extended double-precision floating-point
712| value `a'.
713*----------------------------------------------------------------------------*/
714
715static inline int32_t extractFloatx80Exp(floatx80 a)
716{
717 return a.high & 0x7FFF;
718}
719
720/*----------------------------------------------------------------------------
721| Returns the sign bit of the extended double-precision floating-point value
722| `a'.
723*----------------------------------------------------------------------------*/
724
725static inline flag extractFloatx80Sign(floatx80 a)
726{
727 return a.high >> 15;
728}
729
730/*----------------------------------------------------------------------------
731| Packs the sign `zSign', exponent `zExp', and significand `zSig' into an
732| extended double-precision floating-point value, returning the result.
733*----------------------------------------------------------------------------*/
734
735static inline floatx80 packFloatx80(flag zSign, int32_t zExp, uint64_t zSig)
736{
737 floatx80 z;
738
739 z.low = zSig;
740 z.high = (((uint16_t)zSign) << 15) + zExp;
741 return z;
742}
743
744/*----------------------------------------------------------------------------
745| Normalizes the subnormal extended double-precision floating-point value
746| represented by the denormalized significand `aSig'. The normalized exponent
747| and significand are stored at the locations pointed to by `zExpPtr' and
748| `zSigPtr', respectively.
749*----------------------------------------------------------------------------*/
750
751void normalizeFloatx80Subnormal(uint64_t aSig, int32_t *zExpPtr,
752 uint64_t *zSigPtr);
753
754/*----------------------------------------------------------------------------
755| Takes two extended double-precision floating-point values `a' and `b', one
756| of which is a NaN, and returns the appropriate NaN result. If either `a' or
757| `b' is a signaling NaN, the invalid exception is raised.
758*----------------------------------------------------------------------------*/
759
760floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b, float_status *status);
761
762/*----------------------------------------------------------------------------
763| Takes an abstract floating-point value having sign `zSign', exponent `zExp',
764| and extended significand formed by the concatenation of `zSig0' and `zSig1',
765| and returns the proper extended double-precision floating-point value
766| corresponding to the abstract input. Ordinarily, the abstract value is
767| rounded and packed into the extended double-precision format, with the
768| inexact exception raised if the abstract input cannot be represented
769| exactly. However, if the abstract value is too large, the overflow and
770| inexact exceptions are raised and an infinity or maximal finite value is
771| returned. If the abstract value is too small, the input value is rounded to
772| a subnormal number, and the underflow and inexact exceptions are raised if
773| the abstract input cannot be represented exactly as a subnormal extended
774| double-precision floating-point number.
775| If `roundingPrecision' is 32 or 64, the result is rounded to the same
776| number of bits as single or double precision, respectively. Otherwise, the
777| result is rounded to the full precision of the extended double-precision
778| format.
779| The input significand must be normalized or smaller. If the input
780| significand is not normalized, `zExp' must be 0; in that case, the result
781| returned is a subnormal number, and it must not require rounding. The
782| handling of underflow and overflow follows the IEC/IEEE Standard for Binary
783| Floating-Point Arithmetic.
784*----------------------------------------------------------------------------*/
785
786floatx80 roundAndPackFloatx80(int8_t roundingPrecision, flag zSign,
787 int32_t zExp, uint64_t zSig0, uint64_t zSig1,
788 float_status *status);
789
790/*----------------------------------------------------------------------------
791| Takes an abstract floating-point value having sign `zSign', exponent
792| `zExp', and significand formed by the concatenation of `zSig0' and `zSig1',
793| and returns the proper extended double-precision floating-point value
794| corresponding to the abstract input. This routine is just like
795| `roundAndPackFloatx80' except that the input significand does not have to be
796| normalized.
797*----------------------------------------------------------------------------*/
798
799floatx80 normalizeRoundAndPackFloatx80(int8_t roundingPrecision,
800 flag zSign, int32_t zExp,
801 uint64_t zSig0, uint64_t zSig1,
802 float_status *status);
803
804/*----------------------------------------------------------------------------
805| The pattern for a default generated extended double-precision NaN.
806*----------------------------------------------------------------------------*/
807floatx80 floatx80_default_nan(float_status *status);
808
809/*----------------------------------------------------------------------------
810| Software IEC/IEEE quadruple-precision conversion routines.
811*----------------------------------------------------------------------------*/
812int32_t float128_to_int32(float128, float_status *status);
813int32_t float128_to_int32_round_to_zero(float128, float_status *status);
814int64_t float128_to_int64(float128, float_status *status);
815int64_t float128_to_int64_round_to_zero(float128, float_status *status);
816uint64_t float128_to_uint64(float128, float_status *status);
817uint64_t float128_to_uint64_round_to_zero(float128, float_status *status);
818uint32_t float128_to_uint32(float128, float_status *status);
819uint32_t float128_to_uint32_round_to_zero(float128, float_status *status);
820float32 float128_to_float32(float128, float_status *status);
821float64 float128_to_float64(float128, float_status *status);
822floatx80 float128_to_floatx80(float128, float_status *status);
823
824/*----------------------------------------------------------------------------
825| Software IEC/IEEE quadruple-precision operations.
826*----------------------------------------------------------------------------*/
827float128 float128_round_to_int(float128, float_status *status);
828float128 float128_add(float128, float128, float_status *status);
829float128 float128_sub(float128, float128, float_status *status);
830float128 float128_mul(float128, float128, float_status *status);
831float128 float128_div(float128, float128, float_status *status);
832float128 float128_rem(float128, float128, float_status *status);
833float128 float128_sqrt(float128, float_status *status);
834int float128_eq(float128, float128, float_status *status);
835int float128_le(float128, float128, float_status *status);
836int float128_lt(float128, float128, float_status *status);
837int float128_unordered(float128, float128, float_status *status);
838int float128_eq_quiet(float128, float128, float_status *status);
839int float128_le_quiet(float128, float128, float_status *status);
840int float128_lt_quiet(float128, float128, float_status *status);
841int float128_unordered_quiet(float128, float128, float_status *status);
842int float128_compare(float128, float128, float_status *status);
843int float128_compare_quiet(float128, float128, float_status *status);
844int float128_is_quiet_nan(float128, float_status *status);
845int float128_is_signaling_nan(float128, float_status *status);
846float128 float128_silence_nan(float128, float_status *status);
847float128 float128_scalbn(float128, int, float_status *status);
848
849static inline float128 float128_abs(float128 a)
850{
851 a.high &= 0x7fffffffffffffffLL;
852 return a;
853}
854
855static inline float128 float128_chs(float128 a)
856{
857 a.high ^= 0x8000000000000000LL;
858 return a;
859}
860
861static inline int float128_is_infinity(float128 a)
862{
863 return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0;
864}
865
866static inline int float128_is_neg(float128 a)
867{
868 return a.high >> 63;
869}
870
871static inline int float128_is_zero(float128 a)
872{
873 return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0;
874}
875
876static inline int float128_is_zero_or_denormal(float128 a)
877{
878 return (a.high & 0x7fff000000000000LL) == 0;
879}
880
881static inline bool float128_is_normal(float128 a)
882{
883 return (((a.high >> 48) + 1) & 0x7fff) >= 2;
884}
885
886static inline bool float128_is_denormal(float128 a)
887{
888 return float128_is_zero_or_denormal(a) && !float128_is_zero(a);
889}
890
891static inline int float128_is_any_nan(float128 a)
892{
893 return ((a.high >> 48) & 0x7fff) == 0x7fff &&
894 ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));
895}
896
897#define float128_zero make_float128(0, 0)
898
899/*----------------------------------------------------------------------------
900| The pattern for a default generated quadruple-precision NaN.
901*----------------------------------------------------------------------------*/
902float128 float128_default_nan(float_status *status);
903
904#endif /* SOFTFLOAT_H */