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#define LIT64( a ) a##LL
86
87
88
89
90enum {
91 float_relation_less = -1,
92 float_relation_equal = 0,
93 float_relation_greater = 1,
94 float_relation_unordered = 2
95};
96
97#include "fpu/softfloat-types.h"
98
99static inline void set_float_detect_tininess(int val, float_status *status)
100{
101 status->float_detect_tininess = val;
102}
103static inline void set_float_rounding_mode(int val, float_status *status)
104{
105 status->float_rounding_mode = val;
106}
107static inline void set_float_exception_flags(int val, float_status *status)
108{
109 status->float_exception_flags = val;
110}
111static inline void set_floatx80_rounding_precision(int val,
112 float_status *status)
113{
114 status->floatx80_rounding_precision = val;
115}
116static inline void set_flush_to_zero(flag val, float_status *status)
117{
118 status->flush_to_zero = val;
119}
120static inline void set_flush_inputs_to_zero(flag val, float_status *status)
121{
122 status->flush_inputs_to_zero = val;
123}
124static inline void set_default_nan_mode(flag val, float_status *status)
125{
126 status->default_nan_mode = val;
127}
128static inline void set_snan_bit_is_one(flag val, float_status *status)
129{
130 status->snan_bit_is_one = val;
131}
132static inline int get_float_detect_tininess(float_status *status)
133{
134 return status->float_detect_tininess;
135}
136static inline int get_float_rounding_mode(float_status *status)
137{
138 return status->float_rounding_mode;
139}
140static inline int get_float_exception_flags(float_status *status)
141{
142 return status->float_exception_flags;
143}
144static inline int get_floatx80_rounding_precision(float_status *status)
145{
146 return status->floatx80_rounding_precision;
147}
148static inline flag get_flush_to_zero(float_status *status)
149{
150 return status->flush_to_zero;
151}
152static inline flag get_flush_inputs_to_zero(float_status *status)
153{
154 return status->flush_inputs_to_zero;
155}
156static inline flag get_default_nan_mode(float_status *status)
157{
158 return status->default_nan_mode;
159}
160
161
162
163
164
165void float_raise(uint8_t flags, float_status *status);
166
167
168
169
170
171float16 float16_squash_input_denormal(float16 a, float_status *status);
172float32 float32_squash_input_denormal(float32 a, float_status *status);
173float64 float64_squash_input_denormal(float64 a, float_status *status);
174
175
176
177
178
179
180
181
182
183enum {
184 float_muladd_negate_c = 1,
185 float_muladd_negate_product = 2,
186 float_muladd_negate_result = 4,
187 float_muladd_halve_result = 8,
188};
189
190
191
192
193
194float16 int16_to_float16_scalbn(int16_t a, int, float_status *status);
195float16 int32_to_float16_scalbn(int32_t a, int, float_status *status);
196float16 int64_to_float16_scalbn(int64_t a, int, float_status *status);
197float16 uint16_to_float16_scalbn(uint16_t a, int, float_status *status);
198float16 uint32_to_float16_scalbn(uint32_t a, int, float_status *status);
199float16 uint64_to_float16_scalbn(uint64_t a, int, float_status *status);
200
201float16 int16_to_float16(int16_t a, float_status *status);
202float16 int32_to_float16(int32_t a, float_status *status);
203float16 int64_to_float16(int64_t a, float_status *status);
204float16 uint16_to_float16(uint16_t a, float_status *status);
205float16 uint32_to_float16(uint32_t a, float_status *status);
206float16 uint64_to_float16(uint64_t a, float_status *status);
207
208float32 int16_to_float32_scalbn(int16_t, int, float_status *status);
209float32 int32_to_float32_scalbn(int32_t, int, float_status *status);
210float32 int64_to_float32_scalbn(int64_t, int, float_status *status);
211float32 uint16_to_float32_scalbn(uint16_t, int, float_status *status);
212float32 uint32_to_float32_scalbn(uint32_t, int, float_status *status);
213float32 uint64_to_float32_scalbn(uint64_t, int, float_status *status);
214
215float32 int16_to_float32(int16_t, float_status *status);
216float32 int32_to_float32(int32_t, float_status *status);
217float32 int64_to_float32(int64_t, float_status *status);
218float32 uint16_to_float32(uint16_t, float_status *status);
219float32 uint32_to_float32(uint32_t, float_status *status);
220float32 uint64_to_float32(uint64_t, float_status *status);
221
222float64 int16_to_float64_scalbn(int16_t, int, float_status *status);
223float64 int32_to_float64_scalbn(int32_t, int, float_status *status);
224float64 int64_to_float64_scalbn(int64_t, int, float_status *status);
225float64 uint16_to_float64_scalbn(uint16_t, int, float_status *status);
226float64 uint32_to_float64_scalbn(uint32_t, int, float_status *status);
227float64 uint64_to_float64_scalbn(uint64_t, int, float_status *status);
228
229float64 int16_to_float64(int16_t, float_status *status);
230float64 int32_to_float64(int32_t, float_status *status);
231float64 int64_to_float64(int64_t, float_status *status);
232float64 uint16_to_float64(uint16_t, float_status *status);
233float64 uint32_to_float64(uint32_t, float_status *status);
234float64 uint64_to_float64(uint64_t, float_status *status);
235
236floatx80 int32_to_floatx80(int32_t, float_status *status);
237floatx80 int64_to_floatx80(int64_t, float_status *status);
238
239float128 int32_to_float128(int32_t, float_status *status);
240float128 int64_to_float128(int64_t, float_status *status);
241float128 uint64_to_float128(uint64_t, float_status *status);
242
243
244
245
246
247float16 float32_to_float16(float32, bool ieee, float_status *status);
248float32 float16_to_float32(float16, bool ieee, float_status *status);
249float16 float64_to_float16(float64 a, bool ieee, float_status *status);
250float64 float16_to_float64(float16 a, bool ieee, float_status *status);
251
252int16_t float16_to_int16_scalbn(float16, int, int, float_status *status);
253int32_t float16_to_int32_scalbn(float16, int, int, float_status *status);
254int64_t float16_to_int64_scalbn(float16, int, int, float_status *status);
255
256int16_t float16_to_int16(float16, float_status *status);
257int32_t float16_to_int32(float16, float_status *status);
258int64_t float16_to_int64(float16, float_status *status);
259
260int16_t float16_to_int16_round_to_zero(float16, float_status *status);
261int32_t float16_to_int32_round_to_zero(float16, float_status *status);
262int64_t float16_to_int64_round_to_zero(float16, float_status *status);
263
264uint16_t float16_to_uint16_scalbn(float16 a, int, int, float_status *status);
265uint32_t float16_to_uint32_scalbn(float16 a, int, int, float_status *status);
266uint64_t float16_to_uint64_scalbn(float16 a, int, int, float_status *status);
267
268uint16_t float16_to_uint16(float16 a, float_status *status);
269uint32_t float16_to_uint32(float16 a, float_status *status);
270uint64_t float16_to_uint64(float16 a, float_status *status);
271
272uint16_t float16_to_uint16_round_to_zero(float16 a, float_status *status);
273uint32_t float16_to_uint32_round_to_zero(float16 a, float_status *status);
274uint64_t float16_to_uint64_round_to_zero(float16 a, float_status *status);
275
276
277
278
279
280float16 float16_round_to_int(float16, float_status *status);
281float16 float16_add(float16, float16, float_status *status);
282float16 float16_sub(float16, float16, float_status *status);
283float16 float16_mul(float16, float16, float_status *status);
284float16 float16_muladd(float16, float16, float16, int, float_status *status);
285float16 float16_div(float16, float16, float_status *status);
286float16 float16_scalbn(float16, int, float_status *status);
287float16 float16_min(float16, float16, float_status *status);
288float16 float16_max(float16, float16, float_status *status);
289float16 float16_minnum(float16, float16, float_status *status);
290float16 float16_maxnum(float16, float16, float_status *status);
291float16 float16_minnummag(float16, float16, float_status *status);
292float16 float16_maxnummag(float16, float16, float_status *status);
293float16 float16_sqrt(float16, float_status *status);
294int float16_compare(float16, float16, float_status *status);
295int float16_compare_quiet(float16, float16, float_status *status);
296
297int float16_is_quiet_nan(float16, float_status *status);
298int float16_is_signaling_nan(float16, float_status *status);
299float16 float16_silence_nan(float16, float_status *status);
300
301static inline int float16_is_any_nan(float16 a)
302{
303 return ((float16_val(a) & ~0x8000) > 0x7c00);
304}
305
306static inline int float16_is_neg(float16 a)
307{
308 return float16_val(a) >> 15;
309}
310
311static inline int float16_is_infinity(float16 a)
312{
313 return (float16_val(a) & 0x7fff) == 0x7c00;
314}
315
316static inline int float16_is_zero(float16 a)
317{
318 return (float16_val(a) & 0x7fff) == 0;
319}
320
321static inline int float16_is_zero_or_denormal(float16 a)
322{
323 return (float16_val(a) & 0x7c00) == 0;
324}
325
326static inline float16 float16_abs(float16 a)
327{
328
329
330
331 return make_float16(float16_val(a) & 0x7fff);
332}
333
334static inline float16 float16_chs(float16 a)
335{
336
337
338
339 return make_float16(float16_val(a) ^ 0x8000);
340}
341
342static inline float16 float16_set_sign(float16 a, int sign)
343{
344 return make_float16((float16_val(a) & 0x7fff) | (sign << 15));
345}
346
347#define float16_zero make_float16(0)
348#define float16_half make_float16(0x3800)
349#define float16_one make_float16(0x3c00)
350#define float16_one_point_five make_float16(0x3e00)
351#define float16_two make_float16(0x4000)
352#define float16_three make_float16(0x4200)
353#define float16_infinity make_float16(0x7c00)
354
355
356
357
358float16 float16_default_nan(float_status *status);
359
360
361
362
363
364int16_t float32_to_int16_scalbn(float32, int, int, float_status *status);
365int32_t float32_to_int32_scalbn(float32, int, int, float_status *status);
366int64_t float32_to_int64_scalbn(float32, int, int, float_status *status);
367
368int16_t float32_to_int16(float32, float_status *status);
369int32_t float32_to_int32(float32, float_status *status);
370int64_t float32_to_int64(float32, float_status *status);
371
372int16_t float32_to_int16_round_to_zero(float32, float_status *status);
373int32_t float32_to_int32_round_to_zero(float32, float_status *status);
374int64_t float32_to_int64_round_to_zero(float32, float_status *status);
375
376uint16_t float32_to_uint16_scalbn(float32, int, int, float_status *status);
377uint32_t float32_to_uint32_scalbn(float32, int, int, float_status *status);
378uint64_t float32_to_uint64_scalbn(float32, int, int, float_status *status);
379
380uint16_t float32_to_uint16(float32, float_status *status);
381uint32_t float32_to_uint32(float32, float_status *status);
382uint64_t float32_to_uint64(float32, float_status *status);
383
384uint16_t float32_to_uint16_round_to_zero(float32, float_status *status);
385uint32_t float32_to_uint32_round_to_zero(float32, float_status *status);
386uint64_t float32_to_uint64_round_to_zero(float32, float_status *status);
387
388float64 float32_to_float64(float32, float_status *status);
389floatx80 float32_to_floatx80(float32, float_status *status);
390float128 float32_to_float128(float32, float_status *status);
391
392
393
394
395float32 float32_round_to_int(float32, float_status *status);
396float32 float32_add(float32, float32, float_status *status);
397float32 float32_sub(float32, float32, float_status *status);
398float32 float32_mul(float32, float32, float_status *status);
399float32 float32_div(float32, float32, float_status *status);
400float32 float32_rem(float32, float32, float_status *status);
401float32 float32_muladd(float32, float32, float32, int, float_status *status);
402float32 float32_sqrt(float32, float_status *status);
403float32 float32_exp2(float32, float_status *status);
404float32 float32_log2(float32, float_status *status);
405int float32_eq(float32, float32, float_status *status);
406int float32_le(float32, float32, float_status *status);
407int float32_lt(float32, float32, float_status *status);
408int float32_unordered(float32, float32, float_status *status);
409int float32_eq_quiet(float32, float32, float_status *status);
410int float32_le_quiet(float32, float32, float_status *status);
411int float32_lt_quiet(float32, float32, float_status *status);
412int float32_unordered_quiet(float32, float32, float_status *status);
413int float32_compare(float32, float32, float_status *status);
414int float32_compare_quiet(float32, float32, float_status *status);
415float32 float32_min(float32, float32, float_status *status);
416float32 float32_max(float32, float32, float_status *status);
417float32 float32_minnum(float32, float32, float_status *status);
418float32 float32_maxnum(float32, float32, float_status *status);
419float32 float32_minnummag(float32, float32, float_status *status);
420float32 float32_maxnummag(float32, float32, float_status *status);
421int float32_is_quiet_nan(float32, float_status *status);
422int float32_is_signaling_nan(float32, float_status *status);
423float32 float32_silence_nan(float32, float_status *status);
424float32 float32_scalbn(float32, int, float_status *status);
425
426static inline float32 float32_abs(float32 a)
427{
428
429
430
431 return make_float32(float32_val(a) & 0x7fffffff);
432}
433
434static inline float32 float32_chs(float32 a)
435{
436
437
438
439 return make_float32(float32_val(a) ^ 0x80000000);
440}
441
442static inline int float32_is_infinity(float32 a)
443{
444 return (float32_val(a) & 0x7fffffff) == 0x7f800000;
445}
446
447static inline int float32_is_neg(float32 a)
448{
449 return float32_val(a) >> 31;
450}
451
452static inline int float32_is_zero(float32 a)
453{
454 return (float32_val(a) & 0x7fffffff) == 0;
455}
456
457static inline int float32_is_any_nan(float32 a)
458{
459 return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL);
460}
461
462static inline int float32_is_zero_or_denormal(float32 a)
463{
464 return (float32_val(a) & 0x7f800000) == 0;
465}
466
467static inline bool float32_is_normal(float32 a)
468{
469 return (((float32_val(a) >> 23) + 1) & 0xff) >= 2;
470}
471
472static inline bool float32_is_denormal(float32 a)
473{
474 return float32_is_zero_or_denormal(a) && !float32_is_zero(a);
475}
476
477static inline bool float32_is_zero_or_normal(float32 a)
478{
479 return float32_is_normal(a) || float32_is_zero(a);
480}
481
482static inline float32 float32_set_sign(float32 a, int sign)
483{
484 return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31));
485}
486
487#define float32_zero make_float32(0)
488#define float32_half make_float32(0x3f000000)
489#define float32_one make_float32(0x3f800000)
490#define float32_one_point_five make_float32(0x3fc00000)
491#define float32_two make_float32(0x40000000)
492#define float32_three make_float32(0x40400000)
493#define float32_infinity make_float32(0x7f800000)
494
495
496
497
498
499
500
501
502
503
504
505
506static inline float32 packFloat32(flag zSign, int zExp, uint32_t zSig)
507{
508 return make_float32(
509 (((uint32_t)zSign) << 31) + (((uint32_t)zExp) << 23) + zSig);
510}
511
512
513
514
515float32 float32_default_nan(float_status *status);
516
517
518
519
520
521int16_t float64_to_int16_scalbn(float64, int, int, float_status *status);
522int32_t float64_to_int32_scalbn(float64, int, int, float_status *status);
523int64_t float64_to_int64_scalbn(float64, int, int, float_status *status);
524
525int16_t float64_to_int16(float64, float_status *status);
526int32_t float64_to_int32(float64, float_status *status);
527int64_t float64_to_int64(float64, float_status *status);
528
529int16_t float64_to_int16_round_to_zero(float64, float_status *status);
530int32_t float64_to_int32_round_to_zero(float64, float_status *status);
531int64_t float64_to_int64_round_to_zero(float64, float_status *status);
532
533uint16_t float64_to_uint16_scalbn(float64, int, int, float_status *status);
534uint32_t float64_to_uint32_scalbn(float64, int, int, float_status *status);
535uint64_t float64_to_uint64_scalbn(float64, int, int, float_status *status);
536
537uint16_t float64_to_uint16(float64, float_status *status);
538uint32_t float64_to_uint32(float64, float_status *status);
539uint64_t float64_to_uint64(float64, float_status *status);
540
541uint16_t float64_to_uint16_round_to_zero(float64, float_status *status);
542uint32_t float64_to_uint32_round_to_zero(float64, float_status *status);
543uint64_t float64_to_uint64_round_to_zero(float64, float_status *status);
544
545float32 float64_to_float32(float64, float_status *status);
546floatx80 float64_to_floatx80(float64, float_status *status);
547float128 float64_to_float128(float64, float_status *status);
548
549
550
551
552float64 float64_round_to_int(float64, float_status *status);
553float64 float64_add(float64, float64, float_status *status);
554float64 float64_sub(float64, float64, float_status *status);
555float64 float64_mul(float64, float64, float_status *status);
556float64 float64_div(float64, float64, float_status *status);
557float64 float64_rem(float64, float64, float_status *status);
558float64 float64_muladd(float64, float64, float64, int, float_status *status);
559float64 float64_sqrt(float64, float_status *status);
560float64 float64_log2(float64, float_status *status);
561int float64_eq(float64, float64, float_status *status);
562int float64_le(float64, float64, float_status *status);
563int float64_lt(float64, float64, float_status *status);
564int float64_unordered(float64, float64, float_status *status);
565int float64_eq_quiet(float64, float64, float_status *status);
566int float64_le_quiet(float64, float64, float_status *status);
567int float64_lt_quiet(float64, float64, float_status *status);
568int float64_unordered_quiet(float64, float64, float_status *status);
569int float64_compare(float64, float64, float_status *status);
570int float64_compare_quiet(float64, float64, float_status *status);
571float64 float64_min(float64, float64, float_status *status);
572float64 float64_max(float64, float64, float_status *status);
573float64 float64_minnum(float64, float64, float_status *status);
574float64 float64_maxnum(float64, float64, float_status *status);
575float64 float64_minnummag(float64, float64, float_status *status);
576float64 float64_maxnummag(float64, float64, float_status *status);
577int float64_is_quiet_nan(float64 a, float_status *status);
578int float64_is_signaling_nan(float64, float_status *status);
579float64 float64_silence_nan(float64, float_status *status);
580float64 float64_scalbn(float64, int, float_status *status);
581
582static inline float64 float64_abs(float64 a)
583{
584
585
586
587 return make_float64(float64_val(a) & 0x7fffffffffffffffLL);
588}
589
590static inline float64 float64_chs(float64 a)
591{
592
593
594
595 return make_float64(float64_val(a) ^ 0x8000000000000000LL);
596}
597
598static inline int float64_is_infinity(float64 a)
599{
600 return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL;
601}
602
603static inline int float64_is_neg(float64 a)
604{
605 return float64_val(a) >> 63;
606}
607
608static inline int float64_is_zero(float64 a)
609{
610 return (float64_val(a) & 0x7fffffffffffffffLL) == 0;
611}
612
613static inline int float64_is_any_nan(float64 a)
614{
615 return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL);
616}
617
618static inline int float64_is_zero_or_denormal(float64 a)
619{
620 return (float64_val(a) & 0x7ff0000000000000LL) == 0;
621}
622
623static inline bool float64_is_normal(float64 a)
624{
625 return (((float64_val(a) >> 52) + 1) & 0x7ff) >= 2;
626}
627
628static inline bool float64_is_denormal(float64 a)
629{
630 return float64_is_zero_or_denormal(a) && !float64_is_zero(a);
631}
632
633static inline bool float64_is_zero_or_normal(float64 a)
634{
635 return float64_is_normal(a) || float64_is_zero(a);
636}
637
638static inline float64 float64_set_sign(float64 a, int sign)
639{
640 return make_float64((float64_val(a) & 0x7fffffffffffffffULL)
641 | ((int64_t)sign << 63));
642}
643
644#define float64_zero make_float64(0)
645#define float64_half make_float64(0x3fe0000000000000LL)
646#define float64_one make_float64(0x3ff0000000000000LL)
647#define float64_one_point_five make_float64(0x3FF8000000000000ULL)
648#define float64_two make_float64(0x4000000000000000ULL)
649#define float64_three make_float64(0x4008000000000000ULL)
650#define float64_ln2 make_float64(0x3fe62e42fefa39efLL)
651#define float64_infinity make_float64(0x7ff0000000000000LL)
652
653
654
655
656float64 float64_default_nan(float_status *status);
657
658
659
660
661int32_t floatx80_to_int32(floatx80, float_status *status);
662int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status);
663int64_t floatx80_to_int64(floatx80, float_status *status);
664int64_t floatx80_to_int64_round_to_zero(floatx80, float_status *status);
665float32 floatx80_to_float32(floatx80, float_status *status);
666float64 floatx80_to_float64(floatx80, float_status *status);
667float128 floatx80_to_float128(floatx80, float_status *status);
668
669
670
671
672extern const floatx80 floatx80_infinity;
673
674
675
676
677floatx80 floatx80_round(floatx80 a, float_status *status);
678floatx80 floatx80_round_to_int(floatx80, float_status *status);
679floatx80 floatx80_add(floatx80, floatx80, float_status *status);
680floatx80 floatx80_sub(floatx80, floatx80, float_status *status);
681floatx80 floatx80_mul(floatx80, floatx80, float_status *status);
682floatx80 floatx80_div(floatx80, floatx80, float_status *status);
683floatx80 floatx80_rem(floatx80, floatx80, float_status *status);
684floatx80 floatx80_sqrt(floatx80, float_status *status);
685int floatx80_eq(floatx80, floatx80, float_status *status);
686int floatx80_le(floatx80, floatx80, float_status *status);
687int floatx80_lt(floatx80, floatx80, float_status *status);
688int floatx80_unordered(floatx80, floatx80, float_status *status);
689int floatx80_eq_quiet(floatx80, floatx80, float_status *status);
690int floatx80_le_quiet(floatx80, floatx80, float_status *status);
691int floatx80_lt_quiet(floatx80, floatx80, float_status *status);
692int floatx80_unordered_quiet(floatx80, floatx80, float_status *status);
693int floatx80_compare(floatx80, floatx80, float_status *status);
694int floatx80_compare_quiet(floatx80, floatx80, float_status *status);
695int floatx80_is_quiet_nan(floatx80, float_status *status);
696int floatx80_is_signaling_nan(floatx80, float_status *status);
697floatx80 floatx80_silence_nan(floatx80, float_status *status);
698floatx80 floatx80_scalbn(floatx80, int, float_status *status);
699
700static inline floatx80 floatx80_abs(floatx80 a)
701{
702 a.high &= 0x7fff;
703 return a;
704}
705
706static inline floatx80 floatx80_chs(floatx80 a)
707{
708 a.high ^= 0x8000;
709 return a;
710}
711
712static inline int floatx80_is_infinity(floatx80 a)
713{
714#if defined(TARGET_M68K)
715 return (a.high & 0x7fff) == floatx80_infinity.high && !(a.low << 1);
716#else
717 return (a.high & 0x7fff) == floatx80_infinity.high &&
718 a.low == floatx80_infinity.low;
719#endif
720}
721
722static inline int floatx80_is_neg(floatx80 a)
723{
724 return a.high >> 15;
725}
726
727static inline int floatx80_is_zero(floatx80 a)
728{
729 return (a.high & 0x7fff) == 0 && a.low == 0;
730}
731
732static inline int floatx80_is_zero_or_denormal(floatx80 a)
733{
734 return (a.high & 0x7fff) == 0;
735}
736
737static inline int floatx80_is_any_nan(floatx80 a)
738{
739 return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1);
740}
741
742
743
744
745
746
747
748
749
750
751
752static inline bool floatx80_invalid_encoding(floatx80 a)
753{
754 return (a.low & (1ULL << 63)) == 0 && (a.high & 0x7FFF) != 0;
755}
756
757#define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL)
758#define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL)
759#define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL)
760#define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL)
761#define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL)
762
763
764
765
766
767
768static inline uint64_t extractFloatx80Frac(floatx80 a)
769{
770 return a.low;
771}
772
773
774
775
776
777
778static inline int32_t extractFloatx80Exp(floatx80 a)
779{
780 return a.high & 0x7FFF;
781}
782
783
784
785
786
787
788static inline flag extractFloatx80Sign(floatx80 a)
789{
790 return a.high >> 15;
791}
792
793
794
795
796
797
798static inline floatx80 packFloatx80(flag zSign, int32_t zExp, uint64_t zSig)
799{
800 floatx80 z;
801
802 z.low = zSig;
803 z.high = (((uint16_t)zSign) << 15) + zExp;
804 return z;
805}
806
807
808
809
810
811
812
813
814void normalizeFloatx80Subnormal(uint64_t aSig, int32_t *zExpPtr,
815 uint64_t *zSigPtr);
816
817
818
819
820
821
822
823floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b, float_status *status);
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849floatx80 roundAndPackFloatx80(int8_t roundingPrecision, flag zSign,
850 int32_t zExp, uint64_t zSig0, uint64_t zSig1,
851 float_status *status);
852
853
854
855
856
857
858
859
860
861
862floatx80 normalizeRoundAndPackFloatx80(int8_t roundingPrecision,
863 flag zSign, int32_t zExp,
864 uint64_t zSig0, uint64_t zSig1,
865 float_status *status);
866
867
868
869
870floatx80 floatx80_default_nan(float_status *status);
871
872
873
874
875int32_t float128_to_int32(float128, float_status *status);
876int32_t float128_to_int32_round_to_zero(float128, float_status *status);
877int64_t float128_to_int64(float128, float_status *status);
878int64_t float128_to_int64_round_to_zero(float128, float_status *status);
879uint64_t float128_to_uint64(float128, float_status *status);
880uint64_t float128_to_uint64_round_to_zero(float128, float_status *status);
881uint32_t float128_to_uint32(float128, float_status *status);
882uint32_t float128_to_uint32_round_to_zero(float128, float_status *status);
883float32 float128_to_float32(float128, float_status *status);
884float64 float128_to_float64(float128, float_status *status);
885floatx80 float128_to_floatx80(float128, float_status *status);
886
887
888
889
890float128 float128_round_to_int(float128, float_status *status);
891float128 float128_add(float128, float128, float_status *status);
892float128 float128_sub(float128, float128, float_status *status);
893float128 float128_mul(float128, float128, float_status *status);
894float128 float128_div(float128, float128, float_status *status);
895float128 float128_rem(float128, float128, float_status *status);
896float128 float128_sqrt(float128, float_status *status);
897int float128_eq(float128, float128, float_status *status);
898int float128_le(float128, float128, float_status *status);
899int float128_lt(float128, float128, float_status *status);
900int float128_unordered(float128, float128, float_status *status);
901int float128_eq_quiet(float128, float128, float_status *status);
902int float128_le_quiet(float128, float128, float_status *status);
903int float128_lt_quiet(float128, float128, float_status *status);
904int float128_unordered_quiet(float128, float128, float_status *status);
905int float128_compare(float128, float128, float_status *status);
906int float128_compare_quiet(float128, float128, float_status *status);
907int float128_is_quiet_nan(float128, float_status *status);
908int float128_is_signaling_nan(float128, float_status *status);
909float128 float128_silence_nan(float128, float_status *status);
910float128 float128_scalbn(float128, int, float_status *status);
911
912static inline float128 float128_abs(float128 a)
913{
914 a.high &= 0x7fffffffffffffffLL;
915 return a;
916}
917
918static inline float128 float128_chs(float128 a)
919{
920 a.high ^= 0x8000000000000000LL;
921 return a;
922}
923
924static inline int float128_is_infinity(float128 a)
925{
926 return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0;
927}
928
929static inline int float128_is_neg(float128 a)
930{
931 return a.high >> 63;
932}
933
934static inline int float128_is_zero(float128 a)
935{
936 return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0;
937}
938
939static inline int float128_is_zero_or_denormal(float128 a)
940{
941 return (a.high & 0x7fff000000000000LL) == 0;
942}
943
944static inline bool float128_is_normal(float128 a)
945{
946 return (((a.high >> 48) + 1) & 0x7fff) >= 2;
947}
948
949static inline bool float128_is_denormal(float128 a)
950{
951 return float128_is_zero_or_denormal(a) && !float128_is_zero(a);
952}
953
954static inline int float128_is_any_nan(float128 a)
955{
956 return ((a.high >> 48) & 0x7fff) == 0x7fff &&
957 ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));
958}
959
960#define float128_zero make_float128(0, 0)
961
962
963
964
965float128 float128_default_nan(float_status *status);
966
967#endif
968