![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fpp-softfloat.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous_trunk / src / cpu|
Return to fpp-softfloat.h CVS log | Up to [Previous NeXT emulator] / previous_trunk / src / cpu |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * MC68881 emulation
5: *
6: * Conversion routines for hosts knowing floating point format.
7: *
8: * Copyright 1996 Herman ten Brugge
9: * Modified 2005 Peter Keunecke
10: */
11:
12: #ifndef FPP_H
13: #define FPP_H
14:
15: #include <softfloat.h>
16:
17: float_ctrl fp_ctrl;
18:
19: #define FPCR_ROUNDING_MODE 0x00000030
20: #define FPCR_ROUND_NEAR 0x00000000
21: #define FPCR_ROUND_ZERO 0x00000010
22: #define FPCR_ROUND_MINF 0x00000020
23: #define FPCR_ROUND_PINF 0x00000030
24:
25: #define FPCR_ROUNDING_PRECISION 0x000000c0
26: #define FPCR_PRECISION_SINGLE 0x00000040
27: #define FPCR_PRECISION_DOUBLE 0x00000080
28: #define FPCR_PRECISION_EXTENDED 0x00000000
29:
30: extern uae_u32 fpp_get_fpsr (void);
31:
32:
33: /* Functions for setting host/library modes and getting status */
34: STATIC_INLINE void init_fp_mode(void)
35: {
36: float_init(&fp_ctrl);
37: }
38: STATIC_INLINE void set_fp_mode(uae_u32 mode_control)
39: {
40: set_float_detect_tininess(float_tininess_before_rounding, &fp_ctrl);
41:
42: switch(mode_control & FPCR_ROUNDING_PRECISION) {
43: case FPCR_PRECISION_SINGLE: // single
44: set_float_rounding_precision(32, &fp_ctrl);
45: break;
46: case FPCR_PRECISION_DOUBLE: // double
47: set_float_rounding_precision(64, &fp_ctrl);
48: break;
49: case FPCR_PRECISION_EXTENDED: // extended
50: set_float_rounding_precision(80, &fp_ctrl);
51: break;
52: default: // double
53: set_float_rounding_precision(64, &fp_ctrl);
54: break;
55: }
56:
57: switch(mode_control & FPCR_ROUNDING_MODE) {
58: case FPCR_ROUND_NEAR: // to neareset
59: set_float_rounding_mode(float_round_nearest_even, &fp_ctrl);
60: break;
61: case FPCR_ROUND_ZERO: // to zero
62: set_float_rounding_mode(float_round_to_zero, &fp_ctrl);
63: break;
64: case FPCR_ROUND_MINF: // to minus
65: set_float_rounding_mode(float_round_down, &fp_ctrl);
66: break;
67: case FPCR_ROUND_PINF: // to plus
68: set_float_rounding_mode(float_round_up, &fp_ctrl);
69: break;
70: }
71: }
72: STATIC_INLINE void get_fp_status(uae_u32 *status)
73: {
74: int8 flags = get_float_exception_flags(&fp_ctrl);
75:
76: if (flags & float_flag_signaling)
77: *status |= 0x4000;
78: if (flags & float_flag_invalid)
79: *status |= 0x2000;
80: if (flags & float_flag_overflow)
81: *status |= 0x1000;
82: if (flags & float_flag_underflow)
83: *status |= 0x0800;
84: if (flags & float_flag_divbyzero)
85: *status |= 0x0400;
86: if (flags & float_flag_inexact)
87: *status |= 0x0200;
88: if (flags & float_flag_decimal)
89: *status |= 0x0100;
90: }
91: STATIC_INLINE void clear_fp_status(void)
92: {
93: set_float_exception_flags(0, &fp_ctrl);
94: }
95:
96: /* Helper functions */
97: STATIC_INLINE const char *fp_print(fptype *fx)
98: {
99: static char fs[32];
100: bool n, u, d;
101: fptype x;
102: int32 len;
103: int8 save_exception_flags;
104:
105: n = floatx80_is_negative(*fx);
106: u = floatx80_is_unnormal(*fx);
107: d = floatx80_is_denormal(*fx);
108:
109: if (floatx80_is_infinity(*fx)) {
110: sprintf(fs, "%c%s", n?'-':'+', "inf");
111: } else if (floatx80_is_signaling_nan(*fx)) {
112: sprintf(fs, "%c%s", n?'-':'+', "snan");
113: } else if (floatx80_is_nan(*fx)) {
114: sprintf(fs, "%c%s", n?'-':'+', "nan");
115: } else {
116: len = 17;
117: save_exception_flags = get_float_exception_flags(&fp_ctrl);
118: set_float_exception_flags(0, &fp_ctrl);
119: x = floatx80_to_floatdecimal(*fx, &len, &fp_ctrl);
120:
121: sprintf(fs, "%c%01lld.%016llde%c%04d%s%s", n?'-':'+',
122: x.low/LIT64(10000000000000000), x.low%LIT64(10000000000000000),
123: (x.high&0x4000)?'-':'+', x.high&0x3FFF, d?"D":u?"U":"",
124: (get_float_exception_flags(&fp_ctrl)&float_flag_inexact)?"~":"");
125:
126: set_float_exception_flags(save_exception_flags, &fp_ctrl);
127: }
128:
129: return fs;
130: }
131:
132: /* Functions for detecting float type */
133: STATIC_INLINE bool fp_is_snan(fptype *fp)
134: {
135: return floatx80_is_signaling_nan(*fp) != 0;
136: }
137: STATIC_INLINE void fp_unset_snan(fptype *fp)
138: {
139: fp->low |= LIT64(0x4000000000000000);
140: }
141: STATIC_INLINE bool fp_is_nan (fptype *fp)
142: {
143: return floatx80_is_nan(*fp) != 0;
144: }
145: STATIC_INLINE bool fp_is_infinity (fptype *fp)
146: {
147: return floatx80_is_infinity(*fp) != 0;
148: }
149: STATIC_INLINE bool fp_is_zero(fptype *fp)
150: {
151: return floatx80_is_zero(*fp) != 0;
152: }
153: STATIC_INLINE bool fp_is_neg(fptype *fp)
154: {
155: return floatx80_is_negative(*fp) != 0;
156: }
157: STATIC_INLINE bool fp_is_denormal(fptype *fp)
158: {
159: return floatx80_is_denormal(*fp) != 0;
160: }
161: STATIC_INLINE bool fp_is_unnormal(fptype *fp)
162: {
163: return floatx80_is_unnormal(*fp) != 0;
164: }
165:
166: /* Function for normalizing unnormals */
167: STATIC_INLINE void fp_normalize(fptype *fp)
168: {
169: *fp = floatx80_normalize(*fp);
170: }
171:
172: /* Functions for converting between float formats */
173: STATIC_INLINE void to_single(fptype *fp, uae_u32 wrd1)
174: {
175: float32 f = wrd1;
176: *fp = float32_to_floatx80_allowunnormal(f);
177: }
178: STATIC_INLINE uae_u32 from_single(fptype *fp)
179: {
180: float32 f = floatx80_to_float32(*fp, &fp_ctrl);
181: return f;
182: }
183:
184: STATIC_INLINE void to_double(fptype *fp, uae_u32 wrd1, uae_u32 wrd2)
185: {
186: float64 f = ((float64)wrd1 << 32) | wrd2;
187: *fp = float64_to_floatx80_allowunnormal(f);
188: }
189: STATIC_INLINE void from_double(fptype *fp, uae_u32 *wrd1, uae_u32 *wrd2)
190: {
191: float64 f = floatx80_to_float64(*fp, &fp_ctrl);
192: *wrd1 = f >> 32;
193: *wrd2 = (uae_u32)f;
194: }
195:
196: STATIC_INLINE void to_exten(fptype *fp, uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3)
197: {
198: fp->high = (uae_u16)(wrd1 >> 16);
199: fp->low = ((uae_u64)wrd2 << 32) | wrd3;
200: }
201: STATIC_INLINE void from_exten(fptype *fp, uae_u32 *wrd1, uae_u32 *wrd2, uae_u32 *wrd3)
202: {
203: floatx80 f = floatx80_to_floatx80(*fp, &fp_ctrl);
204: *wrd1 = (uae_u32)(f.high << 16);
205: *wrd2 = f.low >> 32;
206: *wrd3 = (uae_u32)f.low;
207: }
208: STATIC_INLINE void to_exten_fmovem(fptype *fp, uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3)
209: {
210: fp->high = (uae_u16)(wrd1 >> 16);
211: fp->low = ((uae_u64)wrd2 << 32) | wrd3;
212: }
213: STATIC_INLINE void from_exten_fmovem(fptype *fp, uae_u32 *wrd1, uae_u32 *wrd2, uae_u32 *wrd3)
214: {
215: *wrd1 = (uae_u32)(fp->high << 16);
216: *wrd2 = fp->low >> 32;
217: *wrd3 = (uae_u32)fp->low;
218: }
219:
220: STATIC_INLINE uae_s64 to_int(fptype *src, int size)
221: {
222: switch (size) {
223: case 0: return floatx80_to_int8(*src, &fp_ctrl);
224: case 1: return floatx80_to_int16(*src, &fp_ctrl);
225: case 2: return floatx80_to_int32(*src, &fp_ctrl);
226: default: return 0;
227: }
228: }
229: STATIC_INLINE fptype from_int(uae_s32 src)
230: {
231: return int32_to_floatx80(src);
232: }
233:
234: STATIC_INLINE void to_pack(fptype *fp, uae_u32 *wrd)
235: {
236: floatx80 f;
237: int i;
238: uae_s32 exp;
239: uae_s64 mant;
240: uae_u32 pack_exp, pack_int, pack_se, pack_sm;
241: uae_u64 pack_frac;
242:
243: if (((wrd[0] >> 16) & 0x7fff) == 0x7fff) {
244: // infinity has extended exponent and all 0 packed fraction
245: // nans are copies bit by bit
246: to_exten(fp, wrd[0], wrd[1], wrd[2]);
247: return;
248: }
249: if (!(wrd[0] & 0xf) && !wrd[1] && !wrd[2]) {
250: // exponent is not cared about, if mantissa is zero
251: wrd[0] &= 0x80000000;
252: to_exten(fp, wrd[0], wrd[1], wrd[2]);
253: return;
254: }
255:
256: pack_exp = (wrd[0] >> 16) & 0xFFF; // packed exponent
257: pack_int = wrd[0] & 0xF; // packed integer part
258: pack_frac = ((uae_u64)wrd[1] << 32) | wrd[2]; // packed fraction
259: pack_se = (wrd[0] >> 30) & 1; // sign of packed exponent
260: pack_sm = (wrd[0] >> 31) & 1; // sign of packed significand
261:
262: exp = 0;
263:
264: for (i = 0; i < 3; i++) {
265: exp *= 10;
266: exp += (pack_exp >> (8 - i * 4)) & 0xF;
267: }
268:
269: if (pack_se) {
270: exp = -exp;
271: }
272:
273: exp -= 16;
274:
275: if (exp < 0) {
276: exp = -exp;
277: pack_se = 1;
278: }
279:
280: mant = pack_int;
281:
282: for (i = 0; i < 16; i++) {
283: mant *= 10;
284: mant += (pack_frac >> (60 - i * 4)) & 0xF;
285: }
286:
287: f.high = exp & 0x3FFF;
288: f.high |= pack_se ? 0x4000 : 0;
289: f.high |= pack_sm ? 0x8000 : 0;
290: f.low = mant;
291:
292: *fp = floatdecimal_to_floatx80(f, &fp_ctrl);
293: }
294: STATIC_INLINE void from_pack(fptype *fp, uae_u32 *wrd, uae_s32 kfactor)
295: {
296: floatx80 f = floatx80_to_floatdecimal(*fp, &kfactor, &fp_ctrl);
297:
298: uae_u32 pack_exp, pack_exp4, pack_int, pack_se, pack_sm;
299: uae_u64 pack_frac;
300:
301: uae_u32 exponent;
302: uae_u64 significand;
303:
304: uae_s32 len;
305: uae_u64 digit;
306:
307: if ((f.high & 0x7FFF) == 0x7FFF) {
308: wrd[0] = (uae_u32)(f.high << 16);
309: wrd[1] = f.low >> 32;
310: wrd[2] = (uae_u32)f.low;
311: } else {
312: exponent = f.high & 0x3FFF;
313: significand = f.low;
314:
315: pack_int = 0;
316: pack_frac = 0;
317: len = kfactor; // SoftFloat saved len to kfactor variable
318: while (len > 0) {
319: len--;
320: digit = significand % 10;
321: significand /= 10;
322: if (len == 0) {
323: pack_int = digit;
324: } else {
325: pack_frac |= digit << (64 - len * 4);
326: }
327: }
328:
329: pack_exp = 0;
330: pack_exp4 = 0;
331: len = 4;
332: while (len > 0) {
333: len--;
334: digit = exponent % 10;
335: exponent /= 10;
336: if (len == 0) {
337: pack_exp4 = digit;
338: } else {
339: pack_exp |= digit << (12 - len * 4);
340: }
341: }
342:
343: pack_se = f.high & 0x4000;
344: pack_sm = f.high & 0x8000;
345:
346: wrd[0] = pack_exp << 16;
347: wrd[0] |= pack_exp4 << 12;
348: wrd[0] |= pack_int;
349: wrd[0] |= pack_se ? 0x40000000 : 0;
350: wrd[0] |= pack_sm ? 0x80000000 : 0;
351:
352: wrd[1] = pack_frac >> 32;
353: wrd[2] = pack_frac & 0xffffffff;
354: }
355: }
356:
357: /* Functions for returning exception state data */
358: STATIC_INLINE fptype fp_get_internal_overflow(void)
359: {
360: return getFloatInternalOverflow(&fp_ctrl);
361: }
362: STATIC_INLINE fptype fp_get_internal_underflow(void)
363: {
364: return getFloatInternalUnderflow(&fp_ctrl);
365: }
366: STATIC_INLINE fptype fp_get_internal_round_all(void)
367: {
368: return getFloatInternalRoundedAll(&fp_ctrl);
369: }
370: STATIC_INLINE fptype fp_get_internal_round(void)
371: {
372: return getFloatInternalRoundedSome(&fp_ctrl);
373: }
374: STATIC_INLINE fptype fp_get_internal_round_exten(void)
375: {
376: return getFloatInternalFloatx80(&fp_ctrl);
377: }
378: STATIC_INLINE fptype fp_get_internal(void)
379: {
380: return getFloatInternalUnrounded(&fp_ctrl);
381: }
382: STATIC_INLINE uae_u32 fp_get_internal_grs(void)
383: {
384: return (uae_u32)getFloatInternalGRS(&fp_ctrl);
385: }
386:
387: /* Function for denormalizing */
388: STATIC_INLINE void fp_denormalize(fptype *fp, int esign)
389: {
390: *fp = floatx80_denormalize(*fp, esign);
391: }
392:
393: /* Functions for rounding */
394:
395: // round to float with extended precision exponent
396: STATIC_INLINE void fp_round32(fptype *fp)
397: {
398: *fp = floatx80_round32(*fp, &fp_ctrl);
399: }
400:
401: // round to double with extended precision exponent
402: STATIC_INLINE void fp_round64(fptype *fp)
403: {
404: *fp = floatx80_round64(*fp, &fp_ctrl);
405: }
406:
407: // round to float
408: STATIC_INLINE void fp_round_single(fptype *fp)
409: {
410: *fp = floatx80_round_to_float32(*fp, &fp_ctrl);
411: }
412:
413: // round to double
414: STATIC_INLINE void fp_round_double(fptype *fp)
415: {
416: *fp = floatx80_round_to_float64(*fp, &fp_ctrl);
417: }
418:
419: // round to selected precision
420: STATIC_INLINE void fp_round(fptype *a)
421: {
422: switch(get_float_rounding_precision(&fp_ctrl)) {
423: case 32:
424: *a = floatx80_round_to_float32(*a, &fp_ctrl);
425: break;
426: case 64:
427: *a = floatx80_round_to_float64(*a, &fp_ctrl);
428: break;
429: default:
430: break;
431: }
432: }
433:
434: /* Arithmetic functions */
435: STATIC_INLINE void fp_move(fptype *a, fptype *b)
436: {
437: *a = floatx80_move(*b, &fp_ctrl);
438: }
439: STATIC_INLINE void fp_int(fptype *a, fptype *b)
440: {
441: *a = floatx80_round_to_int(*b, &fp_ctrl);
442: }
443: STATIC_INLINE void fp_intrz(fptype *a, fptype *b)
444: {
445: *a = floatx80_round_to_int_toward_zero(*b, &fp_ctrl);
446: }
447: STATIC_INLINE void fp_sqrt(fptype *a, fptype *b)
448: {
449: *a = floatx80_sqrt(*b, &fp_ctrl);
450: }
451: STATIC_INLINE void fp_abs(fptype *a, fptype *b)
452: {
453: *a = floatx80_abs(*b, &fp_ctrl);
454: }
455: STATIC_INLINE void fp_neg(fptype *a, fptype *b)
456: {
457: *a = floatx80_neg(*b, &fp_ctrl);
458: }
459: STATIC_INLINE void fp_getexp(fptype *a, fptype *b)
460: {
461: *a = floatx80_getexp(*b, &fp_ctrl);
462: }
463: STATIC_INLINE void fp_getman(fptype *a, fptype *b)
464: {
465: *a = floatx80_getman(*b, &fp_ctrl);
466: }
467: STATIC_INLINE void fp_div(fptype *a, fptype *b)
468: {
469: *a = floatx80_div(*a, *b, &fp_ctrl);
470: }
471: STATIC_INLINE void fp_mod(fptype *a, fptype *b, uae_u64 *q, uae_s8 *s)
472: {
473: *a = floatx80_mod(*a, *b, q, s, &fp_ctrl);
474: }
475: STATIC_INLINE void fp_add(fptype *a, fptype *b)
476: {
477: *a = floatx80_add(*a, *b, &fp_ctrl);
478: }
479: STATIC_INLINE void fp_mul(fptype *a, fptype *b)
480: {
481: *a = floatx80_mul(*a, *b, &fp_ctrl);
482: }
483: STATIC_INLINE void fp_sgldiv(fptype *a, fptype *b)
484: {
485: *a = floatx80_sgldiv(*a, *b, &fp_ctrl);
486: }
487: STATIC_INLINE void fp_rem(fptype *a, fptype *b, uae_u64 *q, uae_s8 *s)
488: {
489: *a = floatx80_rem(*a, *b, q, s, &fp_ctrl);
490: }
491: STATIC_INLINE void fp_scale(fptype *a, fptype *b)
492: {
493: *a = floatx80_scale(*a, *b, &fp_ctrl);
494: }
495: STATIC_INLINE void fp_sglmul(fptype *a, fptype *b)
496: {
497: *a = floatx80_sglmul(*a, *b, &fp_ctrl);
498: }
499: STATIC_INLINE void fp_sub(fptype *a, fptype *b)
500: {
501: *a = floatx80_sub(*a, *b, &fp_ctrl);
502: }
503: STATIC_INLINE void fp_cmp(fptype *a, fptype *b)
504: {
505: *a = floatx80_cmp(*a, *b, &fp_ctrl);
506: }
507: STATIC_INLINE void fp_tst(fptype *a, fptype *b)
508: {
509: *a = floatx80_tst(*b, &fp_ctrl);
510: }
511:
512: STATIC_INLINE void fp_sinh(fptype *a, fptype *b)
513: {
514: *a = floatx80_sinh(*b, &fp_ctrl);
515: }
516: STATIC_INLINE void fp_lognp1(fptype *a, fptype *b)
517: {
518: *a = floatx80_lognp1(*b, &fp_ctrl);
519: }
520: STATIC_INLINE void fp_etoxm1(fptype *a, fptype *b)
521: {
522: *a = floatx80_etoxm1(*b, &fp_ctrl);
523: }
524: STATIC_INLINE void fp_tanh(fptype *a, fptype *b)
525: {
526: *a = floatx80_tanh(*b, &fp_ctrl);
527: }
528: STATIC_INLINE void fp_atan(fptype *a, fptype *b)
529: {
530: *a = floatx80_atan(*b, &fp_ctrl);
531: }
532: STATIC_INLINE void fp_asin(fptype *a, fptype *b)
533: {
534: *a = floatx80_asin(*b, &fp_ctrl);
535: }
536: STATIC_INLINE void fp_atanh(fptype *a, fptype *b)
537: {
538: *a = floatx80_atanh(*b, &fp_ctrl);
539: }
540: STATIC_INLINE void fp_sin(fptype *a, fptype *b)
541: {
542: *a = floatx80_sin(*b, &fp_ctrl);
543: }
544: STATIC_INLINE void fp_tan(fptype *a, fptype *b)
545: {
546: *a = floatx80_tan(*b, &fp_ctrl);
547: }
548: STATIC_INLINE void fp_etox(fptype *a, fptype *b)
549: {
550: *a = floatx80_etox(*b, &fp_ctrl);
551: }
552: STATIC_INLINE void fp_twotox(fptype *a, fptype *b)
553: {
554: *a = floatx80_twotox(*b, &fp_ctrl);
555: }
556: STATIC_INLINE void fp_tentox(fptype *a, fptype *b)
557: {
558: *a = floatx80_tentox(*b, &fp_ctrl);
559: }
560: STATIC_INLINE void fp_logn(fptype *a, fptype *b)
561: {
562: *a = floatx80_logn(*b, &fp_ctrl);
563: }
564: STATIC_INLINE void fp_log10(fptype *a, fptype *b)
565: {
566: *a = floatx80_log10(*b, &fp_ctrl);
567: }
568: STATIC_INLINE void fp_log2(fptype *a, fptype *b)
569: {
570: *a = floatx80_log2(*b, &fp_ctrl);
571: }
572: STATIC_INLINE void fp_cosh(fptype *a, fptype *b)
573: {
574: *a = floatx80_cosh(*b, &fp_ctrl);
575: }
576: STATIC_INLINE void fp_acos(fptype *a, fptype *b)
577: {
578: *a = floatx80_acos(*b, &fp_ctrl);
579: }
580: STATIC_INLINE void fp_cos(fptype *a, fptype *b)
581: {
582: *a = floatx80_cos(*b, &fp_ctrl);
583: }
584:
585: /* Functions with fixed precision */
586: STATIC_INLINE void fp_move_single(fptype *a, fptype *b)
587: {
588: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
589: set_float_rounding_precision(32, &fp_ctrl);
590: *a = floatx80_move(*b, &fp_ctrl);
591: set_float_rounding_precision(oldprec, &fp_ctrl);
592: }
593: STATIC_INLINE void fp_abs_single(fptype *a, fptype *b)
594: {
595: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
596: set_float_rounding_precision(32, &fp_ctrl);
597: *a = floatx80_abs(*b, &fp_ctrl);
598: set_float_rounding_precision(oldprec, &fp_ctrl);
599: }
600: STATIC_INLINE void fp_neg_single(fptype *a, fptype *b)
601: {
602: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
603: set_float_rounding_precision(32, &fp_ctrl);
604: *a = floatx80_neg(*b, &fp_ctrl);
605: set_float_rounding_precision(oldprec, &fp_ctrl);
606: }
607: STATIC_INLINE void fp_add_single(fptype *a, fptype *b)
608: {
609: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
610: set_float_rounding_precision(32, &fp_ctrl);
611: *a = floatx80_add(*a, *b, &fp_ctrl);
612: set_float_rounding_precision(oldprec, &fp_ctrl);
613: }
614: STATIC_INLINE void fp_sub_single(fptype *a, fptype *b)
615: {
616: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
617: set_float_rounding_precision(32, &fp_ctrl);
618: *a = floatx80_sub(*a, *b, &fp_ctrl);
619: set_float_rounding_precision(oldprec, &fp_ctrl);
620: }
621: STATIC_INLINE void fp_mul_single(fptype *a, fptype *b)
622: {
623: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
624: set_float_rounding_precision(32, &fp_ctrl);
625: *a = floatx80_mul(*a, *b, &fp_ctrl);
626: set_float_rounding_precision(oldprec, &fp_ctrl);
627: }
628: STATIC_INLINE void fp_div_single(fptype *a, fptype *b)
629: {
630: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
631: set_float_rounding_precision(32, &fp_ctrl);
632: *a = floatx80_div(*a, *b, &fp_ctrl);
633: set_float_rounding_precision(oldprec, &fp_ctrl);
634: }
635: STATIC_INLINE void fp_sqrt_single(fptype *a, fptype *b)
636: {
637: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
638: set_float_rounding_precision(32, &fp_ctrl);
639: *a = floatx80_sqrt(*b, &fp_ctrl);
640: set_float_rounding_precision(oldprec, &fp_ctrl);
641: }
642: STATIC_INLINE void fp_move_double(fptype *a, fptype *b)
643: {
644: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
645: set_float_rounding_precision(64, &fp_ctrl);
646: *a = floatx80_move(*b, &fp_ctrl);
647: set_float_rounding_precision(oldprec, &fp_ctrl);
648: }
649: STATIC_INLINE void fp_abs_double(fptype *a, fptype *b)
650: {
651: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
652: set_float_rounding_precision(64, &fp_ctrl);
653: *a = floatx80_abs(*b, &fp_ctrl);
654: set_float_rounding_precision(oldprec, &fp_ctrl);
655: }
656: STATIC_INLINE void fp_neg_double(fptype *a, fptype *b)
657: {
658: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
659: set_float_rounding_precision(64, &fp_ctrl);
660: *a = floatx80_neg(*b, &fp_ctrl);
661: set_float_rounding_precision(oldprec, &fp_ctrl);
662: }
663: STATIC_INLINE void fp_add_double(fptype *a, fptype *b)
664: {
665: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
666: set_float_rounding_precision(64, &fp_ctrl);
667: *a = floatx80_add(*a, *b, &fp_ctrl);
668: set_float_rounding_precision(oldprec, &fp_ctrl);
669: }
670: STATIC_INLINE void fp_sub_double(fptype *a, fptype *b)
671: {
672: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
673: set_float_rounding_precision(64, &fp_ctrl);
674: *a = floatx80_sub(*a, *b, &fp_ctrl);
675: set_float_rounding_precision(oldprec, &fp_ctrl);
676: }
677: STATIC_INLINE void fp_mul_double(fptype *a, fptype *b)
678: {
679: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
680: set_float_rounding_precision(64, &fp_ctrl);
681: *a = floatx80_mul(*a, *b, &fp_ctrl);
682: set_float_rounding_precision(oldprec, &fp_ctrl);
683: }
684: STATIC_INLINE void fp_div_double(fptype *a, fptype *b)
685: {
686: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
687: set_float_rounding_precision(64, &fp_ctrl);
688: *a = floatx80_div(*a, *b, &fp_ctrl);
689: set_float_rounding_precision(oldprec, &fp_ctrl);
690: }
691: STATIC_INLINE void fp_sqrt_double(fptype *a, fptype *b)
692: {
693: int8 oldprec = get_float_rounding_precision(&fp_ctrl);
694: set_float_rounding_precision(64, &fp_ctrl);
695: *a = floatx80_sqrt(*b, &fp_ctrl);
696: set_float_rounding_precision(oldprec, &fp_ctrl);
697: }
698:
699:
700:
701: #if 0 /* Old fallback functions disabled */
702: static const long double twoto32 = 4294967296.0;
703:
704: STATIC_INLINE void to_native(long double *fp, fptype fpx)
705: {
706: int expon;
707: long double frac;
708:
709: expon = fpx.high & 0x7fff;
710:
711: if (floatx80_is_zero(fpx)) {
712: *fp = floatx80_is_negative(fpx) ? -0.0 : +0.0;
713: return;
714: }
715: if (floatx80_is_nan(fpx)) {
716: *fp = sqrtl(-1);
717: return;
718: }
719: if (floatx80_is_infinity(fpx)) {
720: *fp = floatx80_is_negative(fpx) ? logl(0.0) : (1.0/0.0);
721: return;
722: }
723:
724: frac = (long double)fpx.low / (long double)(twoto32 * 2147483648.0);
725: if (floatx80_is_negative(fpx))
726: frac = -frac;
727: *fp = ldexpl (frac, expon - 16383);
728: }
729: STATIC_INLINE void from_native(long double fp, fptype *fpx)
730: {
731: int expon;
732: long double frac;
733:
734: if (signbit(fp))
735: fpx->high = 0x8000;
736: else
737: fpx->high = 0x0000;
738:
739: if (isnan(fp)) {
740: fpx->high |= 0x7fff;
741: fpx->low = LIT64(0xffffffffffffffff);
742: return;
743: }
744: if (isinf(fp)) {
745: fpx->high |= 0x7fff;
746: fpx->low = LIT64(0x0000000000000000);
747: return;
748: }
749: if (fp == 0.0) {
750: fpx->low = LIT64(0x0000000000000000);
751: return;
752: }
753: if (fp < 0.0)
754: fp = -fp;
755:
756: frac = frexpl (fp, &expon);
757: frac += 0.5 / (twoto32 * twoto32);
758: if (frac >= 1.0) {
759: frac /= 2.0;
760: expon++;
761: }
762: fpx->high |= (expon + 16383 - 1) & 0x7fff;
763: fpx->low = (bits64)(frac * (long double)(twoto32 * twoto32));
764:
765: while (!(fpx->low & LIT64( 0x8000000000000000))) {
766: if (fpx->high == 0) {
767: break;
768: }
769: fpx->low <<= 1;
770: fpx->high--;
771: }
772: }
773:
774: STATIC_INLINE void fp_sinhf(fptype *a, fptype *b)
775: {
776: flag e = 0;
777: floatx80_sinh_check(*a, &e);
778: if (e) return;
779: long double fp;
780: to_native(&fp, *b);
781: fp = sinhl(fp);
782: from_native(fp, a);
783: fp_round(a);
784: }
785: STATIC_INLINE void fp_lognp1f(fptype *a, fptype *b)
786: {
787: flag e = 0;
788: floatx80_lognp1_check(*a, &e);
789: if (e) return;
790: long double fp;
791: to_native(&fp, *b);
792: fp = log1pl(fp);
793: from_native(fp, a);
794: fp_round(a);
795: }
796: STATIC_INLINE void fp_etoxm1f(fptype *a, fptype *b)
797: {
798: flag e = 0;
799: floatx80_etoxm1_check(*a, &e);
800: if (e) return;
801: long double fp;
802: to_native(&fp, *b);
803: fp = expm1l(fp);
804: from_native(fp, a);
805: fp_round(a);
806: }
807: STATIC_INLINE void fp_tanhf(fptype *a, fptype *b)
808: {
809: flag e = 0;
810: floatx80_tanh_check(*a, &e);
811: if (e) return;
812: long double fp;
813: to_native(&fp, *b);
814: fp = tanhl(fp);
815: from_native(fp, a);
816: fp_round(a);
817: }
818: STATIC_INLINE void fp_atanf(fptype *a, fptype *b)
819: {
820: flag e = 0;
821: floatx80_atan_check(*a, &e);
822: if (e) return;
823: long double fp;
824: to_native(&fp, *b);
825: fp = atanl(fp);
826: from_native(fp, a);
827: fp_round(a);
828: }
829: STATIC_INLINE void fp_asinf(fptype *a, fptype *b)
830: {
831: flag e = 0;
832: floatx80_asin_check(*a, &e);
833: if (e) return;
834: long double fp;
835: to_native(&fp, *b);
836: fp = asinl(fp);
837: from_native(fp, a);
838: fp_round(a);
839: }
840: STATIC_INLINE void fp_atanhf(fptype *a, fptype *b)
841: {
842: flag e = 0;
843: floatx80_atanh_check(*a, &e);
844: if (e) return;
845: long double fp;
846: to_native(&fp, *b);
847: fp = atanhl(fp);
848: from_native(fp, a);
849: fp_round(a);
850: }
851: STATIC_INLINE void fp_sinf(fptype *a, fptype *b)
852: {
853: flag e = 0;
854: floatx80_sin_check(*a, &e);
855: if (e) return;
856: long double fp;
857: to_native(&fp, *b);
858: fp = sinl(fp);
859: from_native(fp, a);
860: fp_round(a);
861: }
862: STATIC_INLINE void fp_tanf(fptype *a, fptype *b)
863: {
864: flag e = 0;
865: floatx80_tan_check(*a, &e);
866: if (e) return;
867: long double fp;
868: to_native(&fp, *b);
869: fp = tanl(fp);
870: from_native(fp, a);
871: fp_round(a);
872: }
873: STATIC_INLINE void fp_etoxf(fptype *a, fptype *b)
874: {
875: flag e = 0;
876: floatx80_etox_check(*a, &e);
877: if (e) return;
878: long double fp;
879: to_native(&fp, *b);
880: fp = expl(fp);
881: from_native(fp, a);
882: fp_round(a);
883: }
884: STATIC_INLINE void fp_twotoxf(fptype *a, fptype *b)
885: {
886: flag e = 0;
887: floatx80_twotox_check(*a, &e);
888: if (e) return;
889: long double fp;
890: to_native(&fp, *b);
891: fp = powl(2.0, fp);
892: from_native(fp, a);
893: fp_round(a);
894: }
895: STATIC_INLINE void fp_tentoxf(fptype *a, fptype *b)
896: {
897: flag e = 0;
898: floatx80_tentox_check(*a, &e);
899: if (e) return;
900: long double fp;
901: to_native(&fp, *b);
902: fp = powl(10.0, fp);
903: from_native(fp, a);
904: fp_round(a);
905: }
906: STATIC_INLINE void fp_lognf(fptype *a, fptype *b)
907: {
908: flag e = 0;
909: floatx80_logn_check(*a, &e);
910: if (e) return;
911: long double fp;
912: to_native(&fp, *b);
913: fp = logl(fp);
914: from_native(fp, a);
915: fp_round(a);
916: }
917: STATIC_INLINE void fp_log10f(fptype *a, fptype *b)
918: {
919: flag e = 0;
920: floatx80_log10_check(*a, &e);
921: if (e) return;
922: long double fp;
923: to_native(&fp, *b);
924: fp = log10l(fp);
925: from_native(fp, a);
926: fp_round(a);
927: }
928: STATIC_INLINE void fp_log2f(fptype *a, fptype *b)
929: {
930: flag e = 0;
931: floatx80_log2_check(*a, &e);
932: if (e) return;
933: long double fp;
934: to_native(&fp, *b);
935: fp = log2l(fp);
936: from_native(fp, a);
937: fp_round(a);
938: }
939: STATIC_INLINE void fp_coshf(fptype *a, fptype *b)
940: {
941: flag e = 0;
942: floatx80_cosh_check(*a, &e);
943: if (e) return;
944: long double fp;
945: to_native(&fp, *b);
946: fp = coshl(fp);
947: from_native(fp, a);
948: fp_round(a);
949: }
950: STATIC_INLINE void fp_acosf(fptype *a, fptype *b)
951: {
952: flag e = 0;
953: floatx80_acos_check(*a, &e);
954: if (e) return;
955: long double fp;
956: to_native(&fp, *b);
957: fp = acosl(fp);
958: from_native(fp, a);
959: fp_round(a);
960: }
961: STATIC_INLINE void fp_cosf(fptype *a, fptype *b)
962: {
963: flag e = 0;
964: floatx80_cos_check(*a, &e);
965: if (e) return;
966: long double fp;
967: to_native(&fp, *b);
968: fp = cosl(fp);
969: from_native(fp, a);
970: fp_round(a);
971: }
972: #endif
973:
974: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.