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