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 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 } 1645