arch/i386/math-emu/fpu_trig.c

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