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