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