mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
6827709ea0
Bochs/bochs/fpu/fpu_trig.c
Stanislav Shwartsman 25d04e2b4f Remove unused "dummy" parameters for some functions
2003-10-05 12:26:11 +00:00

1898 lines
42 KiB
C
Raw Blame History

/*---------------------------------------------------------------------------+
| fpu_trig.c |
| $Id: fpu_trig.c,v 1.10 2003-10-05 12:26:11 sshwarts Exp $
| |
| Implementation of the FPU "transcendental" functions. |
| |
| Copyright (C) 1992,1993,1994,1997,1999 |
| W. Metzenthen, 22 Parker St, Ormond, Vic 3163, |
| Australia. E-mail billm@melbpc.org.au |
| |
| |
+---------------------------------------------------------------------------*/
#include "fpu_system.h"
#include "exception.h"
#include "fpu_emu.h"
#include "status_w.h"
#include "control_w.h"
#include "reg_constant.h"
static void rem_kernel(u64 st0, u64 *y, u64 st1, u64 q, int n);
#define BETTER_THAN_486
#define FCOS 4
#define FPTAN 8
/* Used only by fptan, fsin, fcos, and fsincos. */
/* This routine produces very accurate results, similar to
using a value of pi with more than 128 bits precision. */
/* Limited measurements show no results worse than 64 bit precision
except for the results for arguments close to 2^63, where the
precision of the result sometimes degrades to about 63.9 bits */
static int trig_arg(FPU_REG *st0_ptr, int flags)
{
FPU_REG tmp;
u_char tmptag;
u64 q;
int old_cw = FPU_control_word, saved_status = FPU_partial_status;
int tag, st0_tag = TAG_Valid;
if (exponent(st0_ptr) >= 63)
{
FPU_partial_status |= SW_C2; /* Reduction incomplete. */
return -1;
}
if (flags & FPTAN)
st0_ptr->exp ++; /* Effectively base the following upon pi/4 */
FPU_control_word &= ~CW_RC;
FPU_control_word |= RC_CHOP;
setpositive(st0_ptr);
tag = FPU_u_div(st0_ptr,
&CONST_PI2,
&tmp, PR_64_BITS | RC_CHOP | 0x3f, SIGN_POS);
FPU_round_to_int(&tmp, tag); /* Fortunately, this can't overflow
to 2^64 */
q = significand(&tmp);
if (q)
{
rem_kernel(significand(st0_ptr),
&significand(&tmp),
significand(&CONST_PI2),
q, exponent(st0_ptr) - exponent(&CONST_PI2));
setexponent16(&tmp, exponent(&CONST_PI2));
st0_tag = FPU_normalize_nuo(&tmp,
EXTENDED_Ebias); /* No underflow or overflow
is possible */
FPU_copy_to_reg0(&tmp, st0_tag);
}
if (((flags & FCOS) && !(q & 1)) || (!(flags & FCOS) && (q & 1)))
{
st0_tag = FPU_sub(REV|LOADED|TAG_Valid, &CONST_PI2, FULL_PRECISION);
#ifdef BETTER_THAN_486
/* So far, the results are exact but based upon a 64 bit
precision approximation to pi/2. The technique used
now is equivalent to using an approximation to pi/2 which
is accurate to about 128 bits. */
if ((exponent(st0_ptr) <= exponent(&CONST_PI2extra) + 64) || (q > 1))
{
/* This code gives the effect of having pi/2 to better than
128 bits precision. */
significand(&tmp) = q + 1;
setexponent16(&tmp, 63);
FPU_normalize_nuo(&tmp,
EXTENDED_Ebias); /* No underflow or overflow
is possible */
tmptag =
FPU_u_mul(&CONST_PI2extra, &tmp, &tmp, FULL_PRECISION, SIGN_POS,
exponent(&CONST_PI2extra) + exponent(&tmp));
setsign(&tmp, getsign(&CONST_PI2extra));
st0_tag = FPU_add(&tmp, tmptag, 0, FULL_PRECISION);
if (signnegative(st0_ptr) && !(flags & FPTAN))
{
/* CONST_PI2extra is negative, so the result of the addition
can be negative. This means that the argument is actually
in a different quadrant. The correction is always < pi/2,
so it can't overflow into yet another quadrant. */
/* The function is even, so we need just adjust the sign
and q. */
setpositive(st0_ptr);
q++;
}
}
#endif /* BETTER_THAN_486 */
}
#ifdef BETTER_THAN_486
else
{
/* So far, the results are exact but based upon a 64 bit
precision approximation to pi/2. The technique used
now is equivalent to using an approximation to pi/2 which
is accurate to about 128 bits. */
if (((q > 0)
&& (exponent(st0_ptr) <= exponent(&CONST_PI2extra) + 64))
|| (q > 1))
{
/* This code gives the effect of having p/2 to better than
128 bits precision. */
significand(&tmp) = q;
setexponent16(&tmp, 63);
FPU_normalize_nuo(&tmp,
EXTENDED_Ebias); /* No underflow or overflow
is possible.
This must return TAG_Valid */
tmptag = FPU_u_mul(&CONST_PI2extra, &tmp, &tmp, FULL_PRECISION,
SIGN_POS,
exponent(&CONST_PI2extra) + exponent(&tmp));
setsign(&tmp, getsign(&CONST_PI2extra));
st0_tag = FPU_sub(LOADED|(tmptag & 0x0f), &tmp,
FULL_PRECISION);
if ((exponent(st0_ptr) == exponent(&CONST_PI2)) &&
((st0_ptr->sigh > CONST_PI2.sigh)
|| ((st0_ptr->sigh == CONST_PI2.sigh)
&& (st0_ptr->sigl > CONST_PI2.sigl))))
{
/* CONST_PI2extra is negative, so the result of the
subtraction can be larger than pi/2. This means
that the argument is actually in a different quadrant.
The correction is always < pi/2, so it can't overflow
into yet another quadrant.
bbd: arg2 used to typecast to (int), corrupting 64-bit ptrs
*/
st0_tag = FPU_sub(REV|LOADED|TAG_Valid, &CONST_PI2,
FULL_PRECISION);
q++;
}
}
}
#endif /* BETTER_THAN_486 */
FPU_settag0(st0_tag);
FPU_control_word = old_cw;
FPU_partial_status = saved_status & ~SW_C2; /* Reduction complete. */
if (flags & FPTAN)
{
st0_ptr->exp --;
return q & 7;
}
return (q & 3) | (flags & FCOS);
}
/* Convert a s32 to register */
static void convert_l2reg(s32 const *arg, int deststnr)
{
int tag;
s32 num = *arg;
u_char sign;
FPU_REG *dest = &st(deststnr);
if (num == 0)
{
FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr);
return;
}
if (num > 0)
{ sign = SIGN_POS; }
else
{ num = -num; sign = SIGN_NEG; }
dest->sigh = num;
dest->sigl = 0;
setexponent16(dest, 31);
tag = FPU_normalize_nuo(dest,
EXTENDED_Ebias); /* No underflow or overflow
is possible */
FPU_settagi(deststnr, tag);
setsign(dest, sign);
return;
}
static void single_arg_error(FPU_REG *st0_ptr, u_char st0_tag)
{
if (st0_tag == TAG_Empty)
FPU_stack_underflow(); /* Puts a QNaN in st(0) */
else if (st0_tag == TW_NaN)
real_1op_NaN(st0_ptr); /* return with a NaN in st(0) */
#ifdef PARANOID
else
INTERNAL(0x0112);
#endif /* PARANOID */
}
static void single_arg_2_error(FPU_REG *st0_ptr, u_char st0_tag)
{
int isNaN;
switch (st0_tag)
{
case TW_NaN:
isNaN = (exponent(st0_ptr) == EXP_OVER) && (st0_ptr->sigh & 0x80000000);
if (isNaN && !(st0_ptr->sigh & 0x40000000)) /* Signaling ? */
{
EXCEPTION(EX_Invalid);
if (FPU_control_word & CW_Invalid)
{
/* The masked response */
/* Convert to a QNaN */
st0_ptr->sigh |= 0x40000000;
FPU_push();
FPU_copy_to_reg0(st0_ptr, TAG_Special);
}
}
else if (isNaN)
{
/* A QNaN */
FPU_push();
FPU_copy_to_reg0(st0_ptr, TAG_Special);
}
else
{
/* pseudoNaN or other unsupported */
EXCEPTION(EX_Invalid);
if (FPU_control_word & CW_Invalid)
{
/* The masked response */
FPU_copy_to_reg0(&CONST_QNaN, TAG_Special);
FPU_push();
FPU_copy_to_reg0(&CONST_QNaN, TAG_Special);
}
}
break; /* return with a NaN in st(0) */
#ifdef PARANOID
default:
INTERNAL(0x0112);
#endif /* PARANOID */
}
}
/*---------------------------------------------------------------------------*/
static void f2xm1(FPU_REG *st0_ptr, u_char tag)
{
FPU_REG a;
clear_C1();
if (tag == TAG_Valid)
{
/* For an 80486 FPU, the result is undefined if the arg is >= 1.0 */
if (exponent(st0_ptr) < 0)
{
denormal_arg:
FPU_to_exp16(st0_ptr, &a);
/* poly_2xm1(x) requires 0 < st(0) < 1. */
poly_2xm1(getsign(st0_ptr), &a, st0_ptr);
}
set_precision_flag_up(); /* 80486 appears to always do this */
return;
}
if (tag == TAG_Zero)
return;
if (tag == TAG_Special)
tag = FPU_Special(st0_ptr);
switch (tag)
{
case TW_Denormal:
if (denormal_operand() < 0)
return;
goto denormal_arg;
case TW_Infinity:
if (signnegative(st0_ptr))
{
/* -infinity gives -1 (p16-10) */
FPU_copy_to_reg0(&CONST_1, TAG_Valid);
setnegative(st0_ptr);
}
return;
default:
single_arg_error(st0_ptr, tag);
}
}
static void fptan(FPU_REG *st0_ptr, u_char st0_tag)
{
FPU_REG *st_new_ptr;
u32 q;
u_char arg_sign = getsign(st0_ptr);
int invert[] = { 0, 1, 1, 0, 0, 1, 1, 0 };
/* Stack underflow has higher priority */
if (st0_tag == TAG_Empty)
{
FPU_stack_underflow(); /* Puts a QNaN in st(0) */
if (FPU_control_word & CW_Invalid)
{
st_new_ptr = &st(-1);
FPU_push();
FPU_stack_underflow(); /* Puts a QNaN in the new st(0) */
}
return;
}
if (FPU_stackoverflow(&st_new_ptr))
{ FPU_stack_overflow();
return;
}
if (st0_tag == TAG_Valid)
{
if (exponent(st0_ptr) > -40)
{
if ((q = trig_arg(st0_ptr, FPTAN)) == -1)
{
/* Operand is out of range */
return;
}
poly_tan(st0_ptr, invert[q]);
setsign(st0_ptr, ((q & 2) != 0) ^ (arg_sign != 0));
set_precision_flag_up(); /* We do not really know if up or down */
}
else
{
/* For a small arg, the result == the argument */
/* Underflow may happen */
denormal_arg:
FPU_to_exp16(st0_ptr, st0_ptr);
st0_tag = FPU_round(st0_ptr, 1, FULL_PRECISION, arg_sign);
FPU_settag0(st0_tag);
}
FPU_push();
FPU_copy_to_reg0(&CONST_1, TAG_Valid);
return;
}
if (st0_tag == TAG_Zero)
{
FPU_push();
FPU_copy_to_reg0(&CONST_1, TAG_Valid);
setcc(0);
return;
}
if (st0_tag == TAG_Special)
st0_tag = FPU_Special(st0_ptr);
if (st0_tag == TW_Denormal)
{
if (denormal_operand() < 0)
return;
goto denormal_arg;
}
if (st0_tag == TW_Infinity)
{
/* The 80486 treats infinity as an invalid operand */
if (arith_invalid(0) >= 0)
{
st_new_ptr = &st(-1);
FPU_push();
arith_invalid(0);
}
return;
}
single_arg_2_error(st0_ptr, st0_tag);
}
static void fxtract(FPU_REG *st0_ptr, u_char st0_tag)
{
FPU_REG *st_new_ptr;
u_char sign;
register FPU_REG *st1_ptr = st0_ptr; /* anticipate */
if (FPU_stackoverflow(&st_new_ptr))
{ FPU_stack_overflow();
return;
}
clear_C1();
if (st0_tag == TAG_Valid)
{
s32 e;
FPU_push();
sign = getsign(st1_ptr);
reg_copy(st1_ptr, st_new_ptr);
setexponent16(st_new_ptr, exponent(st_new_ptr));
denormal_arg:
e = exponent16(st_new_ptr);
convert_l2reg(&e, 1);
setexponentpos(st_new_ptr, 0);
setsign(st_new_ptr, sign);
FPU_settag0(TAG_Valid); /* Needed if arg was a denormal */
return;
}
else if (st0_tag == TAG_Zero)
{
sign = getsign(st0_ptr);
if (FPU_divide_by_zero(0, SIGN_NEG) < 0)
return;
FPU_push();
FPU_copy_to_reg0(&CONST_Z, TAG_Zero);
setsign(st_new_ptr, sign);
return;
}
if (st0_tag == TAG_Special)
st0_tag = FPU_Special(st0_ptr);
if (st0_tag == TW_Denormal)
{
if (denormal_operand() < 0)
return;
FPU_push();
sign = getsign(st1_ptr);
FPU_to_exp16(st1_ptr, st_new_ptr);
goto denormal_arg;
}
else if (st0_tag == TW_Infinity)
{
sign = getsign(st0_ptr);
setpositive(st0_ptr);
FPU_push();
FPU_copy_to_reg0(&CONST_INF, TAG_Special);
setsign(st_new_ptr, sign);
return;
}
else if (st0_tag == TW_NaN)
{
if (real_1op_NaN(st0_ptr) < 0)
return;
FPU_push();
FPU_copy_to_reg0(st0_ptr, TAG_Special);
return;
}
else if (st0_tag == TAG_Empty)
{
/* Is this the correct behaviour? */
if (FPU_control_word & EX_Invalid)
{
FPU_stack_underflow();
FPU_push();
FPU_stack_underflow();
}
else
EXCEPTION(EX_StackUnder);
}
#ifdef PARANOID
else
INTERNAL(0x119);
#endif /* PARANOID */
}
static void fdecstp(void)
{
clear_C1();
FPU_tos--;
}
static void fincstp(void)
{
clear_C1();
FPU_tos++;
}
static void fsqrt_(FPU_REG *st0_ptr, u_char st0_tag)
{
int expon;
clear_C1();
if (st0_tag == TAG_Valid)
{
u_char tag;
if (signnegative(st0_ptr))
{
arith_invalid(0); /* sqrt(negative) is invalid */
return;
}
/* make st(0) in [1.0 .. 4.0) */
expon = exponent(st0_ptr);
denormal_arg:
setexponent16(st0_ptr, (expon & 1));
/* Do the computation, the sign of the result will be positive. */
tag = wm_sqrt(st0_ptr, FPU_control_word, SIGN_POS);
addexponent(st0_ptr, expon >> 1);
FPU_settag0(tag);
return;
}
if (st0_tag == TAG_Zero)
return;
if (st0_tag == TAG_Special)
st0_tag = FPU_Special(st0_ptr);
if (st0_tag == TW_Infinity)
{
if (signnegative(st0_ptr))
arith_invalid(0); /* sqrt(-Infinity) is invalid */
return;
}
else if (st0_tag == TW_Denormal)
{
if (signnegative(st0_ptr))
{
arith_invalid(0); /* sqrt(negative) is invalid */
return;
}
if (denormal_operand() < 0)
return;
FPU_to_exp16(st0_ptr, st0_ptr);
expon = exponent16(st0_ptr);
goto denormal_arg;
}
single_arg_error(st0_ptr, st0_tag);
}
static void frndint_(FPU_REG *st0_ptr, u_char st0_tag)
{
int flags, tag;
if (st0_tag == TAG_Valid)
{
u_char sign;
denormal_arg:
sign = getsign(st0_ptr);
if (exponent(st0_ptr) > 63)
return;
if (st0_tag == TW_Denormal)
{
if (denormal_operand() < 0)
return;
}
/* Fortunately, this can't overflow to 2^64 */
if ((flags = FPU_round_to_int(st0_ptr, st0_tag)))
set_precision_flag(flags);
setexponent16(st0_ptr, 63);
tag = FPU_normalize_nuo(st0_ptr,
EXTENDED_Ebias); /* No underflow or overflow
is possible */
setsign(st0_ptr, sign);
FPU_settag0(tag);
return;
}
if (st0_tag == TAG_Zero)
return;
if (st0_tag == TAG_Special)
st0_tag = FPU_Special(st0_ptr);
if (st0_tag == TW_Denormal)
goto denormal_arg;
else if (st0_tag == TW_Infinity)
return;
else
single_arg_error(st0_ptr, st0_tag);
}
static int fsin(FPU_REG *st0_ptr, u_char tag)
{
u_char arg_sign = getsign(st0_ptr);
if (tag == TAG_Valid)
{
u32 q;
if (exponent(st0_ptr) > -40)
{
if ((q = trig_arg(st0_ptr, 0)) == -1)
{
/* Operand is out of range */
return 1;
}
poly_sine(st0_ptr);
if (q & 2)
changesign(st0_ptr);
setsign(st0_ptr, getsign(st0_ptr) ^ arg_sign);
/* We do not really know if up or down */
set_precision_flag_up();
return 0;
}
else
{
/* For a small arg, the result == the argument */
set_precision_flag_up(); /* Must be up. */
return 0;
}
}
if (tag == TAG_Zero)
{
setcc(0);
return 0;
}
if (tag == TAG_Special)
tag = FPU_Special(st0_ptr);
if (tag == TW_Denormal)
{
if (denormal_operand() < 0)
return 1;
/* For a small arg, the result == the argument */
/* Underflow may happen */
FPU_to_exp16(st0_ptr, st0_ptr);
tag = FPU_round(st0_ptr, 1, FULL_PRECISION, arg_sign);
FPU_settag0(tag);
return 0;
}
else if (tag == TW_Infinity)
{
/* The 80486 treats infinity as an invalid operand */
arith_invalid(0);
return 1;
}
else
{
single_arg_error(st0_ptr, tag);
return 1;
}
}
static int f_cos(FPU_REG *st0_ptr, u_char tag)
{
u_char st0_sign;
st0_sign = getsign(st0_ptr);
if (tag == TAG_Valid)
{
u32 q;
if (exponent(st0_ptr) > -40)
{
if ((exponent(st0_ptr) < 0)
|| ((exponent(st0_ptr) == 0)
&& (significand(st0_ptr) <= BX_CONST64(0xc90fdaa22168c234))))
{
poly_cos(st0_ptr);
/* We do not really know if up or down */
set_precision_flag_down();
return 0;
}
else if ((q = trig_arg(st0_ptr, FCOS)) != -1)
{
poly_sine(st0_ptr);
if ((q+1) & 2)
changesign(st0_ptr);
/* We do not really know if up or down */
set_precision_flag_down();
return 0;
}
else
{
/* Operand is out of range */
return 1;
}
}
else
{
denormal_arg:
setcc(0);
FPU_copy_to_reg0(&CONST_1, TAG_Valid);
#ifdef PECULIAR_486
set_precision_flag_down(); /* 80486 appears to do this. */
#else
set_precision_flag_up(); /* Must be up. */
#endif /* PECULIAR_486 */
return 0;
}
}
else if (tag == TAG_Zero)
{
FPU_copy_to_reg0(&CONST_1, TAG_Valid);
setcc(0);
return 0;
}
if (tag == TAG_Special)
tag = FPU_Special(st0_ptr);
if (tag == TW_Denormal)
{
if (denormal_operand() < 0)
return 1;
goto denormal_arg;
}
else if (tag == TW_Infinity)
{
/* The 80486 treats infinity as an invalid operand */
arith_invalid(0);
return 1;
}
else
{
single_arg_error(st0_ptr, tag); /* requires st0_ptr == &st(0) */
return 1;
}
}
static void fcos(FPU_REG *st0_ptr, u_char st0_tag)
{
f_cos(st0_ptr, st0_tag);
}
static void fsincos(FPU_REG *st0_ptr, u_char st0_tag)
{
FPU_REG *st_new_ptr;
FPU_REG arg;
u_char tag;
/* Stack underflow has higher priority */
if (st0_tag == TAG_Empty)
{
FPU_stack_underflow(); /* Puts a QNaN in st(0) */
if (FPU_control_word & CW_Invalid)
{
st_new_ptr = &st(-1);
FPU_push();
FPU_stack_underflow(); /* Puts a QNaN in the new st(0) */
}
return;
}
if (FPU_stackoverflow(&st_new_ptr))
{ FPU_stack_overflow();
return;
}
if (st0_tag == TAG_Special)
tag = FPU_Special(st0_ptr);
else
tag = st0_tag;
if (tag == TW_NaN)
{
single_arg_2_error(st0_ptr, TW_NaN);
return;
}
else if (tag == TW_Infinity)
{
/* The 80486 treats infinity as an invalid operand */
if (arith_invalid(0) >= 0)
{
/* Masked response */
FPU_push();
arith_invalid(0);
}
return;
}
reg_copy(st0_ptr, &arg);
if (!fsin(st0_ptr, st0_tag))
{
FPU_push();
FPU_copy_to_reg0(&arg, st0_tag);
f_cos(&st(0), st0_tag);
}
else
{
/* An error, so restore st(0) */
FPU_copy_to_reg0(&arg, st0_tag);
}
}
/*---------------------------------------------------------------------------*/
/* The following all require two arguments: st(0) and st(1) */
/* A lean, mean kernel for the fprem instructions. This relies upon
the division and rounding to an integer in do_fprem giving an
exact result. Because of this, rem_kernel() needs to deal only with
the least significant 64 bits, the more significant bits of the
result must be zero.
*/
static void rem_kernel(u64 st0, u64 *y, u64 st1, u64 q, int n)
{
u64 x;
#ifdef NO_ASSEMBLER
u64 work;
x = st0 << n;
work = (u32)st1;
work *= (u32)q;
x -= work;
work = st1 >> 32;
work *= (u32)q;
x -= work << 32;
work = (u32)st1;
work *= q >> 32;
x -= work << 32;
#else
int dummy;
x = st0 << n;
/* Do the required multiplication and subtraction in the one operation */
/* lsw x -= lsw st1 * lsw q */
asm volatile ("mull %4; subl %%eax,%0; sbbl %%edx,%1"
:"=m" (((u32 *)&x)[0]), "=m" (((u32 *)&x)[1]),
"=a" (dummy)
:"2" (((u32 *)&st1)[0]), "m" (((u32 *)&q)[0])
:"%dx");
/* msw x -= msw st1 * lsw q */
asm volatile ("mull %3; subl %%eax,%0"
:"=m" (((u32 *)&x)[1]), "=a" (dummy)
:"1" (((u32 *)&st1)[1]), "m" (((u32 *)&q)[0])
:"%dx");
/* msw x -= lsw st1 * msw q */
asm volatile ("mull %3; subl %%eax,%0"
:"=m" (((u32 *)&x)[1]), "=a" (dummy)
:"1" (((u32 *)&st1)[0]), "m" (((u32 *)&q)[1])
:"%dx");
#endif
*y = x;
}
/* Remainder of st(0) / st(1) */
/* This routine produces exact results, i.e. there is never any
rounding or truncation, etc of the result. */
static void do_fprem(FPU_REG *st0_ptr, u_char st0_tag, int round)
{
FPU_REG *st1_ptr = &st(1);
u_char st1_tag = FPU_gettagi(1);
if (!((st0_tag ^ TAG_Valid) | (st1_tag ^ TAG_Valid)))
{
FPU_REG tmp, st0, st1;
u_char st0_sign, st1_sign;
u_char tmptag;
int tag;
int old_cw;
int expdif;
s64 q;
u16 saved_status;
int cc;
fprem_valid:
/* Convert registers for internal use. */
st0_sign = FPU_to_exp16(st0_ptr, &st0);
st1_sign = FPU_to_exp16(st1_ptr, &st1);
expdif = exponent16(&st0) - exponent16(&st1);
old_cw = FPU_control_word;
cc = 0;
/* We want the status following the denorm tests, but don't want
the status changed by the arithmetic operations. */
saved_status = FPU_partial_status;
FPU_control_word &= ~CW_RC;
FPU_control_word |= RC_CHOP;
if (expdif < 64)
{
/* This should be the most common case */
if (expdif > -2)
{
u_char sign = st0_sign ^ st1_sign;
tag = FPU_u_div(&st0, &st1, &tmp,
PR_64_BITS | RC_CHOP | 0x3f,
sign);
setsign(&tmp, sign);
if (exponent(&tmp) >= 0)
{
FPU_round_to_int(&tmp, tag); /* Fortunately, this can't
overflow to 2^64 */
q = significand(&tmp);
rem_kernel(significand(&st0),
&significand(&tmp),
significand(&st1),
q, expdif);
setexponent16(&tmp, exponent16(&st1));
}
else
{
reg_copy(&st0, &tmp);
q = 0;
}
if ((round == RC_RND) && (tmp.sigh & 0xc0000000))
{
/* We may need to subtract st(1) once more,
to get a result <= 1/2 of st(1). */
u64 x;
expdif = exponent16(&st1) - exponent16(&tmp);
if (expdif <= 1)
{
if (expdif == 0)
x = significand(&st1) - significand(&tmp);
else /* expdif is 1 */
x = (significand(&st1) << 1) - significand(&tmp);
if ((x < significand(&tmp)) ||
/* or equi-distant (from 0 & st(1)) and q is odd */
((x == significand(&tmp)) && (q & 1)))
{
st0_sign = ! st0_sign;
significand(&tmp) = x;
q++;
}
}
}
if (q & 4) cc |= SW_C0;
if (q & 2) cc |= SW_C3;
if (q & 1) cc |= SW_C1;
}
else
{
FPU_control_word = old_cw;
setcc(0);
return;
}
}
else
{
/* There is a large exponent difference (>= 64) */
/* To make much sense, the code in this section should
be done at high precision. */
int exp_1, N;
u_char sign;
/* prevent overflow here */
/* N is 'a number between 32 and 63' (p26-113) */
reg_copy(&st0, &tmp);
tmptag = st0_tag;
N = (expdif & 0x0000001f) + 32; /* This choice gives results
identical to an AMD 486 */
setexponent16(&tmp, N);
exp_1 = exponent16(&st1);
setexponent16(&st1, 0);
expdif -= N;
sign = getsign(&tmp) ^ st1_sign;
tag = FPU_u_div(&tmp, &st1, &tmp, PR_64_BITS | RC_CHOP | 0x3f,
sign);
setsign(&tmp, sign);
FPU_round_to_int(&tmp, tag); /* Fortunately, this can't
overflow to 2^64 */
rem_kernel(significand(&st0),
&significand(&tmp),
significand(&st1),
significand(&tmp),
exponent(&tmp)
);
setexponent16(&tmp, exp_1 + expdif);
/* It is possible for the operation to be complete here.
What does the IEEE standard say? The Intel 80486 manual
implies that the operation will never be completed at this
point, and the behaviour of a real 80486 confirms this.
*/
if (!(tmp.sigh | tmp.sigl))
{
/* The result is zero */
FPU_control_word = old_cw;
FPU_partial_status = saved_status;
FPU_copy_to_reg0(&CONST_Z, TAG_Zero);
setsign(&st0, st0_sign);
#ifdef PECULIAR_486
setcc(SW_C2);
#else
setcc(0);
#endif /* PECULIAR_486 */
return;
}
cc = SW_C2;
}
FPU_control_word = old_cw;
FPU_partial_status = saved_status;
tag = FPU_normalize_nuo(&tmp, 0);
reg_copy(&tmp, st0_ptr);
/* The only condition to be looked for is underflow,
and it can occur here only if underflow is unmasked. */
if ((exponent16(&tmp) <= EXP_UNDER) && (tag != TAG_Zero)
&& !(FPU_control_word & CW_Underflow))
{
setcc(cc);
tag = arith_underflow(st0_ptr);
setsign(st0_ptr, st0_sign);
FPU_settag0(tag);
return;
}
else if ((exponent16(&tmp) > EXP_UNDER) || (tag == TAG_Zero))
{
stdexp(st0_ptr);
setsign(st0_ptr, st0_sign);
}
else
{
tag = FPU_round(st0_ptr, 0, FULL_PRECISION, st0_sign);
}
FPU_settag0(tag);
setcc(cc);
return;
}
if (st0_tag == TAG_Special)
st0_tag = FPU_Special(st0_ptr);
if (st1_tag == TAG_Special)
st1_tag = FPU_Special(st1_ptr);
if (((st0_tag == TAG_Valid) && (st1_tag == TW_Denormal))
|| ((st0_tag == TW_Denormal) && (st1_tag == TAG_Valid))
|| ((st0_tag == TW_Denormal) && (st1_tag == TW_Denormal)))
{
if (denormal_operand() < 0)
return;
goto fprem_valid;
}
else if ((st0_tag == TAG_Empty) | (st1_tag == TAG_Empty))
{
FPU_stack_underflow();
return;
}
else if (st0_tag == TAG_Zero)
{
if (st1_tag == TAG_Valid)
{
setcc(0); return;
}
else if (st1_tag == TW_Denormal)
{
if (denormal_operand() < 0)
return;
setcc(0); return;
}
else if (st1_tag == TAG_Zero)
{ arith_invalid(0); return; } /* fprem(?,0) always invalid */
else if (st1_tag == TW_Infinity)
{ setcc(0); return; }
}
else if ((st0_tag == TAG_Valid) || (st0_tag == TW_Denormal))
{
if (st1_tag == TAG_Zero)
{
arith_invalid(0); /* fprem(Valid,Zero) is invalid */
return;
}
else if (st1_tag != TW_NaN)
{
if (((st0_tag == TW_Denormal) || (st1_tag == TW_Denormal))
&& (denormal_operand() < 0))
return;
if (st1_tag == TW_Infinity)
{
/* fprem(Valid,Infinity) is o.k. */
setcc(0); return;
}
}
}
else if (st0_tag == TW_Infinity)
{
if (st1_tag != TW_NaN)
{
arith_invalid(0); /* fprem(Infinity,?) is invalid */
return;
}
}
/* One of the registers must contain a NaN if we got here. */
#ifdef PARANOID
if ((st0_tag != TW_NaN) && (st1_tag != TW_NaN))
INTERNAL(0x118);
#endif /* PARANOID */
real_2op_NaN(st1_ptr, st1_tag, 0, st1_ptr);
}
/* ST(1) <- ST(1) * log ST; pop ST */
static void fyl2x(FPU_REG *st0_ptr, u_char st0_tag)
{
FPU_REG *st1_ptr = &st(1), exponent;
u_char st1_tag = FPU_gettagi(1);
u_char sign;
int e, tag;
clear_C1();
if ((st0_tag == TAG_Valid) && (st1_tag == TAG_Valid))
{
both_valid:
/* Both regs are Valid or Denormal */
if (signpositive(st0_ptr))
{
if (st0_tag == TW_Denormal)
FPU_to_exp16(st0_ptr, st0_ptr);
else
/* Convert st(0) for internal use. */
setexponent16(st0_ptr, exponent(st0_ptr));
if ((st0_ptr->sigh == 0x80000000) && (st0_ptr->sigl == 0))
{
/* Special case. The result can be precise. */
u_char esign;
e = exponent16(st0_ptr);
if (e >= 0)
{
exponent.sigh = e;
esign = SIGN_POS;
}
else
{
exponent.sigh = -e;
esign = SIGN_NEG;
}
exponent.sigl = 0;
setexponent16(&exponent, 31);
tag = FPU_normalize_nuo(&exponent, 0);
stdexp(&exponent);
setsign(&exponent, esign);
tag = FPU_mul(&exponent, tag, 1, FULL_PRECISION);
if (tag >= 0)
FPU_settagi(1, tag);
}
else
{
/* The usual case */
sign = getsign(st1_ptr);
if (st1_tag == TW_Denormal)
FPU_to_exp16(st1_ptr, st1_ptr);
else
/* Convert st(1) for internal use. */
setexponent16(st1_ptr, exponent(st1_ptr));
poly_l2(st0_ptr, st1_ptr, sign);
}
}
else
{
/* negative */
if (arith_invalid(1) < 0)
return;
}
FPU_pop();
return;
}
if (st0_tag == TAG_Special)
st0_tag = FPU_Special(st0_ptr);
if (st1_tag == TAG_Special)
st1_tag = FPU_Special(st1_ptr);
if ((st0_tag == TAG_Empty) || (st1_tag == TAG_Empty))
{
FPU_stack_underflow_pop(1);
return;
}
else if ((st0_tag <= TW_Denormal) && (st1_tag <= TW_Denormal))
{
if (st0_tag == TAG_Zero)
{
if (st1_tag == TAG_Zero)
{
/* Both args zero is invalid */
if (arith_invalid(1) < 0)
return;
}
else
{
u_char sign;
sign = getsign(st1_ptr)^SIGN_NEG;
if (FPU_divide_by_zero(1, sign) < 0)
return;
setsign(st1_ptr, sign);
}
}
else if (st1_tag == TAG_Zero)
{
/* st(1) contains zero, st(0) valid <> 0 */
/* Zero is the valid answer */
sign = getsign(st1_ptr);
if (signnegative(st0_ptr))
{
/* log(negative) */
if (arith_invalid(1) < 0)
return;
}
else if ((st0_tag == TW_Denormal) && (denormal_operand() < 0))
return;
else
{
if (exponent(st0_ptr) < 0)
sign ^= SIGN_NEG;
FPU_copy_to_reg1(&CONST_Z, TAG_Zero);
setsign(st1_ptr, sign);
}
}
else
{
/* One or both operands are denormals. */
if (denormal_operand() < 0)
return;
goto both_valid;
}
}
else if ((st0_tag == TW_NaN) || (st1_tag == TW_NaN))
{
if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0)
return;
}
/* One or both arg must be an infinity */
else if (st0_tag == TW_Infinity)
{
if ((signnegative(st0_ptr)) || (st1_tag == TAG_Zero))
{
/* log(-infinity) or 0*log(infinity) */
if (arith_invalid(1) < 0)
return;
}
else
{
u_char sign = getsign(st1_ptr);
if ((st1_tag == TW_Denormal) && (denormal_operand() < 0))
return;
FPU_copy_to_reg1(&CONST_INF, TAG_Special);
setsign(st1_ptr, sign);
}
}
/* st(1) must be infinity here */
else if (((st0_tag == TAG_Valid) || (st0_tag == TW_Denormal))
&& (signpositive(st0_ptr)))
{
if (exponent(st0_ptr) >= 0)
{
if ((exponent(st0_ptr) == 0) &&
(st0_ptr->sigh == 0x80000000) &&
(st0_ptr->sigl == 0))
{
/* st(0) holds 1.0 */
/* infinity*log(1) */
if (arith_invalid(1) < 0)
return;
}
/* else st(0) is positive and > 1.0 */
}
else
{
/* st(0) is positive and < 1.0 */
if ((st0_tag == TW_Denormal) && (denormal_operand() < 0))
return;
changesign(st1_ptr);
}
}
else
{
/* st(0) must be zero or negative */
if (st0_tag == TAG_Zero)
{
/* This should be invalid, but a real 80486 is happy with it. */
#ifndef PECULIAR_486
sign = getsign(st1_ptr);
if (FPU_divide_by_zero(1, sign) < 0)
return;
#endif /* PECULIAR_486 */
changesign(st1_ptr);
}
else if (arith_invalid(1) < 0) /* log(negative) */
return;
}
FPU_pop();
}
static void fpatan(FPU_REG *st0_ptr, u_char st0_tag)
{
FPU_REG *st1_ptr = &st(1);
u_char st1_tag = FPU_gettagi(1);
int tag;
clear_C1();
if (!((st0_tag ^ TAG_Valid) | (st1_tag ^ TAG_Valid)))
{
valid_atan:
poly_atan(st0_ptr, st0_tag, st1_ptr, st1_tag);
FPU_pop();
return;
}
if (st0_tag == TAG_Special)
st0_tag = FPU_Special(st0_ptr);
if (st1_tag == TAG_Special)
st1_tag = FPU_Special(st1_ptr);
if (((st0_tag == TAG_Valid) && (st1_tag == TW_Denormal))
|| ((st0_tag == TW_Denormal) && (st1_tag == TAG_Valid))
|| ((st0_tag == TW_Denormal) && (st1_tag == TW_Denormal)))
{
if (denormal_operand() < 0)
return;
goto valid_atan;
}
else if ((st0_tag == TAG_Empty) || (st1_tag == TAG_Empty))
{
FPU_stack_underflow_pop(1);
return;
}
else if ((st0_tag == TW_NaN) || (st1_tag == TW_NaN))
{
if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) >= 0)
FPU_pop();
return;
}
else if ((st0_tag == TW_Infinity) || (st1_tag == TW_Infinity))
{
u_char sign = getsign(st1_ptr);
if (st0_tag == TW_Infinity)
{
if (st1_tag == TW_Infinity)
{
if (signpositive(st0_ptr))
{
FPU_copy_to_reg1(&CONST_PI4, TAG_Valid);
}
else
{
setpositive(st1_ptr);
tag = FPU_u_add(&CONST_PI4, &CONST_PI2, st1_ptr,
FULL_PRECISION, SIGN_POS,
exponent(&CONST_PI4), exponent(&CONST_PI2));
if (tag >= 0)
FPU_settagi(1, tag);
}
}
else
{
if ((st1_tag == TW_Denormal) && (denormal_operand() < 0))
return;
if (signpositive(st0_ptr))
{
FPU_copy_to_reg1(&CONST_Z, TAG_Zero);
setsign(st1_ptr, sign); /* An 80486 preserves the sign */
FPU_pop();
return;
}
else
{
FPU_copy_to_reg1(&CONST_PI, TAG_Valid);
}
}
}
else
{
/* st(1) is infinity, st(0) not infinity */
if ((st0_tag == TW_Denormal) && (denormal_operand() < 0))
return;
FPU_copy_to_reg1(&CONST_PI2, TAG_Valid);
}
setsign(st1_ptr, sign);
}
else if (st1_tag == TAG_Zero)
{
/* st(0) must be valid or zero */
u_char sign = getsign(st1_ptr);
if ((st0_tag == TW_Denormal) && (denormal_operand() < 0))
return;
if (signpositive(st0_ptr))
{
/* An 80486 preserves the sign */
FPU_pop();
return;
}
FPU_copy_to_reg1(&CONST_PI, TAG_Valid);
setsign(st1_ptr, sign);
}
else if (st0_tag == TAG_Zero)
{
/* st(1) must be TAG_Valid here */
u_char sign = getsign(st1_ptr);
if ((st1_tag == TW_Denormal) && (denormal_operand() < 0))
return;
FPU_copy_to_reg1(&CONST_PI2, TAG_Valid);
setsign(st1_ptr, sign);
}
#ifdef PARANOID
else
INTERNAL(0x125);
#endif /* PARANOID */
FPU_pop();
set_precision_flag_up(); /* We do not really know if up or down */
}
static void fprem(FPU_REG *st0_ptr, u_char st0_tag)
{
do_fprem(st0_ptr, st0_tag, RC_CHOP);
}
static void fprem1(FPU_REG *st0_ptr, u_char st0_tag)
{
do_fprem(st0_ptr, st0_tag, RC_RND);
}
static void fyl2xp1(FPU_REG *st0_ptr, u_char st0_tag)
{
u_char sign, sign1;
FPU_REG *st1_ptr = &st(1), a, b;
u_char st1_tag = FPU_gettagi(1);
clear_C1();
if (!((st0_tag ^ TAG_Valid) | (st1_tag ^ TAG_Valid)))
{
valid_yl2xp1:
sign = getsign(st0_ptr);
sign1 = getsign(st1_ptr);
FPU_to_exp16(st0_ptr, &a);
FPU_to_exp16(st1_ptr, &b);
if (poly_l2p1(sign, sign1, &a, &b, st1_ptr))
return;
FPU_pop();
return;
}
if (st0_tag == TAG_Special)
st0_tag = FPU_Special(st0_ptr);
if (st1_tag == TAG_Special)
st1_tag = FPU_Special(st1_ptr);
if (((st0_tag == TAG_Valid) && (st1_tag == TW_Denormal))
|| ((st0_tag == TW_Denormal) && (st1_tag == TAG_Valid))
|| ((st0_tag == TW_Denormal) && (st1_tag == TW_Denormal)))
{
if (denormal_operand() < 0)
return;
goto valid_yl2xp1;
}
else if ((st0_tag == TAG_Empty) | (st1_tag == TAG_Empty))
{
FPU_stack_underflow_pop(1);
return;
}
else if (st0_tag == TAG_Zero)
{
switch (st1_tag)
{
case TW_Denormal:
if (denormal_operand() < 0)
return;
case TAG_Zero:
case TAG_Valid:
setsign(st0_ptr, getsign(st0_ptr) ^ getsign(st1_ptr));
FPU_copy_to_reg1(st0_ptr, st0_tag);
break;
case TW_Infinity:
/* Infinity*log(1) */
if (arith_invalid(1) < 0)
return;
break;
case TW_NaN:
if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0)
return;
break;
default:
#ifdef PARANOID
INTERNAL(0x116);
return;
#endif /* PARANOID */
}
}
else if ((st0_tag == TAG_Valid) || (st0_tag == TW_Denormal))
{
switch (st1_tag)
{
case TAG_Zero:
if (signnegative(st0_ptr))
{
if (exponent(st0_ptr) >= 0)
{
/* st(0) holds <= -1.0 */
#ifdef PECULIAR_486 /* Stupid 80486 doesn't worry about log(negative). */
changesign(st1_ptr);
#else
if (arith_invalid(1) < 0)
return;
#endif /* PECULIAR_486 */
}
else if ((st0_tag == TW_Denormal) && (denormal_operand() < 0))
return;
else
changesign(st1_ptr);
}
else if ((st0_tag == TW_Denormal) && (denormal_operand() < 0))
return;
break;
case TW_Infinity:
if (signnegative(st0_ptr))
{
if ((exponent(st0_ptr) >= 0) &&
!((st0_ptr->sigh == 0x80000000) &&
(st0_ptr->sigl == 0)))
{
/* st(0) holds < -1.0 */
#ifdef PECULIAR_486 /* Stupid 80486 doesn't worry about log(negative). */
changesign(st1_ptr);
#else
if (arith_invalid(1) < 0) return;
#endif /* PECULIAR_486 */
}
else if ((st0_tag == TW_Denormal) && (denormal_operand() < 0))
return;
else
changesign(st1_ptr);
}
else if ((st0_tag == TW_Denormal) && (denormal_operand() < 0))
return;
break;
case TW_NaN:
if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0)
return;
}
}
else if (st0_tag == TW_NaN)
{
if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0)
return;
}
else if (st0_tag == TW_Infinity)
{
if (st1_tag == TW_NaN)
{
if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0)
return;
}
else if (signnegative(st0_ptr))
{
#ifndef PECULIAR_486
/* This should have higher priority than denormals, but... */
if (arith_invalid(1) < 0) /* log(-infinity) */
return;
#endif /* PECULIAR_486 */
if ((st1_tag == TW_Denormal) && (denormal_operand() < 0))
return;
#ifdef PECULIAR_486
/* Denormal operands actually get higher priority */
if (arith_invalid(1) < 0) /* log(-infinity) */
return;
#endif /* PECULIAR_486 */
}
else if (st1_tag == TAG_Zero)
{
/* log(infinity) */
if (arith_invalid(1) < 0)
return;
}
/* st(1) must be valid here. */
else if ((st1_tag == TW_Denormal) && (denormal_operand() < 0))
return;
/* The Manual says that log(Infinity) is invalid, but a real
80486 sensibly says that it is o.k. */
else
{
u_char sign = getsign(st1_ptr);
FPU_copy_to_reg1(&CONST_INF, TAG_Special);
setsign(st1_ptr, sign);
}
}
#ifdef PARANOID
else
{
INTERNAL(0x117);
return;
}
#endif /* PARANOID */
FPU_pop();
return;
}
static void fscale(FPU_REG *st0_ptr, u_char st0_tag)
{
FPU_REG *st1_ptr = &st(1);
u_char st1_tag = FPU_gettagi(1);
int old_cw = FPU_control_word;
u_char sign = getsign(st0_ptr);
clear_C1();
if (!((st0_tag ^ TAG_Valid) | (st1_tag ^ TAG_Valid)))
{
s32 scale;
FPU_REG tmp;
/* Convert register for internal use. */
setexponent16(st0_ptr, exponent(st0_ptr));
valid_scale:
if (exponent(st1_ptr) > 30)
{
/* 2^31 is far too large, would require 2^(2^30) or 2^(-2^30) */
if (signpositive(st1_ptr))
{
EXCEPTION(EX_Overflow);
FPU_copy_to_reg0(&CONST_INF, TAG_Special);
}
else
{
EXCEPTION(EX_Underflow);
FPU_copy_to_reg0(&CONST_Z, TAG_Zero);
}
setsign(st0_ptr, sign);
return;
}
FPU_control_word &= ~CW_RC;
FPU_control_word |= RC_CHOP;
reg_copy(st1_ptr, &tmp);
FPU_round_to_int(&tmp, st1_tag); /* This can never overflow here */
FPU_control_word = old_cw;
scale = signnegative(st1_ptr) ? -tmp.sigl : tmp.sigl;
scale += exponent16(st0_ptr);
setexponent16(st0_ptr, scale);
/* Use FPU_round() to properly detect under/overflow etc */
FPU_round(st0_ptr, 0, FPU_control_word, sign);
return;
}
if (st0_tag == TAG_Special)
st0_tag = FPU_Special(st0_ptr);
if (st1_tag == TAG_Special)
st1_tag = FPU_Special(st1_ptr);
if ((st0_tag == TAG_Valid) || (st0_tag == TW_Denormal))
{
switch (st1_tag)
{
case TAG_Valid:
/* st(0) must be a denormal */
if ((st0_tag == TW_Denormal) && (denormal_operand() < 0))
return;
FPU_to_exp16(st0_ptr, st0_ptr); /* Will not be left on stack */
goto valid_scale;
case TAG_Zero:
if (st0_tag == TW_Denormal)
denormal_operand();
return;
case TW_Denormal:
denormal_operand();
return;
case TW_Infinity:
if ((st0_tag == TW_Denormal) && (denormal_operand() < 0))
return;
if (signpositive(st1_ptr))
FPU_copy_to_reg0(&CONST_INF, TAG_Special);
else
FPU_copy_to_reg0(&CONST_Z, TAG_Zero);
setsign(st0_ptr, sign);
return;
case TW_NaN:
real_2op_NaN(st1_ptr, st1_tag, 0, st0_ptr);
return;
}
}
else if (st0_tag == TAG_Zero)
{
switch (st1_tag)
{
case TAG_Valid:
case TAG_Zero:
return;
case TW_Denormal:
denormal_operand();
return;
case TW_Infinity:
if (signpositive(st1_ptr))
arith_invalid(0); /* Zero scaled by +Infinity */
return;
case TW_NaN:
real_2op_NaN(st1_ptr, st1_tag, 0, st0_ptr);
return;
}
}
else if (st0_tag == TW_Infinity)
{
switch (st1_tag)
{
case TAG_Valid:
case TAG_Zero:
return;
case TW_Denormal:
denormal_operand();
return;
case TW_Infinity:
if (signnegative(st1_ptr))
arith_invalid(0); /* Infinity scaled by -Infinity */
return;
case TW_NaN:
real_2op_NaN(st1_ptr, st1_tag, 0, st0_ptr);
return;
}
}
else if (st0_tag == TW_NaN)
{
if (st1_tag != TAG_Empty)
{ real_2op_NaN(st1_ptr, st1_tag, 0, st0_ptr); return; }
}
#ifdef PARANOID
if (!((st0_tag == TAG_Empty) || (st1_tag == TAG_Empty)))
{
INTERNAL(0x115);
return;
}
#endif
/* At least one of st(0), st(1) must be empty */
FPU_stack_underflow();
}
/*---------------------------------------------------------------------------*/
static FUNC_ST0 const trig_table_a[] = {
f2xm1, fyl2x, fptan, fpatan,
fxtract, fprem1, (FUNC_ST0)fdecstp, (FUNC_ST0)fincstp
};
void FPU_triga(void)
{
(trig_table_a[FPU_rm])(&st(0), FPU_gettag0());
}
static FUNC_ST0 const trig_table_b[] =
{
fprem, fyl2xp1, fsqrt_, fsincos, frndint_, fscale, (FUNC_ST0)fsin, fcos
};
void FPU_trigb(void)
{
(trig_table_b[FPU_rm])(&st(0), FPU_gettag0());
}
Reference in New Issue View Git Blame Copy Permalink