?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MERGE-master-patchset-edits
[linux-2.6/openmoko-kernel.git] / arch / x86 / math-emu / fpu_trig.c
blobecd06680581c51cbb7631cd0240708e92d9ef919
1 /*---------------------------------------------------------------------------+
2 | fpu_trig.c |
3 | |
4 | Implementation of the FPU "transcendental" functions. |
5 | |
6 | Copyright (C) 1992,1993,1994,1997,1999 |
7 | W. Metzenthen, 22 Parker St, Ormond, Vic 3163, |
8 | Australia. E-mail billm@melbpc.org.au |
9 | |
10 | |
11 +---------------------------------------------------------------------------*/
12
13 #include "fpu_system.h"
14 #include "exception.h"
15 #include "fpu_emu.h"
16 #include "status_w.h"
17 #include "control_w.h"
18 #include "reg_constant.h"
19
20 static void rem_kernel(unsigned long long st0, unsigned long long *y,
21 unsigned long long st1, unsigned long long q, int n);
22
23 #define BETTER_THAN_486
24
25 #define FCOS 4
26
27 /* Used only by fptan, fsin, fcos, and fsincos. */
28 /* This routine produces very accurate results, similar to
29 using a value of pi with more than 128 bits precision. */
30 /* Limited measurements show no results worse than 64 bit precision
31 except for the results for arguments close to 2^63, where the
32 precision of the result sometimes degrades to about 63.9 bits */
33 static int trig_arg(FPU_REG *st0_ptr, int even)
34 {
35 FPU_REG tmp;
36 u_char tmptag;
37 unsigned long long q;
38 int old_cw = control_word, saved_status = partial_status;
39 int tag, st0_tag = TAG_Valid;
40
41 if (exponent(st0_ptr) >= 63) {
42 partial_status |= SW_C2; /* Reduction incomplete. */
43 return -1;
44 }
45
46 control_word &= ~CW_RC;
47 control_word |= RC_CHOP;
48
49 setpositive(st0_ptr);
50 tag = FPU_u_div(st0_ptr, &CONST_PI2, &tmp, PR_64_BITS | RC_CHOP | 0x3f,
51 SIGN_POS);
52
53 FPU_round_to_int(&tmp, tag); /* Fortunately, this can't overflow
54 to 2^64 */
55 q = significand(&tmp);
56 if (q) {
57 rem_kernel(significand(st0_ptr),
58 &significand(&tmp),
59 significand(&CONST_PI2),
60 q, exponent(st0_ptr) - exponent(&CONST_PI2));
61 setexponent16(&tmp, exponent(&CONST_PI2));
62 st0_tag = FPU_normalize(&tmp);
63 FPU_copy_to_reg0(&tmp, st0_tag);
64 }
65
66 if ((even && !(q & 1)) || (!even && (q & 1))) {
67 st0_tag =
68 FPU_sub(REV | LOADED | TAG_Valid, (int)&CONST_PI2,
69 FULL_PRECISION);
70
71 #ifdef BETTER_THAN_486
72 /* So far, the results are exact but based upon a 64 bit
73 precision approximation to pi/2. The technique used
74 now is equivalent to using an approximation to pi/2 which
75 is accurate to about 128 bits. */
76 if ((exponent(st0_ptr) <= exponent(&CONST_PI2extra) + 64)
77 || (q > 1)) {
78 /* This code gives the effect of having pi/2 to better than
79 128 bits precision. */
80
81 significand(&tmp) = q + 1;
82 setexponent16(&tmp, 63);
83 FPU_normalize(&tmp);
84 tmptag =
85 FPU_u_mul(&CONST_PI2extra, &tmp, &tmp,
86 FULL_PRECISION, SIGN_POS,
87 exponent(&CONST_PI2extra) +
88 exponent(&tmp));
89 setsign(&tmp, getsign(&CONST_PI2extra));
90 st0_tag = FPU_add(&tmp, tmptag, 0, FULL_PRECISION);
91 if (signnegative(st0_ptr)) {
92 /* CONST_PI2extra is negative, so the result of the addition
93 can be negative. This means that the argument is actually
94 in a different quadrant. The correction is always < pi/2,
95 so it can't overflow into yet another quadrant. */
96 setpositive(st0_ptr);
97 q++;
98 }
99 }
100 #endif /* BETTER_THAN_486 */
101 }
102 #ifdef BETTER_THAN_486
103 else {
104 /* So far, the results are exact but based upon a 64 bit
105 precision approximation to pi/2. The technique used
106 now is equivalent to using an approximation to pi/2 which
107 is accurate to about 128 bits. */
108 if (((q > 0)
109 && (exponent(st0_ptr) <= exponent(&CONST_PI2extra) + 64))
110 || (q > 1)) {
111 /* This code gives the effect of having p/2 to better than
112 128 bits precision. */
113
114 significand(&tmp) = q;
115 setexponent16(&tmp, 63);
116 FPU_normalize(&tmp); /* This must return TAG_Valid */
117 tmptag =
118 FPU_u_mul(&CONST_PI2extra, &tmp, &tmp,
119 FULL_PRECISION, SIGN_POS,
120 exponent(&CONST_PI2extra) +
121 exponent(&tmp));
122 setsign(&tmp, getsign(&CONST_PI2extra));
123 st0_tag = FPU_sub(LOADED | (tmptag & 0x0f), (int)&tmp,
124 FULL_PRECISION);
125 if ((exponent(st0_ptr) == exponent(&CONST_PI2)) &&
126 ((st0_ptr->sigh > CONST_PI2.sigh)
127 || ((st0_ptr->sigh == CONST_PI2.sigh)
128 && (st0_ptr->sigl > CONST_PI2.sigl)))) {
129 /* CONST_PI2extra is negative, so the result of the
130 subtraction can be larger than pi/2. This means
131 that the argument is actually in a different quadrant.
132 The correction is always < pi/2, so it can't overflow
133 into yet another quadrant. */
134 st0_tag =
135 FPU_sub(REV | LOADED | TAG_Valid,
136 (int)&CONST_PI2, FULL_PRECISION);
137 q++;
138 }
139 }
140 }
141 #endif /* BETTER_THAN_486 */
142
143 FPU_settag0(st0_tag);
144 control_word = old_cw;
145 partial_status = saved_status & ~SW_C2; /* Reduction complete. */
146
147 return (q & 3) | even;
148 }
149
150 /* Convert a long to register */
151 static void convert_l2reg(long const *arg, int deststnr)
152 {
153 int tag;
154 long num = *arg;
155 u_char sign;
156 FPU_REG *dest = &st(deststnr);
157
158 if (num == 0) {
159 FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr);
160 return;
161 }
162
163 if (num > 0) {
164 sign = SIGN_POS;
165 } else {
166 num = -num;
167 sign = SIGN_NEG;
168 }
169
170 dest->sigh = num;
171 dest->sigl = 0;
172 setexponent16(dest, 31);
173 tag = FPU_normalize(dest);
174 FPU_settagi(deststnr, tag);
175 setsign(dest, sign);
176 return;
177 }
178
179 static void single_arg_error(FPU_REG *st0_ptr, u_char st0_tag)
180 {
181 if (st0_tag == TAG_Empty)
182 FPU_stack_underflow(); /* Puts a QNaN in st(0) */
183 else if (st0_tag == TW_NaN)
184 real_1op_NaN(st0_ptr); /* return with a NaN in st(0) */
185 #ifdef PARANOID
186 else
187 EXCEPTION(EX_INTERNAL | 0x0112);
188 #endif /* PARANOID */
189 }
190
191 static void single_arg_2_error(FPU_REG *st0_ptr, u_char st0_tag)
192 {
193 int isNaN;
194
195 switch (st0_tag) {
196 case TW_NaN:
197 isNaN = (exponent(st0_ptr) == EXP_OVER)
198 && (st0_ptr->sigh & 0x80000000);
199 if (isNaN && !(st0_ptr->sigh & 0x40000000)) { /* Signaling ? */
200 EXCEPTION(EX_Invalid);
201 if (control_word & CW_Invalid) {
202 /* The masked response */
203 /* Convert to a QNaN */
204 st0_ptr->sigh |= 0x40000000;
205 push();
206 FPU_copy_to_reg0(st0_ptr, TAG_Special);
207 }
208 } else if (isNaN) {
209 /* A QNaN */
210 push();
211 FPU_copy_to_reg0(st0_ptr, TAG_Special);
212 } else {
213 /* pseudoNaN or other unsupported */
214 EXCEPTION(EX_Invalid);
215 if (control_word & CW_Invalid) {
216 /* The masked response */
217 FPU_copy_to_reg0(&CONST_QNaN, TAG_Special);
218 push();
219 FPU_copy_to_reg0(&CONST_QNaN, TAG_Special);
220 }
221 }
222 break; /* return with a NaN in st(0) */
223 #ifdef PARANOID
224 default:
225 EXCEPTION(EX_INTERNAL | 0x0112);
226 #endif /* PARANOID */
227 }
228 }
229
230 /*---------------------------------------------------------------------------*/
231
232 static void f2xm1(FPU_REG *st0_ptr, u_char tag)
233 {
234 FPU_REG a;
235
236 clear_C1();
237
238 if (tag == TAG_Valid) {
239 /* For an 80486 FPU, the result is undefined if the arg is >= 1.0 */
240 if (exponent(st0_ptr) < 0) {
241 denormal_arg:
242
243 FPU_to_exp16(st0_ptr, &a);
244
245 /* poly_2xm1(x) requires 0 < st(0) < 1. */
246 poly_2xm1(getsign(st0_ptr), &a, st0_ptr);
247 }
248 set_precision_flag_up(); /* 80486 appears to always do this */
249 return;
250 }
251
252 if (tag == TAG_Zero)
253 return;
254
255 if (tag == TAG_Special)
256 tag = FPU_Special(st0_ptr);
257
258 switch (tag) {
259 case TW_Denormal:
260 if (denormal_operand() < 0)
261 return;
262 goto denormal_arg;
263 case TW_Infinity:
264 if (signnegative(st0_ptr)) {
265 /* -infinity gives -1 (p16-10) */
266 FPU_copy_to_reg0(&CONST_1, TAG_Valid);
267 setnegative(st0_ptr);
268 }
269 return;
270 default:
271 single_arg_error(st0_ptr, tag);
272 }
273 }
274
275 static void fptan(FPU_REG *st0_ptr, u_char st0_tag)
276 {
277 FPU_REG *st_new_ptr;
278 int q;
279 u_char arg_sign = getsign(st0_ptr);
280
281 /* Stack underflow has higher priority */
282 if (st0_tag == TAG_Empty) {
283 FPU_stack_underflow(); /* Puts a QNaN in st(0) */
284 if (control_word & CW_Invalid) {
285 st_new_ptr = &st(-1);
286 push();
287 FPU_stack_underflow(); /* Puts a QNaN in the new st(0) */
288 }
289 return;
290 }
291
292 if (STACK_OVERFLOW) {
293 FPU_stack_overflow();
294 return;
295 }
296
297 if (st0_tag == TAG_Valid) {
298 if (exponent(st0_ptr) > -40) {
299 if ((q = trig_arg(st0_ptr, 0)) == -1) {
300 /* Operand is out of range */
301 return;
302 }
303
304 poly_tan(st0_ptr);
305 setsign(st0_ptr, (q & 1) ^ (arg_sign != 0));
306 set_precision_flag_up(); /* We do not really know if up or down */
307 } else {
308 /* For a small arg, the result == the argument */
309 /* Underflow may happen */
310
311 denormal_arg:
312
313 FPU_to_exp16(st0_ptr, st0_ptr);
314
315 st0_tag =
316 FPU_round(st0_ptr, 1, 0, FULL_PRECISION, arg_sign);
317 FPU_settag0(st0_tag);
318 }
319 push();
320 FPU_copy_to_reg0(&CONST_1, TAG_Valid);
321 return;
322 }
323
324 if (st0_tag == TAG_Zero) {
325 push();
326 FPU_copy_to_reg0(&CONST_1, TAG_Valid);
327 setcc(0);
328 return;
329 }
330
331 if (st0_tag == TAG_Special)
332 st0_tag = FPU_Special(st0_ptr);
333
334 if (st0_tag == TW_Denormal) {
335 if (denormal_operand() < 0)
336 return;
337
338 goto denormal_arg;
339 }
340
341 if (st0_tag == TW_Infinity) {
342 /* The 80486 treats infinity as an invalid operand */
343 if (arith_invalid(0) >= 0) {
344 st_new_ptr = &st(-1);
345 push();
346 arith_invalid(0);
347 }
348 return;
349 }
350
351 single_arg_2_error(st0_ptr, st0_tag);
352 }
353
354 static void fxtract(FPU_REG *st0_ptr, u_char st0_tag)
355 {
356 FPU_REG *st_new_ptr;
357 u_char sign;
358 register FPU_REG *st1_ptr = st0_ptr; /* anticipate */
359
360 if (STACK_OVERFLOW) {
361 FPU_stack_overflow();
362 return;
363 }
364
365 clear_C1();
366
367 if (st0_tag == TAG_Valid) {
368 long e;
369
370 push();
371 sign = getsign(st1_ptr);
372 reg_copy(st1_ptr, st_new_ptr);
373 setexponent16(st_new_ptr, exponent(st_new_ptr));
374
375 denormal_arg:
376
377 e = exponent16(st_new_ptr);
378 convert_l2reg(&e, 1);
379 setexponentpos(st_new_ptr, 0);
380 setsign(st_new_ptr, sign);
381 FPU_settag0(TAG_Valid); /* Needed if arg was a denormal */
382 return;
383 } else if (st0_tag == TAG_Zero) {
384 sign = getsign(st0_ptr);
385
386 if (FPU_divide_by_zero(0, SIGN_NEG) < 0)
387 return;
388
389 push();
390 FPU_copy_to_reg0(&CONST_Z, TAG_Zero);
391 setsign(st_new_ptr, sign);
392 return;
393 }
394
395 if (st0_tag == TAG_Special)
396 st0_tag = FPU_Special(st0_ptr);
397
398 if (st0_tag == TW_Denormal) {
399 if (denormal_operand() < 0)
400 return;
401
402 push();
403 sign = getsign(st1_ptr);
404 FPU_to_exp16(st1_ptr, st_new_ptr);
405 goto denormal_arg;
406 } else if (st0_tag == TW_Infinity) {
407 sign = getsign(st0_ptr);
408 setpositive(st0_ptr);
409 push();
410 FPU_copy_to_reg0(&CONST_INF, TAG_Special);
411 setsign(st_new_ptr, sign);
412 return;
413 } else if (st0_tag == TW_NaN) {
414 if (real_1op_NaN(st0_ptr) < 0)
415 return;
416
417 push();
418 FPU_copy_to_reg0(st0_ptr, TAG_Special);
419 return;
420 } else if (st0_tag == TAG_Empty) {
421 /* Is this the correct behaviour? */
422 if (control_word & EX_Invalid) {
423 FPU_stack_underflow();
424 push();
425 FPU_stack_underflow();
426 } else
427 EXCEPTION(EX_StackUnder);
428 }
429 #ifdef PARANOID
430 else
431 EXCEPTION(EX_INTERNAL | 0x119);
432 #endif /* PARANOID */
433 }
434
435 static void fdecstp(void)
436 {
437 clear_C1();
438 top--;
439 }
440
441 static void fincstp(void)
442 {
443 clear_C1();
444 top++;
445 }
446
447 static void fsqrt_(FPU_REG *st0_ptr, u_char st0_tag)
448 {
449 int expon;
450
451 clear_C1();
452
453 if (st0_tag == TAG_Valid) {
454 u_char tag;
455
456 if (signnegative(st0_ptr)) {
457 arith_invalid(0); /* sqrt(negative) is invalid */
458 return;
459 }
460
461 /* make st(0) in [1.0 .. 4.0) */
462 expon = exponent(st0_ptr);
463
464 denormal_arg:
465
466 setexponent16(st0_ptr, (expon & 1));
467
468 /* Do the computation, the sign of the result will be positive. */
469 tag = wm_sqrt(st0_ptr, 0, 0, control_word, SIGN_POS);
470 addexponent(st0_ptr, expon >> 1);
471 FPU_settag0(tag);
472 return;
473 }
474
475 if (st0_tag == TAG_Zero)
476 return;
477
478 if (st0_tag == TAG_Special)
479 st0_tag = FPU_Special(st0_ptr);
480
481 if (st0_tag == TW_Infinity) {
482 if (signnegative(st0_ptr))
483 arith_invalid(0); /* sqrt(-Infinity) is invalid */
484 return;
485 } else if (st0_tag == TW_Denormal) {
486 if (signnegative(st0_ptr)) {
487 arith_invalid(0); /* sqrt(negative) is invalid */
488 return;
489 }
490
491 if (denormal_operand() < 0)
492 return;
493
494 FPU_to_exp16(st0_ptr, st0_ptr);
495
496 expon = exponent16(st0_ptr);
497
498 goto denormal_arg;
499 }
500
501 single_arg_error(st0_ptr, st0_tag);
502
503 }
504
505 static void frndint_(FPU_REG *st0_ptr, u_char st0_tag)
506 {
507 int flags, tag;
508
509 if (st0_tag == TAG_Valid) {
510 u_char sign;
511
512 denormal_arg:
513
514 sign = getsign(st0_ptr);
515
516 if (exponent(st0_ptr) > 63)
517 return;
518
519 if (st0_tag == TW_Denormal) {
520 if (denormal_operand() < 0)
521 return;
522 }
523
524 /* Fortunately, this can't overflow to 2^64 */
525 if ((flags = FPU_round_to_int(st0_ptr, st0_tag)))
526 set_precision_flag(flags);
527
528 setexponent16(st0_ptr, 63);
529 tag = FPU_normalize(st0_ptr);
530 setsign(st0_ptr, sign);
531 FPU_settag0(tag);
532 return;
533 }
534
535 if (st0_tag == TAG_Zero)
536 return;
537
538 if (st0_tag == TAG_Special)
539 st0_tag = FPU_Special(st0_ptr);
540
541 if (st0_tag == TW_Denormal)
542 goto denormal_arg;
543 else if (st0_tag == TW_Infinity)
544 return;
545 else
546 single_arg_error(st0_ptr, st0_tag);
547 }
548
549 static int fsin(FPU_REG *st0_ptr, u_char tag)
550 {
551 u_char arg_sign = getsign(st0_ptr);
552
553 if (tag == TAG_Valid) {
554 int q;
555
556 if (exponent(st0_ptr) > -40) {
557 if ((q = trig_arg(st0_ptr, 0)) == -1) {
558 /* Operand is out of range */
559 return 1;
560 }
561
562 poly_sine(st0_ptr);
563
564 if (q & 2)
565 changesign(st0_ptr);
566
567 setsign(st0_ptr, getsign(st0_ptr) ^ arg_sign);
568
569 /* We do not really know if up or down */
570 set_precision_flag_up();
571 return 0;
572 } else {
573 /* For a small arg, the result == the argument */
574 set_precision_flag_up(); /* Must be up. */
575 return 0;
576 }
577 }
578
579 if (tag == TAG_Zero) {
580 setcc(0);
581 return 0;
582 }
583
584 if (tag == TAG_Special)
585 tag = FPU_Special(st0_ptr);
586
587 if (tag == TW_Denormal) {
588 if (denormal_operand() < 0)
589 return 1;
590
591 /* For a small arg, the result == the argument */
592 /* Underflow may happen */
593 FPU_to_exp16(st0_ptr, st0_ptr);
594
595 tag = FPU_round(st0_ptr, 1, 0, FULL_PRECISION, arg_sign);
596
597 FPU_settag0(tag);
598
599 return 0;
600 } else if (tag == TW_Infinity) {
601 /* The 80486 treats infinity as an invalid operand */
602 arith_invalid(0);
603 return 1;
604 } else {
605 single_arg_error(st0_ptr, tag);
606 return 1;
607 }
608 }
609
610 static int f_cos(FPU_REG *st0_ptr, u_char tag)
611 {
612 u_char st0_sign;
613
614 st0_sign = getsign(st0_ptr);
615
616 if (tag == TAG_Valid) {
617 int q;
618
619 if (exponent(st0_ptr) > -40) {
620 if ((exponent(st0_ptr) < 0)
621 || ((exponent(st0_ptr) == 0)
622 && (significand(st0_ptr) <=
623 0xc90fdaa22168c234LL))) {
624 poly_cos(st0_ptr);
625
626 /* We do not really know if up or down */
627 set_precision_flag_down();
628
629 return 0;
630 } else if ((q = trig_arg(st0_ptr, FCOS)) != -1) {
631 poly_sine(st0_ptr);
632
633 if ((q + 1) & 2)
634 changesign(st0_ptr);
635
636 /* We do not really know if up or down */
637 set_precision_flag_down();
638
639 return 0;
640 } else {
641 /* Operand is out of range */
642 return 1;
643 }
644 } else {
645 denormal_arg:
646
647 setcc(0);
648 FPU_copy_to_reg0(&CONST_1, TAG_Valid);
649 #ifdef PECULIAR_486
650 set_precision_flag_down(); /* 80486 appears to do this. */
651 #else
652 set_precision_flag_up(); /* Must be up. */
653 #endif /* PECULIAR_486 */
654 return 0;
655 }
656 } else if (tag == TAG_Zero) {
657 FPU_copy_to_reg0(&CONST_1, TAG_Valid);
658 setcc(0);
659 return 0;
660 }
661
662 if (tag == TAG_Special)
663 tag = FPU_Special(st0_ptr);
664
665 if (tag == TW_Denormal) {
666 if (denormal_operand() < 0)
667 return 1;
668
669 goto denormal_arg;
670 } else if (tag == TW_Infinity) {
671 /* The 80486 treats infinity as an invalid operand */
672 arith_invalid(0);
673 return 1;
674 } else {
675 single_arg_error(st0_ptr, tag); /* requires st0_ptr == &st(0) */
676 return 1;
677 }
678 }
679
680 static void fcos(FPU_REG *st0_ptr, u_char st0_tag)
681 {
682 f_cos(st0_ptr, st0_tag);
683 }
684
685 static void fsincos(FPU_REG *st0_ptr, u_char st0_tag)
686 {
687 FPU_REG *st_new_ptr;
688 FPU_REG arg;
689 u_char tag;
690
691 /* Stack underflow has higher priority */
692 if (st0_tag == TAG_Empty) {
693 FPU_stack_underflow(); /* Puts a QNaN in st(0) */
694 if (control_word & CW_Invalid) {
695 st_new_ptr = &st(-1);
696 push();
697 FPU_stack_underflow(); /* Puts a QNaN in the new st(0) */
698 }
699 return;
700 }
701
702 if (STACK_OVERFLOW) {
703 FPU_stack_overflow();
704 return;
705 }
706
707 if (st0_tag == TAG_Special)
708 tag = FPU_Special(st0_ptr);
709 else
710 tag = st0_tag;
711
712 if (tag == TW_NaN) {
713 single_arg_2_error(st0_ptr, TW_NaN);
714 return;
715 } else if (tag == TW_Infinity) {
716 /* The 80486 treats infinity as an invalid operand */
717 if (arith_invalid(0) >= 0) {
718 /* Masked response */
719 push();
720 arith_invalid(0);
721 }
722 return;
723 }
724
725 reg_copy(st0_ptr, &arg);
726 if (!fsin(st0_ptr, st0_tag)) {
727 push();
728 FPU_copy_to_reg0(&arg, st0_tag);
729 f_cos(&st(0), st0_tag);
730 } else {
731 /* An error, so restore st(0) */
732 FPU_copy_to_reg0(&arg, st0_tag);
733 }
734 }
735
736 /*---------------------------------------------------------------------------*/
737 /* The following all require two arguments: st(0) and st(1) */
738
739 /* A lean, mean kernel for the fprem instructions. This relies upon
740 the division and rounding to an integer in do_fprem giving an
741 exact result. Because of this, rem_kernel() needs to deal only with
742 the least significant 64 bits, the more significant bits of the
743 result must be zero.
744 */
745 static void rem_kernel(unsigned long long st0, unsigned long long *y,
746 unsigned long long st1, unsigned long long q, int n)
747 {
748 int dummy;
749 unsigned long long x;
750
751 x = st0 << n;
752
753 /* Do the required multiplication and subtraction in the one operation */
754
755 /* lsw x -= lsw st1 * lsw q */
756 asm volatile ("mull %4; subl %%eax,%0; sbbl %%edx,%1":"=m"
757 (((unsigned *)&x)[0]), "=m"(((unsigned *)&x)[1]),
758 "=a"(dummy)
759 :"2"(((unsigned *)&st1)[0]), "m"(((unsigned *)&q)[0])
760 :"%dx");
761 /* msw x -= msw st1 * lsw q */
762 asm volatile ("mull %3; subl %%eax,%0":"=m" (((unsigned *)&x)[1]),
763 "=a"(dummy)
764 :"1"(((unsigned *)&st1)[1]), "m"(((unsigned *)&q)[0])
765 :"%dx");
766 /* msw x -= lsw st1 * msw q */
767 asm volatile ("mull %3; subl %%eax,%0":"=m" (((unsigned *)&x)[1]),
768 "=a"(dummy)
769 :"1"(((unsigned *)&st1)[0]), "m"(((unsigned *)&q)[1])
770 :"%dx");
771
772 *y = x;
773 }
774
775 /* Remainder of st(0) / st(1) */
776 /* This routine produces exact results, i.e. there is never any
777 rounding or truncation, etc of the result. */
778 static void do_fprem(FPU_REG *st0_ptr, u_char st0_tag, int round)
779 {
780 FPU_REG *st1_ptr = &st(1);
781 u_char st1_tag = FPU_gettagi(1);
782
783 if (!((st0_tag ^ TAG_Valid) | (st1_tag ^ TAG_Valid))) {
784 FPU_REG tmp, st0, st1;
785 u_char st0_sign, st1_sign;
786 u_char tmptag;
787 int tag;
788 int old_cw;
789 int expdif;
790 long long q;
791 unsigned short saved_status;
792 int cc;
793
794 fprem_valid:
795 /* Convert registers for internal use. */
796 st0_sign = FPU_to_exp16(st0_ptr, &st0);
797 st1_sign = FPU_to_exp16(st1_ptr, &st1);
798 expdif = exponent16(&st0) - exponent16(&st1);
799
800 old_cw = control_word;
801 cc = 0;
802
803 /* We want the status following the denorm tests, but don't want
804 the status changed by the arithmetic operations. */
805 saved_status = partial_status;
806 control_word &= ~CW_RC;
807 control_word |= RC_CHOP;
808
809 if (expdif < 64) {
810 /* This should be the most common case */
811
812 if (expdif > -2) {
813 u_char sign = st0_sign ^ st1_sign;
814 tag = FPU_u_div(&st0, &st1, &tmp,
815 PR_64_BITS | RC_CHOP | 0x3f,
816 sign);
817 setsign(&tmp, sign);
818
819 if (exponent(&tmp) >= 0) {
820 FPU_round_to_int(&tmp, tag); /* Fortunately, this can't
821 overflow to 2^64 */
822 q = significand(&tmp);
823
824 rem_kernel(significand(&st0),
825 &significand(&tmp),
826 significand(&st1),
827 q, expdif);
828
829 setexponent16(&tmp, exponent16(&st1));
830 } else {
831 reg_copy(&st0, &tmp);
832 q = 0;
833 }
834
835 if ((round == RC_RND)
836 && (tmp.sigh & 0xc0000000)) {
837 /* We may need to subtract st(1) once more,
838 to get a result <= 1/2 of st(1). */
839 unsigned long long x;
840 expdif =
841 exponent16(&st1) - exponent16(&tmp);
842 if (expdif <= 1) {
843 if (expdif == 0)
844 x = significand(&st1) -
845 significand(&tmp);
846 else /* expdif is 1 */
847 x = (significand(&st1)
848 << 1) -
849 significand(&tmp);
850 if ((x < significand(&tmp)) ||
851 /* or equi-distant (from 0 & st(1)) and q is odd */
852 ((x == significand(&tmp))
853 && (q & 1))) {
854 st0_sign = !st0_sign;
855 significand(&tmp) = x;
856 q++;
857 }
858 }
859 }
860
861 if (q & 4)
862 cc |= SW_C0;
863 if (q & 2)
864 cc |= SW_C3;
865 if (q & 1)
866 cc |= SW_C1;
867 } else {
868 control_word = old_cw;
869 setcc(0);
870 return;
871 }
872 } else {
873 /* There is a large exponent difference ( >= 64 ) */
874 /* To make much sense, the code in this section should
875 be done at high precision. */
876 int exp_1, N;
877 u_char sign;
878
879 /* prevent overflow here */
880 /* N is 'a number between 32 and 63' (p26-113) */
881 reg_copy(&st0, &tmp);
882 tmptag = st0_tag;
883 N = (expdif & 0x0000001f) + 32; /* This choice gives results
884 identical to an AMD 486 */
885 setexponent16(&tmp, N);
886 exp_1 = exponent16(&st1);
887 setexponent16(&st1, 0);
888 expdif -= N;
889
890 sign = getsign(&tmp) ^ st1_sign;
891 tag =
892 FPU_u_div(&tmp, &st1, &tmp,
893 PR_64_BITS | RC_CHOP | 0x3f, sign);
894 setsign(&tmp, sign);
895
896 FPU_round_to_int(&tmp, tag); /* Fortunately, this can't
897 overflow to 2^64 */
898
899 rem_kernel(significand(&st0),
900 &significand(&tmp),
901 significand(&st1),
902 significand(&tmp), exponent(&tmp)
903 );
904 setexponent16(&tmp, exp_1 + expdif);
905
906 /* It is possible for the operation to be complete here.
907 What does the IEEE standard say? The Intel 80486 manual
908 implies that the operation will never be completed at this
909 point, and the behaviour of a real 80486 confirms this.
910 */
911 if (!(tmp.sigh | tmp.sigl)) {
912 /* The result is zero */
913 control_word = old_cw;
914 partial_status = saved_status;
915 FPU_copy_to_reg0(&CONST_Z, TAG_Zero);
916 setsign(&st0, st0_sign);
917 #ifdef PECULIAR_486
918 setcc(SW_C2);
919 #else
920 setcc(0);
921 #endif /* PECULIAR_486 */
922 return;
923 }
924 cc = SW_C2;
925 }
926
927 control_word = old_cw;
928 partial_status = saved_status;
929 tag = FPU_normalize_nuo(&tmp);
930 reg_copy(&tmp, st0_ptr);
931
932 /* The only condition to be looked for is underflow,
933 and it can occur here only if underflow is unmasked. */
934 if ((exponent16(&tmp) <= EXP_UNDER) && (tag != TAG_Zero)
935 && !(control_word & CW_Underflow)) {
936 setcc(cc);
937 tag = arith_underflow(st0_ptr);
938 setsign(st0_ptr, st0_sign);
939 FPU_settag0(tag);
940 return;
941 } else if ((exponent16(&tmp) > EXP_UNDER) || (tag == TAG_Zero)) {
942 stdexp(st0_ptr);
943 setsign(st0_ptr, st0_sign);
944 } else {
945 tag =
946 FPU_round(st0_ptr, 0, 0, FULL_PRECISION, st0_sign);
947 }
948 FPU_settag0(tag);
949 setcc(cc);
950
951 return;
952 }
953
954 if (st0_tag == TAG_Special)
955 st0_tag = FPU_Special(st0_ptr);
956 if (st1_tag == TAG_Special)
957 st1_tag = FPU_Special(st1_ptr);
958
959 if (((st0_tag == TAG_Valid) && (st1_tag == TW_Denormal))
960 || ((st0_tag == TW_Denormal) && (st1_tag == TAG_Valid))
961 || ((st0_tag == TW_Denormal) && (st1_tag == TW_Denormal))) {
962 if (denormal_operand() < 0)
963 return;
964 goto fprem_valid;
965 } else if ((st0_tag == TAG_Empty) || (st1_tag == TAG_Empty)) {
966 FPU_stack_underflow();
967 return;
968 } else if (st0_tag == TAG_Zero) {
969 if (st1_tag == TAG_Valid) {
970 setcc(0);
971 return;
972 } else if (st1_tag == TW_Denormal) {
973 if (denormal_operand() < 0)
974 return;
975 setcc(0);
976 return;
977 } else if (st1_tag == TAG_Zero) {
978 arith_invalid(0);
979 return;
980 } /* fprem(?,0) always invalid */
981 else if (st1_tag == TW_Infinity) {
982 setcc(0);
983 return;
984 }
985 } else if ((st0_tag == TAG_Valid) || (st0_tag == TW_Denormal)) {
986 if (st1_tag == TAG_Zero) {
987 arith_invalid(0); /* fprem(Valid,Zero) is invalid */
988 return;
989 } else if (st1_tag != TW_NaN) {
990 if (((st0_tag == TW_Denormal)
991 || (st1_tag == TW_Denormal))
992 && (denormal_operand() < 0))
993 return;
994
995 if (st1_tag == TW_Infinity) {
996 /* fprem(Valid,Infinity) is o.k. */
997 setcc(0);
998 return;
999 }
1000 }
1001 } else if (st0_tag == TW_Infinity) {
1002 if (st1_tag != TW_NaN) {
1003 arith_invalid(0); /* fprem(Infinity,?) is invalid */
1004 return;
1005 }
1006 }
1007
1008 /* One of the registers must contain a NaN if we got here. */
1009
1010 #ifdef PARANOID
1011 if ((st0_tag != TW_NaN) && (st1_tag != TW_NaN))
1012 EXCEPTION(EX_INTERNAL | 0x118);
1013 #endif /* PARANOID */
1014
1015 real_2op_NaN(st1_ptr, st1_tag, 0, st1_ptr);
1016
1017 }
1018
1019 /* ST(1) <- ST(1) * log ST; pop ST */
1020 static void fyl2x(FPU_REG *st0_ptr, u_char st0_tag)
1021 {
1022 FPU_REG *st1_ptr = &st(1), exponent;
1023 u_char st1_tag = FPU_gettagi(1);
1024 u_char sign;
1025 int e, tag;
1026
1027 clear_C1();
1028
1029 if ((st0_tag == TAG_Valid) && (st1_tag == TAG_Valid)) {
1030 both_valid:
1031 /* Both regs are Valid or Denormal */
1032 if (signpositive(st0_ptr)) {
1033 if (st0_tag == TW_Denormal)
1034 FPU_to_exp16(st0_ptr, st0_ptr);
1035 else
1036 /* Convert st(0) for internal use. */
1037 setexponent16(st0_ptr, exponent(st0_ptr));
1038
1039 if ((st0_ptr->sigh == 0x80000000)
1040 && (st0_ptr->sigl == 0)) {
1041 /* Special case. The result can be precise. */
1042 u_char esign;
1043 e = exponent16(st0_ptr);
1044 if (e >= 0) {
1045 exponent.sigh = e;
1046 esign = SIGN_POS;
1047 } else {
1048 exponent.sigh = -e;
1049 esign = SIGN_NEG;
1050 }
1051 exponent.sigl = 0;
1052 setexponent16(&exponent, 31);
1053 tag = FPU_normalize_nuo(&exponent);
1054 stdexp(&exponent);
1055 setsign(&exponent, esign);
1056 tag =
1057 FPU_mul(&exponent, tag, 1, FULL_PRECISION);
1058 if (tag >= 0)
1059 FPU_settagi(1, tag);
1060 } else {
1061 /* The usual case */
1062 sign = getsign(st1_ptr);
1063 if (st1_tag == TW_Denormal)
1064 FPU_to_exp16(st1_ptr, st1_ptr);
1065 else
1066 /* Convert st(1) for internal use. */
1067 setexponent16(st1_ptr,
1068 exponent(st1_ptr));
1069 poly_l2(st0_ptr, st1_ptr, sign);
1070 }
1071 } else {
1072 /* negative */
1073 if (arith_invalid(1) < 0)
1074 return;
1075 }
1076
1077 FPU_pop();
1078
1079 return;
1080 }
1081
1082 if (st0_tag == TAG_Special)
1083 st0_tag = FPU_Special(st0_ptr);
1084 if (st1_tag == TAG_Special)
1085 st1_tag = FPU_Special(st1_ptr);
1086
1087 if ((st0_tag == TAG_Empty) || (st1_tag == TAG_Empty)) {
1088 FPU_stack_underflow_pop(1);
1089 return;
1090 } else if ((st0_tag <= TW_Denormal) && (st1_tag <= TW_Denormal)) {
1091 if (st0_tag == TAG_Zero) {
1092 if (st1_tag == TAG_Zero) {
1093 /* Both args zero is invalid */
1094 if (arith_invalid(1) < 0)
1095 return;
1096 } else {
1097 u_char sign;
1098 sign = getsign(st1_ptr) ^ SIGN_NEG;
1099 if (FPU_divide_by_zero(1, sign) < 0)
1100 return;
1101
1102 setsign(st1_ptr, sign);
1103 }
1104 } else if (st1_tag == TAG_Zero) {
1105 /* st(1) contains zero, st(0) valid <> 0 */
1106 /* Zero is the valid answer */
1107 sign = getsign(st1_ptr);
1108
1109 if (signnegative(st0_ptr)) {
1110 /* log(negative) */
1111 if (arith_invalid(1) < 0)
1112 return;
1113 } else if ((st0_tag == TW_Denormal)
1114 && (denormal_operand() < 0))
1115 return;
1116 else {
1117 if (exponent(st0_ptr) < 0)
1118 sign ^= SIGN_NEG;
1119
1120 FPU_copy_to_reg1(&CONST_Z, TAG_Zero);
1121 setsign(st1_ptr, sign);
1122 }
1123 } else {
1124 /* One or both operands are denormals. */
1125 if (denormal_operand() < 0)
1126 return;
1127 goto both_valid;
1128 }
1129 } else if ((st0_tag == TW_NaN) || (st1_tag == TW_NaN)) {
1130 if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0)
1131 return;
1132 }
1133 /* One or both arg must be an infinity */
1134 else if (st0_tag == TW_Infinity) {
1135 if ((signnegative(st0_ptr)) || (st1_tag == TAG_Zero)) {
1136 /* log(-infinity) or 0*log(infinity) */
1137 if (arith_invalid(1) < 0)
1138 return;
1139 } else {
1140 u_char sign = getsign(st1_ptr);
1141
1142 if ((st1_tag == TW_Denormal)
1143 && (denormal_operand() < 0))
1144 return;
1145
1146 FPU_copy_to_reg1(&CONST_INF, TAG_Special);
1147 setsign(st1_ptr, sign);
1148 }
1149 }
1150 /* st(1) must be infinity here */
1151 else if (((st0_tag == TAG_Valid) || (st0_tag == TW_Denormal))
1152 && (signpositive(st0_ptr))) {
1153 if (exponent(st0_ptr) >= 0) {
1154 if ((exponent(st0_ptr) == 0) &&
1155 (st0_ptr->sigh == 0x80000000) &&
1156 (st0_ptr->sigl == 0)) {
1157 /* st(0) holds 1.0 */
1158 /* infinity*log(1) */
1159 if (arith_invalid(1) < 0)
1160 return;
1161 }
1162 /* else st(0) is positive and > 1.0 */
1163 } else {
1164 /* st(0) is positive and < 1.0 */
1165
1166 if ((st0_tag == TW_Denormal)
1167 && (denormal_operand() < 0))
1168 return;
1169
1170 changesign(st1_ptr);
1171 }
1172 } else {
1173 /* st(0) must be zero or negative */
1174 if (st0_tag == TAG_Zero) {
1175 /* This should be invalid, but a real 80486 is happy with it. */
1176
1177 #ifndef PECULIAR_486
1178 sign = getsign(st1_ptr);
1179 if (FPU_divide_by_zero(1, sign) < 0)
1180 return;
1181 #endif /* PECULIAR_486 */
1182
1183 changesign(st1_ptr);
1184 } else if (arith_invalid(1) < 0) /* log(negative) */
1185 return;
1186 }
1187
1188 FPU_pop();
1189 }
1190
1191 static void fpatan(FPU_REG *st0_ptr, u_char st0_tag)
1192 {
1193 FPU_REG *st1_ptr = &st(1);
1194 u_char st1_tag = FPU_gettagi(1);
1195 int tag;
1196
1197 clear_C1();
1198 if (!((st0_tag ^ TAG_Valid) | (st1_tag ^ TAG_Valid))) {
1199 valid_atan:
1200
1201 poly_atan(st0_ptr, st0_tag, st1_ptr, st1_tag);
1202
1203 FPU_pop();
1204
1205 return;
1206 }
1207
1208 if (st0_tag == TAG_Special)
1209 st0_tag = FPU_Special(st0_ptr);
1210 if (st1_tag == TAG_Special)
1211 st1_tag = FPU_Special(st1_ptr);
1212
1213 if (((st0_tag == TAG_Valid) && (st1_tag == TW_Denormal))
1214 || ((st0_tag == TW_Denormal) && (st1_tag == TAG_Valid))
1215 || ((st0_tag == TW_Denormal) && (st1_tag == TW_Denormal))) {
1216 if (denormal_operand() < 0)
1217 return;
1218
1219 goto valid_atan;
1220 } else if ((st0_tag == TAG_Empty) || (st1_tag == TAG_Empty)) {
1221 FPU_stack_underflow_pop(1);
1222 return;
1223 } else if ((st0_tag == TW_NaN) || (st1_tag == TW_NaN)) {
1224 if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) >= 0)
1225 FPU_pop();
1226 return;
1227 } else if ((st0_tag == TW_Infinity) || (st1_tag == TW_Infinity)) {
1228 u_char sign = getsign(st1_ptr);
1229 if (st0_tag == TW_Infinity) {
1230 if (st1_tag == TW_Infinity) {
1231 if (signpositive(st0_ptr)) {
1232 FPU_copy_to_reg1(&CONST_PI4, TAG_Valid);
1233 } else {
1234 setpositive(st1_ptr);
1235 tag =
1236 FPU_u_add(&CONST_PI4, &CONST_PI2,
1237 st1_ptr, FULL_PRECISION,
1238 SIGN_POS,
1239 exponent(&CONST_PI4),
1240 exponent(&CONST_PI2));
1241 if (tag >= 0)
1242 FPU_settagi(1, tag);
1243 }
1244 } else {
1245 if ((st1_tag == TW_Denormal)
1246 && (denormal_operand() < 0))
1247 return;
1248
1249 if (signpositive(st0_ptr)) {
1250 FPU_copy_to_reg1(&CONST_Z, TAG_Zero);
1251 setsign(st1_ptr, sign); /* An 80486 preserves the sign */
1252 FPU_pop();
1253 return;
1254 } else {
1255 FPU_copy_to_reg1(&CONST_PI, TAG_Valid);
1256 }
1257 }
1258 } else {
1259 /* st(1) is infinity, st(0) not infinity */
1260 if ((st0_tag == TW_Denormal)
1261 && (denormal_operand() < 0))
1262 return;
1263
1264 FPU_copy_to_reg1(&CONST_PI2, TAG_Valid);
1265 }
1266 setsign(st1_ptr, sign);
1267 } else if (st1_tag == TAG_Zero) {
1268 /* st(0) must be valid or zero */
1269 u_char sign = getsign(st1_ptr);
1270
1271 if ((st0_tag == TW_Denormal) && (denormal_operand() < 0))
1272 return;
1273
1274 if (signpositive(st0_ptr)) {
1275 /* An 80486 preserves the sign */
1276 FPU_pop();
1277 return;
1278 }
1279
1280 FPU_copy_to_reg1(&CONST_PI, TAG_Valid);
1281 setsign(st1_ptr, sign);
1282 } else if (st0_tag == TAG_Zero) {
1283 /* st(1) must be TAG_Valid here */
1284 u_char sign = getsign(st1_ptr);
1285
1286 if ((st1_tag == TW_Denormal) && (denormal_operand() < 0))
1287 return;
1288
1289 FPU_copy_to_reg1(&CONST_PI2, TAG_Valid);
1290 setsign(st1_ptr, sign);
1291 }
1292 #ifdef PARANOID
1293 else
1294 EXCEPTION(EX_INTERNAL | 0x125);
1295 #endif /* PARANOID */
1296
1297 FPU_pop();
1298 set_precision_flag_up(); /* We do not really know if up or down */
1299 }
1300
1301 static void fprem(FPU_REG *st0_ptr, u_char st0_tag)
1302 {
1303 do_fprem(st0_ptr, st0_tag, RC_CHOP);
1304 }
1305
1306 static void fprem1(FPU_REG *st0_ptr, u_char st0_tag)
1307 {
1308 do_fprem(st0_ptr, st0_tag, RC_RND);
1309 }
1310
1311 static void fyl2xp1(FPU_REG *st0_ptr, u_char st0_tag)
1312 {
1313 u_char sign, sign1;
1314 FPU_REG *st1_ptr = &st(1), a, b;
1315 u_char st1_tag = FPU_gettagi(1);
1316
1317 clear_C1();
1318 if (!((st0_tag ^ TAG_Valid) | (st1_tag ^ TAG_Valid))) {
1319 valid_yl2xp1:
1320
1321 sign = getsign(st0_ptr);
1322 sign1 = getsign(st1_ptr);
1323
1324 FPU_to_exp16(st0_ptr, &a);
1325 FPU_to_exp16(st1_ptr, &b);
1326
1327 if (poly_l2p1(sign, sign1, &a, &b, st1_ptr))
1328 return;
1329
1330 FPU_pop();
1331 return;
1332 }
1333
1334 if (st0_tag == TAG_Special)
1335 st0_tag = FPU_Special(st0_ptr);
1336 if (st1_tag == TAG_Special)
1337 st1_tag = FPU_Special(st1_ptr);
1338
1339 if (((st0_tag == TAG_Valid) && (st1_tag == TW_Denormal))
1340 || ((st0_tag == TW_Denormal) && (st1_tag == TAG_Valid))
1341 || ((st0_tag == TW_Denormal) && (st1_tag == TW_Denormal))) {
1342 if (denormal_operand() < 0)
1343 return;
1344
1345 goto valid_yl2xp1;
1346 } else if ((st0_tag == TAG_Empty) | (st1_tag == TAG_Empty)) {
1347 FPU_stack_underflow_pop(1);
1348 return;
1349 } else if (st0_tag == TAG_Zero) {
1350 switch (st1_tag) {
1351 case TW_Denormal:
1352 if (denormal_operand() < 0)
1353 return;
1354
1355 case TAG_Zero:
1356 case TAG_Valid:
1357 setsign(st0_ptr, getsign(st0_ptr) ^ getsign(st1_ptr));
1358 FPU_copy_to_reg1(st0_ptr, st0_tag);
1359 break;
1360
1361 case TW_Infinity:
1362 /* Infinity*log(1) */
1363 if (arith_invalid(1) < 0)
1364 return;
1365 break;
1366
1367 case TW_NaN:
1368 if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0)
1369 return;
1370 break;
1371
1372 default:
1373 #ifdef PARANOID
1374 EXCEPTION(EX_INTERNAL | 0x116);
1375 return;
1376 #endif /* PARANOID */
1377 break;
1378 }
1379 } else if ((st0_tag == TAG_Valid) || (st0_tag == TW_Denormal)) {
1380 switch (st1_tag) {
1381 case TAG_Zero:
1382 if (signnegative(st0_ptr)) {
1383 if (exponent(st0_ptr) >= 0) {
1384 /* st(0) holds <= -1.0 */
1385 #ifdef PECULIAR_486 /* Stupid 80486 doesn't worry about log(negative). */
1386 changesign(st1_ptr);
1387 #else
1388 if (arith_invalid(1) < 0)
1389 return;
1390 #endif /* PECULIAR_486 */
1391 } else if ((st0_tag == TW_Denormal)
1392 && (denormal_operand() < 0))
1393 return;
1394 else
1395 changesign(st1_ptr);
1396 } else if ((st0_tag == TW_Denormal)
1397 && (denormal_operand() < 0))
1398 return;
1399 break;
1400
1401 case TW_Infinity:
1402 if (signnegative(st0_ptr)) {
1403 if ((exponent(st0_ptr) >= 0) &&
1404 !((st0_ptr->sigh == 0x80000000) &&
1405 (st0_ptr->sigl == 0))) {
1406 /* st(0) holds < -1.0 */
1407 #ifdef PECULIAR_486 /* Stupid 80486 doesn't worry about log(negative). */
1408 changesign(st1_ptr);
1409 #else
1410 if (arith_invalid(1) < 0)
1411 return;
1412 #endif /* PECULIAR_486 */
1413 } else if ((st0_tag == TW_Denormal)
1414 && (denormal_operand() < 0))
1415 return;
1416 else
1417 changesign(st1_ptr);
1418 } else if ((st0_tag == TW_Denormal)
1419 && (denormal_operand() < 0))
1420 return;
1421 break;
1422
1423 case TW_NaN:
1424 if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0)
1425 return;
1426 }
1427
1428 } else if (st0_tag == TW_NaN) {
1429 if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0)
1430 return;
1431 } else if (st0_tag == TW_Infinity) {
1432 if (st1_tag == TW_NaN) {
1433 if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0)
1434 return;
1435 } else if (signnegative(st0_ptr)) {
1436 #ifndef PECULIAR_486
1437 /* This should have higher priority than denormals, but... */
1438 if (arith_invalid(1) < 0) /* log(-infinity) */
1439 return;
1440 #endif /* PECULIAR_486 */
1441 if ((st1_tag == TW_Denormal)
1442 && (denormal_operand() < 0))
1443 return;
1444 #ifdef PECULIAR_486
1445 /* Denormal operands actually get higher priority */
1446 if (arith_invalid(1) < 0) /* log(-infinity) */
1447 return;
1448 #endif /* PECULIAR_486 */
1449 } else if (st1_tag == TAG_Zero) {
1450 /* log(infinity) */
1451 if (arith_invalid(1) < 0)
1452 return;
1453 }
1454
1455 /* st(1) must be valid here. */
1456
1457 else if ((st1_tag == TW_Denormal) && (denormal_operand() < 0))
1458 return;
1459
1460 /* The Manual says that log(Infinity) is invalid, but a real
1461 80486 sensibly says that it is o.k. */
1462 else {
1463 u_char sign = getsign(st1_ptr);
1464 FPU_copy_to_reg1(&CONST_INF, TAG_Special);
1465 setsign(st1_ptr, sign);
1466 }
1467 }
1468 #ifdef PARANOID
1469 else {
1470 EXCEPTION(EX_INTERNAL | 0x117);
1471 return;
1472 }
1473 #endif /* PARANOID */
1474
1475 FPU_pop();
1476 return;
1477
1478 }
1479
1480 static void fscale(FPU_REG *st0_ptr, u_char st0_tag)
1481 {
1482 FPU_REG *st1_ptr = &st(1);
1483 u_char st1_tag = FPU_gettagi(1);
1484 int old_cw = control_word;
1485 u_char sign = getsign(st0_ptr);
1486
1487 clear_C1();
1488 if (!((st0_tag ^ TAG_Valid) | (st1_tag ^ TAG_Valid))) {
1489 long scale;
1490 FPU_REG tmp;
1491
1492 /* Convert register for internal use. */
1493 setexponent16(st0_ptr, exponent(st0_ptr));
1494
1495 valid_scale:
1496
1497 if (exponent(st1_ptr) > 30) {
1498 /* 2^31 is far too large, would require 2^(2^30) or 2^(-2^30) */
1499
1500 if (signpositive(st1_ptr)) {
1501 EXCEPTION(EX_Overflow);
1502 FPU_copy_to_reg0(&CONST_INF, TAG_Special);
1503 } else {
1504 EXCEPTION(EX_Underflow);
1505 FPU_copy_to_reg0(&CONST_Z, TAG_Zero);
1506 }
1507 setsign(st0_ptr, sign);
1508 return;
1509 }
1510
1511 control_word &= ~CW_RC;
1512 control_word |= RC_CHOP;
1513 reg_copy(st1_ptr, &tmp);
1514 FPU_round_to_int(&tmp, st1_tag); /* This can never overflow here */
1515 control_word = old_cw;
1516 scale = signnegative(st1_ptr) ? -tmp.sigl : tmp.sigl;
1517 scale += exponent16(st0_ptr);
1518
1519 setexponent16(st0_ptr, scale);
1520
1521 /* Use FPU_round() to properly detect under/overflow etc */
1522 FPU_round(st0_ptr, 0, 0, control_word, sign);
1523
1524 return;
1525 }
1526
1527 if (st0_tag == TAG_Special)
1528 st0_tag = FPU_Special(st0_ptr);
1529 if (st1_tag == TAG_Special)
1530 st1_tag = FPU_Special(st1_ptr);
1531
1532 if ((st0_tag == TAG_Valid) || (st0_tag == TW_Denormal)) {
1533 switch (st1_tag) {
1534 case TAG_Valid:
1535 /* st(0) must be a denormal */
1536 if ((st0_tag == TW_Denormal)
1537 && (denormal_operand() < 0))
1538 return;
1539
1540 FPU_to_exp16(st0_ptr, st0_ptr); /* Will not be left on stack */
1541 goto valid_scale;
1542
1543 case TAG_Zero:
1544 if (st0_tag == TW_Denormal)
1545 denormal_operand();
1546 return;
1547
1548 case TW_Denormal:
1549 denormal_operand();
1550 return;
1551
1552 case TW_Infinity:
1553 if ((st0_tag == TW_Denormal)
1554 && (denormal_operand() < 0))
1555 return;
1556
1557 if (signpositive(st1_ptr))
1558 FPU_copy_to_reg0(&CONST_INF, TAG_Special);
1559 else
1560 FPU_copy_to_reg0(&CONST_Z, TAG_Zero);
1561 setsign(st0_ptr, sign);
1562 return;
1563
1564 case TW_NaN:
1565 real_2op_NaN(st1_ptr, st1_tag, 0, st0_ptr);
1566 return;
1567 }
1568 } else if (st0_tag == TAG_Zero) {
1569 switch (st1_tag) {
1570 case TAG_Valid:
1571 case TAG_Zero:
1572 return;
1573
1574 case TW_Denormal:
1575 denormal_operand();
1576 return;
1577
1578 case TW_Infinity:
1579 if (signpositive(st1_ptr))
1580 arith_invalid(0); /* Zero scaled by +Infinity */
1581 return;
1582
1583 case TW_NaN:
1584 real_2op_NaN(st1_ptr, st1_tag, 0, st0_ptr);
1585 return;
1586 }
1587 } else if (st0_tag == TW_Infinity) {
1588 switch (st1_tag) {
1589 case TAG_Valid:
1590 case TAG_Zero:
1591 return;
1592
1593 case TW_Denormal:
1594 denormal_operand();
1595 return;
1596
1597 case TW_Infinity:
1598 if (signnegative(st1_ptr))
1599 arith_invalid(0); /* Infinity scaled by -Infinity */
1600 return;
1601
1602 case TW_NaN:
1603 real_2op_NaN(st1_ptr, st1_tag, 0, st0_ptr);
1604 return;
1605 }
1606 } else if (st0_tag == TW_NaN) {
1607 if (st1_tag != TAG_Empty) {
1608 real_2op_NaN(st1_ptr, st1_tag, 0, st0_ptr);
1609 return;
1610 }
1611 }
1612 #ifdef PARANOID
1613 if (!((st0_tag == TAG_Empty) || (st1_tag == TAG_Empty))) {
1614 EXCEPTION(EX_INTERNAL | 0x115);
1615 return;
1616 }
1617 #endif
1618
1619 /* At least one of st(0), st(1) must be empty */
1620 FPU_stack_underflow();
1621
1622 }
1623
1624 /*---------------------------------------------------------------------------*/
1625
1626 static FUNC_ST0 const trig_table_a[] = {
1627 f2xm1, fyl2x, fptan, fpatan,
1628 fxtract, fprem1, (FUNC_ST0) fdecstp, (FUNC_ST0) fincstp
1629 };
1630
1631 void FPU_triga(void)
1632 {
1633 (trig_table_a[FPU_rm]) (&st(0), FPU_gettag0());
1634 }
1635
1636 static FUNC_ST0 const trig_table_b[] = {
1637 fprem, fyl2xp1, fsqrt_, fsincos, frndint_, fscale, (FUNC_ST0) fsin, fcos
1638 };
1639
1640 void FPU_trigb(void)
1641 {
1642 (trig_table_b[FPU_rm]) (&st(0), FPU_gettag0());
1643 }
Openmoko development kernel tree