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#if defined(CONFIG_SOLARIS) && defined(CONFIG_NEEDS_LIBSUNMATH)
86#include <sunmath.h>
87#endif
88
89
90
91
92
93
94typedef uint8_t flag;
95
96#define LIT64( a ) a##LL
97
98
99
100
101enum {
102 float_relation_less = -1,
103 float_relation_equal = 0,
104 float_relation_greater = 1,
105 float_relation_unordered = 2
106};
107
108
109
110
111
112
113
114
115
116#ifdef USE_SOFTFLOAT_STRUCT_TYPES
117typedef struct {
118 uint16_t v;
119} float16;
120#define float16_val(x) (((float16)(x)).v)
121#define make_float16(x) __extension__ ({ float16 f16_val = {x}; f16_val; })
122#define const_float16(x) { x }
123typedef struct {
124 uint32_t v;
125} float32;
126
127#define float32_val(x) (((float32)(x)).v)
128#define make_float32(x) __extension__ ({ float32 f32_val = {x}; f32_val; })
129#define const_float32(x) { x }
130typedef struct {
131 uint64_t v;
132} float64;
133#define float64_val(x) (((float64)(x)).v)
134#define make_float64(x) __extension__ ({ float64 f64_val = {x}; f64_val; })
135#define const_float64(x) { x }
136#else
137typedef uint16_t float16;
138typedef uint32_t float32;
139typedef uint64_t float64;
140#define float16_val(x) (x)
141#define float32_val(x) (x)
142#define float64_val(x) (x)
143#define make_float16(x) (x)
144#define make_float32(x) (x)
145#define make_float64(x) (x)
146#define const_float16(x) (x)
147#define const_float32(x) (x)
148#define const_float64(x) (x)
149#endif
150typedef struct {
151 uint64_t low;
152 uint16_t high;
153} floatx80;
154#define make_floatx80(exp, mant) ((floatx80) { mant, exp })
155#define make_floatx80_init(exp, mant) { .low = mant, .high = exp }
156typedef struct {
157#ifdef HOST_WORDS_BIGENDIAN
158 uint64_t high, low;
159#else
160 uint64_t low, high;
161#endif
162} float128;
163#define make_float128(high_, low_) ((float128) { .high = high_, .low = low_ })
164#define make_float128_init(high_, low_) { .high = high_, .low = low_ }
165
166
167
168
169enum {
170 float_tininess_after_rounding = 0,
171 float_tininess_before_rounding = 1
172};
173
174
175
176
177enum {
178 float_round_nearest_even = 0,
179 float_round_down = 1,
180 float_round_up = 2,
181 float_round_to_zero = 3,
182 float_round_ties_away = 4,
183};
184
185
186
187
188enum {
189 float_flag_invalid = 1,
190 float_flag_divbyzero = 4,
191 float_flag_overflow = 8,
192 float_flag_underflow = 16,
193 float_flag_inexact = 32,
194 float_flag_input_denormal = 64,
195 float_flag_output_denormal = 128
196};
197
198typedef struct float_status {
199 signed char float_detect_tininess;
200 signed char float_rounding_mode;
201 signed char float_exception_flags;
202 signed char floatx80_rounding_precision;
203
204 flag flush_to_zero;
205
206 flag flush_inputs_to_zero;
207 flag default_nan_mode;
208} float_status;
209
210static inline void set_float_detect_tininess(int val, float_status *status)
211{
212 status->float_detect_tininess = val;
213}
214static inline void set_float_rounding_mode(int val, float_status *status)
215{
216 status->float_rounding_mode = val;
217}
218static inline void set_float_exception_flags(int val, float_status *status)
219{
220 status->float_exception_flags = val;
221}
222static inline void set_floatx80_rounding_precision(int val,
223 float_status *status)
224{
225 status->floatx80_rounding_precision = val;
226}
227static inline void set_flush_to_zero(flag val, float_status *status)
228{
229 status->flush_to_zero = val;
230}
231static inline void set_flush_inputs_to_zero(flag val, float_status *status)
232{
233 status->flush_inputs_to_zero = val;
234}
235static inline void set_default_nan_mode(flag val, float_status *status)
236{
237 status->default_nan_mode = val;
238}
239static inline int get_float_detect_tininess(float_status *status)
240{
241 return status->float_detect_tininess;
242}
243static inline int get_float_rounding_mode(float_status *status)
244{
245 return status->float_rounding_mode;
246}
247static inline int get_float_exception_flags(float_status *status)
248{
249 return status->float_exception_flags;
250}
251static inline int get_floatx80_rounding_precision(float_status *status)
252{
253 return status->floatx80_rounding_precision;
254}
255static inline flag get_flush_to_zero(float_status *status)
256{
257 return status->flush_to_zero;
258}
259static inline flag get_flush_inputs_to_zero(float_status *status)
260{
261 return status->flush_inputs_to_zero;
262}
263static inline flag get_default_nan_mode(float_status *status)
264{
265 return status->default_nan_mode;
266}
267
268
269
270
271
272void float_raise(int8_t flags, float_status *status);
273
274
275
276
277
278float32 float32_squash_input_denormal(float32 a, float_status *status);
279float64 float64_squash_input_denormal(float64 a, float_status *status);
280
281
282
283
284
285
286
287
288
289enum {
290 float_muladd_negate_c = 1,
291 float_muladd_negate_product = 2,
292 float_muladd_negate_result = 4,
293 float_muladd_halve_result = 8,
294};
295
296
297
298
299float32 int32_to_float32(int32_t, float_status *status);
300float64 int32_to_float64(int32_t, float_status *status);
301float32 uint32_to_float32(uint32_t, float_status *status);
302float64 uint32_to_float64(uint32_t, float_status *status);
303floatx80 int32_to_floatx80(int32_t, float_status *status);
304float128 int32_to_float128(int32_t, float_status *status);
305float32 int64_to_float32(int64_t, float_status *status);
306float64 int64_to_float64(int64_t, float_status *status);
307floatx80 int64_to_floatx80(int64_t, float_status *status);
308float128 int64_to_float128(int64_t, float_status *status);
309float32 uint64_to_float32(uint64_t, float_status *status);
310float64 uint64_to_float64(uint64_t, float_status *status);
311float128 uint64_to_float128(uint64_t, float_status *status);
312
313
314static inline float32 int16_to_float32(int16_t v, float_status *status)
315{
316 return int32_to_float32(v, status);
317}
318
319static inline float32 uint16_to_float32(uint16_t v, float_status *status)
320{
321 return uint32_to_float32(v, status);
322}
323
324static inline float64 int16_to_float64(int16_t v, float_status *status)
325{
326 return int32_to_float64(v, status);
327}
328
329static inline float64 uint16_to_float64(uint16_t v, float_status *status)
330{
331 return uint32_to_float64(v, status);
332}
333
334
335
336
337float16 float32_to_float16(float32, flag, float_status *status);
338float32 float16_to_float32(float16, flag, float_status *status);
339float16 float64_to_float16(float64 a, flag ieee, float_status *status);
340float64 float16_to_float64(float16 a, flag ieee, float_status *status);
341
342
343
344
345int float16_is_quiet_nan( float16 );
346int float16_is_signaling_nan( float16 );
347float16 float16_maybe_silence_nan( float16 );
348
349static inline int float16_is_any_nan(float16 a)
350{
351 return ((float16_val(a) & ~0x8000) > 0x7c00);
352}
353
354
355
356
357extern const float16 float16_default_nan;
358
359
360
361
362int16_t float32_to_int16(float32, float_status *status);
363uint16_t float32_to_uint16(float32, float_status *status);
364int16_t float32_to_int16_round_to_zero(float32, float_status *status);
365uint16_t float32_to_uint16_round_to_zero(float32, float_status *status);
366int32_t float32_to_int32(float32, float_status *status);
367int32_t float32_to_int32_round_to_zero(float32, float_status *status);
368uint32_t float32_to_uint32(float32, float_status *status);
369uint32_t float32_to_uint32_round_to_zero(float32, float_status *status);
370int64_t float32_to_int64(float32, float_status *status);
371uint64_t float32_to_uint64(float32, float_status *status);
372uint64_t float32_to_uint64_round_to_zero(float32, float_status *status);
373int64_t float32_to_int64_round_to_zero(float32, float_status *status);
374float64 float32_to_float64(float32, float_status *status);
375floatx80 float32_to_floatx80(float32, float_status *status);
376float128 float32_to_float128(float32, float_status *status);
377
378
379
380
381float32 float32_round_to_int(float32, float_status *status);
382float32 float32_add(float32, float32, float_status *status);
383float32 float32_sub(float32, float32, float_status *status);
384float32 float32_mul(float32, float32, float_status *status);
385float32 float32_div(float32, float32, float_status *status);
386float32 float32_rem(float32, float32, float_status *status);
387float32 float32_muladd(float32, float32, float32, int, float_status *status);
388float32 float32_sqrt(float32, float_status *status);
389float32 float32_exp2(float32, float_status *status);
390float32 float32_log2(float32, float_status *status);
391int float32_eq(float32, float32, float_status *status);
392int float32_le(float32, float32, float_status *status);
393int float32_lt(float32, float32, float_status *status);
394int float32_unordered(float32, float32, float_status *status);
395int float32_eq_quiet(float32, float32, float_status *status);
396int float32_le_quiet(float32, float32, float_status *status);
397int float32_lt_quiet(float32, float32, float_status *status);
398int float32_unordered_quiet(float32, float32, float_status *status);
399int float32_compare(float32, float32, float_status *status);
400int float32_compare_quiet(float32, float32, float_status *status);
401float32 float32_min(float32, float32, float_status *status);
402float32 float32_max(float32, float32, float_status *status);
403float32 float32_minnum(float32, float32, float_status *status);
404float32 float32_maxnum(float32, float32, float_status *status);
405float32 float32_minnummag(float32, float32, float_status *status);
406float32 float32_maxnummag(float32, float32, float_status *status);
407int float32_is_quiet_nan( float32 );
408int float32_is_signaling_nan( float32 );
409float32 float32_maybe_silence_nan( float32 );
410float32 float32_scalbn(float32, int, float_status *status);
411
412static inline float32 float32_abs(float32 a)
413{
414
415
416
417 return make_float32(float32_val(a) & 0x7fffffff);
418}
419
420static inline float32 float32_chs(float32 a)
421{
422
423
424
425 return make_float32(float32_val(a) ^ 0x80000000);
426}
427
428static inline int float32_is_infinity(float32 a)
429{
430 return (float32_val(a) & 0x7fffffff) == 0x7f800000;
431}
432
433static inline int float32_is_neg(float32 a)
434{
435 return float32_val(a) >> 31;
436}
437
438static inline int float32_is_zero(float32 a)
439{
440 return (float32_val(a) & 0x7fffffff) == 0;
441}
442
443static inline int float32_is_any_nan(float32 a)
444{
445 return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL);
446}
447
448static inline int float32_is_zero_or_denormal(float32 a)
449{
450 return (float32_val(a) & 0x7f800000) == 0;
451}
452
453static inline float32 float32_set_sign(float32 a, int sign)
454{
455 return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31));
456}
457
458#define float32_zero make_float32(0)
459#define float32_one make_float32(0x3f800000)
460#define float32_ln2 make_float32(0x3f317218)
461#define float32_pi make_float32(0x40490fdb)
462#define float32_half make_float32(0x3f000000)
463#define float32_infinity make_float32(0x7f800000)
464
465
466
467
468
469extern const float32 float32_default_nan;
470
471
472
473
474int16_t float64_to_int16(float64, float_status *status);
475uint16_t float64_to_uint16(float64, float_status *status);
476int16_t float64_to_int16_round_to_zero(float64, float_status *status);
477uint16_t float64_to_uint16_round_to_zero(float64, float_status *status);
478int32_t float64_to_int32(float64, float_status *status);
479int32_t float64_to_int32_round_to_zero(float64, float_status *status);
480uint32_t float64_to_uint32(float64, float_status *status);
481uint32_t float64_to_uint32_round_to_zero(float64, float_status *status);
482int64_t float64_to_int64(float64, float_status *status);
483int64_t float64_to_int64_round_to_zero(float64, float_status *status);
484uint64_t float64_to_uint64(float64 a, float_status *status);
485uint64_t float64_to_uint64_round_to_zero(float64 a, float_status *status);
486float32 float64_to_float32(float64, float_status *status);
487floatx80 float64_to_floatx80(float64, float_status *status);
488float128 float64_to_float128(float64, float_status *status);
489
490
491
492
493float64 float64_round_to_int(float64, float_status *status);
494float64 float64_trunc_to_int(float64, float_status *status);
495float64 float64_add(float64, float64, float_status *status);
496float64 float64_sub(float64, float64, float_status *status);
497float64 float64_mul(float64, float64, float_status *status);
498float64 float64_div(float64, float64, float_status *status);
499float64 float64_rem(float64, float64, float_status *status);
500float64 float64_muladd(float64, float64, float64, int, float_status *status);
501float64 float64_sqrt(float64, float_status *status);
502float64 float64_log2(float64, float_status *status);
503int float64_eq(float64, float64, float_status *status);
504int float64_le(float64, float64, float_status *status);
505int float64_lt(float64, float64, float_status *status);
506int float64_unordered(float64, float64, float_status *status);
507int float64_eq_quiet(float64, float64, float_status *status);
508int float64_le_quiet(float64, float64, float_status *status);
509int float64_lt_quiet(float64, float64, float_status *status);
510int float64_unordered_quiet(float64, float64, float_status *status);
511int float64_compare(float64, float64, float_status *status);
512int float64_compare_quiet(float64, float64, float_status *status);
513float64 float64_min(float64, float64, float_status *status);
514float64 float64_max(float64, float64, float_status *status);
515float64 float64_minnum(float64, float64, float_status *status);
516float64 float64_maxnum(float64, float64, float_status *status);
517float64 float64_minnummag(float64, float64, float_status *status);
518float64 float64_maxnummag(float64, float64, float_status *status);
519int float64_is_quiet_nan( float64 a );
520int float64_is_signaling_nan( float64 );
521float64 float64_maybe_silence_nan( float64 );
522float64 float64_scalbn(float64, int, float_status *status);
523
524static inline float64 float64_abs(float64 a)
525{
526
527
528
529 return make_float64(float64_val(a) & 0x7fffffffffffffffLL);
530}
531
532static inline float64 float64_chs(float64 a)
533{
534
535
536
537 return make_float64(float64_val(a) ^ 0x8000000000000000LL);
538}
539
540static inline int float64_is_infinity(float64 a)
541{
542 return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL;
543}
544
545static inline int float64_is_neg(float64 a)
546{
547 return float64_val(a) >> 63;
548}
549
550static inline int float64_is_zero(float64 a)
551{
552 return (float64_val(a) & 0x7fffffffffffffffLL) == 0;
553}
554
555static inline int float64_is_any_nan(float64 a)
556{
557 return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL);
558}
559
560static inline int float64_is_zero_or_denormal(float64 a)
561{
562 return (float64_val(a) & 0x7ff0000000000000LL) == 0;
563}
564
565static inline float64 float64_set_sign(float64 a, int sign)
566{
567 return make_float64((float64_val(a) & 0x7fffffffffffffffULL)
568 | ((int64_t)sign << 63));
569}
570
571#define float64_zero make_float64(0)
572#define float64_one make_float64(0x3ff0000000000000LL)
573#define float64_ln2 make_float64(0x3fe62e42fefa39efLL)
574#define float64_pi make_float64(0x400921fb54442d18LL)
575#define float64_half make_float64(0x3fe0000000000000LL)
576#define float64_infinity make_float64(0x7ff0000000000000LL)
577
578
579
580
581extern const float64 float64_default_nan;
582
583
584
585
586int32_t floatx80_to_int32(floatx80, float_status *status);
587int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status);
588int64_t floatx80_to_int64(floatx80, float_status *status);
589int64_t floatx80_to_int64_round_to_zero(floatx80, float_status *status);
590float32 floatx80_to_float32(floatx80, float_status *status);
591float64 floatx80_to_float64(floatx80, float_status *status);
592float128 floatx80_to_float128(floatx80, float_status *status);
593
594
595
596
597floatx80 floatx80_round_to_int(floatx80, float_status *status);
598floatx80 floatx80_add(floatx80, floatx80, float_status *status);
599floatx80 floatx80_sub(floatx80, floatx80, float_status *status);
600floatx80 floatx80_mul(floatx80, floatx80, float_status *status);
601floatx80 floatx80_div(floatx80, floatx80, float_status *status);
602floatx80 floatx80_rem(floatx80, floatx80, float_status *status);
603floatx80 floatx80_sqrt(floatx80, float_status *status);
604int floatx80_eq(floatx80, floatx80, float_status *status);
605int floatx80_le(floatx80, floatx80, float_status *status);
606int floatx80_lt(floatx80, floatx80, float_status *status);
607int floatx80_unordered(floatx80, floatx80, float_status *status);
608int floatx80_eq_quiet(floatx80, floatx80, float_status *status);
609int floatx80_le_quiet(floatx80, floatx80, float_status *status);
610int floatx80_lt_quiet(floatx80, floatx80, float_status *status);
611int floatx80_unordered_quiet(floatx80, floatx80, float_status *status);
612int floatx80_compare(floatx80, floatx80, float_status *status);
613int floatx80_compare_quiet(floatx80, floatx80, float_status *status);
614int floatx80_is_quiet_nan( floatx80 );
615int floatx80_is_signaling_nan( floatx80 );
616floatx80 floatx80_maybe_silence_nan( floatx80 );
617floatx80 floatx80_scalbn(floatx80, int, float_status *status);
618
619static inline floatx80 floatx80_abs(floatx80 a)
620{
621 a.high &= 0x7fff;
622 return a;
623}
624
625static inline floatx80 floatx80_chs(floatx80 a)
626{
627 a.high ^= 0x8000;
628 return a;
629}
630
631static inline int floatx80_is_infinity(floatx80 a)
632{
633 return (a.high & 0x7fff) == 0x7fff && a.low == 0x8000000000000000LL;
634}
635
636static inline int floatx80_is_neg(floatx80 a)
637{
638 return a.high >> 15;
639}
640
641static inline int floatx80_is_zero(floatx80 a)
642{
643 return (a.high & 0x7fff) == 0 && a.low == 0;
644}
645
646static inline int floatx80_is_zero_or_denormal(floatx80 a)
647{
648 return (a.high & 0x7fff) == 0;
649}
650
651static inline int floatx80_is_any_nan(floatx80 a)
652{
653 return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1);
654}
655
656#define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL)
657#define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL)
658#define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL)
659#define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL)
660#define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL)
661#define floatx80_infinity make_floatx80(0x7fff, 0x8000000000000000LL)
662
663
664
665
666extern const floatx80 floatx80_default_nan;
667
668
669
670
671int32_t float128_to_int32(float128, float_status *status);
672int32_t float128_to_int32_round_to_zero(float128, float_status *status);
673int64_t float128_to_int64(float128, float_status *status);
674int64_t float128_to_int64_round_to_zero(float128, float_status *status);
675float32 float128_to_float32(float128, float_status *status);
676float64 float128_to_float64(float128, float_status *status);
677floatx80 float128_to_floatx80(float128, float_status *status);
678
679
680
681
682float128 float128_round_to_int(float128, float_status *status);
683float128 float128_add(float128, float128, float_status *status);
684float128 float128_sub(float128, float128, float_status *status);
685float128 float128_mul(float128, float128, float_status *status);
686float128 float128_div(float128, float128, float_status *status);
687float128 float128_rem(float128, float128, float_status *status);
688float128 float128_sqrt(float128, float_status *status);
689int float128_eq(float128, float128, float_status *status);
690int float128_le(float128, float128, float_status *status);
691int float128_lt(float128, float128, float_status *status);
692int float128_unordered(float128, float128, float_status *status);
693int float128_eq_quiet(float128, float128, float_status *status);
694int float128_le_quiet(float128, float128, float_status *status);
695int float128_lt_quiet(float128, float128, float_status *status);
696int float128_unordered_quiet(float128, float128, float_status *status);
697int float128_compare(float128, float128, float_status *status);
698int float128_compare_quiet(float128, float128, float_status *status);
699int float128_is_quiet_nan( float128 );
700int float128_is_signaling_nan( float128 );
701float128 float128_maybe_silence_nan( float128 );
702float128 float128_scalbn(float128, int, float_status *status);
703
704static inline float128 float128_abs(float128 a)
705{
706 a.high &= 0x7fffffffffffffffLL;
707 return a;
708}
709
710static inline float128 float128_chs(float128 a)
711{
712 a.high ^= 0x8000000000000000LL;
713 return a;
714}
715
716static inline int float128_is_infinity(float128 a)
717{
718 return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0;
719}
720
721static inline int float128_is_neg(float128 a)
722{
723 return a.high >> 63;
724}
725
726static inline int float128_is_zero(float128 a)
727{
728 return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0;
729}
730
731static inline int float128_is_zero_or_denormal(float128 a)
732{
733 return (a.high & 0x7fff000000000000LL) == 0;
734}
735
736static inline int float128_is_any_nan(float128 a)
737{
738 return ((a.high >> 48) & 0x7fff) == 0x7fff &&
739 ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));
740}
741
742#define float128_zero make_float128(0, 0)
743
744
745
746
747extern const float128 float128_default_nan;
748
749#endif
750