Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/include/fpu/softfloat.h
Line
Count
Source
1
/*
2
 * QEMU float support
3
 *
4
 * The code in this source file is derived from release 2a of the SoftFloat
5
 * IEC/IEEE Floating-point Arithmetic Package. Those parts of the code (and
6
 * some later contributions) are provided under that license, as detailed below.
7
 * It has subsequently been modified by contributors to the QEMU Project,
8
 * so some portions are provided under:
9
 *  the SoftFloat-2a license
10
 *  the BSD license
11
 *  GPL-v2-or-later
12
 *
13
 * Any future contributions to this file after December 1st 2014 will be
14
 * taken to be licensed under the Softfloat-2a license unless specifically
15
 * indicated otherwise.
16
 */
17
18
/*
19
===============================================================================
20
This C header file is part of the SoftFloat IEC/IEEE Floating-point
21
Arithmetic Package, Release 2a.
22
23
Written by John R. Hauser.  This work was made possible in part by the
24
International Computer Science Institute, located at Suite 600, 1947 Center
25
Street, Berkeley, California 94704.  Funding was partially provided by the
26
National Science Foundation under grant MIP-9311980.  The original version
27
of this code was written as part of a project to build a fixed-point vector
28
processor in collaboration with the University of California at Berkeley,
29
overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
30
is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
31
arithmetic/SoftFloat.html'.
32
33
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
34
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
35
TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
36
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
37
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
38
39
Derivative works are acceptable, even for commercial purposes, so long as
40
(1) they include prominent notice that the work is derivative, and (2) they
41
include prominent notice akin to these four paragraphs for those parts of
42
this code that are retained.
43
44
===============================================================================
45
*/
46
47
/* BSD licensing:
48
 * Copyright (c) 2006, Fabrice Bellard
49
 * All rights reserved.
50
 *
51
 * Redistribution and use in source and binary forms, with or without
52
 * modification, are permitted provided that the following conditions are met:
53
 *
54
 * 1. Redistributions of source code must retain the above copyright notice,
55
 * this list of conditions and the following disclaimer.
56
 *
57
 * 2. Redistributions in binary form must reproduce the above copyright notice,
58
 * this list of conditions and the following disclaimer in the documentation
59
 * and/or other materials provided with the distribution.
60
 *
61
 * 3. Neither the name of the copyright holder nor the names of its contributors
62
 * may be used to endorse or promote products derived from this software without
63
 * specific prior written permission.
64
 *
65
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
66
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
67
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
68
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
69
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
70
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
71
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
72
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
73
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
74
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
75
 * THE POSSIBILITY OF SUCH DAMAGE.
76
 */
77
78
/* Portions of this work are licensed under the terms of the GNU GPL,
79
 * version 2 or later. See the COPYING file in the top-level directory.
80
 */
81
82
#ifndef SOFTFLOAT_H
83
#define SOFTFLOAT_H
84
85
/*----------------------------------------------------------------------------
86
| Software IEC/IEEE floating-point ordering relations
87
*----------------------------------------------------------------------------*/
88
89
typedef enum {
90
    float_relation_less      = -1,
91
    float_relation_equal     =  0,
92
    float_relation_greater   =  1,
93
    float_relation_unordered =  2
94
} FloatRelation;
95
96
#include "fpu/softfloat-types.h"
97
#include "fpu/softfloat-helpers.h"
98
#include "qemu/int128.h"
99
100
/*----------------------------------------------------------------------------
101
| Routine to raise any or all of the software IEC/IEEE floating-point
102
| exception flags.
103
*----------------------------------------------------------------------------*/
104
static inline void float_raise(FloatExceptionFlags flags, float_status *status)
105
0
{
106
0
    status->float_exception_flags |= flags;
107
0
}
Unexecuted instantiation: softfloat.c:float_raise
Unexecuted instantiation: fpu_helper.c:float_raise
Unexecuted instantiation: translate.c:float_raise
108
109
/*----------------------------------------------------------------------------
110
| If `a' is denormal and we are in flush-to-zero mode then set the
111
| input-denormal exception and return zero. Otherwise just return the value.
112
*----------------------------------------------------------------------------*/
113
float16 float16_squash_input_denormal(float16 a, float_status *status);
114
float32 float32_squash_input_denormal(float32 a, float_status *status);
115
float64 float64_squash_input_denormal(float64 a, float_status *status);
116
bfloat16 bfloat16_squash_input_denormal(bfloat16 a, float_status *status);
117
118
/*----------------------------------------------------------------------------
119
| Options to indicate which negations to perform in float*_muladd()
120
| Using these differs from negating an input or output before calling
121
| the muladd function in that this means that a NaN doesn't have its
122
| sign bit inverted before it is propagated.
123
|
124
| With float_muladd_suppress_add_product_zero, if A or B is zero
125
| such that the product is a true zero, then return C without addition.
126
| This preserves the sign of C when C is +/- 0.  Used for Hexagon.
127
*----------------------------------------------------------------------------*/
128
enum {
129
    float_muladd_negate_c = 1,
130
    float_muladd_negate_product = 2,
131
    float_muladd_negate_result = 4,
132
    float_muladd_suppress_add_product_zero = 8,
133
};
134
135
/*----------------------------------------------------------------------------
136
| Options to indicate which negations to perform in float*_minmax()
137
*----------------------------------------------------------------------------*/
138
139
/* Flags for parts_minmax. */
140
enum {
141
    /* Set for minimum; clear for maximum. */
142
    float_minmax_ismin = 1,
143
    /* Set for the IEEE 754-2008 minNum() and maxNum() operations. */
144
    float_minmax_isnum = 2,
145
    /* Set for the IEEE 754-2008 minNumMag() and minNumMag() operations. */
146
    float_minmax_ismag = 4,
147
    /*
148
     * Set for the IEEE 754-2019 minimumNumber() and maximumNumber()
149
     * operations.
150
     */
151
    float_minmax_isnumber = 8,
152
};
153
154
/*----------------------------------------------------------------------------
155
| Software IEC/IEEE integer-to-floating-point conversion routines.
156
*----------------------------------------------------------------------------*/
157
158
float16 int16_to_float16_scalbn(int16_t a, int, float_status *status);
159
float16 int32_to_float16_scalbn(int32_t a, int, float_status *status);
160
float16 int64_to_float16_scalbn(int64_t a, int, float_status *status);
161
float16 uint16_to_float16_scalbn(uint16_t a, int, float_status *status);
162
float16 uint32_to_float16_scalbn(uint32_t a, int, float_status *status);
163
float16 uint64_to_float16_scalbn(uint64_t a, int, float_status *status);
164
165
float16 int8_to_float16(int8_t a, float_status *status);
166
float16 int16_to_float16(int16_t a, float_status *status);
167
float16 int32_to_float16(int32_t a, float_status *status);
168
float16 int64_to_float16(int64_t a, float_status *status);
169
float16 uint8_to_float16(uint8_t a, float_status *status);
170
float16 uint16_to_float16(uint16_t a, float_status *status);
171
float16 uint32_to_float16(uint32_t a, float_status *status);
172
float16 uint64_to_float16(uint64_t a, float_status *status);
173
174
float32 int16_to_float32_scalbn(int16_t, int, float_status *status);
175
float32 int32_to_float32_scalbn(int32_t, int, float_status *status);
176
float32 int64_to_float32_scalbn(int64_t, int, float_status *status);
177
float32 uint16_to_float32_scalbn(uint16_t, int, float_status *status);
178
float32 uint32_to_float32_scalbn(uint32_t, int, float_status *status);
179
float32 uint64_to_float32_scalbn(uint64_t, int, float_status *status);
180
181
float32 int16_to_float32(int16_t, float_status *status);
182
float32 int32_to_float32(int32_t, float_status *status);
183
float32 int64_to_float32(int64_t, float_status *status);
184
float32 uint16_to_float32(uint16_t, float_status *status);
185
float32 uint32_to_float32(uint32_t, float_status *status);
186
float32 uint64_to_float32(uint64_t, float_status *status);
187
188
float64 int16_to_float64_scalbn(int16_t, int, float_status *status);
189
float64 int32_to_float64_scalbn(int32_t, int, float_status *status);
190
float64 int64_to_float64_scalbn(int64_t, int, float_status *status);
191
float64 uint16_to_float64_scalbn(uint16_t, int, float_status *status);
192
float64 uint32_to_float64_scalbn(uint32_t, int, float_status *status);
193
float64 uint64_to_float64_scalbn(uint64_t, int, float_status *status);
194
195
float64 int16_to_float64(int16_t, float_status *status);
196
float64 int32_to_float64(int32_t, float_status *status);
197
float64 int64_to_float64(int64_t, float_status *status);
198
float64 uint16_to_float64(uint16_t, float_status *status);
199
float64 uint32_to_float64(uint32_t, float_status *status);
200
float64 uint64_to_float64(uint64_t, float_status *status);
201
202
floatx80 int32_to_floatx80(int32_t, float_status *status);
203
floatx80 int64_to_floatx80(int64_t, float_status *status);
204
205
float128 int32_to_float128(int32_t, float_status *status);
206
float128 int64_to_float128(int64_t, float_status *status);
207
float128 int128_to_float128(Int128, float_status *status);
208
float128 uint64_to_float128(uint64_t, float_status *status);
209
float128 uint128_to_float128(Int128, float_status *status);
210
211
/*----------------------------------------------------------------------------
212
| OCP FP{4,8} conversion routines.
213
*----------------------------------------------------------------------------*/
214
215
float8_e4m3 float4_e2m1_to_float8_e4m3(float4_e2m1, float_status *status);
216
217
bfloat16 float8_e4m3_to_bfloat16(float8_e4m3, float_status *status);
218
float8_e4m3 bfloat16_to_float8_e4m3(bfloat16, bool sat, float_status *status);
219
float8_e4m3 float32_to_float8_e4m3(float32, bool sat, float_status *status);
220
221
bfloat16 float8_e5m2_to_bfloat16(float8_e5m2, float_status *status);
222
float8_e5m2 bfloat16_to_float8_e5m2(bfloat16, bool sat, float_status *status);
223
float8_e5m2 float32_to_float8_e5m2(float32, bool sat, float_status *status);
224
225
/*----------------------------------------------------------------------------
226
| Software half-precision conversion routines.
227
*----------------------------------------------------------------------------*/
228
229
float16 float32_to_float16(float32, bool ieee, float_status *status);
230
float32 float16_to_float32(float16, bool ieee, float_status *status);
231
float16 float64_to_float16(float64 a, bool ieee, float_status *status);
232
float64 float16_to_float64(float16 a, bool ieee, float_status *status);
233
234
int8_t  float16_to_int8_scalbn(float16, FloatRoundMode, int,
235
                               float_status *status);
236
int16_t float16_to_int16_scalbn(float16, FloatRoundMode, int, float_status *);
237
int32_t float16_to_int32_scalbn(float16, FloatRoundMode, int, float_status *);
238
int64_t float16_to_int64_scalbn(float16, FloatRoundMode, int, float_status *);
239
240
int8_t  float16_to_int8(float16, float_status *status);
241
int16_t float16_to_int16(float16, float_status *status);
242
int32_t float16_to_int32(float16, float_status *status);
243
int64_t float16_to_int64(float16, float_status *status);
244
245
int16_t float16_to_int16_round_to_zero(float16, float_status *status);
246
int32_t float16_to_int32_round_to_zero(float16, float_status *status);
247
int64_t float16_to_int64_round_to_zero(float16, float_status *status);
248
249
uint8_t float16_to_uint8_scalbn(float16 a, FloatRoundMode,
250
                                int, float_status *status);
251
uint16_t float16_to_uint16_scalbn(float16 a, FloatRoundMode,
252
                                  int, float_status *status);
253
uint32_t float16_to_uint32_scalbn(float16 a, FloatRoundMode,
254
                                  int, float_status *status);
255
uint64_t float16_to_uint64_scalbn(float16 a, FloatRoundMode,
256
                                  int, float_status *status);
257
258
uint8_t  float16_to_uint8(float16 a, float_status *status);
259
uint16_t float16_to_uint16(float16 a, float_status *status);
260
uint32_t float16_to_uint32(float16 a, float_status *status);
261
uint64_t float16_to_uint64(float16 a, float_status *status);
262
263
uint16_t float16_to_uint16_round_to_zero(float16 a, float_status *status);
264
uint32_t float16_to_uint32_round_to_zero(float16 a, float_status *status);
265
uint64_t float16_to_uint64_round_to_zero(float16 a, float_status *status);
266
267
/*----------------------------------------------------------------------------
268
| Software half-precision operations.
269
*----------------------------------------------------------------------------*/
270
271
float16 float16_round_to_int(float16, float_status *status);
272
float16 float16_add(float16, float16, float_status *status);
273
float16 float16_sub(float16, float16, float_status *status);
274
float16 float16_mul(float16, float16, float_status *status);
275
float16 float16_muladd(float16, float16, float16, int, float_status *status);
276
float16 float16_muladd_scalbn(float16, float16, float16,
277
                              int, int, float_status *status);
278
float16 float16_div(float16, float16, float_status *status);
279
float16 float16_scalbn(float16, int, float_status *status);
280
float16 float16_minmax(float16, float16, float_status *status, int flags);
281
float16 float16_sqrt(float16, float_status *status);
282
FloatRelation float16_compare(float16, float16, float_status *status);
283
FloatRelation float16_compare_quiet(float16, float16, float_status *status);
284
285
bool float16_is_quiet_nan(float16, float_status *status);
286
bool float16_is_signaling_nan(float16, float_status *status);
287
float16 float16_silence_nan(float16, float_status *status);
288
289
static inline bool float16_is_any_nan(float16 a)
290
0
{
291
0
    return ((float16_val(a) & ~0x8000) > 0x7c00);
292
0
}
Unexecuted instantiation: softfloat.c:float16_is_any_nan
Unexecuted instantiation: fpu_helper.c:float16_is_any_nan
Unexecuted instantiation: translate.c:float16_is_any_nan
293
294
static inline bool float16_is_neg(float16 a)
295
0
{
296
0
    return float16_val(a) >> 15;
297
0
}
Unexecuted instantiation: softfloat.c:float16_is_neg
Unexecuted instantiation: fpu_helper.c:float16_is_neg
Unexecuted instantiation: translate.c:float16_is_neg
298
299
static inline bool float16_is_infinity(float16 a)
300
0
{
301
0
    return (float16_val(a) & 0x7fff) == 0x7c00;
302
0
}
Unexecuted instantiation: softfloat.c:float16_is_infinity
Unexecuted instantiation: fpu_helper.c:float16_is_infinity
Unexecuted instantiation: translate.c:float16_is_infinity
303
304
static inline bool float16_is_zero(float16 a)
305
0
{
306
0
    return (float16_val(a) & 0x7fff) == 0;
307
0
}
Unexecuted instantiation: softfloat.c:float16_is_zero
Unexecuted instantiation: fpu_helper.c:float16_is_zero
Unexecuted instantiation: translate.c:float16_is_zero
308
309
static inline bool float16_is_zero_or_denormal(float16 a)
310
0
{
311
0
    return (float16_val(a) & 0x7c00) == 0;
312
0
}
Unexecuted instantiation: softfloat.c:float16_is_zero_or_denormal
Unexecuted instantiation: fpu_helper.c:float16_is_zero_or_denormal
Unexecuted instantiation: translate.c:float16_is_zero_or_denormal
313
314
static inline bool float16_is_normal(float16 a)
315
0
{
316
0
    return (((float16_val(a) >> 10) + 1) & 0x1f) >= 2;
317
0
}
Unexecuted instantiation: softfloat.c:float16_is_normal
Unexecuted instantiation: fpu_helper.c:float16_is_normal
Unexecuted instantiation: translate.c:float16_is_normal
318
319
static inline float16 float16_abs(float16 a)
320
0
{
321
0
    /* Note that abs does *not* handle NaN specially, nor does
322
0
     * it flush denormal inputs to zero.
323
0
     */
324
0
    return make_float16(float16_val(a) & 0x7fff);
325
0
}
Unexecuted instantiation: softfloat.c:float16_abs
Unexecuted instantiation: fpu_helper.c:float16_abs
Unexecuted instantiation: translate.c:float16_abs
326
327
static inline float16 float16_chs(float16 a)
328
0
{
329
0
    /* Note that chs does *not* handle NaN specially, nor does
330
0
     * it flush denormal inputs to zero.
331
0
     */
332
0
    return make_float16(float16_val(a) ^ 0x8000);
333
0
}
Unexecuted instantiation: softfloat.c:float16_chs
Unexecuted instantiation: fpu_helper.c:float16_chs
Unexecuted instantiation: translate.c:float16_chs
334
335
static inline float16 float16_set_sign(float16 a, int sign)
336
0
{
337
0
    return make_float16((float16_val(a) & 0x7fff) | (sign << 15));
338
0
}
Unexecuted instantiation: softfloat.c:float16_set_sign
Unexecuted instantiation: fpu_helper.c:float16_set_sign
Unexecuted instantiation: translate.c:float16_set_sign
339
340
static inline bool float16_eq(float16 a, float16 b, float_status *s)
341
0
{
342
0
    return float16_compare(a, b, s) == float_relation_equal;
343
0
}
Unexecuted instantiation: softfloat.c:float16_eq
Unexecuted instantiation: fpu_helper.c:float16_eq
Unexecuted instantiation: translate.c:float16_eq
344
345
static inline bool float16_le(float16 a, float16 b, float_status *s)
346
0
{
347
0
    return float16_compare(a, b, s) <= float_relation_equal;
348
0
}
Unexecuted instantiation: softfloat.c:float16_le
Unexecuted instantiation: fpu_helper.c:float16_le
Unexecuted instantiation: translate.c:float16_le
349
350
static inline bool float16_lt(float16 a, float16 b, float_status *s)
351
0
{
352
0
    return float16_compare(a, b, s) < float_relation_equal;
353
0
}
Unexecuted instantiation: softfloat.c:float16_lt
Unexecuted instantiation: fpu_helper.c:float16_lt
Unexecuted instantiation: translate.c:float16_lt
354
355
static inline bool float16_unordered(float16 a, float16 b, float_status *s)
356
0
{
357
0
    return float16_compare(a, b, s) == float_relation_unordered;
358
0
}
Unexecuted instantiation: softfloat.c:float16_unordered
Unexecuted instantiation: fpu_helper.c:float16_unordered
Unexecuted instantiation: translate.c:float16_unordered
359
360
static inline bool float16_eq_quiet(float16 a, float16 b, float_status *s)
361
0
{
362
0
    return float16_compare_quiet(a, b, s) == float_relation_equal;
363
0
}
Unexecuted instantiation: softfloat.c:float16_eq_quiet
Unexecuted instantiation: fpu_helper.c:float16_eq_quiet
Unexecuted instantiation: translate.c:float16_eq_quiet
364
365
static inline bool float16_le_quiet(float16 a, float16 b, float_status *s)
366
0
{
367
0
    return float16_compare_quiet(a, b, s) <= float_relation_equal;
368
0
}
Unexecuted instantiation: softfloat.c:float16_le_quiet
Unexecuted instantiation: fpu_helper.c:float16_le_quiet
Unexecuted instantiation: translate.c:float16_le_quiet
369
370
static inline bool float16_lt_quiet(float16 a, float16 b, float_status *s)
371
0
{
372
0
    return float16_compare_quiet(a, b, s) < float_relation_equal;
373
0
}
Unexecuted instantiation: softfloat.c:float16_lt_quiet
Unexecuted instantiation: fpu_helper.c:float16_lt_quiet
Unexecuted instantiation: translate.c:float16_lt_quiet
374
375
static inline bool float16_unordered_quiet(float16 a, float16 b,
376
                                           float_status *s)
377
0
{
378
0
    return float16_compare_quiet(a, b, s) == float_relation_unordered;
379
0
}
Unexecuted instantiation: softfloat.c:float16_unordered_quiet
Unexecuted instantiation: fpu_helper.c:float16_unordered_quiet
Unexecuted instantiation: translate.c:float16_unordered_quiet
380
381
0
#define float16_zero make_float16(0)
382
#define float16_half make_float16(0x3800)
383
#define float16_one make_float16(0x3c00)
384
#define float16_one_point_five make_float16(0x3e00)
385
#define float16_two make_float16(0x4000)
386
#define float16_three make_float16(0x4200)
387
#define float16_infinity make_float16(0x7c00)
388
389
/*----------------------------------------------------------------------------
390
| Software bfloat16 conversion routines.
391
*----------------------------------------------------------------------------*/
392
393
bfloat16 bfloat16_round_to_int(bfloat16, float_status *status);
394
bfloat16 float32_to_bfloat16(float32, float_status *status);
395
float32 bfloat16_to_float32(bfloat16, float_status *status);
396
bfloat16 float64_to_bfloat16(float64 a, float_status *status);
397
float64 bfloat16_to_float64(bfloat16 a, float_status *status);
398
399
int8_t bfloat16_to_int8_scalbn(bfloat16, FloatRoundMode,
400
                               int, float_status *status);
401
int16_t bfloat16_to_int16_scalbn(bfloat16, FloatRoundMode,
402
                                 int, float_status *status);
403
int32_t bfloat16_to_int32_scalbn(bfloat16, FloatRoundMode,
404
                                 int, float_status *status);
405
int64_t bfloat16_to_int64_scalbn(bfloat16, FloatRoundMode,
406
                                 int, float_status *status);
407
408
int8_t bfloat16_to_int8(bfloat16, float_status *status);
409
int16_t bfloat16_to_int16(bfloat16, float_status *status);
410
int32_t bfloat16_to_int32(bfloat16, float_status *status);
411
int64_t bfloat16_to_int64(bfloat16, float_status *status);
412
413
int8_t bfloat16_to_int8_round_to_zero(bfloat16, float_status *status);
414
int16_t bfloat16_to_int16_round_to_zero(bfloat16, float_status *status);
415
int32_t bfloat16_to_int32_round_to_zero(bfloat16, float_status *status);
416
int64_t bfloat16_to_int64_round_to_zero(bfloat16, float_status *status);
417
418
uint8_t bfloat16_to_uint8_scalbn(bfloat16 a, FloatRoundMode,
419
                                 int, float_status *status);
420
uint16_t bfloat16_to_uint16_scalbn(bfloat16 a, FloatRoundMode,
421
                                   int, float_status *status);
422
uint32_t bfloat16_to_uint32_scalbn(bfloat16 a, FloatRoundMode,
423
                                   int, float_status *status);
424
uint64_t bfloat16_to_uint64_scalbn(bfloat16 a, FloatRoundMode,
425
                                   int, float_status *status);
426
427
uint8_t bfloat16_to_uint8(bfloat16 a, float_status *status);
428
uint16_t bfloat16_to_uint16(bfloat16 a, float_status *status);
429
uint32_t bfloat16_to_uint32(bfloat16 a, float_status *status);
430
uint64_t bfloat16_to_uint64(bfloat16 a, float_status *status);
431
432
uint8_t bfloat16_to_uint8_round_to_zero(bfloat16 a, float_status *status);
433
uint16_t bfloat16_to_uint16_round_to_zero(bfloat16 a, float_status *status);
434
uint32_t bfloat16_to_uint32_round_to_zero(bfloat16 a, float_status *status);
435
uint64_t bfloat16_to_uint64_round_to_zero(bfloat16 a, float_status *status);
436
437
bfloat16 int8_to_bfloat16_scalbn(int8_t a, int, float_status *status);
438
bfloat16 int16_to_bfloat16_scalbn(int16_t a, int, float_status *status);
439
bfloat16 int32_to_bfloat16_scalbn(int32_t a, int, float_status *status);
440
bfloat16 int64_to_bfloat16_scalbn(int64_t a, int, float_status *status);
441
bfloat16 uint8_to_bfloat16_scalbn(uint8_t a, int, float_status *status);
442
bfloat16 uint16_to_bfloat16_scalbn(uint16_t a, int, float_status *status);
443
bfloat16 uint32_to_bfloat16_scalbn(uint32_t a, int, float_status *status);
444
bfloat16 uint64_to_bfloat16_scalbn(uint64_t a, int, float_status *status);
445
446
bfloat16 int8_to_bfloat16(int8_t a, float_status *status);
447
bfloat16 int16_to_bfloat16(int16_t a, float_status *status);
448
bfloat16 int32_to_bfloat16(int32_t a, float_status *status);
449
bfloat16 int64_to_bfloat16(int64_t a, float_status *status);
450
bfloat16 uint8_to_bfloat16(uint8_t a, float_status *status);
451
bfloat16 uint16_to_bfloat16(uint16_t a, float_status *status);
452
bfloat16 uint32_to_bfloat16(uint32_t a, float_status *status);
453
bfloat16 uint64_to_bfloat16(uint64_t a, float_status *status);
454
455
/*----------------------------------------------------------------------------
456
| Software bfloat16 operations.
457
*----------------------------------------------------------------------------*/
458
459
bfloat16 bfloat16_add(bfloat16, bfloat16, float_status *status);
460
bfloat16 bfloat16_sub(bfloat16, bfloat16, float_status *status);
461
bfloat16 bfloat16_mul(bfloat16, bfloat16, float_status *status);
462
bfloat16 bfloat16_div(bfloat16, bfloat16, float_status *status);
463
bfloat16 bfloat16_muladd(bfloat16, bfloat16, bfloat16, int,
464
                         float_status *status);
465
float16 bfloat16_scalbn(bfloat16, int, float_status *status);
466
bfloat16 bfloat16_minmax(bfloat16, bfloat16, float_status *status, int flags);
467
bfloat16 bfloat16_sqrt(bfloat16, float_status *status);
468
FloatRelation bfloat16_compare(bfloat16, bfloat16, float_status *status);
469
FloatRelation bfloat16_compare_quiet(bfloat16, bfloat16, float_status *status);
470
471
bool bfloat16_is_quiet_nan(bfloat16, float_status *status);
472
bool bfloat16_is_signaling_nan(bfloat16, float_status *status);
473
bfloat16 bfloat16_silence_nan(bfloat16, float_status *status);
474
bfloat16 bfloat16_default_nan(float_status *status);
475
476
static inline bool bfloat16_is_any_nan(bfloat16 a)
477
0
{
478
0
    return ((a & ~0x8000) > 0x7F80);
479
0
}
Unexecuted instantiation: softfloat.c:bfloat16_is_any_nan
Unexecuted instantiation: fpu_helper.c:bfloat16_is_any_nan
Unexecuted instantiation: translate.c:bfloat16_is_any_nan
480
481
static inline bool bfloat16_is_neg(bfloat16 a)
482
0
{
483
0
    return a >> 15;
484
0
}
Unexecuted instantiation: softfloat.c:bfloat16_is_neg
Unexecuted instantiation: fpu_helper.c:bfloat16_is_neg
Unexecuted instantiation: translate.c:bfloat16_is_neg
485
486
static inline bool bfloat16_is_infinity(bfloat16 a)
487
0
{
488
0
    return (a & 0x7fff) == 0x7F80;
489
0
}
Unexecuted instantiation: softfloat.c:bfloat16_is_infinity
Unexecuted instantiation: fpu_helper.c:bfloat16_is_infinity
Unexecuted instantiation: translate.c:bfloat16_is_infinity
490
491
static inline bool bfloat16_is_zero(bfloat16 a)
492
0
{
493
0
    return (a & 0x7fff) == 0;
494
0
}
Unexecuted instantiation: softfloat.c:bfloat16_is_zero
Unexecuted instantiation: fpu_helper.c:bfloat16_is_zero
Unexecuted instantiation: translate.c:bfloat16_is_zero
495
496
static inline bool bfloat16_is_zero_or_denormal(bfloat16 a)
497
0
{
498
0
    return (a & 0x7F80) == 0;
499
0
}
Unexecuted instantiation: softfloat.c:bfloat16_is_zero_or_denormal
Unexecuted instantiation: fpu_helper.c:bfloat16_is_zero_or_denormal
Unexecuted instantiation: translate.c:bfloat16_is_zero_or_denormal
500
501
static inline bool bfloat16_is_normal(bfloat16 a)
502
0
{
503
0
    return (((a >> 7) + 1) & 0xff) >= 2;
504
0
}
Unexecuted instantiation: softfloat.c:bfloat16_is_normal
Unexecuted instantiation: fpu_helper.c:bfloat16_is_normal
Unexecuted instantiation: translate.c:bfloat16_is_normal
505
506
static inline bfloat16 bfloat16_abs(bfloat16 a)
507
0
{
508
0
    /* Note that abs does *not* handle NaN specially, nor does
509
0
     * it flush denormal inputs to zero.
510
0
     */
511
0
    return a & 0x7fff;
512
0
}
Unexecuted instantiation: softfloat.c:bfloat16_abs
Unexecuted instantiation: fpu_helper.c:bfloat16_abs
Unexecuted instantiation: translate.c:bfloat16_abs
513
514
static inline bfloat16 bfloat16_chs(bfloat16 a)
515
0
{
516
0
    /* Note that chs does *not* handle NaN specially, nor does
517
0
     * it flush denormal inputs to zero.
518
0
     */
519
0
    return a ^ 0x8000;
520
0
}
Unexecuted instantiation: softfloat.c:bfloat16_chs
Unexecuted instantiation: fpu_helper.c:bfloat16_chs
Unexecuted instantiation: translate.c:bfloat16_chs
521
522
static inline bfloat16 bfloat16_set_sign(bfloat16 a, int sign)
523
0
{
524
0
    return (a & 0x7fff) | (sign << 15);
525
0
}
Unexecuted instantiation: softfloat.c:bfloat16_set_sign
Unexecuted instantiation: fpu_helper.c:bfloat16_set_sign
Unexecuted instantiation: translate.c:bfloat16_set_sign
526
527
static inline bool bfloat16_eq(bfloat16 a, bfloat16 b, float_status *s)
528
0
{
529
0
    return bfloat16_compare(a, b, s) == float_relation_equal;
530
0
}
Unexecuted instantiation: softfloat.c:bfloat16_eq
Unexecuted instantiation: fpu_helper.c:bfloat16_eq
Unexecuted instantiation: translate.c:bfloat16_eq
531
532
static inline bool bfloat16_le(bfloat16 a, bfloat16 b, float_status *s)
533
0
{
534
0
    return bfloat16_compare(a, b, s) <= float_relation_equal;
535
0
}
Unexecuted instantiation: softfloat.c:bfloat16_le
Unexecuted instantiation: fpu_helper.c:bfloat16_le
Unexecuted instantiation: translate.c:bfloat16_le
536
537
static inline bool bfloat16_lt(bfloat16 a, bfloat16 b, float_status *s)
538
0
{
539
0
    return bfloat16_compare(a, b, s) < float_relation_equal;
540
0
}
Unexecuted instantiation: softfloat.c:bfloat16_lt
Unexecuted instantiation: fpu_helper.c:bfloat16_lt
Unexecuted instantiation: translate.c:bfloat16_lt
541
542
static inline bool bfloat16_unordered(bfloat16 a, bfloat16 b, float_status *s)
543
0
{
544
0
    return bfloat16_compare(a, b, s) == float_relation_unordered;
545
0
}
Unexecuted instantiation: softfloat.c:bfloat16_unordered
Unexecuted instantiation: fpu_helper.c:bfloat16_unordered
Unexecuted instantiation: translate.c:bfloat16_unordered
546
547
static inline bool bfloat16_eq_quiet(bfloat16 a, bfloat16 b, float_status *s)
548
0
{
549
0
    return bfloat16_compare_quiet(a, b, s) == float_relation_equal;
550
0
}
Unexecuted instantiation: softfloat.c:bfloat16_eq_quiet
Unexecuted instantiation: fpu_helper.c:bfloat16_eq_quiet
Unexecuted instantiation: translate.c:bfloat16_eq_quiet
551
552
static inline bool bfloat16_le_quiet(bfloat16 a, bfloat16 b, float_status *s)
553
0
{
554
0
    return bfloat16_compare_quiet(a, b, s) <= float_relation_equal;
555
0
}
Unexecuted instantiation: softfloat.c:bfloat16_le_quiet
Unexecuted instantiation: fpu_helper.c:bfloat16_le_quiet
Unexecuted instantiation: translate.c:bfloat16_le_quiet
556
557
static inline bool bfloat16_lt_quiet(bfloat16 a, bfloat16 b, float_status *s)
558
0
{
559
0
    return bfloat16_compare_quiet(a, b, s) < float_relation_equal;
560
0
}
Unexecuted instantiation: softfloat.c:bfloat16_lt_quiet
Unexecuted instantiation: fpu_helper.c:bfloat16_lt_quiet
Unexecuted instantiation: translate.c:bfloat16_lt_quiet
561
562
static inline bool bfloat16_unordered_quiet(bfloat16 a, bfloat16 b,
563
                                           float_status *s)
564
0
{
565
0
    return bfloat16_compare_quiet(a, b, s) == float_relation_unordered;
566
0
}
Unexecuted instantiation: softfloat.c:bfloat16_unordered_quiet
Unexecuted instantiation: fpu_helper.c:bfloat16_unordered_quiet
Unexecuted instantiation: translate.c:bfloat16_unordered_quiet
567
568
0
#define bfloat16_zero 0
569
#define bfloat16_half 0x3f00
570
#define bfloat16_one 0x3f80
571
#define bfloat16_one_point_five 0x3fc0
572
#define bfloat16_two 0x4000
573
#define bfloat16_three 0x4040
574
#define bfloat16_infinity 0x7f80
575
576
/*----------------------------------------------------------------------------
577
| The pattern for a default generated half-precision NaN.
578
*----------------------------------------------------------------------------*/
579
float16 float16_default_nan(float_status *status);
580
581
/*----------------------------------------------------------------------------
582
| Software IEC/IEEE single-precision conversion routines.
583
*----------------------------------------------------------------------------*/
584
585
int16_t float32_to_int16_scalbn(float32, FloatRoundMode, int, float_status *);
586
int32_t float32_to_int32_scalbn(float32, FloatRoundMode, int, float_status *);
587
int64_t float32_to_int64_scalbn(float32, FloatRoundMode, int, float_status *);
588
589
int16_t float32_to_int16(float32, float_status *status);
590
int32_t float32_to_int32(float32, float_status *status);
591
int64_t float32_to_int64(float32, float_status *status);
592
593
int16_t float32_to_int16_round_to_zero(float32, float_status *status);
594
int32_t float32_to_int32_round_to_zero(float32, float_status *status);
595
int64_t float32_to_int64_round_to_zero(float32, float_status *status);
596
597
uint16_t float32_to_uint16_scalbn(float32, FloatRoundMode, int, float_status *);
598
uint32_t float32_to_uint32_scalbn(float32, FloatRoundMode, int, float_status *);
599
uint64_t float32_to_uint64_scalbn(float32, FloatRoundMode, int, float_status *);
600
601
uint16_t float32_to_uint16(float32, float_status *status);
602
uint32_t float32_to_uint32(float32, float_status *status);
603
uint64_t float32_to_uint64(float32, float_status *status);
604
605
uint16_t float32_to_uint16_round_to_zero(float32, float_status *status);
606
uint32_t float32_to_uint32_round_to_zero(float32, float_status *status);
607
uint64_t float32_to_uint64_round_to_zero(float32, float_status *status);
608
609
float64 float32_to_float64(float32, float_status *status);
610
floatx80 float32_to_floatx80(float32, float_status *status);
611
float128 float32_to_float128(float32, float_status *status);
612
613
/*----------------------------------------------------------------------------
614
| Software IEC/IEEE single-precision operations.
615
*----------------------------------------------------------------------------*/
616
float32 float32_round_to_int(float32, float_status *status);
617
float32 float32_add(float32, float32, float_status *status);
618
float32 float32_sub(float32, float32, float_status *status);
619
float32 float32_mul(float32, float32, float_status *status);
620
float32 float32_div(float32, float32, float_status *status);
621
float32 float32_rem(float32, float32, float_status *status);
622
float32 float32_muladd(float32, float32, float32, int, float_status *status);
623
float32 float32_muladd_scalbn(float32, float32, float32,
624
                              int, int, float_status *status);
625
float32 float32_sqrt(float32, float_status *status);
626
float32 float32_exp2(float32, float_status *status);
627
float32 float32_log2(float32, float_status *status);
628
FloatRelation float32_compare(float32, float32, float_status *status);
629
FloatRelation float32_compare_quiet(float32, float32, float_status *status);
630
float32 float32_minmax(float32, float32, float_status *status, int flags);
631
bool float32_is_quiet_nan(float32, float_status *status);
632
bool float32_is_signaling_nan(float32, float_status *status);
633
float32 float32_silence_nan(float32, float_status *status);
634
float32 float32_scalbn(float32, int, float_status *status);
635
636
static inline float32 float32_abs(float32 a)
637
0
{
638
0
    /* Note that abs does *not* handle NaN specially, nor does
639
0
     * it flush denormal inputs to zero.
640
0
     */
641
0
    return make_float32(float32_val(a) & 0x7fffffff);
642
0
}
Unexecuted instantiation: softfloat.c:float32_abs
Unexecuted instantiation: fpu_helper.c:float32_abs
Unexecuted instantiation: translate.c:float32_abs
643
644
static inline float32 float32_chs(float32 a)
645
0
{
646
    /* Note that chs does *not* handle NaN specially, nor does
647
     * it flush denormal inputs to zero.
648
     */
649
0
    return make_float32(float32_val(a) ^ 0x80000000);
650
0
}
Unexecuted instantiation: softfloat.c:float32_chs
Unexecuted instantiation: fpu_helper.c:float32_chs
Unexecuted instantiation: translate.c:float32_chs
651
652
static inline bool float32_is_infinity(float32 a)
653
0
{
654
0
    return (float32_val(a) & 0x7fffffff) == 0x7f800000;
655
0
}
Unexecuted instantiation: softfloat.c:float32_is_infinity
Unexecuted instantiation: fpu_helper.c:float32_is_infinity
Unexecuted instantiation: translate.c:float32_is_infinity
656
657
static inline bool float32_is_neg(float32 a)
658
0
{
659
0
    return float32_val(a) >> 31;
660
0
}
Unexecuted instantiation: softfloat.c:float32_is_neg
Unexecuted instantiation: fpu_helper.c:float32_is_neg
Unexecuted instantiation: translate.c:float32_is_neg
661
662
static inline bool float32_is_zero(float32 a)
663
0
{
664
0
    return (float32_val(a) & 0x7fffffff) == 0;
665
0
}
Unexecuted instantiation: softfloat.c:float32_is_zero
Unexecuted instantiation: fpu_helper.c:float32_is_zero
Unexecuted instantiation: translate.c:float32_is_zero
666
667
static inline bool float32_is_any_nan(float32 a)
668
0
{
669
0
    return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL);
670
0
}
Unexecuted instantiation: softfloat.c:float32_is_any_nan
Unexecuted instantiation: fpu_helper.c:float32_is_any_nan
Unexecuted instantiation: translate.c:float32_is_any_nan
671
672
static inline bool float32_is_zero_or_denormal(float32 a)
673
0
{
674
0
    return (float32_val(a) & 0x7f800000) == 0;
675
0
}
Unexecuted instantiation: softfloat.c:float32_is_zero_or_denormal
Unexecuted instantiation: fpu_helper.c:float32_is_zero_or_denormal
Unexecuted instantiation: translate.c:float32_is_zero_or_denormal
676
677
static inline bool float32_is_normal(float32 a)
678
0
{
679
0
    return (((float32_val(a) >> 23) + 1) & 0xff) >= 2;
680
0
}
Unexecuted instantiation: softfloat.c:float32_is_normal
Unexecuted instantiation: fpu_helper.c:float32_is_normal
Unexecuted instantiation: translate.c:float32_is_normal
681
682
static inline bool float32_is_denormal(float32 a)
683
0
{
684
0
    return float32_is_zero_or_denormal(a) && !float32_is_zero(a);
685
0
}
Unexecuted instantiation: softfloat.c:float32_is_denormal
Unexecuted instantiation: fpu_helper.c:float32_is_denormal
Unexecuted instantiation: translate.c:float32_is_denormal
686
687
static inline bool float32_is_zero_or_normal(float32 a)
688
0
{
689
0
    return float32_is_normal(a) || float32_is_zero(a);
690
0
}
Unexecuted instantiation: softfloat.c:float32_is_zero_or_normal
Unexecuted instantiation: fpu_helper.c:float32_is_zero_or_normal
Unexecuted instantiation: translate.c:float32_is_zero_or_normal
691
692
static inline float32 float32_set_sign(float32 a, int sign)
693
0
{
694
0
    return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31));
695
0
}
Unexecuted instantiation: softfloat.c:float32_set_sign
Unexecuted instantiation: fpu_helper.c:float32_set_sign
Unexecuted instantiation: translate.c:float32_set_sign
696
697
static inline bool float32_eq(float32 a, float32 b, float_status *s)
698
0
{
699
0
    return float32_compare(a, b, s) == float_relation_equal;
700
0
}
Unexecuted instantiation: softfloat.c:float32_eq
Unexecuted instantiation: fpu_helper.c:float32_eq
Unexecuted instantiation: translate.c:float32_eq
701
702
static inline bool float32_le(float32 a, float32 b, float_status *s)
703
0
{
704
0
    return float32_compare(a, b, s) <= float_relation_equal;
705
0
}
Unexecuted instantiation: softfloat.c:float32_le
Unexecuted instantiation: fpu_helper.c:float32_le
Unexecuted instantiation: translate.c:float32_le
706
707
static inline bool float32_lt(float32 a, float32 b, float_status *s)
708
0
{
709
0
    return float32_compare(a, b, s) < float_relation_equal;
710
0
}
Unexecuted instantiation: softfloat.c:float32_lt
Unexecuted instantiation: fpu_helper.c:float32_lt
Unexecuted instantiation: translate.c:float32_lt
711
712
static inline bool float32_unordered(float32 a, float32 b, float_status *s)
713
0
{
714
0
    return float32_compare(a, b, s) == float_relation_unordered;
715
0
}
Unexecuted instantiation: softfloat.c:float32_unordered
Unexecuted instantiation: fpu_helper.c:float32_unordered
Unexecuted instantiation: translate.c:float32_unordered
716
717
static inline bool float32_eq_quiet(float32 a, float32 b, float_status *s)
718
0
{
719
0
    return float32_compare_quiet(a, b, s) == float_relation_equal;
720
0
}
Unexecuted instantiation: softfloat.c:float32_eq_quiet
Unexecuted instantiation: fpu_helper.c:float32_eq_quiet
Unexecuted instantiation: translate.c:float32_eq_quiet
721
722
static inline bool float32_le_quiet(float32 a, float32 b, float_status *s)
723
0
{
724
0
    return float32_compare_quiet(a, b, s) <= float_relation_equal;
725
0
}
Unexecuted instantiation: softfloat.c:float32_le_quiet
Unexecuted instantiation: fpu_helper.c:float32_le_quiet
Unexecuted instantiation: translate.c:float32_le_quiet
726
727
static inline bool float32_lt_quiet(float32 a, float32 b, float_status *s)
728
0
{
729
0
    return float32_compare_quiet(a, b, s) < float_relation_equal;
730
0
}
Unexecuted instantiation: softfloat.c:float32_lt_quiet
Unexecuted instantiation: fpu_helper.c:float32_lt_quiet
Unexecuted instantiation: translate.c:float32_lt_quiet
731
732
static inline bool float32_unordered_quiet(float32 a, float32 b,
733
                                           float_status *s)
734
0
{
735
0
    return float32_compare_quiet(a, b, s) == float_relation_unordered;
736
0
}
Unexecuted instantiation: softfloat.c:float32_unordered_quiet
Unexecuted instantiation: fpu_helper.c:float32_unordered_quiet
Unexecuted instantiation: translate.c:float32_unordered_quiet
737
738
0
#define float32_zero make_float32(0)
739
#define float32_half make_float32(0x3f000000)
740
0
#define float32_one make_float32(0x3f800000)
741
#define float32_one_point_five make_float32(0x3fc00000)
742
#define float32_two make_float32(0x40000000)
743
#define float32_three make_float32(0x40400000)
744
#define float32_infinity make_float32(0x7f800000)
745
746
/*----------------------------------------------------------------------------
747
| Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
748
| single-precision floating-point value, returning the result.  After being
749
| shifted into the proper positions, the three fields are simply added
750
| together to form the result.  This means that any integer portion of `zSig'
751
| will be added into the exponent.  Since a properly normalized significand
752
| will have an integer portion equal to 1, the `zExp' input should be 1 less
753
| than the desired result exponent whenever `zSig' is a complete, normalized
754
| significand.
755
*----------------------------------------------------------------------------*/
756
757
static inline float32 packFloat32(bool zSign, int zExp, uint32_t zSig)
758
0
{
759
0
    return make_float32(
760
0
          (((uint32_t)zSign) << 31) + (((uint32_t)zExp) << 23) + zSig);
761
0
}
Unexecuted instantiation: softfloat.c:packFloat32
Unexecuted instantiation: fpu_helper.c:packFloat32
Unexecuted instantiation: translate.c:packFloat32
762
763
/*----------------------------------------------------------------------------
764
| The pattern for a default generated single-precision NaN.
765
*----------------------------------------------------------------------------*/
766
float32 float32_default_nan(float_status *status);
767
768
/*----------------------------------------------------------------------------
769
| Software IEC/IEEE double-precision conversion routines.
770
*----------------------------------------------------------------------------*/
771
772
int16_t float64_to_int16_scalbn(float64, FloatRoundMode, int, float_status *);
773
int32_t float64_to_int32_scalbn(float64, FloatRoundMode, int, float_status *);
774
int64_t float64_to_int64_scalbn(float64, FloatRoundMode, int, float_status *);
775
776
int16_t float64_to_int16(float64, float_status *status);
777
int32_t float64_to_int32(float64, float_status *status);
778
int64_t float64_to_int64(float64, float_status *status);
779
780
int16_t float64_to_int16_round_to_zero(float64, float_status *status);
781
int32_t float64_to_int32_round_to_zero(float64, float_status *status);
782
int64_t float64_to_int64_round_to_zero(float64, float_status *status);
783
784
int32_t float64_to_int32_modulo(float64, FloatRoundMode, float_status *status);
785
int64_t float64_to_int64_modulo(float64, FloatRoundMode, float_status *status);
786
787
uint16_t float64_to_uint16_scalbn(float64, FloatRoundMode, int, float_status *);
788
uint32_t float64_to_uint32_scalbn(float64, FloatRoundMode, int, float_status *);
789
uint64_t float64_to_uint64_scalbn(float64, FloatRoundMode, int, float_status *);
790
791
uint16_t float64_to_uint16(float64, float_status *status);
792
uint32_t float64_to_uint32(float64, float_status *status);
793
uint64_t float64_to_uint64(float64, float_status *status);
794
795
uint16_t float64_to_uint16_round_to_zero(float64, float_status *status);
796
uint32_t float64_to_uint32_round_to_zero(float64, float_status *status);
797
uint64_t float64_to_uint64_round_to_zero(float64, float_status *status);
798
799
float32 float64_to_float32(float64, float_status *status);
800
floatx80 float64_to_floatx80(float64, float_status *status);
801
float128 float64_to_float128(float64, float_status *status);
802
803
/*----------------------------------------------------------------------------
804
| Software IEC/IEEE double-precision operations.
805
*----------------------------------------------------------------------------*/
806
float64 float64_round_to_int(float64, float_status *status);
807
float64 float64_add(float64, float64, float_status *status);
808
float64 float64_sub(float64, float64, float_status *status);
809
float64 float64_mul(float64, float64, float_status *status);
810
float64 float64_div(float64, float64, float_status *status);
811
float64 float64_rem(float64, float64, float_status *status);
812
float64 float64_muladd(float64, float64, float64, int, float_status *status);
813
float64 float64_muladd_scalbn(float64, float64, float64,
814
                              int, int, float_status *status);
815
float64 float64_sqrt(float64, float_status *status);
816
float64 float64_log2(float64, float_status *status);
817
FloatRelation float64_compare(float64, float64, float_status *status);
818
FloatRelation float64_compare_quiet(float64, float64, float_status *status);
819
float64 float64_minmax(float64, float64, float_status *status, int flags);
820
bool float64_is_quiet_nan(float64 a, float_status *status);
821
bool float64_is_signaling_nan(float64, float_status *status);
822
float64 float64_silence_nan(float64, float_status *status);
823
float64 float64_scalbn(float64, int, float_status *status);
824
825
static inline float64 float64_abs(float64 a)
826
0
{
827
0
    /* Note that abs does *not* handle NaN specially, nor does
828
0
     * it flush denormal inputs to zero.
829
0
     */
830
0
    return make_float64(float64_val(a) & 0x7fffffffffffffffLL);
831
0
}
Unexecuted instantiation: softfloat.c:float64_abs
Unexecuted instantiation: fpu_helper.c:float64_abs
Unexecuted instantiation: translate.c:float64_abs
832
833
static inline float64 float64_chs(float64 a)
834
0
{
835
    /* Note that chs does *not* handle NaN specially, nor does
836
     * it flush denormal inputs to zero.
837
     */
838
0
    return make_float64(float64_val(a) ^ 0x8000000000000000LL);
839
0
}
Unexecuted instantiation: softfloat.c:float64_chs
Unexecuted instantiation: fpu_helper.c:float64_chs
Unexecuted instantiation: translate.c:float64_chs
840
841
static inline bool float64_is_infinity(float64 a)
842
0
{
843
0
    return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL;
844
0
}
Unexecuted instantiation: softfloat.c:float64_is_infinity
Unexecuted instantiation: fpu_helper.c:float64_is_infinity
Unexecuted instantiation: translate.c:float64_is_infinity
845
846
static inline bool float64_is_neg(float64 a)
847
0
{
848
0
    return float64_val(a) >> 63;
849
0
}
Unexecuted instantiation: softfloat.c:float64_is_neg
Unexecuted instantiation: fpu_helper.c:float64_is_neg
Unexecuted instantiation: translate.c:float64_is_neg
850
851
static inline bool float64_is_zero(float64 a)
852
0
{
853
0
    return (float64_val(a) & 0x7fffffffffffffffLL) == 0;
854
0
}
Unexecuted instantiation: softfloat.c:float64_is_zero
Unexecuted instantiation: fpu_helper.c:float64_is_zero
Unexecuted instantiation: translate.c:float64_is_zero
855
856
static inline bool float64_is_any_nan(float64 a)
857
0
{
858
0
    return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL);
859
0
}
Unexecuted instantiation: softfloat.c:float64_is_any_nan
Unexecuted instantiation: fpu_helper.c:float64_is_any_nan
Unexecuted instantiation: translate.c:float64_is_any_nan
860
861
static inline bool float64_is_zero_or_denormal(float64 a)
862
0
{
863
0
    return (float64_val(a) & 0x7ff0000000000000LL) == 0;
864
0
}
Unexecuted instantiation: softfloat.c:float64_is_zero_or_denormal
Unexecuted instantiation: fpu_helper.c:float64_is_zero_or_denormal
Unexecuted instantiation: translate.c:float64_is_zero_or_denormal
865
866
static inline bool float64_is_normal(float64 a)
867
0
{
868
0
    return (((float64_val(a) >> 52) + 1) & 0x7ff) >= 2;
869
0
}
Unexecuted instantiation: softfloat.c:float64_is_normal
Unexecuted instantiation: fpu_helper.c:float64_is_normal
Unexecuted instantiation: translate.c:float64_is_normal
870
871
static inline bool float64_is_denormal(float64 a)
872
0
{
873
0
    return float64_is_zero_or_denormal(a) && !float64_is_zero(a);
874
0
}
Unexecuted instantiation: softfloat.c:float64_is_denormal
Unexecuted instantiation: fpu_helper.c:float64_is_denormal
Unexecuted instantiation: translate.c:float64_is_denormal
875
876
static inline bool float64_is_zero_or_normal(float64 a)
877
0
{
878
0
    return float64_is_normal(a) || float64_is_zero(a);
879
0
}
Unexecuted instantiation: softfloat.c:float64_is_zero_or_normal
Unexecuted instantiation: fpu_helper.c:float64_is_zero_or_normal
Unexecuted instantiation: translate.c:float64_is_zero_or_normal
880
881
static inline float64 float64_set_sign(float64 a, int sign)
882
0
{
883
0
    return make_float64((float64_val(a) & 0x7fffffffffffffffULL)
884
0
                        | ((int64_t)sign << 63));
885
0
}
Unexecuted instantiation: softfloat.c:float64_set_sign
Unexecuted instantiation: fpu_helper.c:float64_set_sign
Unexecuted instantiation: translate.c:float64_set_sign
886
887
static inline bool float64_eq(float64 a, float64 b, float_status *s)
888
0
{
889
0
    return float64_compare(a, b, s) == float_relation_equal;
890
0
}
Unexecuted instantiation: softfloat.c:float64_eq
Unexecuted instantiation: fpu_helper.c:float64_eq
Unexecuted instantiation: translate.c:float64_eq
891
892
static inline bool float64_le(float64 a, float64 b, float_status *s)
893
0
{
894
0
    return float64_compare(a, b, s) <= float_relation_equal;
895
0
}
Unexecuted instantiation: softfloat.c:float64_le
Unexecuted instantiation: fpu_helper.c:float64_le
Unexecuted instantiation: translate.c:float64_le
896
897
static inline bool float64_lt(float64 a, float64 b, float_status *s)
898
0
{
899
0
    return float64_compare(a, b, s) < float_relation_equal;
900
0
}
Unexecuted instantiation: softfloat.c:float64_lt
Unexecuted instantiation: fpu_helper.c:float64_lt
Unexecuted instantiation: translate.c:float64_lt
901
902
static inline bool float64_unordered(float64 a, float64 b, float_status *s)
903
0
{
904
0
    return float64_compare(a, b, s) == float_relation_unordered;
905
0
}
Unexecuted instantiation: softfloat.c:float64_unordered
Unexecuted instantiation: fpu_helper.c:float64_unordered
Unexecuted instantiation: translate.c:float64_unordered
906
907
static inline bool float64_eq_quiet(float64 a, float64 b, float_status *s)
908
0
{
909
0
    return float64_compare_quiet(a, b, s) == float_relation_equal;
910
0
}
Unexecuted instantiation: softfloat.c:float64_eq_quiet
Unexecuted instantiation: fpu_helper.c:float64_eq_quiet
Unexecuted instantiation: translate.c:float64_eq_quiet
911
912
static inline bool float64_le_quiet(float64 a, float64 b, float_status *s)
913
0
{
914
0
    return float64_compare_quiet(a, b, s) <= float_relation_equal;
915
0
}
Unexecuted instantiation: softfloat.c:float64_le_quiet
Unexecuted instantiation: fpu_helper.c:float64_le_quiet
Unexecuted instantiation: translate.c:float64_le_quiet
916
917
static inline bool float64_lt_quiet(float64 a, float64 b, float_status *s)
918
0
{
919
0
    return float64_compare_quiet(a, b, s) < float_relation_equal;
920
0
}
Unexecuted instantiation: softfloat.c:float64_lt_quiet
Unexecuted instantiation: fpu_helper.c:float64_lt_quiet
Unexecuted instantiation: translate.c:float64_lt_quiet
921
922
static inline bool float64_unordered_quiet(float64 a, float64 b,
923
                                           float_status *s)
924
0
{
925
0
    return float64_compare_quiet(a, b, s) == float_relation_unordered;
926
0
}
Unexecuted instantiation: softfloat.c:float64_unordered_quiet
Unexecuted instantiation: fpu_helper.c:float64_unordered_quiet
Unexecuted instantiation: translate.c:float64_unordered_quiet
927
928
0
#define float64_zero make_float64(0)
929
#define float64_half make_float64(0x3fe0000000000000LL)
930
0
#define float64_one make_float64(0x3ff0000000000000LL)
931
#define float64_one_point_five make_float64(0x3FF8000000000000ULL)
932
#define float64_two make_float64(0x4000000000000000ULL)
933
#define float64_three make_float64(0x4008000000000000ULL)
934
0
#define float64_ln2 make_float64(0x3fe62e42fefa39efLL)
935
#define float64_infinity make_float64(0x7ff0000000000000LL)
936
937
/*----------------------------------------------------------------------------
938
| The pattern for a default generated double-precision NaN.
939
*----------------------------------------------------------------------------*/
940
float64 float64_default_nan(float_status *status);
941
942
/*----------------------------------------------------------------------------
943
| Software IEC/IEEE double-precision operations, rounding to single precision,
944
| returning a result in double precision, with only one rounding step.
945
*----------------------------------------------------------------------------*/
946
947
float64 float64r32_add(float64, float64, float_status *status);
948
float64 float64r32_sub(float64, float64, float_status *status);
949
float64 float64r32_mul(float64, float64, float_status *status);
950
float64 float64r32_div(float64, float64, float_status *status);
951
float64 float64r32_muladd(float64, float64, float64, int, float_status *status);
952
float64 float64r32_sqrt(float64, float_status *status);
953
954
/*----------------------------------------------------------------------------
955
| Software IEC/IEEE extended double-precision conversion routines.
956
*----------------------------------------------------------------------------*/
957
int32_t floatx80_to_int32(floatx80, float_status *status);
958
int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status);
959
int64_t floatx80_to_int64(floatx80, float_status *status);
960
int64_t floatx80_to_int64_round_to_zero(floatx80, float_status *status);
961
float32 floatx80_to_float32(floatx80, float_status *status);
962
float64 floatx80_to_float64(floatx80, float_status *status);
963
float128 floatx80_to_float128(floatx80, float_status *status);
964
965
/*----------------------------------------------------------------------------
966
| The pattern for an extended double-precision inf.
967
*----------------------------------------------------------------------------*/
968
floatx80 floatx80_default_inf(bool zSign, float_status *status);
969
970
/*----------------------------------------------------------------------------
971
| Software IEC/IEEE extended double-precision operations.
972
*----------------------------------------------------------------------------*/
973
floatx80 floatx80_round(floatx80 a, float_status *status);
974
floatx80 floatx80_round_to_int(floatx80, float_status *status);
975
floatx80 floatx80_add(floatx80, floatx80, float_status *status);
976
floatx80 floatx80_sub(floatx80, floatx80, float_status *status);
977
floatx80 floatx80_mul(floatx80, floatx80, float_status *status);
978
floatx80 floatx80_div(floatx80, floatx80, float_status *status);
979
floatx80 floatx80_modrem(floatx80, floatx80, bool, uint64_t *,
980
                         float_status *status);
981
floatx80 floatx80_mod(floatx80, floatx80, float_status *status);
982
floatx80 floatx80_rem(floatx80, floatx80, float_status *status);
983
floatx80 floatx80_sqrt(floatx80, float_status *status);
984
FloatRelation floatx80_compare(floatx80, floatx80, float_status *status);
985
FloatRelation floatx80_compare_quiet(floatx80, floatx80, float_status *status);
986
bool floatx80_is_quiet_nan(floatx80, float_status *status);
987
bool floatx80_is_signaling_nan(floatx80, float_status *status);
988
floatx80 floatx80_silence_nan(floatx80, float_status *status);
989
floatx80 floatx80_scalbn(floatx80, int, float_status *status);
990
991
static inline floatx80 floatx80_abs(floatx80 a)
992
0
{
993
0
    a.high &= 0x7fff;
994
0
    return a;
995
0
}
Unexecuted instantiation: softfloat.c:floatx80_abs
Unexecuted instantiation: fpu_helper.c:floatx80_abs
Unexecuted instantiation: translate.c:floatx80_abs
996
997
static inline floatx80 floatx80_chs(floatx80 a)
998
0
{
999
0
    a.high ^= 0x8000;
1000
0
    return a;
1001
0
}
Unexecuted instantiation: softfloat.c:floatx80_chs
Unexecuted instantiation: fpu_helper.c:floatx80_chs
Unexecuted instantiation: translate.c:floatx80_chs
1002
1003
static inline bool floatx80_is_infinity(floatx80 a, float_status *status)
1004
0
{
1005
    /*
1006
     * It's target-specific whether the Integer bit is permitted
1007
     * to be 0 in a valid Infinity value. (x86 says no, m68k says yes).
1008
     */
1009
0
    bool intbit = a.low >> 63;
1010
1011
0
    if (!intbit &&
1012
0
        !(get_floatx80_behaviour(status) & floatx80_pseudo_inf_valid)) {
1013
0
        return false;
1014
0
    }
1015
0
    return (a.high & 0x7fff) == 0x7fff && !(a.low << 1);
1016
0
}
Unexecuted instantiation: softfloat.c:floatx80_is_infinity
Unexecuted instantiation: fpu_helper.c:floatx80_is_infinity
Unexecuted instantiation: translate.c:floatx80_is_infinity
1017
1018
static inline bool floatx80_is_neg(floatx80 a)
1019
0
{
1020
0
    return a.high >> 15;
1021
0
}
Unexecuted instantiation: softfloat.c:floatx80_is_neg
Unexecuted instantiation: fpu_helper.c:floatx80_is_neg
Unexecuted instantiation: translate.c:floatx80_is_neg
1022
1023
static inline bool floatx80_is_zero(floatx80 a)
1024
0
{
1025
0
    return (a.high & 0x7fff) == 0 && a.low == 0;
1026
0
}
Unexecuted instantiation: softfloat.c:floatx80_is_zero
Unexecuted instantiation: fpu_helper.c:floatx80_is_zero
Unexecuted instantiation: translate.c:floatx80_is_zero
1027
1028
static inline bool floatx80_is_zero_or_denormal(floatx80 a)
1029
0
{
1030
0
    return (a.high & 0x7fff) == 0;
1031
0
}
Unexecuted instantiation: softfloat.c:floatx80_is_zero_or_denormal
Unexecuted instantiation: fpu_helper.c:floatx80_is_zero_or_denormal
Unexecuted instantiation: translate.c:floatx80_is_zero_or_denormal
1032
1033
static inline bool floatx80_is_any_nan(floatx80 a)
1034
0
{
1035
0
    return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1);
1036
0
}
Unexecuted instantiation: softfloat.c:floatx80_is_any_nan
Unexecuted instantiation: fpu_helper.c:floatx80_is_any_nan
Unexecuted instantiation: translate.c:floatx80_is_any_nan
1037
1038
static inline bool floatx80_eq(floatx80 a, floatx80 b, float_status *s)
1039
0
{
1040
0
    return floatx80_compare(a, b, s) == float_relation_equal;
1041
0
}
Unexecuted instantiation: softfloat.c:floatx80_eq
Unexecuted instantiation: fpu_helper.c:floatx80_eq
Unexecuted instantiation: translate.c:floatx80_eq
1042
1043
static inline bool floatx80_le(floatx80 a, floatx80 b, float_status *s)
1044
0
{
1045
0
    return floatx80_compare(a, b, s) <= float_relation_equal;
1046
0
}
Unexecuted instantiation: softfloat.c:floatx80_le
Unexecuted instantiation: fpu_helper.c:floatx80_le
Unexecuted instantiation: translate.c:floatx80_le
1047
1048
static inline bool floatx80_lt(floatx80 a, floatx80 b, float_status *s)
1049
0
{
1050
0
    return floatx80_compare(a, b, s) < float_relation_equal;
1051
0
}
Unexecuted instantiation: softfloat.c:floatx80_lt
Unexecuted instantiation: fpu_helper.c:floatx80_lt
Unexecuted instantiation: translate.c:floatx80_lt
1052
1053
static inline bool floatx80_unordered(floatx80 a, floatx80 b, float_status *s)
1054
0
{
1055
0
    return floatx80_compare(a, b, s) == float_relation_unordered;
1056
0
}
Unexecuted instantiation: softfloat.c:floatx80_unordered
Unexecuted instantiation: fpu_helper.c:floatx80_unordered
Unexecuted instantiation: translate.c:floatx80_unordered
1057
1058
static inline bool floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *s)
1059
0
{
1060
0
    return floatx80_compare_quiet(a, b, s) == float_relation_equal;
1061
0
}
Unexecuted instantiation: softfloat.c:floatx80_eq_quiet
Unexecuted instantiation: fpu_helper.c:floatx80_eq_quiet
Unexecuted instantiation: translate.c:floatx80_eq_quiet
1062
1063
static inline bool floatx80_le_quiet(floatx80 a, floatx80 b, float_status *s)
1064
0
{
1065
0
    return floatx80_compare_quiet(a, b, s) <= float_relation_equal;
1066
0
}
Unexecuted instantiation: softfloat.c:floatx80_le_quiet
Unexecuted instantiation: fpu_helper.c:floatx80_le_quiet
Unexecuted instantiation: translate.c:floatx80_le_quiet
1067
1068
static inline bool floatx80_lt_quiet(floatx80 a, floatx80 b, float_status *s)
1069
0
{
1070
0
    return floatx80_compare_quiet(a, b, s) < float_relation_equal;
1071
0
}
Unexecuted instantiation: softfloat.c:floatx80_lt_quiet
Unexecuted instantiation: fpu_helper.c:floatx80_lt_quiet
Unexecuted instantiation: translate.c:floatx80_lt_quiet
1072
1073
static inline bool floatx80_unordered_quiet(floatx80 a, floatx80 b,
1074
                                           float_status *s)
1075
0
{
1076
0
    return floatx80_compare_quiet(a, b, s) == float_relation_unordered;
1077
0
}
Unexecuted instantiation: softfloat.c:floatx80_unordered_quiet
Unexecuted instantiation: fpu_helper.c:floatx80_unordered_quiet
Unexecuted instantiation: translate.c:floatx80_unordered_quiet
1078
1079
/*----------------------------------------------------------------------------
1080
| Return whether the given value is an invalid floatx80 encoding.
1081
| Invalid floatx80 encodings may arise when the integer bit is not set
1082
| correctly; this is target-specific. In Intel terminology the
1083
| categories are:
1084
|  exp == 0, int = 0, mantissa == 0 : zeroes
1085
|  exp == 0, int = 0, mantissa != 0 : denormals
1086
|  exp == 0, int = 1 : pseudo-denormals
1087
|  0 < exp < 0x7fff, int = 0 : unnormals
1088
|  0 < exp < 0x7fff, int = 1 : normals
1089
|  exp == 0x7fff, int = 0, mantissa == 0 : pseudo-infinities
1090
|  exp == 0x7fff, int = 1, mantissa == 0 : infinities
1091
|  exp == 0x7fff, int = 0, mantissa != 0 : pseudo-NaNs
1092
|  exp == 0x7fff, int = 1, mantissa == 0 : NaNs
1093
|
1094
| The usual IEEE cases of zero, denormal, normal, inf and NaN are always valid.
1095
| x87 permits as input also pseudo-denormals.
1096
| m68k permits all those and also pseudo-infinities, pseudo-NaNs and unnormals.
1097
|
1098
| Since we don't have a target that handles floatx80 but prohibits
1099
| pseudo-denormals in input, we don't currently have a floatx80_behaviour
1100
| flag for that case, but instead always accept it. Conveniently this
1101
| means that all cases with either exponent 0 or the integer bit set are
1102
| valid for all targets.
1103
*----------------------------------------------------------------------------*/
1104
static inline bool floatx80_invalid_encoding(floatx80 a, float_status *s)
1105
0
{
1106
0
    FloatX80Behaviour rule = get_floatx80_behaviour(s);
1107
1108
0
    if ((a.low >> 63) || (a.high & 0x7fff) == 0) {
1109
        /* Anything with the Integer bit set or the exponent 0 is valid */
1110
0
        return false;
1111
0
    }
1112
1113
0
    if ((a.high & 0x7fff) == 0x7fff) {
1114
0
        if (a.low) {
1115
0
            return !(rule & floatx80_pseudo_nan_valid);
1116
0
        } else {
1117
0
            return !(rule & floatx80_pseudo_inf_valid);
1118
0
        }
1119
0
    } else {
1120
0
        return !(rule & floatx80_unnormal_valid);
1121
0
    }
1122
0
}
Unexecuted instantiation: softfloat.c:floatx80_invalid_encoding
Unexecuted instantiation: fpu_helper.c:floatx80_invalid_encoding
Unexecuted instantiation: translate.c:floatx80_invalid_encoding
1123
1124
0
#define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL)
1125
#define floatx80_zero_init make_floatx80_init(0x0000, 0x0000000000000000LL)
1126
0
#define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL)
1127
0
#define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL)
1128
0
#define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL)
1129
#define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL)
1130
1131
/*----------------------------------------------------------------------------
1132
| Returns the fraction bits of the extended double-precision floating-point
1133
| value `a'.
1134
*----------------------------------------------------------------------------*/
1135
1136
static inline uint64_t extractFloatx80Frac(floatx80 a)
1137
0
{
1138
0
    return a.low;
1139
0
}
Unexecuted instantiation: softfloat.c:extractFloatx80Frac
Unexecuted instantiation: fpu_helper.c:extractFloatx80Frac
Unexecuted instantiation: translate.c:extractFloatx80Frac
1140
1141
/*----------------------------------------------------------------------------
1142
| Returns the exponent bits of the extended double-precision floating-point
1143
| value `a'.
1144
*----------------------------------------------------------------------------*/
1145
1146
static inline int32_t extractFloatx80Exp(floatx80 a)
1147
0
{
1148
0
    return a.high & 0x7FFF;
1149
0
}
Unexecuted instantiation: softfloat.c:extractFloatx80Exp
Unexecuted instantiation: fpu_helper.c:extractFloatx80Exp
Unexecuted instantiation: translate.c:extractFloatx80Exp
1150
1151
/*----------------------------------------------------------------------------
1152
| Returns the sign bit of the extended double-precision floating-point value
1153
| `a'.
1154
*----------------------------------------------------------------------------*/
1155
1156
static inline bool extractFloatx80Sign(floatx80 a)
1157
0
{
1158
0
    return a.high >> 15;
1159
0
}
Unexecuted instantiation: softfloat.c:extractFloatx80Sign
Unexecuted instantiation: fpu_helper.c:extractFloatx80Sign
Unexecuted instantiation: translate.c:extractFloatx80Sign
1160
1161
/*----------------------------------------------------------------------------
1162
| Packs the sign `zSign', exponent `zExp', and significand `zSig' into an
1163
| extended double-precision floating-point value, returning the result.
1164
*----------------------------------------------------------------------------*/
1165
1166
static inline floatx80 packFloatx80(bool zSign, int32_t zExp, uint64_t zSig)
1167
0
{
1168
0
    floatx80 z;
1169
1170
0
    z.low = zSig;
1171
0
    z.high = (((uint16_t)zSign) << 15) + zExp;
1172
0
    return z;
1173
0
}
Unexecuted instantiation: softfloat.c:packFloatx80
Unexecuted instantiation: fpu_helper.c:packFloatx80
Unexecuted instantiation: translate.c:packFloatx80
1174
1175
/*----------------------------------------------------------------------------
1176
| Normalizes the subnormal extended double-precision floating-point value
1177
| represented by the denormalized significand `aSig'.  The normalized exponent
1178
| and significand are stored at the locations pointed to by `zExpPtr' and
1179
| `zSigPtr', respectively.
1180
*----------------------------------------------------------------------------*/
1181
1182
void normalizeFloatx80Subnormal(uint64_t aSig, int32_t *zExpPtr,
1183
                                uint64_t *zSigPtr);
1184
1185
/*----------------------------------------------------------------------------
1186
| Takes two extended double-precision floating-point values `a' and `b', one
1187
| of which is a NaN, and returns the appropriate NaN result.  If either `a' or
1188
| `b' is a signaling NaN, the invalid exception is raised.
1189
*----------------------------------------------------------------------------*/
1190
1191
floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b, float_status *status);
1192
1193
/*----------------------------------------------------------------------------
1194
| Takes an abstract floating-point value having sign `zSign', exponent `zExp',
1195
| and extended significand formed by the concatenation of `zSig0' and `zSig1',
1196
| and returns the proper extended double-precision floating-point value
1197
| corresponding to the abstract input.  Ordinarily, the abstract value is
1198
| rounded and packed into the extended double-precision format, with the
1199
| inexact exception raised if the abstract input cannot be represented
1200
| exactly.  However, if the abstract value is too large, the overflow and
1201
| inexact exceptions are raised and an infinity or maximal finite value is
1202
| returned.  If the abstract value is too small, the input value is rounded to
1203
| a subnormal number, and the underflow and inexact exceptions are raised if
1204
| the abstract input cannot be represented exactly as a subnormal extended
1205
| double-precision floating-point number.
1206
|     If `roundingPrecision' is 32 or 64, the result is rounded to the same
1207
| number of bits as single or double precision, respectively.  Otherwise, the
1208
| result is rounded to the full precision of the extended double-precision
1209
| format.
1210
|     The input significand must be normalized or smaller.  If the input
1211
| significand is not normalized, `zExp' must be 0; in that case, the result
1212
| returned is a subnormal number, and it must not require rounding.  The
1213
| handling of underflow and overflow follows the IEC/IEEE Standard for Binary
1214
| Floating-Point Arithmetic.
1215
*----------------------------------------------------------------------------*/
1216
1217
floatx80 roundAndPackFloatx80(FloatX80RoundPrec roundingPrecision, bool zSign,
1218
                              int32_t zExp, uint64_t zSig0, uint64_t zSig1,
1219
                              float_status *status);
1220
1221
/*----------------------------------------------------------------------------
1222
| Takes an abstract floating-point value having sign `zSign', exponent
1223
| `zExp', and significand formed by the concatenation of `zSig0' and `zSig1',
1224
| and returns the proper extended double-precision floating-point value
1225
| corresponding to the abstract input.  This routine is just like
1226
| `roundAndPackFloatx80' except that the input significand does not have to be
1227
| normalized.
1228
*----------------------------------------------------------------------------*/
1229
1230
floatx80 normalizeRoundAndPackFloatx80(FloatX80RoundPrec roundingPrecision,
1231
                                       bool zSign, int32_t zExp,
1232
                                       uint64_t zSig0, uint64_t zSig1,
1233
                                       float_status *status);
1234
1235
/*----------------------------------------------------------------------------
1236
| The pattern for a default generated extended double-precision NaN.
1237
*----------------------------------------------------------------------------*/
1238
floatx80 floatx80_default_nan(float_status *status);
1239
1240
/*----------------------------------------------------------------------------
1241
| Software IEC/IEEE quadruple-precision conversion routines.
1242
*----------------------------------------------------------------------------*/
1243
int32_t float128_to_int32(float128, float_status *status);
1244
int32_t float128_to_int32_round_to_zero(float128, float_status *status);
1245
int64_t float128_to_int64(float128, float_status *status);
1246
Int128 float128_to_int128(float128, float_status *status);
1247
int64_t float128_to_int64_round_to_zero(float128, float_status *status);
1248
Int128 float128_to_int128_round_to_zero(float128, float_status *status);
1249
uint64_t float128_to_uint64(float128, float_status *status);
1250
Int128 float128_to_uint128(float128, float_status *status);
1251
uint64_t float128_to_uint64_round_to_zero(float128, float_status *status);
1252
Int128 float128_to_uint128_round_to_zero(float128, float_status *status);
1253
uint32_t float128_to_uint32(float128, float_status *status);
1254
uint32_t float128_to_uint32_round_to_zero(float128, float_status *status);
1255
float32 float128_to_float32(float128, float_status *status);
1256
float64 float128_to_float64(float128, float_status *status);
1257
floatx80 float128_to_floatx80(float128, float_status *status);
1258
1259
/*----------------------------------------------------------------------------
1260
| Software IEC/IEEE quadruple-precision operations.
1261
*----------------------------------------------------------------------------*/
1262
float128 float128_round_to_int(float128, float_status *status);
1263
float128 float128_add(float128, float128, float_status *status);
1264
float128 float128_sub(float128, float128, float_status *status);
1265
float128 float128_mul(float128, float128, float_status *status);
1266
float128 float128_muladd(float128, float128, float128, int,
1267
                         float_status *status);
1268
float128 float128_div(float128, float128, float_status *status);
1269
float128 float128_rem(float128, float128, float_status *status);
1270
float128 float128_sqrt(float128, float_status *status);
1271
FloatRelation float128_compare(float128, float128, float_status *status);
1272
FloatRelation float128_compare_quiet(float128, float128, float_status *status);
1273
float128 float128_minmax(float128, float128, float_status *status, int flags);
1274
bool float128_is_quiet_nan(float128, float_status *status);
1275
bool float128_is_signaling_nan(float128, float_status *status);
1276
float128 float128_silence_nan(float128, float_status *status);
1277
float128 float128_scalbn(float128, int, float_status *status);
1278
1279
static inline float128 float128_abs(float128 a)
1280
0
{
1281
0
    a.high &= 0x7fffffffffffffffLL;
1282
0
    return a;
1283
0
}
Unexecuted instantiation: softfloat.c:float128_abs
Unexecuted instantiation: fpu_helper.c:float128_abs
Unexecuted instantiation: translate.c:float128_abs
1284
1285
static inline float128 float128_chs(float128 a)
1286
0
{
1287
0
    a.high ^= 0x8000000000000000LL;
1288
0
    return a;
1289
0
}
Unexecuted instantiation: softfloat.c:float128_chs
Unexecuted instantiation: fpu_helper.c:float128_chs
Unexecuted instantiation: translate.c:float128_chs
1290
1291
static inline bool float128_is_infinity(float128 a)
1292
0
{
1293
0
    return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0;
1294
0
}
Unexecuted instantiation: softfloat.c:float128_is_infinity
Unexecuted instantiation: fpu_helper.c:float128_is_infinity
Unexecuted instantiation: translate.c:float128_is_infinity
1295
1296
static inline bool float128_is_neg(float128 a)
1297
0
{
1298
0
    return a.high >> 63;
1299
0
}
Unexecuted instantiation: softfloat.c:float128_is_neg
Unexecuted instantiation: fpu_helper.c:float128_is_neg
Unexecuted instantiation: translate.c:float128_is_neg
1300
1301
static inline bool float128_is_zero(float128 a)
1302
0
{
1303
0
    return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0;
1304
0
}
Unexecuted instantiation: softfloat.c:float128_is_zero
Unexecuted instantiation: fpu_helper.c:float128_is_zero
Unexecuted instantiation: translate.c:float128_is_zero
1305
1306
static inline bool float128_is_zero_or_denormal(float128 a)
1307
0
{
1308
0
    return (a.high & 0x7fff000000000000LL) == 0;
1309
0
}
Unexecuted instantiation: softfloat.c:float128_is_zero_or_denormal
Unexecuted instantiation: fpu_helper.c:float128_is_zero_or_denormal
Unexecuted instantiation: translate.c:float128_is_zero_or_denormal
1310
1311
static inline bool float128_is_normal(float128 a)
1312
0
{
1313
0
    return (((a.high >> 48) + 1) & 0x7fff) >= 2;
1314
0
}
Unexecuted instantiation: softfloat.c:float128_is_normal
Unexecuted instantiation: fpu_helper.c:float128_is_normal
Unexecuted instantiation: translate.c:float128_is_normal
1315
1316
static inline bool float128_is_denormal(float128 a)
1317
0
{
1318
0
    return float128_is_zero_or_denormal(a) && !float128_is_zero(a);
1319
0
}
Unexecuted instantiation: softfloat.c:float128_is_denormal
Unexecuted instantiation: fpu_helper.c:float128_is_denormal
Unexecuted instantiation: translate.c:float128_is_denormal
1320
1321
static inline bool float128_is_any_nan(float128 a)
1322
0
{
1323
0
    return ((a.high >> 48) & 0x7fff) == 0x7fff &&
1324
0
        ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));
1325
0
}
Unexecuted instantiation: softfloat.c:float128_is_any_nan
Unexecuted instantiation: fpu_helper.c:float128_is_any_nan
Unexecuted instantiation: translate.c:float128_is_any_nan
1326
1327
static inline bool float128_eq(float128 a, float128 b, float_status *s)
1328
0
{
1329
0
    return float128_compare(a, b, s) == float_relation_equal;
1330
0
}
Unexecuted instantiation: softfloat.c:float128_eq
Unexecuted instantiation: fpu_helper.c:float128_eq
Unexecuted instantiation: translate.c:float128_eq
1331
1332
static inline bool float128_le(float128 a, float128 b, float_status *s)
1333
0
{
1334
0
    return float128_compare(a, b, s) <= float_relation_equal;
1335
0
}
Unexecuted instantiation: softfloat.c:float128_le
Unexecuted instantiation: fpu_helper.c:float128_le
Unexecuted instantiation: translate.c:float128_le
1336
1337
static inline bool float128_lt(float128 a, float128 b, float_status *s)
1338
0
{
1339
0
    return float128_compare(a, b, s) < float_relation_equal;
1340
0
}
Unexecuted instantiation: softfloat.c:float128_lt
Unexecuted instantiation: fpu_helper.c:float128_lt
Unexecuted instantiation: translate.c:float128_lt
1341
1342
static inline bool float128_unordered(float128 a, float128 b, float_status *s)
1343
0
{
1344
0
    return float128_compare(a, b, s) == float_relation_unordered;
1345
0
}
Unexecuted instantiation: softfloat.c:float128_unordered
Unexecuted instantiation: fpu_helper.c:float128_unordered
Unexecuted instantiation: translate.c:float128_unordered
1346
1347
static inline bool float128_eq_quiet(float128 a, float128 b, float_status *s)
1348
0
{
1349
0
    return float128_compare_quiet(a, b, s) == float_relation_equal;
1350
0
}
Unexecuted instantiation: softfloat.c:float128_eq_quiet
Unexecuted instantiation: fpu_helper.c:float128_eq_quiet
Unexecuted instantiation: translate.c:float128_eq_quiet
1351
1352
static inline bool float128_le_quiet(float128 a, float128 b, float_status *s)
1353
0
{
1354
0
    return float128_compare_quiet(a, b, s) <= float_relation_equal;
1355
0
}
Unexecuted instantiation: softfloat.c:float128_le_quiet
Unexecuted instantiation: fpu_helper.c:float128_le_quiet
Unexecuted instantiation: translate.c:float128_le_quiet
1356
1357
static inline bool float128_lt_quiet(float128 a, float128 b, float_status *s)
1358
0
{
1359
0
    return float128_compare_quiet(a, b, s) < float_relation_equal;
1360
0
}
Unexecuted instantiation: softfloat.c:float128_lt_quiet
Unexecuted instantiation: fpu_helper.c:float128_lt_quiet
Unexecuted instantiation: translate.c:float128_lt_quiet
1361
1362
static inline bool float128_unordered_quiet(float128 a, float128 b,
1363
                                           float_status *s)
1364
0
{
1365
0
    return float128_compare_quiet(a, b, s) == float_relation_unordered;
1366
0
}
Unexecuted instantiation: softfloat.c:float128_unordered_quiet
Unexecuted instantiation: fpu_helper.c:float128_unordered_quiet
Unexecuted instantiation: translate.c:float128_unordered_quiet
1367
1368
#define float128_zero make_float128(0, 0)
1369
1370
/*----------------------------------------------------------------------------
1371
| The pattern for a default generated quadruple-precision NaN.
1372
*----------------------------------------------------------------------------*/
1373
float128 float128_default_nan(float_status *status);
1374
1375
/*----------------------------------------------------------------------------
1376
| Minumum and maximum functions.
1377
*----------------------------------------------------------------------------*/
1378
1379
#define MINMAX_1(type, name, flags)                                     \
1380
    static inline type type##_##name(type a, type b, float_status *s)   \
1381
0
    { return type##_minmax(a, b, s, flags); }
Unexecuted instantiation: softfloat.c:float16_max
Unexecuted instantiation: softfloat.c:float16_maxnum
Unexecuted instantiation: softfloat.c:float16_maxnummag
Unexecuted instantiation: softfloat.c:float16_maximum_number
Unexecuted instantiation: softfloat.c:float16_min
Unexecuted instantiation: softfloat.c:float16_minnum
Unexecuted instantiation: softfloat.c:float16_minnummag
Unexecuted instantiation: softfloat.c:float16_minimum_number
Unexecuted instantiation: softfloat.c:bfloat16_max
Unexecuted instantiation: softfloat.c:bfloat16_maxnum
Unexecuted instantiation: softfloat.c:bfloat16_maxnummag
Unexecuted instantiation: softfloat.c:bfloat16_maximum_number
Unexecuted instantiation: softfloat.c:bfloat16_min
Unexecuted instantiation: softfloat.c:bfloat16_minnum
Unexecuted instantiation: softfloat.c:bfloat16_minnummag
Unexecuted instantiation: softfloat.c:bfloat16_minimum_number
Unexecuted instantiation: softfloat.c:float32_max
Unexecuted instantiation: softfloat.c:float32_maxnum
Unexecuted instantiation: softfloat.c:float32_maxnummag
Unexecuted instantiation: softfloat.c:float32_maximum_number
Unexecuted instantiation: softfloat.c:float32_min
Unexecuted instantiation: softfloat.c:float32_minnum
Unexecuted instantiation: softfloat.c:float32_minnummag
Unexecuted instantiation: softfloat.c:float32_minimum_number
Unexecuted instantiation: softfloat.c:float64_max
Unexecuted instantiation: softfloat.c:float64_maxnum
Unexecuted instantiation: softfloat.c:float64_maxnummag
Unexecuted instantiation: softfloat.c:float64_maximum_number
Unexecuted instantiation: softfloat.c:float64_min
Unexecuted instantiation: softfloat.c:float64_minnum
Unexecuted instantiation: softfloat.c:float64_minnummag
Unexecuted instantiation: softfloat.c:float64_minimum_number
Unexecuted instantiation: softfloat.c:float128_max
Unexecuted instantiation: softfloat.c:float128_maxnum
Unexecuted instantiation: softfloat.c:float128_maxnummag
Unexecuted instantiation: softfloat.c:float128_maximum_number
Unexecuted instantiation: softfloat.c:float128_min
Unexecuted instantiation: softfloat.c:float128_minnum
Unexecuted instantiation: softfloat.c:float128_minnummag
Unexecuted instantiation: softfloat.c:float128_minimum_number
Unexecuted instantiation: fpu_helper.c:float16_max
Unexecuted instantiation: fpu_helper.c:float16_maxnum
Unexecuted instantiation: fpu_helper.c:float16_maxnummag
Unexecuted instantiation: fpu_helper.c:float16_maximum_number
Unexecuted instantiation: fpu_helper.c:float16_min
Unexecuted instantiation: fpu_helper.c:float16_minnum
Unexecuted instantiation: fpu_helper.c:float16_minnummag
Unexecuted instantiation: fpu_helper.c:float16_minimum_number
Unexecuted instantiation: fpu_helper.c:bfloat16_max
Unexecuted instantiation: fpu_helper.c:bfloat16_maxnum
Unexecuted instantiation: fpu_helper.c:bfloat16_maxnummag
Unexecuted instantiation: fpu_helper.c:bfloat16_maximum_number
Unexecuted instantiation: fpu_helper.c:bfloat16_min
Unexecuted instantiation: fpu_helper.c:bfloat16_minnum
Unexecuted instantiation: fpu_helper.c:bfloat16_minnummag
Unexecuted instantiation: fpu_helper.c:bfloat16_minimum_number
Unexecuted instantiation: fpu_helper.c:float32_max
Unexecuted instantiation: fpu_helper.c:float32_maxnum
Unexecuted instantiation: fpu_helper.c:float32_maxnummag
Unexecuted instantiation: fpu_helper.c:float32_maximum_number
Unexecuted instantiation: fpu_helper.c:float32_min
Unexecuted instantiation: fpu_helper.c:float32_minnum
Unexecuted instantiation: fpu_helper.c:float32_minnummag
Unexecuted instantiation: fpu_helper.c:float32_minimum_number
Unexecuted instantiation: fpu_helper.c:float64_max
Unexecuted instantiation: fpu_helper.c:float64_maxnum
Unexecuted instantiation: fpu_helper.c:float64_maxnummag
Unexecuted instantiation: fpu_helper.c:float64_maximum_number
Unexecuted instantiation: fpu_helper.c:float64_min
Unexecuted instantiation: fpu_helper.c:float64_minnum
Unexecuted instantiation: fpu_helper.c:float64_minnummag
Unexecuted instantiation: fpu_helper.c:float64_minimum_number
Unexecuted instantiation: fpu_helper.c:float128_max
Unexecuted instantiation: fpu_helper.c:float128_maxnum
Unexecuted instantiation: fpu_helper.c:float128_maxnummag
Unexecuted instantiation: fpu_helper.c:float128_maximum_number
Unexecuted instantiation: fpu_helper.c:float128_min
Unexecuted instantiation: fpu_helper.c:float128_minnum
Unexecuted instantiation: fpu_helper.c:float128_minnummag
Unexecuted instantiation: fpu_helper.c:float128_minimum_number
Unexecuted instantiation: translate.c:float16_max
Unexecuted instantiation: translate.c:float16_maxnum
Unexecuted instantiation: translate.c:float16_maxnummag
Unexecuted instantiation: translate.c:float16_maximum_number
Unexecuted instantiation: translate.c:float16_min
Unexecuted instantiation: translate.c:float16_minnum
Unexecuted instantiation: translate.c:float16_minnummag
Unexecuted instantiation: translate.c:float16_minimum_number
Unexecuted instantiation: translate.c:bfloat16_max
Unexecuted instantiation: translate.c:bfloat16_maxnum
Unexecuted instantiation: translate.c:bfloat16_maxnummag
Unexecuted instantiation: translate.c:bfloat16_maximum_number
Unexecuted instantiation: translate.c:bfloat16_min
Unexecuted instantiation: translate.c:bfloat16_minnum
Unexecuted instantiation: translate.c:bfloat16_minnummag
Unexecuted instantiation: translate.c:bfloat16_minimum_number
Unexecuted instantiation: translate.c:float32_max
Unexecuted instantiation: translate.c:float32_maxnum
Unexecuted instantiation: translate.c:float32_maxnummag
Unexecuted instantiation: translate.c:float32_maximum_number
Unexecuted instantiation: translate.c:float32_min
Unexecuted instantiation: translate.c:float32_minnum
Unexecuted instantiation: translate.c:float32_minnummag
Unexecuted instantiation: translate.c:float32_minimum_number
Unexecuted instantiation: translate.c:float64_max
Unexecuted instantiation: translate.c:float64_maxnum
Unexecuted instantiation: translate.c:float64_maxnummag
Unexecuted instantiation: translate.c:float64_maximum_number
Unexecuted instantiation: translate.c:float64_min
Unexecuted instantiation: translate.c:float64_minnum
Unexecuted instantiation: translate.c:float64_minnummag
Unexecuted instantiation: translate.c:float64_minimum_number
Unexecuted instantiation: translate.c:float128_max
Unexecuted instantiation: translate.c:float128_maxnum
Unexecuted instantiation: translate.c:float128_maxnummag
Unexecuted instantiation: translate.c:float128_maximum_number
Unexecuted instantiation: translate.c:float128_min
Unexecuted instantiation: translate.c:float128_minnum
Unexecuted instantiation: translate.c:float128_minnummag
Unexecuted instantiation: translate.c:float128_minimum_number
1382
1383
#define MINMAX_2(type)                                                  \
1384
    MINMAX_1(type, max, 0)                                              \
1385
    MINMAX_1(type, maxnum, float_minmax_isnum)                          \
1386
    MINMAX_1(type, maxnummag, float_minmax_isnum | float_minmax_ismag)  \
1387
    MINMAX_1(type, maximum_number, float_minmax_isnumber)               \
1388
    MINMAX_1(type, min, float_minmax_ismin)                             \
1389
    MINMAX_1(type, minnum, float_minmax_ismin | float_minmax_isnum)     \
1390
    MINMAX_1(type, minnummag,                                           \
1391
             float_minmax_ismin | float_minmax_isnum | float_minmax_ismag) \
1392
    MINMAX_1(type, minimum_number,                                      \
1393
             float_minmax_ismin | float_minmax_isnumber)
1394
1395
MINMAX_2(float16)
1396
MINMAX_2(bfloat16)
1397
MINMAX_2(float32)
1398
MINMAX_2(float64)
1399
MINMAX_2(float128)
1400
1401
#undef MINMAX_1
1402
#undef MINMAX_2
1403
1404
#endif /* SOFTFLOAT_H */