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