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_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
914int32_t floatx80_to_int32(floatx80, float_status *status);
915int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status);
916int64_t floatx80_to_int64(floatx80, float_status *status);
917int64_t floatx80_to_int64_round_to_zero(floatx80, float_status *status);
918float32 floatx80_to_float32(floatx80, float_status *status);
919float64 floatx80_to_float64(floatx80, float_status *status);
920float128 floatx80_to_float128(floatx80, float_status *status);
921
922
923
924
925extern const floatx80 floatx80_infinity;
926
927
928
929
930floatx80 floatx80_round(floatx80 a, float_status *status);
931floatx80 floatx80_round_to_int(floatx80, float_status *status);
932floatx80 floatx80_add(floatx80, floatx80, float_status *status);
933floatx80 floatx80_sub(floatx80, floatx80, float_status *status);
934floatx80 floatx80_mul(floatx80, floatx80, float_status *status);
935floatx80 floatx80_div(floatx80, floatx80, float_status *status);
936floatx80 floatx80_modrem(floatx80, floatx80, bool, uint64_t *,
937 float_status *status);
938floatx80 floatx80_mod(floatx80, floatx80, float_status *status);
939floatx80 floatx80_rem(floatx80, floatx80, float_status *status);
940floatx80 floatx80_sqrt(floatx80, float_status *status);
941FloatRelation floatx80_compare(floatx80, floatx80, float_status *status);
942FloatRelation floatx80_compare_quiet(floatx80, floatx80, float_status *status);
943int floatx80_is_quiet_nan(floatx80, float_status *status);
944int floatx80_is_signaling_nan(floatx80, float_status *status);
945floatx80 floatx80_silence_nan(floatx80, float_status *status);
946floatx80 floatx80_scalbn(floatx80, int, float_status *status);
947
948static inline floatx80 floatx80_abs(floatx80 a)
949{
950 a.high &= 0x7fff;
951 return a;
952}
953
954static inline floatx80 floatx80_chs(floatx80 a)
955{
956 a.high ^= 0x8000;
957 return a;
958}
959
960static inline bool floatx80_is_infinity(floatx80 a)
961{
962#if defined(TARGET_M68K)
963 return (a.high & 0x7fff) == floatx80_infinity.high && !(a.low << 1);
964#else
965 return (a.high & 0x7fff) == floatx80_infinity.high &&
966 a.low == floatx80_infinity.low;
967#endif
968}
969
970static inline bool floatx80_is_neg(floatx80 a)
971{
972 return a.high >> 15;
973}
974
975static inline bool floatx80_is_zero(floatx80 a)
976{
977 return (a.high & 0x7fff) == 0 && a.low == 0;
978}
979
980static inline bool floatx80_is_zero_or_denormal(floatx80 a)
981{
982 return (a.high & 0x7fff) == 0;
983}
984
985static inline bool floatx80_is_any_nan(floatx80 a)
986{
987 return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1);
988}
989
990static inline bool floatx80_eq(floatx80 a, floatx80 b, float_status *s)
991{
992 return floatx80_compare(a, b, s) == float_relation_equal;
993}
994
995static inline bool floatx80_le(floatx80 a, floatx80 b, float_status *s)
996{
997 return floatx80_compare(a, b, s) <= float_relation_equal;
998}
999
1000static inline bool floatx80_lt(floatx80 a, floatx80 b, float_status *s)
1001{
1002 return floatx80_compare(a, b, s) < float_relation_equal;
1003}
1004
1005static inline bool floatx80_unordered(floatx80 a, floatx80 b, float_status *s)
1006{
1007 return floatx80_compare(a, b, s) == float_relation_unordered;
1008}
1009
1010static inline bool floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *s)
1011{
1012 return floatx80_compare_quiet(a, b, s) == float_relation_equal;
1013}
1014
1015static inline bool floatx80_le_quiet(floatx80 a, floatx80 b, float_status *s)
1016{
1017 return floatx80_compare_quiet(a, b, s) <= float_relation_equal;
1018}
1019
1020static inline bool floatx80_lt_quiet(floatx80 a, floatx80 b, float_status *s)
1021{
1022 return floatx80_compare_quiet(a, b, s) < float_relation_equal;
1023}
1024
1025static inline bool floatx80_unordered_quiet(floatx80 a, floatx80 b,
1026 float_status *s)
1027{
1028 return floatx80_compare_quiet(a, b, s) == float_relation_unordered;
1029}
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041static inline bool floatx80_invalid_encoding(floatx80 a)
1042{
1043#if defined(TARGET_M68K)
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064 return false;
1065#else
1066 return (a.low & (1ULL << 63)) == 0 && (a.high & 0x7FFF) != 0;
1067#endif
1068}
1069
1070#define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL)
1071#define floatx80_zero_init make_floatx80_init(0x0000, 0x0000000000000000LL)
1072#define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL)
1073#define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL)
1074#define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL)
1075#define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL)
1076
1077
1078
1079
1080
1081
1082static inline uint64_t extractFloatx80Frac(floatx80 a)
1083{
1084 return a.low;
1085}
1086
1087
1088
1089
1090
1091
1092static inline int32_t extractFloatx80Exp(floatx80 a)
1093{
1094 return a.high & 0x7FFF;
1095}
1096
1097
1098
1099
1100
1101
1102static inline bool extractFloatx80Sign(floatx80 a)
1103{
1104 return a.high >> 15;
1105}
1106
1107
1108
1109
1110
1111
1112static inline floatx80 packFloatx80(bool zSign, int32_t zExp, uint64_t zSig)
1113{
1114 floatx80 z;
1115
1116 z.low = zSig;
1117 z.high = (((uint16_t)zSign) << 15) + zExp;
1118 return z;
1119}
1120
1121
1122
1123
1124
1125
1126
1127
1128void normalizeFloatx80Subnormal(uint64_t aSig, int32_t *zExpPtr,
1129 uint64_t *zSigPtr);
1130
1131
1132
1133
1134
1135
1136
1137floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b, float_status *status);
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163floatx80 roundAndPackFloatx80(FloatX80RoundPrec roundingPrecision, bool zSign,
1164 int32_t zExp, uint64_t zSig0, uint64_t zSig1,
1165 float_status *status);
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176floatx80 normalizeRoundAndPackFloatx80(FloatX80RoundPrec roundingPrecision,
1177 bool zSign, int32_t zExp,
1178 uint64_t zSig0, uint64_t zSig1,
1179 float_status *status);
1180
1181
1182
1183
1184floatx80 floatx80_default_nan(float_status *status);
1185
1186
1187
1188
1189int32_t float128_to_int32(float128, float_status *status);
1190int32_t float128_to_int32_round_to_zero(float128, float_status *status);
1191int64_t float128_to_int64(float128, float_status *status);
1192int64_t float128_to_int64_round_to_zero(float128, float_status *status);
1193uint64_t float128_to_uint64(float128, float_status *status);
1194uint64_t float128_to_uint64_round_to_zero(float128, float_status *status);
1195uint32_t float128_to_uint32(float128, float_status *status);
1196uint32_t float128_to_uint32_round_to_zero(float128, float_status *status);
1197float32 float128_to_float32(float128, float_status *status);
1198float64 float128_to_float64(float128, float_status *status);
1199floatx80 float128_to_floatx80(float128, float_status *status);
1200
1201
1202
1203
1204float128 float128_round_to_int(float128, float_status *status);
1205float128 float128_add(float128, float128, float_status *status);
1206float128 float128_sub(float128, float128, float_status *status);
1207float128 float128_mul(float128, float128, float_status *status);
1208float128 float128_muladd(float128, float128, float128, int,
1209 float_status *status);
1210float128 float128_div(float128, float128, float_status *status);
1211float128 float128_rem(float128, float128, float_status *status);
1212float128 float128_sqrt(float128, float_status *status);
1213FloatRelation float128_compare(float128, float128, float_status *status);
1214FloatRelation float128_compare_quiet(float128, float128, float_status *status);
1215float128 float128_min(float128, float128, float_status *status);
1216float128 float128_max(float128, float128, float_status *status);
1217float128 float128_minnum(float128, float128, float_status *status);
1218float128 float128_maxnum(float128, float128, float_status *status);
1219float128 float128_minnummag(float128, float128, float_status *status);
1220float128 float128_maxnummag(float128, float128, float_status *status);
1221float128 float128_minimum_number(float128, float128, float_status *status);
1222float128 float128_maximum_number(float128, float128, float_status *status);
1223bool float128_is_quiet_nan(float128, float_status *status);
1224bool float128_is_signaling_nan(float128, float_status *status);
1225float128 float128_silence_nan(float128, float_status *status);
1226float128 float128_scalbn(float128, int, float_status *status);
1227
1228static inline float128 float128_abs(float128 a)
1229{
1230 a.high &= 0x7fffffffffffffffLL;
1231 return a;
1232}
1233
1234static inline float128 float128_chs(float128 a)
1235{
1236 a.high ^= 0x8000000000000000LL;
1237 return a;
1238}
1239
1240static inline bool float128_is_infinity(float128 a)
1241{
1242 return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0;
1243}
1244
1245static inline bool float128_is_neg(float128 a)
1246{
1247 return a.high >> 63;
1248}
1249
1250static inline bool float128_is_zero(float128 a)
1251{
1252 return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0;
1253}
1254
1255static inline bool float128_is_zero_or_denormal(float128 a)
1256{
1257 return (a.high & 0x7fff000000000000LL) == 0;
1258}
1259
1260static inline bool float128_is_normal(float128 a)
1261{
1262 return (((a.high >> 48) + 1) & 0x7fff) >= 2;
1263}
1264
1265static inline bool float128_is_denormal(float128 a)
1266{
1267 return float128_is_zero_or_denormal(a) && !float128_is_zero(a);
1268}
1269
1270static inline bool float128_is_any_nan(float128 a)
1271{
1272 return ((a.high >> 48) & 0x7fff) == 0x7fff &&
1273 ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));
1274}
1275
1276static inline bool float128_eq(float128 a, float128 b, float_status *s)
1277{
1278 return float128_compare(a, b, s) == float_relation_equal;
1279}
1280
1281static inline bool float128_le(float128 a, float128 b, float_status *s)
1282{
1283 return float128_compare(a, b, s) <= float_relation_equal;
1284}
1285
1286static inline bool float128_lt(float128 a, float128 b, float_status *s)
1287{
1288 return float128_compare(a, b, s) < float_relation_equal;
1289}
1290
1291static inline bool float128_unordered(float128 a, float128 b, float_status *s)
1292{
1293 return float128_compare(a, b, s) == float_relation_unordered;
1294}
1295
1296static inline bool float128_eq_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_le_quiet(float128 a, float128 b, float_status *s)
1302{
1303 return float128_compare_quiet(a, b, s) <= float_relation_equal;
1304}
1305
1306static inline bool float128_lt_quiet(float128 a, float128 b, float_status *s)
1307{
1308 return float128_compare_quiet(a, b, s) < float_relation_equal;
1309}
1310
1311static inline bool float128_unordered_quiet(float128 a, float128 b,
1312 float_status *s)
1313{
1314 return float128_compare_quiet(a, b, s) == float_relation_unordered;
1315}
1316
1317#define float128_zero make_float128(0, 0)
1318
1319
1320
1321
1322float128 float128_default_nan(float_status *status);
1323
1324#endif
1325