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