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