![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fpu_trig.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / emulator|
Return to fpu_trig.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / emulator |
1.1 root 1: /*---------------------------------------------------------------------------+
2: | fpu_trig.c |
3: | |
4: | Implementation of the FPU "transcendental" functions. |
5: | |
6: | Copyright (C) 1992 W. Metzenthen, 22 Parker St, Ormond, Vic 3163, |
7: | Australia. E-mail [email protected] |
8: | |
9: | |
10: +---------------------------------------------------------------------------*/
11:
12: #include "fpu_system.h"
13: #include "exception.h"
14: #include "fpu_emu.h"
15: #include "status_w.h"
16: #include "control_w.h"
17: #include "reg_constant.h"
18:
19:
20:
21: static int trig_arg(FPU_REG *X)
22: {
23: FPU_REG tmp, quot;
24: int rv;
25: long long q;
26: int old_cw = control_word;
27:
28: control_word &= ~CW_RC;
29: control_word |= RC_CHOP;
30:
31: reg_move(X, ");
32: reg_div(", &CONST_PI2, ");
33:
34: reg_move(", &tmp);
35: round_to_int(&tmp);
36: if ( tmp.sigh & 0x80000000 )
37: return -1; /* |Arg| is >= 2^63 */
38: tmp.exp = EXP_BIAS + 63;
39: q = *(long long *)&(tmp.sigl);
40: normalize(&tmp);
41:
42: reg_sub(", &tmp, X);
43: rv = q & 7;
44:
45: control_word = old_cw;
46: return rv;;
47: }
48:
49:
50: /* Convert a long to register */
51: void convert_l2reg(long *arg, FPU_REG *dest)
52: {
53: long num = *arg;
54:
55: if (num == 0)
56: { reg_move(&CONST_Z, dest); return; }
57:
58: if (num > 0)
59: dest->sign = SIGN_POS;
60: else
61: { num = -num; dest->sign = SIGN_NEG; }
62:
63: dest->sigh = num;
64: dest->sigl = 0;
65: dest->exp = EXP_BIAS + 31;
66: dest->tag = TW_Valid;
67: normalize(dest);
68: }
69:
70:
71: static void single_arg_error(void)
72: {
73: switch ( FPU_st0_tag )
74: {
75: case TW_NaN:
76: if ( !(FPU_st0_ptr->sigh & 0x40000000) ) /* Signaling ? */
77: {
78: EXCEPTION(EX_Invalid);
79: /* Convert to a QNaN */
80: FPU_st0_ptr->sigh |= 0x40000000;
81: }
82: case TW_Empty:
83: stack_underflow();
84: #ifdef PARANOID
85: default:
86: EXCEPTION(EX_INTERNAL|0x0112);
87: #endif PARANOID
88: }
89: }
90:
91:
92: /*---------------------------------------------------------------------------*/
93:
94: static void f2xm1()
95: {
96: switch ( FPU_st0_tag )
97: {
98: case TW_Valid:
99: {
100: FPU_REG rv, tmp;
101:
102: if ( FPU_st0_ptr->sign == SIGN_POS )
103: {
104: /* poly_2xm1(x) requires 0 < x < 1. */
105: if ( poly_2xm1(FPU_st0_ptr, &rv) )
106: return;
107: reg_mul(&rv, FPU_st0_ptr, FPU_st0_ptr);
108: return;
109: }
110: else
111: {
112: /* **** Should change poly_2xm1() to at least handle numbers near 0 */
113: /* poly_2xm1(x) doesn't handle negative numbers. */
114: /* So we compute (poly_2xm1(x+1)-1)/2, for -1 < x < 0 */
115: reg_add(FPU_st0_ptr, &CONST_1, &tmp);
116: poly_2xm1(&tmp, &rv);
117: reg_mul(&rv, &tmp, &tmp);
118: reg_sub(&tmp, &CONST_1, FPU_st0_ptr);
119: FPU_st0_ptr->exp--;
120: }
121: if ( FPU_st0_ptr->exp <= EXP_UNDER )
122: arith_underflow(FPU_st0_ptr);
123: return;
124: }
125: case TW_Zero:
126: return;
127: case TW_Infinity:
128: if ( FPU_st0_ptr->sign == SIGN_NEG )
129: {
130: /* -infinity gives -1 (p16-10) */
131: reg_move(&CONST_1, FPU_st0_ptr);
132: FPU_st0_ptr->sign = SIGN_NEG;
133: }
134: return;
135: default:
136: single_arg_error();
137: }
138: }
139:
140: static void fptan()
141: {
142: FPU_REG *st_new_ptr;
143: int q;
144: char arg_sign = FPU_st0_ptr->sign;
145:
146: if ( STACK_OVERFLOW )
147: { stack_overflow(); return; }
148:
149: switch ( FPU_st0_tag )
150: {
151: case TW_Valid:
152: FPU_st0_ptr->sign = SIGN_POS;
153: if ( (q = trig_arg(FPU_st0_ptr)) != -1 )
154: {
155: if (q & 1)
156: reg_sub(&CONST_1, FPU_st0_ptr, FPU_st0_ptr);
157:
158: poly_tan(FPU_st0_ptr, FPU_st0_ptr);
159:
160: FPU_st0_ptr->sign = (q & 1) ^ arg_sign;
161:
162: if ( FPU_st0_ptr->exp <= EXP_UNDER )
163: arith_underflow(FPU_st0_ptr);
164:
165: push();
166: reg_move(&CONST_1, FPU_st0_ptr);
167: setcc(0);
168: }
169: else
170: {
171: /* Operand is out of range */
172: setcc(SW_C2);
173: FPU_st0_ptr->sign = arg_sign; /* restore st(0) */
174: return;
175: }
176: break;
177: case TW_Infinity:
178: arith_invalid(FPU_st0_ptr);
179: setcc(0);
180: return;
181: case TW_Zero:
182: push();
183: reg_move(&CONST_1, FPU_st0_ptr);
184: setcc(0);
185: break;
186: default:
187: single_arg_error();
188: break;
189: }
190: }
191:
192:
193: static void fxtract()
194: {
195: FPU_REG *st_new_ptr;
196: register FPU_REG *st1_ptr = FPU_st0_ptr; /* anticipate */
197:
198: if ( STACK_OVERFLOW )
199: { stack_overflow(); return; }
200:
201: if ( !(FPU_st0_tag ^ TW_Valid) )
202: {
203: long e;
204:
205: push();
206: reg_move(st1_ptr, FPU_st0_ptr);
207: FPU_st0_ptr->exp = EXP_BIAS;
208: e = st1_ptr->exp - EXP_BIAS;
209: convert_l2reg(&e, st1_ptr);
210: return;
211: }
212: else if ( FPU_st0_tag == TW_Zero )
213: {
214: char sign = FPU_st0_ptr->sign;
215: divide_by_zero(SIGN_NEG, FPU_st0_ptr);
216: push();
217: reg_move(&CONST_Z, FPU_st0_ptr);
218: FPU_st0_ptr->sign = sign;
219: return;
220: }
221: else if ( FPU_st0_tag == TW_Infinity )
222: {
223: char sign = FPU_st0_ptr->sign;
224: FPU_st0_ptr->sign = SIGN_POS;
225: push();
226: reg_move(&CONST_INF, FPU_st0_ptr);
227: FPU_st0_ptr->sign = sign;
228: return;
229: }
230: else if ( FPU_st0_tag == TW_NaN )
231: {
232: if ( !(FPU_st0_ptr->sigh & 0x40000000) ) /* Signaling ? */
233: {
234: EXCEPTION(EX_Invalid);
235: /* Convert to a QNaN */
236: FPU_st0_ptr->sigh |= 0x40000000;
237: }
238: push();
239: reg_move(st1_ptr, FPU_st0_ptr);
240: return;
241: }
242: else if ( FPU_st0_tag == TW_Empty )
243: {
244: /* Is this the correct behaviour? */
245: if ( control_word & EX_Invalid )
246: {
247: stack_underflow();
248: push();
249: stack_underflow();
250: }
251: else
252: EXCEPTION(EX_StackUnder);
253: }
254: #ifdef PARANOID
255: else
256: EXCEPTION(EX_INTERNAL | 0x119);
257: #endif PARANOID
258: }
259:
260:
261: static void fdecstp()
262: {
263: top--; /* FPU_st0_ptr will be fixed in math_emulate() before the next instr */
264: }
265:
266: static void fincstp()
267: {
268: top++; /* FPU_st0_ptr will be fixed in math_emulate() before the next instr */
269: }
270:
271:
272: static void fsqrt_()
273: {
274: if ( !(FPU_st0_tag ^ TW_Valid) )
275: {
276: int expon;
277:
278: if (FPU_st0_ptr->sign == SIGN_NEG)
279: {
280: arith_invalid(FPU_st0_ptr);
281: return;
282: }
283:
284: expon = FPU_st0_ptr->exp - EXP_BIAS;
285: FPU_st0_ptr->exp = EXP_BIAS + (expon & 1); /* make st(0) in [1.0 .. 4.0) */
286:
287: wm_sqrt(FPU_st0_ptr); /* Do the computation */
288:
289: FPU_st0_ptr->exp += expon >> 1;
290: FPU_st0_ptr->tag = TW_Valid;
291: FPU_st0_ptr->sign = SIGN_POS;
292: }
293: else if ( FPU_st0_tag == TW_Zero )
294: return;
295: else if ( FPU_st0_tag == TW_Infinity )
296: {
297: if ( FPU_st0_ptr->sign == SIGN_NEG )
298: arith_invalid(FPU_st0_ptr);
299: return;
300: }
301: else
302: single_arg_error();
303: }
304:
305:
306: static void frndint_()
307: {
308: if ( !(FPU_st0_tag ^ TW_Valid) )
309: {
310: if (FPU_st0_ptr->exp > EXP_BIAS+63)
311: return;
312:
313: round_to_int(FPU_st0_ptr); /* Fortunately, this can't overflow to 2^64 */
314: FPU_st0_ptr->exp = EXP_BIAS + 63;
315: normalize(FPU_st0_ptr);
316: return;
317: }
318: else if ( (FPU_st0_tag == TW_Zero) || (FPU_st0_tag == TW_Infinity) )
319: return;
320: else
321: single_arg_error();
322: }
323:
324:
325: static void fsin()
326: {
327: if ( FPU_st0_tag == TW_Valid )
328: {
329: int q;
330: char arg_sign = FPU_st0_ptr->sign;
331: FPU_st0_ptr->sign = SIGN_POS;
332: if ( (q = trig_arg(FPU_st0_ptr)) != -1 )
333: {
334: FPU_REG rv;
335:
336: if (q & 1)
337: reg_sub(&CONST_1, FPU_st0_ptr, FPU_st0_ptr);
338:
339: poly_sine(FPU_st0_ptr, &rv);
340:
341: setcc(0);
342: if (q & 2)
343: rv.sign ^= SIGN_POS ^ SIGN_NEG;
344: rv.sign ^= arg_sign;
345: reg_move(&rv, FPU_st0_ptr);
346:
347: if ( FPU_st0_ptr->exp <= EXP_UNDER )
348: arith_underflow(FPU_st0_ptr);
349:
350: return;
351: }
352: else
353: {
354: /* Operand is out of range */
355: setcc(SW_C2);
356: FPU_st0_ptr->sign = arg_sign; /* restore st(0) */
357: EXCEPTION(EX_Invalid);
358: return;
359: }
360: }
361: else if ( FPU_st0_tag == TW_Zero )
362: {
363: setcc(0);
364: return;
365: }
366: else if ( FPU_st0_tag == TW_Infinity )
367: {
368: arith_invalid(FPU_st0_ptr);
369: setcc(0);
370: return;
371: }
372: else
373: single_arg_error();
374: }
375:
376:
377: static int f_cos(FPU_REG *arg)
378: {
379: if ( arg->tag == TW_Valid )
380: {
381: int q;
382: char arg_sign = arg->sign;
383: arg->sign = SIGN_POS;
384: if ( (q = trig_arg(arg)) != -1 )
385: {
386: FPU_REG rv;
387:
388: if ( !(q & 1) )
389: reg_sub(&CONST_1, arg, arg);
390:
391: poly_sine(arg, &rv);
392:
393: setcc(0);
394: if ((q+1) & 2)
395: rv.sign ^= SIGN_POS ^ SIGN_NEG;
396: reg_move(&rv, arg);
397:
398: return 0;
399: }
400: else
401: {
402: /* Operand is out of range */
403: setcc(SW_C2);
404: arg->sign = arg_sign; /* restore st(0) */
405: EXCEPTION(EX_Invalid);
406: return 1;
407: }
408: }
409: else if ( arg->tag == TW_Zero )
410: {
411: reg_move(&CONST_1, arg);
412: setcc(0);
413: return 0;
414: }
415: else if ( FPU_st0_tag == TW_Infinity )
416: {
417: arith_invalid(FPU_st0_ptr);
418: setcc(0);
419: return 1;
420: }
421: else
422: {
423: single_arg_error(); /* requires arg == &st(0) */
424: return 1;
425: }
426: }
427:
428:
429: static void fcos()
430: {
431: f_cos(FPU_st0_ptr);
432: }
433:
434:
435: static void fsincos()
436: {
437: FPU_REG *st_new_ptr;
438: FPU_REG arg;
439:
440: if ( STACK_OVERFLOW )
441: { stack_overflow(); return; }
442:
443: reg_move(FPU_st0_ptr,&arg);
444: if ( !f_cos(&arg) )
445: {
446: fsin();
447: push();
448: reg_move(&arg,FPU_st0_ptr);
449: }
450:
451: }
452:
453:
454: /*---------------------------------------------------------------------------*/
455: /* The following all require two arguments: st(0) and st(1) */
456:
457: /* remainder of st(0) / st(1) */
458: /* Assumes that st(0) and st(1) are both TW_Valid */
459: static void fprem_kernel(int round)
460: {
461: FPU_REG *st1_ptr = &st(1);
462: char st1_tag = st1_ptr->tag;
463:
464: if ( !((FPU_st0_tag ^ TW_Valid) | (st1_tag ^ TW_Valid)) )
465: {
466: FPU_REG tmp;
467: int old_cw = control_word;
468: int expdif = FPU_st0_ptr->exp - (st1_ptr)->exp;
469:
470: control_word &= ~CW_RC;
471: control_word |= round;
472:
473: if (expdif < 64)
474: {
475: /* This should be the most common case */
476: long long q;
477: int c = 0;
478: reg_div(FPU_st0_ptr, st1_ptr, &tmp);
479:
480: round_to_int(&tmp); /* Fortunately, this can't overflow to 2^64 */
481: tmp.exp = EXP_BIAS + 63;
482: q = *(long long *)&(tmp.sigl);
483: normalize(&tmp);
484:
485: reg_mul(st1_ptr, &tmp, &tmp);
486: reg_sub(FPU_st0_ptr, &tmp, FPU_st0_ptr);
487:
488: if (q&4) c |= SW_C3;
489: if (q&2) c |= SW_C1;
490: if (q&1) c |= SW_C0;
491:
492: setcc(c);
493: }
494: else
495: {
496: /* There is a large exponent difference ( >= 64 ) */
497: int N_exp;
498:
499: reg_div(FPU_st0_ptr, st1_ptr, &tmp);
500: /* N is 'a number between 32 and 63' (p26-113) */
501: N_exp = (tmp.exp & 31) + 32;
502: tmp.exp = EXP_BIAS + N_exp;
503:
504: round_to_int(&tmp); /* Fortunately, this can't overflow to 2^64 */
505: tmp.exp = EXP_BIAS + 63;
506: normalize(&tmp);
507:
508: tmp.exp = EXP_BIAS + expdif - N_exp;
509:
510: reg_mul(st1_ptr, &tmp, &tmp);
511: reg_sub(FPU_st0_ptr, &tmp, FPU_st0_ptr);
512:
513: setcc(SW_C2);
514: }
515: control_word = old_cw;
516:
517: if ( FPU_st0_ptr->exp <= EXP_UNDER )
518: arith_underflow(FPU_st0_ptr);
519: return;
520: }
521: else if ( (FPU_st0_tag == TW_Empty) | (st1_tag == TW_Empty) )
522: { stack_underflow(); return; }
523: else if ( FPU_st0_tag == TW_Zero )
524: {
525: if ( (st1_tag == TW_Valid) || (st1_tag == TW_Infinity) )
526: { setcc(0); return; }
527: if ( st1_tag == TW_Zero )
528: { arith_invalid(FPU_st0_ptr); return; }
529: }
530:
531: if ( (FPU_st0_tag == TW_NaN) | (st1_tag == TW_NaN) )
532: { real_2op_NaN(FPU_st0_ptr, st1_ptr, FPU_st0_ptr); return; }
533: else if ( FPU_st0_tag == TW_Infinity )
534: { arith_invalid(FPU_st0_ptr); return; }
535: #ifdef PARANOID
536: else
537: EXCEPTION(EX_INTERNAL | 0x118);
538: #endif PARANOID
539:
540: }
541:
542:
543: /* ST(1) <- ST(1) * log ST; pop ST */
544: static void fyl2x()
545: {
546: FPU_REG *st1_ptr = &st(1);
547: char st1_tag = st1_ptr->tag;
548:
549: if ( !((FPU_st0_tag ^ TW_Valid) | (st1_tag ^ TW_Valid)) )
550: {
551: if ( FPU_st0_ptr->sign == SIGN_POS )
552: {
553: poly_l2(FPU_st0_ptr, FPU_st0_ptr);
554:
555: reg_mul(FPU_st0_ptr, st1_ptr, st1_ptr);
556: pop(); FPU_st0_ptr = &st(0);
557: if ( FPU_st0_ptr->exp <= EXP_UNDER )
558: arith_underflow(FPU_st0_ptr);
559: else if ( FPU_st0_ptr->exp >= EXP_OVER )
560: arith_overflow(FPU_st0_ptr);
561: }
562: else
563: {
564: /* negative */
565: pop(); FPU_st0_ptr = &st(0);
566: arith_invalid(FPU_st0_ptr);
567: }
568: return;
569: }
570:
571: if ( (FPU_st0_tag == TW_Empty) || (st1_tag == TW_Empty) )
572: { stack_underflow(); return; }
573:
574: if ( (FPU_st0_tag == TW_NaN) || (st1_tag == TW_NaN) )
575: {
576: real_2op_NaN(FPU_st0_ptr, st1_ptr, st1_ptr);
577: pop();
578: return;
579: }
580:
581: if ( (FPU_st0_tag <= TW_Zero) && (st1_tag <= TW_Zero) )
582: {
583: /* one of the args is zero, the other valid, or both zero */
584: if ( FPU_st0_tag == TW_Zero )
585: {
586: pop(); FPU_st0_ptr = &st(0);
587: if ( FPU_st0_ptr->tag == TW_Zero )
588: arith_invalid(FPU_st0_ptr);
589: else
590: divide_by_zero(st1_ptr->sign ^ SIGN_NEG, FPU_st0_ptr);
591: return;
592: }
593: if ( st1_ptr->sign == SIGN_POS )
594: {
595: /* Zero is the valid answer */
596: char sign = FPU_st0_ptr->sign;
597: if ( FPU_st0_ptr->exp < EXP_BIAS ) sign ^= SIGN_NEG;
598: pop(); FPU_st0_ptr = &st(0);
599: reg_move(&CONST_Z, FPU_st0_ptr);
600: FPU_st0_ptr->sign = sign;
601: return;
602: }
603: pop(); FPU_st0_ptr = &st(0);
604: arith_invalid(FPU_st0_ptr);
605: return;
606: }
607:
608: /* One or both arg must be an infinity */
609: if ( FPU_st0_tag == TW_Infinity )
610: {
611: if ( (FPU_st0_ptr->sign == SIGN_NEG) || (st1_tag == TW_Zero) )
612: { pop(); FPU_st0_ptr = &st(0); arith_invalid(FPU_st0_ptr); return; }
613: else
614: {
615: char sign = st1_ptr->sign;
616: pop(); FPU_st0_ptr = &st(0);
617: reg_move(&CONST_INF, FPU_st0_ptr);
618: FPU_st0_ptr->sign = sign;
619: return;
620: }
621: }
622:
623: /* st(1) must be infinity here */
624: if ( (FPU_st0_tag == TW_Valid) && (FPU_st0_ptr->sign == SIGN_POS) )
625: {
626: if ( FPU_st0_ptr->exp >= EXP_BIAS )
627: {
628: if ( (FPU_st0_ptr->exp == EXP_BIAS) &&
629: (FPU_st0_ptr->sigh == 0x80000000) &&
630: (FPU_st0_ptr->sigl == 0) )
631: {
632: pop(); FPU_st0_ptr = &st(0);
633: arith_invalid(FPU_st0_ptr);
634: return;
635: }
636: pop();
637: return;
638: }
639: else
640: {
641: pop(); FPU_st0_ptr = &st(0);
642: FPU_st0_ptr->sign ^= SIGN_NEG;
643: return;
644: }
645: }
646: /* st(0) must be zero or negative */
647: pop(); FPU_st0_ptr = &st(0);
648: arith_invalid(FPU_st0_ptr);
649: return;
650: }
651:
652:
653: static void fpatan()
654: {
655: FPU_REG *st1_ptr = &st(1);
656: char st1_tag = st1_ptr->tag;
657:
658: if ( !((FPU_st0_tag ^ TW_Valid) | (st1_tag ^ TW_Valid)) )
659: {
660: FPU_REG sum;
661: int quadrant = st1_ptr->sign | ((FPU_st0_ptr->sign)<<1);
662: st1_ptr->sign = FPU_st0_ptr->sign = SIGN_POS;
663: if (emCompare(st1_ptr) == COMP_A_LT_B)
664: {
665: quadrant |= 4;
666: reg_div(FPU_st0_ptr, st1_ptr, &sum);
667: }
668: else
669: reg_div(st1_ptr, FPU_st0_ptr, &sum);
670:
671: poly_atan(&sum);
672:
673: if (quadrant & 4)
674: {
675: reg_sub(&CONST_PI2, &sum, &sum);
676: }
677: if (quadrant & 2)
678: {
679: reg_sub(&CONST_PI, &sum, &sum);
680: }
681: if (quadrant & 1)
682: sum.sign ^= SIGN_POS^SIGN_NEG;
683:
684: reg_move(&sum, st1_ptr);
685: pop(); FPU_st0_ptr = &st(0);
686: if ( FPU_st0_ptr->exp <= EXP_UNDER )
687: arith_underflow(FPU_st0_ptr);
688: return;
689: }
690:
691: if ( (FPU_st0_tag == TW_Empty) || (st1_tag == TW_Empty) )
692: { stack_underflow(); return; }
693:
694: if ( (FPU_st0_tag == TW_NaN) || (st1_tag == TW_NaN) )
695: {
696: real_2op_NaN(FPU_st0_ptr, st1_ptr, st1_ptr);
697: pop();
698: return;
699: }
700:
701: if ( (FPU_st0_tag == TW_Infinity) || (st1_tag == TW_Infinity) )
702: {
703: char sign = st1_ptr->sign;
704: if ( FPU_st0_tag == TW_Infinity )
705: {
706: if ( st1_tag == TW_Infinity )
707: {
708: if ( FPU_st0_ptr->sign == SIGN_POS )
709: { reg_move(&CONST_PI4, st1_ptr); }
710: else
711: reg_add(&CONST_PI4, &CONST_PI2, st1_ptr);
712: }
713: else
714: {
715: if ( FPU_st0_ptr->sign == SIGN_POS )
716: { reg_move(&CONST_Z, st1_ptr); }
717: else
718: reg_move(&CONST_PI, st1_ptr);
719: }
720: }
721: else
722: {
723: reg_move(&CONST_PI2, st1_ptr);
724: }
725: st1_ptr->sign = sign;
726: pop();
727: return;
728: }
729:
730: if ( st1_tag == TW_Zero )
731: {
732: char sign = st1_ptr->sign;
733: /* st(0) must be valid or zero */
734: if ( FPU_st0_ptr->sign == SIGN_POS )
735: { reg_move(&CONST_Z, st1_ptr); }
736: else
737: reg_move(&CONST_PI, st1_ptr);
738: st1_tag = sign;
739: pop();
740: return;
741: }
742: else if ( FPU_st0_tag == TW_Zero )
743: {
744: char sign = st1_ptr->sign;
745: /* st(1) must be TW_Valid here */
746: reg_move(&CONST_PI2, st1_ptr);
747: st1_tag = sign;
748: pop();
749: return;
750: }
751: #ifdef PARANOID
752: EXCEPTION(EX_INTERNAL | 0x220);
753: #endif PARANOID
754: }
755:
756:
757: static void fprem()
758: {
759: fprem_kernel(RC_CHOP);
760: }
761:
762:
763: static void fprem1()
764: {
765: fprem_kernel(RC_RND);
766: }
767:
768:
769: static void fyl2xp1()
770: {
771: FPU_REG *st1_ptr = &st(1);
772: char st1_tag = st1_ptr->tag;
773:
774: if ( !((FPU_st0_tag ^ TW_Valid) | (st1_tag ^ TW_Valid)) )
775: {
776: if ( poly_l2p1(FPU_st0_ptr, FPU_st0_ptr) )
777: {
778: arith_invalid(st1_ptr); pop(); return;
779: }
780:
781: reg_mul(FPU_st0_ptr, st1_ptr, st1_ptr);
782: pop();
783: return;
784: }
785: else if ( (FPU_st0_tag == TW_Empty) | (st1_tag == TW_Empty) )
786: stack_underflow();
787: else if ( FPU_st0_tag == TW_Zero )
788: {
789: if ( st1_tag <= TW_Zero )
790: {
791: st1_ptr->sign ^= FPU_st0_ptr->sign;
792: reg_move(FPU_st0_ptr, st1_ptr);
793: }
794: else if ( st1_tag == TW_Infinity )
795: {
796: arith_invalid(st1_ptr);
797: }
798: else if ( st1_tag == TW_NaN )
799: {
800: if ( !(st1_ptr->sigh & 0x40000000) )
801: EXCEPTION(EX_Invalid); /* signaling NaN */
802: st1_ptr->sigh |= 0x40000000; /* QNaN */
803: }
804: #ifdef PARANOID
805: else
806: {
807: EXCEPTION(EX_INTERNAL | 0x116);
808: }
809: #endif PARANOID
810: pop();
811: return;
812: }
813: else if ( FPU_st0_tag == TW_NaN )
814: {
815: real_2op_NaN(FPU_st0_ptr, st1_ptr, st1_ptr);
816: pop();
817: return;
818: }
819: else if ( FPU_st0_tag == TW_Infinity )
820: {
821: if ( st1_tag == TW_NaN )
822: real_2op_NaN(FPU_st0_ptr, st1_ptr, st1_ptr);
823: else
824: arith_invalid(st1_ptr);
825: pop();
826: return;
827: }
828: #ifdef PARANOID
829: else
830: EXCEPTION(EX_INTERNAL | 0x117);
831: #endif PARANOID
832: }
833:
834:
835: static void fscale()
836: {
837: FPU_REG *st1_ptr = &st(1);
838: char st1_tag = st1_ptr->tag;
839:
840: if ( !((FPU_st0_tag ^ TW_Valid) | (st1_tag ^ TW_Valid)) )
841: {
842: long scale;
843: FPU_REG tmp;
844:
845: /* 2^31 is far too large, 2^-31 is far too small */
846: if ( st1_ptr->exp > EXP_BIAS + 30 )
847: {
848: char sign;
849: EXCEPTION(EX_Overflow);
850: sign = FPU_st0_ptr->sign;
851: reg_move(&CONST_INF, FPU_st0_ptr);
852: FPU_st0_ptr->sign = sign;
853: return;
854: }
855: else if ( st1_ptr->exp < EXP_BIAS - 30 )
856: {
857: EXCEPTION(EX_Underflow);
858: reg_move(&CONST_Z, FPU_st0_ptr);
859: return;
860: }
861:
862: reg_move(st1_ptr, &tmp);
863: round_to_int(&tmp); /* This can never overflow here */
864: scale = st1_ptr->sign ? -tmp.sigl : tmp.sigl;
865: scale += FPU_st0_ptr->exp;
866: FPU_st0_ptr->exp = scale;
867:
868: if ( scale <= EXP_UNDER )
869: arith_underflow(FPU_st0_ptr);
870: else if ( scale >= EXP_OVER )
871: arith_overflow(FPU_st0_ptr);
872:
873: return;
874: }
875: else if ( FPU_st0_tag == TW_Valid )
876: {
877: if ( st1_tag == TW_Zero )
878: { return; }
879: if ( st1_tag == TW_Infinity )
880: {
881: char sign = st1_ptr->sign;
882: if ( sign == SIGN_POS )
883: { reg_move(&CONST_INF, FPU_st0_ptr); }
884: else
885: reg_move(&CONST_Z, FPU_st0_ptr);
886: FPU_st0_ptr->sign = sign;
887: return;
888: }
889: if ( st1_tag == TW_NaN )
890: { real_2op_NaN(FPU_st0_ptr, st1_ptr, FPU_st0_ptr); return; }
891: }
892: else if ( FPU_st0_tag == TW_Zero )
893: {
894: if ( st1_tag <= TW_Zero ) { return; }
895: else if ( st1_tag == TW_Infinity )
896: {
897: if ( st1_ptr->sign == SIGN_NEG )
898: return;
899: else
900: { arith_invalid(FPU_st0_ptr); return; }
901: }
902: else if ( st1_tag == TW_NaN )
903: { real_2op_NaN(FPU_st0_ptr, st1_ptr, FPU_st0_ptr); return; }
904: }
905: else if ( FPU_st0_tag == TW_Infinity )
906: {
907: if ( ((st1_tag == TW_Infinity) && (st1_ptr->sign == SIGN_POS))
908: || (st1_tag <= TW_Zero) )
909: return;
910: else if ( st1_tag == TW_Infinity )
911: { arith_invalid(FPU_st0_ptr); return; }
912: else if ( st1_tag == TW_NaN )
913: { real_2op_NaN(FPU_st0_ptr, st1_ptr, FPU_st0_ptr); return; }
914: }
915: else if ( FPU_st0_tag == TW_NaN )
916: {
917: if ( st1_tag != TW_Empty )
918: { real_2op_NaN(FPU_st0_ptr, st1_ptr, FPU_st0_ptr); return; }
919: }
920:
921: #ifdef PARANOID
922: if ( !((FPU_st0_tag == TW_Empty) || (st1_tag == TW_Empty)) )
923: {
924: EXCEPTION(EX_INTERNAL | 0x115);
925: return;
926: }
927: #endif
928:
929: /* At least one of st(0), st(1) must be empty */
930: stack_underflow();
931:
932: }
933:
934:
935: /*---------------------------------------------------------------------------*/
936:
937: static FUNC trig_table_a[] = {
938: f2xm1, fyl2x, fptan, fpatan, fxtract, fprem1, fdecstp, fincstp
939: };
940:
941: void trig_a()
942: {
943: (trig_table_a[FPU_rm])();
944: }
945:
946:
947: static FUNC trig_table_b[] =
948: {
949: fprem, fyl2xp1, fsqrt_, fsincos, frndint_, fscale, fsin, fcos
950: };
951:
952: void trig_b()
953: {
954: (trig_table_b[FPU_rm])();
955: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.