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