mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
870c5aa9af
Bochs/bochs/fpu/reg_ld_str.c
Stanislav Shwartsman d596a6eb97 C++ style commets // not valid in pure C
2003-05-15 16:19:39 +00:00

1480 lines
36 KiB
C
Raw Blame History

/*---------------------------------------------------------------------------+
| reg_ld_str.c |
| $Id: reg_ld_str.c,v 1.12 2003-05-15 16:19:39 sshwarts Exp $
| |
| All of the functions which transfer data between user memory and FPU_REGs.|
| |
| Copyright (C) 1992,1993,1994,1996,1997 |
| W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia |
| E-mail billm@suburbia.net |
| |
| |
+---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------+
| Note: |
| The file contains code which accesses user memory. |
| Emulator static data may change when user memory is accessed, due to |
| other processes using the emulator while swapping is in progress. |
+---------------------------------------------------------------------------*/
#include "fpu_emu.h"
#include "fpu_system.h"
#include "exception.h"
#include "reg_constant.h"
#include "control_w.h"
#include "status_w.h"
#define DOUBLE_Emax 1023 /* largest valid exponent */
#define DOUBLE_Ebias 1023
#define DOUBLE_Emin (-1022) /* smallest valid exponent */
#define SINGLE_Emax 127 /* largest valid exponent */
#define SINGLE_Ebias 127
#define SINGLE_Emin (-126) /* smallest valid exponent */
static u_char BX_CPP_AttrRegparmN(3)
normalize_no_excep(FPU_REG *r, int exp, int sign)
{
u_char tag;
setexponent16(r, exp);
tag = FPU_normalize_nuo(r, 0);
stdexp(r);
if (sign)
setnegative(r);
return tag;
}
int BX_CPP_AttrRegparmN(1)
FPU_tagof(FPU_REG *ptr)
{
int exp;
exp = exponent16(ptr) & 0x7fff;
if (exp == 0)
{
if (!(ptr->sigh | ptr->sigl))
{
return TAG_Zero;
}
/* The number is a de-normal or pseudodenormal. */
return TAG_Special;
}
if (exp == 0x7fff)
{
/* Is an Infinity, a NaN, or an unsupported data type. */
return TAG_Special;
}
if (!(ptr->sigh & 0x80000000))
{
/* Unsupported data type. */
/* Valid numbers have the ms bit set to 1. */
/* Unnormal. */
return TAG_Special;
}
return TAG_Valid;
}
/* Get a long double from user memory */
int BX_CPP_AttrRegparmN(2)
FPU_load_extended(long double *s, int stnr)
{
FPU_REG *sti_ptr = &st(stnr);
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_READ, s, 10);
FPU_get_user(sti_ptr->sigl, (u32*)(((u8*)s)+0));
FPU_get_user(sti_ptr->sigh, (u32*)(((u8*)s)+4));
FPU_get_user(sti_ptr->exp, (u16*)(((u8*)s)+8));
RE_ENTRANT_CHECK_ON;
return FPU_tagof(sti_ptr);
}
/* Get a double from user memory */
int BX_CPP_AttrRegparmN(2)
FPU_load_double(double *dfloat, FPU_REG *loaded_data)
{
int exp, tag, negative;
u32 m64, l64;
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_READ, dfloat, 8);
FPU_get_user(m64, 1 + (u32 *) dfloat);
FPU_get_user(l64, (u32 *) dfloat);
RE_ENTRANT_CHECK_ON;
negative = (m64 & 0x80000000) ? SIGN_Negative : SIGN_Positive;
exp = ((m64 & 0x7ff00000) >> 20) - DOUBLE_Ebias + EXTENDED_Ebias;
m64 &= 0xfffff;
if (exp > DOUBLE_Emax + EXTENDED_Ebias)
{
/* Infinity or NaN */
if ((m64 == 0) && (l64 == 0))
{
/* +- infinity */
loaded_data->sigh = 0x80000000;
loaded_data->sigl = 0x00000000;
exp = EXP_Infinity + EXTENDED_Ebias;
tag = TAG_Special;
}
else
{
/* Must be a signaling or quiet NaN */
exp = EXP_NaN + EXTENDED_Ebias;
loaded_data->sigh = (m64 << 11) | 0x80000000;
loaded_data->sigh |= l64 >> 21;
loaded_data->sigl = l64 << 11;
tag = TAG_Special; /* The calling function must look for NaNs */
}
}
else if (exp < DOUBLE_Emin + EXTENDED_Ebias)
{
/* Zero or de-normal */
if ((m64 == 0) && (l64 == 0))
{
/* Zero */
reg_copy(&CONST_Z, loaded_data);
exp = 0;
tag = TAG_Zero;
}
else
{
/* De-normal */
loaded_data->sigh = m64 << 11;
loaded_data->sigh |= l64 >> 21;
loaded_data->sigl = l64 << 11;
return normalize_no_excep(loaded_data, DOUBLE_Emin, negative)
| (denormal_operand() < 0 ? FPU_Exception : 0);
}
}
else
{
loaded_data->sigh = (m64 << 11) | 0x80000000;
loaded_data->sigh |= l64 >> 21;
loaded_data->sigl = l64 << 11;
tag = TAG_Valid;
}
setexponent16(loaded_data, exp | negative);
return tag;
}
/* Get a float from user memory */
int BX_CPP_AttrRegparmN(2)
FPU_load_single(float *single, FPU_REG *loaded_data)
{
u32 m32;
int exp, tag, negative;
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_READ, single, 4);
FPU_get_user(m32, (u32 *) single);
RE_ENTRANT_CHECK_ON;
negative = (m32 & 0x80000000) ? SIGN_Negative : SIGN_Positive;
if (!(m32 & 0x7fffffff))
{
/* Zero */
reg_copy(&CONST_Z, loaded_data);
addexponent(loaded_data, negative);
return TAG_Zero;
}
exp = ((m32 & 0x7f800000) >> 23) - SINGLE_Ebias + EXTENDED_Ebias;
m32 = (m32 & 0x7fffff) << 8;
if (exp < SINGLE_Emin + EXTENDED_Ebias)
{
/* De-normals */
loaded_data->sigh = m32;
loaded_data->sigl = 0;
return normalize_no_excep(loaded_data, SINGLE_Emin, negative)
| (denormal_operand() < 0 ? FPU_Exception : 0);
}
else if (exp > SINGLE_Emax + EXTENDED_Ebias)
{
/* Infinity or NaN */
if (m32 == 0)
{
/* +- infinity */
loaded_data->sigh = 0x80000000;
loaded_data->sigl = 0x00000000;
exp = EXP_Infinity + EXTENDED_Ebias;
tag = TAG_Special;
}
else
{
/* Must be a signaling or quiet NaN */
exp = EXP_NaN + EXTENDED_Ebias;
loaded_data->sigh = m32 | 0x80000000;
loaded_data->sigl = 0;
tag = TAG_Special; /* The calling function must look for NaNs */
}
}
else
{
loaded_data->sigh = m32 | 0x80000000;
loaded_data->sigl = 0;
tag = TAG_Valid;
}
setexponent16(loaded_data, exp | negative); /* Set the sign. */
return tag;
}
/* Get a 64bit quantity from user memory */
int BX_CPP_AttrRegparmN(1)
FPU_load_int64(s64 *_s)
{
s64 s;
int sign;
FPU_REG *st0_ptr = &st(0);
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_READ, _s, 8);
{
u32 chunk0, chunk1;
FPU_get_user(chunk0, (u32*)(((u8*)_s)+0));
FPU_get_user(chunk1, (u32*)(((u8*)_s)+4));
s = chunk0;
s |= (((u64)chunk1) << 32);
}
RE_ENTRANT_CHECK_ON;
if (s == 0)
{
reg_copy(&CONST_Z, st0_ptr);
return TAG_Zero;
}
if (s > 0)
sign = SIGN_Positive;
else
{
s = -s;
sign = SIGN_Negative;
}
significand(st0_ptr) = s;
return normalize_no_excep(st0_ptr, 63, sign);
}
/* Get a long from user memory */
int BX_CPP_AttrRegparmN(2)
FPU_load_int32(s32 *_s, FPU_REG *loaded_data)
{
s32 s;
int negative;
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_READ, _s, 4);
FPU_get_user(s, _s);
RE_ENTRANT_CHECK_ON;
if (s == 0)
{ reg_copy(&CONST_Z, loaded_data); return TAG_Zero; }
if (s > 0)
negative = SIGN_Positive;
else
{
s = -s;
negative = SIGN_Negative;
}
loaded_data->sigh = s;
loaded_data->sigl = 0;
return normalize_no_excep(loaded_data, 31, negative);
}
/* Get a short from user memory */
int BX_CPP_AttrRegparmN(1)
FPU_load_int16(s16 *_s, FPU_REG *loaded_data)
{
s16 s, negative;
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_READ, _s, 2);
/* Cast as short to get the sign extended. */
FPU_get_user(s, _s);
RE_ENTRANT_CHECK_ON;
if (s == 0)
{ reg_copy(&CONST_Z, loaded_data); return TAG_Zero; }
if (s > 0)
negative = SIGN_Positive;
else
{
s = -s;
negative = SIGN_Negative;
}
loaded_data->sigh = s << 16;
loaded_data->sigl = 0;
return normalize_no_excep(loaded_data, 15, negative);
}
/* Get a packed bcd array from user memory */
int BX_CPP_AttrRegparmN(1)
FPU_load_bcd(u_char *s)
{
FPU_REG *st0_ptr = &st(0);
int pos;
u_char bcd;
s64 l=0;
int sign;
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_READ, s, 10);
RE_ENTRANT_CHECK_ON;
for (pos = 8; pos >= 0; pos--)
{
l *= 10;
RE_ENTRANT_CHECK_OFF;
FPU_get_user(bcd, (u_char *) s+pos);
RE_ENTRANT_CHECK_ON;
l += bcd >> 4;
l *= 10;
l += bcd & 0x0f;
}
RE_ENTRANT_CHECK_OFF;
FPU_get_user(sign, (u_char *) s+9);
sign = sign & 0x80 ? SIGN_Negative : SIGN_Positive;
RE_ENTRANT_CHECK_ON;
if (l == 0)
{
reg_copy(&CONST_Z, st0_ptr);
addexponent(st0_ptr, sign); /* Set the sign. */
return TAG_Zero;
}
else
{
significand(st0_ptr) = l;
return normalize_no_excep(st0_ptr, 63, sign);
}
}
/*===========================================================================*/
/* Put a long double into user memory */
int BX_CPP_AttrRegparmN(3)
FPU_store_extended(FPU_REG *st0_ptr, u_char st0_tag, long double *d)
{
/*
The only exception raised by an attempt to store to an
extended format is the Invalid Stack exception, i.e.
attempting to store from an empty register.
*/
if (st0_tag != TAG_Empty)
{
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_WRITE, d, 10);
FPU_put_user(st0_ptr->sigl, (u32 *) d);
FPU_put_user(st0_ptr->sigh, (u32 *) ((u_char *)d + 4));
FPU_put_user(exponent16(st0_ptr), (u16 *) ((u_char *)d + 8));
RE_ENTRANT_CHECK_ON;
return 1;
}
/* Empty register (stack underflow) */
EXCEPTION(EX_StackUnder);
if (control_word & CW_Invalid)
{
/* The masked response */
/* Put out the QNaN indefinite */
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_WRITE,d,10);
FPU_put_user(0, (u32 *) d);
FPU_put_user(0xc0000000, 1 + (u32 *) d);
FPU_put_user(0xffff, 4 + (s16 *) d);
RE_ENTRANT_CHECK_ON;
return 1;
}
else
return 0;
}
/* Put a double into user memory */
int BX_CPP_AttrRegparmN(3)
FPU_store_double(FPU_REG *st0_ptr, u_char st0_tag, double *dfloat)
{
u32 l[2];
u32 increment = 0; /* avoid gcc warnings */
int precision_loss;
int exp;
int rc = control_word & CW_RC;
FPU_REG tmp;
if (st0_tag == TAG_Valid)
{
reg_copy(st0_ptr, &tmp);
exp = exponent(&tmp);
if (exp < DOUBLE_Emin) /* It may be a denormal */
{
addexponent(&tmp, -DOUBLE_Emin + 52); /* largest exp to be 51 */
denormal_arg:
if ((precision_loss = FPU_round_to_int(&tmp, st0_tag)))
{
#ifdef PECULIAR_486
/* Did it round to a non-denormal ? */
/* This behaviour might be regarded as peculiar, it appears
that the 80486 rounds to the dest precision, then
converts to decide underflow. */
if (!((tmp.sigh == 0x00100000) && (tmp.sigl == 0) &&
(st0_ptr->sigl & 0x000007ff)))
#endif /* PECULIAR_486 */
{
EXCEPTION(EX_Underflow);
/* This is a special case: see sec 16.2.5.1 of
the 80486 book */
if (!(control_word & CW_Underflow))
return 0;
}
EXCEPTION(precision_loss);
if (!(control_word & CW_Precision))
return 0;
}
l[0] = tmp.sigl;
l[1] = tmp.sigh;
}
else
{
if (tmp.sigl & 0x000007ff)
{
precision_loss = 1;
switch (rc)
{
case RC_RND:
/* Rounding can get a little messy.. */
increment = ((tmp.sigl & 0x7ff) > 0x400) | /* nearest */
((tmp.sigl & 0xc00) == 0xc00); /* odd -> even */
break;
case RC_DOWN: /* towards -infinity */
increment = signpositive(&tmp) ? 0 : tmp.sigl & 0x7ff;
break;
case RC_UP: /* towards +infinity */
increment = signpositive(&tmp) ? tmp.sigl & 0x7ff : 0;
break;
case RC_CHOP:
increment = 0;
break;
}
/* Truncate the mantissa */
tmp.sigl &= 0xfffff800;
if (increment)
{
if (tmp.sigl >= 0xfffff800)
{
/* the sigl part overflows */
if (tmp.sigh == 0xffffffff)
{
/* The sigh part overflows */
tmp.sigh = 0x80000000;
exp++;
if (exp >= EXP_OVER)
goto overflow;
}
else
{
tmp.sigh ++;
}
tmp.sigl = 0x00000000;
}
else
{
/* We only need to increment sigl */
tmp.sigl += 0x00000800;
}
}
}
else
precision_loss = 0;
l[0] = (tmp.sigl >> 11) | (tmp.sigh << 21);
l[1] = ((tmp.sigh >> 11) & 0xfffff);
if (exp > DOUBLE_Emax)
{
overflow:
EXCEPTION(EX_Overflow);
if (!(control_word & CW_Overflow))
return 0;
set_precision_flag_up();
if (!(control_word & CW_Precision))
return 0;
/* This is a special case: see sec 16.2.5.1 of the 80486 book */
/* Overflow to infinity */
/* ssd: add code to store real indefinite when required */
if (rc == RC_CHOP)
{
l[0] = 0xFFFFFFFF; /* 8 byte real indefinite encoding */
l[1] = 0x7FEFFFFF;
}
else if (rc == RC_DOWN && signpositive(&tmp))
{
l[0] = 0xFFFFFFFF; /* 8 byte real indefinite encoding */
l[1] = 0x7FEFFFFF;
}
else if (rc == RC_UP && !signpositive(&tmp))
{
l[0] = 0xFFFFFFFF; /* 8 byte real indefinite encoding */
l[1] = 0x7FEFFFFF;
}
else /* rc == RC_RND */
{
l[0] = 0x00000000; /* Set to */
l[1] = 0x7ff00000; /* + INF */
}
}
else
{
if (precision_loss)
{
if (increment)
set_precision_flag_up();
else
set_precision_flag_down();
}
/* Add the exponent */
l[1] |= (((exp+DOUBLE_Ebias) & 0x7ff) << 20);
}
}
}
else if (st0_tag == TAG_Zero)
{
/* Number is zero */
l[0] = 0;
l[1] = 0;
}
else if (st0_tag == TAG_Special)
{
st0_tag = FPU_Special(st0_ptr);
if (st0_tag == TW_Denormal)
{
/* A denormal will always underflow. */
#ifndef PECULIAR_486
/* An 80486 is supposed to be able to generate
a denormal exception here, but... */
/* Underflow has priority. */
if (control_word & CW_Underflow)
denormal_operand();
#endif /* PECULIAR_486 */
reg_copy(st0_ptr, &tmp);
goto denormal_arg;
}
else if (st0_tag == TW_Infinity)
{
l[0] = 0;
l[1] = 0x7ff00000;
}
else if (st0_tag == TW_NaN)
{
/* Is it really a NaN ? */
if ((exponent(st0_ptr) == EXP_OVER)
&& (st0_ptr->sigh & 0x80000000))
{
/* See if we can get a valid NaN from the FPU_REG */
l[0] = (st0_ptr->sigl >> 11) | (st0_ptr->sigh << 21);
l[1] = ((st0_ptr->sigh >> 11) & 0xfffff);
if (!(st0_ptr->sigh & 0x40000000))
{
/* It is a signalling NaN */
EXCEPTION(EX_Invalid);
if (!(control_word & CW_Invalid))
return 0;
l[1] |= (0x40000000 >> 11);
}
l[1] |= 0x7ff00000;
}
else
{
/* It is an unsupported data type */
EXCEPTION(EX_Invalid);
if (!(control_word & CW_Invalid))
return 0;
l[0] = 0;
l[1] = 0xfff80000;
}
}
}
else if (st0_tag == TAG_Empty)
{
/* Empty register (stack underflow) */
EXCEPTION(EX_StackUnder);
if (control_word & CW_Invalid)
{
/* The masked response */
/* Put out the QNaN indefinite */
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_WRITE,(void *)dfloat,8);
FPU_put_user(0, (u32 *) dfloat);
FPU_put_user(0xfff80000, 1 + (u32 *) dfloat);
RE_ENTRANT_CHECK_ON;
return 1;
}
else
return 0;
}
if (getsign(st0_ptr))
l[1] |= 0x80000000;
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_WRITE,(void *)dfloat,8);
FPU_put_user(l[0], (u32 *)dfloat);
FPU_put_user(l[1], 1 + (u32 *)dfloat);
RE_ENTRANT_CHECK_ON;
return 1;
}
/* Put a float into user memory */
int BX_CPP_AttrRegparmN(3)
FPU_store_single(FPU_REG *st0_ptr, u_char st0_tag, float *single)
{
s32 templ;
u32 increment = 0; /* avoid gcc warnings */
int precision_loss;
int exp;
int rc = control_word & CW_RC;
FPU_REG tmp;
if (st0_tag == TAG_Valid)
{
reg_copy(st0_ptr, &tmp);
exp = exponent(&tmp);
if (exp < SINGLE_Emin)
{
addexponent(&tmp, -SINGLE_Emin + 23); /* largest exp to be 22 */
denormal_arg:
if ((precision_loss = FPU_round_to_int(&tmp, st0_tag)))
{
#ifdef PECULIAR_486
/* Did it round to a non-denormal ? */
/* This behaviour might be regarded as peculiar, it appears
that the 80486 rounds to the dest precision, then
converts to decide underflow. */
if (!((tmp.sigl == 0x00800000) &&
((st0_ptr->sigh & 0x000000ff) || st0_ptr->sigl)))
#endif /* PECULIAR_486 */
{
EXCEPTION(EX_Underflow);
/* This is a special case: see sec 16.2.5.1 of
the 80486 book */
if (!(control_word & CW_Underflow))
return 0;
}
EXCEPTION(precision_loss);
if (!(control_word & CW_Precision))
return 0;
}
templ = tmp.sigl;
}
else
{
if (tmp.sigl | (tmp.sigh & 0x000000ff))
{
u32 sigh = tmp.sigh;
u32 sigl = tmp.sigl;
precision_loss = 1;
switch (rc)
{
case RC_RND:
increment = ((sigh & 0xff) > 0x80) /* more than half */
|| (((sigh & 0xff) == 0x80) && sigl) /* more than half */
|| ((sigh & 0x180) == 0x180); /* round to even */
break;
case RC_DOWN: /* towards -infinity */
increment = signpositive(&tmp)
? 0 : (sigl | (sigh & 0xff));
break;
case RC_UP: /* towards +infinity */
increment = signpositive(&tmp)
? (sigl | (sigh & 0xff)) : 0;
break;
case RC_CHOP:
increment = 0;
break;
}
/* Truncate part of the mantissa */
tmp.sigl = 0;
if (increment)
{
if (sigh >= 0xffffff00)
{
/* The sigh part overflows */
tmp.sigh = 0x80000000;
exp++;
if (exp >= EXP_OVER)
goto overflow;
}
else
{
tmp.sigh &= 0xffffff00;
tmp.sigh += 0x100;
}
}
else
{
tmp.sigh &= 0xffffff00; /* Finish the truncation */
}
}
else
precision_loss = 0;
templ = (tmp.sigh >> 8) & 0x007fffff;
if (exp > SINGLE_Emax)
{
overflow:
EXCEPTION(EX_Overflow);
if (!(control_word & CW_Overflow))
return 0;
set_precision_flag_up();
if (!(control_word & CW_Precision))
return 0;
/* This is a special case: see sec 16.2.5.1 of the 80486 book. */
/* Masked response is overflow to infinity. */
if (rc == RC_CHOP)
templ = 0x7F7FFFFF; /* 4 byte real indefinite encoding */
else if (rc == RC_DOWN && signpositive(&tmp))
templ = 0x7F7FFFFF; /* 4 byte real indefinite encoding */
else if (rc == RC_UP && !signpositive(&tmp))
templ = 0x7F7FFFFF; /* 4 byte real indefinite encoding */
else /* rc == RC_RND */
templ = 0x7f800000; /* Set to +INF */
}
else
{
if (precision_loss)
{
if (increment)
set_precision_flag_up();
else
set_precision_flag_down();
}
/* Add the exponent */
templ |= ((exp+SINGLE_Ebias) & 0xff) << 23;
}
}
}
else if (st0_tag == TAG_Zero)
{
templ = 0;
}
else if (st0_tag == TAG_Special)
{
st0_tag = FPU_Special(st0_ptr);
if (st0_tag == TW_Denormal)
{
reg_copy(st0_ptr, &tmp);
/* A denormal will always underflow. */
#ifndef PECULIAR_486
/* An 80486 is supposed to be able to generate
a denormal exception here, but... */
/* Underflow has priority. */
if (control_word & CW_Underflow)
denormal_operand();
#endif /* PECULIAR_486 */
goto denormal_arg;
}
else if (st0_tag == TW_Infinity)
{
templ = 0x7f800000;
}
else if (st0_tag == TW_NaN)
{
/* Is it really a NaN ? */
if ((exponent(st0_ptr) == EXP_OVER) && (st0_ptr->sigh & 0x80000000))
{
/* See if we can get a valid NaN from the FPU_REG */
templ = st0_ptr->sigh >> 8;
if (!(st0_ptr->sigh & 0x40000000))
{
/* It is a signalling NaN */
EXCEPTION(EX_Invalid);
if (!(control_word & CW_Invalid))
return 0;
templ |= (0x40000000 >> 8);
}
templ |= 0x7f800000;
}
else
{
/* It is an unsupported data type */
EXCEPTION(EX_Invalid);
if (!(control_word & CW_Invalid))
return 0;
templ = 0xffc00000;
}
}
#ifdef PARANOID
else
{
EXCEPTION(EX_INTERNAL|0x164);
return 0;
}
#endif
}
else if (st0_tag == TAG_Empty)
{
/* Empty register (stack underflow) */
EXCEPTION(EX_StackUnder);
if (control_word & EX_Invalid)
{
/* The masked response */
/* Put out the QNaN indefinite */
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_WRITE,(void *)single,4);
FPU_put_user(0xffc00000, (u32 *) single);
RE_ENTRANT_CHECK_ON;
return 1;
}
else
return 0;
}
#ifdef PARANOID
else
{
EXCEPTION(EX_INTERNAL|0x163);
return 0;
}
#endif
if (getsign(st0_ptr))
templ |= 0x80000000;
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_WRITE,(void *)single,4);
FPU_put_user(templ,(u32 *) single);
RE_ENTRANT_CHECK_ON;
return 1;
}
/* Put a 64bit quantity into user memory */
int BX_CPP_AttrRegparmN(3)
FPU_store_int64(FPU_REG *st0_ptr, u_char st0_tag, s64 *d)
{
FPU_REG t;
s64 tll;
int precision_loss;
if (st0_tag == TAG_Empty)
{
/* Empty register (stack underflow) */
EXCEPTION(EX_StackUnder);
goto invalid_operand;
}
else if (st0_tag == TAG_Special)
{
st0_tag = FPU_Special(st0_ptr);
if ((st0_tag == TW_Infinity) ||
(st0_tag == TW_NaN))
{
EXCEPTION(EX_Invalid);
goto invalid_operand;
}
}
reg_copy(st0_ptr, &t);
precision_loss = FPU_round_to_int(&t, st0_tag);
#ifndef EMU_BIG_ENDIAN
((u32 *)&tll)[0] = t.sigl;
((u32 *)&tll)[1] = t.sigh;
#else
((u32 *)&tll)[0] = t.sigh;
((u32 *)&tll)[1] = t.sigl;
#endif
if ((precision_loss == 1) ||
((t.sigh & 0x80000000) &&
!((t.sigh == 0x80000000) && (t.sigl == 0) &&
signnegative(&t))))
{
EXCEPTION(EX_Invalid);
/* This is a special case: see sec 16.2.5.1 of the 80486 book */
invalid_operand:
if (control_word & EX_Invalid)
{
/* Produce something like QNaN "indefinite" */
tll = BX_CONST64(0x8000000000000000);
}
else
return 0;
}
else
{
if (precision_loss)
set_precision_flag(precision_loss);
if (signnegative(&t))
tll = - tll;
}
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_WRITE,(void *)d,8);
FPU_put_user((u32) tll, (u32*)(((u8 *)d)+0));
FPU_put_user((u32) (tll>>32), (u32*)(((u8 *)d)+4));
RE_ENTRANT_CHECK_ON;
return 1;
}
/* Put a long into user memory */
int BX_CPP_AttrRegparmN(3)
FPU_store_int32(FPU_REG *st0_ptr, u_char st0_tag, s32 *d)
{
FPU_REG t;
int precision_loss;
if (st0_tag == TAG_Empty)
{
/* Empty register (stack underflow) */
EXCEPTION(EX_StackUnder);
goto invalid_operand;
}
else if (st0_tag == TAG_Special)
{
st0_tag = FPU_Special(st0_ptr);
if ((st0_tag == TW_Infinity) ||
(st0_tag == TW_NaN))
{
EXCEPTION(EX_Invalid);
goto invalid_operand;
}
}
reg_copy(st0_ptr, &t);
precision_loss = FPU_round_to_int(&t, st0_tag);
if (t.sigh ||
((t.sigl & 0x80000000) &&
!((t.sigl == 0x80000000) && signnegative(&t))))
{
EXCEPTION(EX_Invalid);
/* This is a special case: see sec 16.2.5.1 of the 80486 book */
invalid_operand:
if (control_word & EX_Invalid)
{
/* Produce something like QNaN "indefinite" */
t.sigl = 0x80000000;
}
else
return 0;
}
else
{
if (precision_loss)
set_precision_flag(precision_loss);
if (signnegative(&t))
t.sigl = -(s32)t.sigl;
}
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_WRITE,d,4);
FPU_put_user(t.sigl, (u32 *) d);
RE_ENTRANT_CHECK_ON;
return 1;
}
/* Put a short into user memory */
int BX_CPP_AttrRegparmN(3)
FPU_store_int16(FPU_REG *st0_ptr, u_char st0_tag, s16 *d)
{
FPU_REG t;
int precision_loss;
if (st0_tag == TAG_Empty)
{
/* Empty register (stack underflow) */
EXCEPTION(EX_StackUnder);
goto invalid_operand;
}
else if (st0_tag == TAG_Special)
{
st0_tag = FPU_Special(st0_ptr);
if ((st0_tag == TW_Infinity) ||
(st0_tag == TW_NaN))
{
EXCEPTION(EX_Invalid);
goto invalid_operand;
}
}
reg_copy(st0_ptr, &t);
precision_loss = FPU_round_to_int(&t, st0_tag);
if (t.sigh ||
((t.sigl & 0xffff8000) &&
!((t.sigl == 0x8000) && signnegative(&t))))
{
EXCEPTION(EX_Invalid);
/* This is a special case: see sec 16.2.5.1 of the 80486 book */
invalid_operand:
if (control_word & EX_Invalid)
{
/* Produce something like QNaN "indefinite" */
t.sigl = 0x8000;
}
else
return 0;
}
else
{
if (precision_loss)
set_precision_flag(precision_loss);
if (signnegative(&t))
t.sigl = -t.sigl;
}
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_WRITE,d,2);
FPU_put_user((s16)t.sigl,(s16 *) d);
RE_ENTRANT_CHECK_ON;
return 1;
}
/* Put a packed bcd array into user memory */
int BX_CPP_AttrRegparmN(3)
FPU_store_bcd(FPU_REG *st0_ptr, u_char st0_tag, u_char *d)
{
FPU_REG t;
u64 ll;
u_char b;
int i, precision_loss;
u_char sign = (getsign(st0_ptr) == SIGN_NEG) ? 0x80 : 0;
if (st0_tag == TAG_Empty)
{
/* Empty register (stack underflow) */
EXCEPTION(EX_StackUnder);
goto invalid_operand;
}
else if (st0_tag == TAG_Special)
{
st0_tag = FPU_Special(st0_ptr);
if ((st0_tag == TW_Infinity) ||
(st0_tag == TW_NaN))
{
EXCEPTION(EX_Invalid);
goto invalid_operand;
}
}
reg_copy(st0_ptr, &t);
precision_loss = FPU_round_to_int(&t, st0_tag);
ll = significand(&t);
/* Check for overflow, by comparing with 999999999999999999 decimal. */
if ((t.sigh > 0x0de0b6b3) ||
((t.sigh == 0x0de0b6b3) && (t.sigl > 0xa763ffff)))
{
EXCEPTION(EX_Invalid);
/* This is a special case: see sec 16.2.5.1 of the 80486 book */
invalid_operand:
if (control_word & CW_Invalid)
{
/* Produce the QNaN "indefinite" */
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_WRITE,d,10);
for (i = 0; i < 7; i++)
FPU_put_user(0, (u_char *) d+i); /* These bytes "undefined" */
FPU_put_user(0xc0, (u_char *) d+7); /* This byte "undefined" */
FPU_put_user(0xff, (u_char *) d+8);
FPU_put_user(0xff, (u_char *) d+9);
RE_ENTRANT_CHECK_ON;
return 1;
}
else
return 0;
}
else if (precision_loss)
{
/* Precision loss doesn't stop the data transfer */
set_precision_flag(precision_loss);
}
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_WRITE,d,10);
RE_ENTRANT_CHECK_ON;
for (i = 0; i < 9; i++)
{
b = FPU_div_small(&ll, 10);
b |= (FPU_div_small(&ll, 10)) << 4;
RE_ENTRANT_CHECK_OFF;
FPU_put_user(b,(u_char *) d+i);
RE_ENTRANT_CHECK_ON;
}
RE_ENTRANT_CHECK_OFF;
FPU_put_user(sign,(u_char *) d+9);
RE_ENTRANT_CHECK_ON;
return 1;
}
/*===========================================================================*/
/* r gets mangled such that sig is int, sign:
it is NOT normalized */
/* The return value (in eax) is zero if the result is exact,
if bits are changed due to rounding, truncation, etc, then
a non-zero value is returned */
/* Overflow is signalled by a non-zero return value (in eax).
In the case of overflow, the returned significand always has the
largest possible value */
int BX_CPP_AttrRegparmN(2)
FPU_round_to_int(FPU_REG *r, u_char tag)
{
u_char very_big;
unsigned eax;
if (tag == TAG_Zero)
{
/* Make sure that zero is returned */
significand(r) = 0;
return 0; /* o.k. */
}
if (exponent(r) > 63)
{
r->sigl = r->sigh = ~0; /* The largest representable number */
return 1; /* overflow */
}
#ifndef EMU_BIG_ENDIAN
eax = FPU_shrxs(&r->sigl, 63 - exponent(r));
#else
eax = FPU_shrxs(&r->sigh, 63 - exponent(r));
#endif
very_big = !(~(r->sigh) | ~(r->sigl)); /* test for 0xfff...fff */
#define half_or_more (eax & 0x80000000)
#define frac_part (eax)
#define more_than_half (eax > 0x80000000)
switch (control_word & CW_RC)
{
case RC_RND:
if (more_than_half /* nearest */
|| (half_or_more && (r->sigl & 1))) /* odd -> even */
{
if (very_big) return 1; /* overflow */
significand(r) ++;
return PRECISION_LOST_UP;
}
break;
case RC_DOWN:
if (frac_part && getsign(r))
{
if (very_big) return 1; /* overflow */
significand(r) ++;
return PRECISION_LOST_UP;
}
break;
case RC_UP:
if (frac_part && !getsign(r))
{
if (very_big) return 1; /* overflow */
significand(r) ++;
return PRECISION_LOST_UP;
}
break;
case RC_CHOP:
break;
}
return eax ? PRECISION_LOST_DOWN : 0;
}
/*===========================================================================*/
u_char BX_CPP_AttrRegparmN(2)
*fldenv(fpu_addr_modes addr_modes, u_char *s)
{
u16 tag_word = 0;
u_char tag;
int i;
if ((addr_modes.default_mode == VM86) ||
((addr_modes.default_mode == PM16)
^ (addr_modes.override.operand_size == OP_SIZE_PREFIX)))
{
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_READ, s, 0x0e);
FPU_get_user(control_word, (u16 *) s);
FPU_get_user(partial_status, (u16 *) (s+2));
FPU_get_user(tag_word, (u16 *) (s+4));
FPU_get_user(instruction_address.offset, (u16 *) (s+6));
FPU_get_user(instruction_address.selector, (u16 *) (s+8));
FPU_get_user(operand_address.offset, (u16 *) (s+0x0a));
FPU_get_user(operand_address.selector, (u16 *) (s+0x0c));
RE_ENTRANT_CHECK_ON;
s += 0x0e;
if (addr_modes.default_mode == VM86)
{
instruction_address.offset
+= (instruction_address.selector & 0xf000) << 4;
operand_address.offset += (operand_address.selector & 0xf000) << 4;
}
}
else
{
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_READ, s, 0x1c);
FPU_get_user(control_word, (u16 *) s);
FPU_get_user(partial_status, (u16 *) (s+4));
FPU_get_user(tag_word, (u16 *) (s+8));
FPU_get_user(instruction_address.offset, (u32 *) (s+0x0c));
FPU_get_user(instruction_address.selector, (u16 *) (s+0x10));
FPU_get_user(instruction_address.opcode, (u16 *) (s+0x12));
FPU_get_user(operand_address.offset, (u32 *) (s+0x14));
FPU_get_user(operand_address.selector, (u32 *) (s+0x18));
RE_ENTRANT_CHECK_ON;
s += 0x1c;
}
#ifdef PECULIAR_486
control_word &= ~0xe080;
#endif /* PECULIAR_486 */
top = (partial_status >> SW_Top_Shift) & 7;
if (partial_status & ~control_word & CW_Exceptions)
partial_status |= (SW_Summary | SW_Backward);
else
partial_status &= ~(SW_Summary | SW_Backward);
for (i = 0; i < 8; i++)
{
tag = tag_word & 3;
tag_word >>= 2;
if (tag == TAG_Empty)
/* New tag is empty. Accept it */
FPU_settag(i, TAG_Empty);
else if (FPU_gettag(i) == TAG_Empty)
{
/* Old tag is empty and new tag is not empty. New tag is determined
by old reg contents */
if (exponent(&fpu_register(i)) == - EXTENDED_Ebias)
{
if (!(fpu_register(i).sigl | fpu_register(i).sigh))
FPU_settag(i, TAG_Zero);
else
FPU_settag(i, TAG_Special);
}
else if (exponent(&fpu_register(i)) == 0x7fff - EXTENDED_Ebias)
{
FPU_settag(i, TAG_Special);
}
else if (fpu_register(i).sigh & 0x80000000)
FPU_settag(i, TAG_Valid);
else
FPU_settag(i, TAG_Special); /* An Un-normal */
}
/* Else old tag is not empty and new tag is not empty. Old tag
remains correct */
}
return s;
}
void BX_CPP_AttrRegparmN(2)
frstor(fpu_addr_modes addr_modes, u_char *data_address)
{
int i, regnr;
u_char *s = fldenv(addr_modes, data_address);
int offset = (top & 7) * sizeof(FPU_REG), other = 8*sizeof(FPU_REG) - offset;
/* Copy all registers in stack order. */
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_READ,s,80);
{
FPU_REG *fpu_reg_p;
fpu_reg_p = (FPU_REG *) (register_base+offset);
while (other>0) {
FPU_get_user(fpu_reg_p->sigl, (u32*)(s+0));
FPU_get_user(fpu_reg_p->sigh, (u32*)(s+4));
FPU_get_user(fpu_reg_p->exp, (u16*)(s+8));
fpu_reg_p++;
s += 10;
other -= sizeof(FPU_REG);
}
fpu_reg_p = (FPU_REG *) register_base;
while (offset>0) {
FPU_get_user(fpu_reg_p->sigl, (u32*)(s+0));
FPU_get_user(fpu_reg_p->sigh, (u32*)(s+4));
FPU_get_user(fpu_reg_p->exp, (u16*)(s+8));
fpu_reg_p++;
s += 10;
offset -= sizeof(FPU_REG);
}
}
RE_ENTRANT_CHECK_ON;
for (i = 0; i < 8; i++)
{
regnr = (i+top) & 7;
if (FPU_gettag(regnr) != TAG_Empty)
/* The loaded data over-rides all other cases. */
FPU_settag(regnr, FPU_tagof(&st(i)));
}
}
u_char BX_CPP_AttrRegparmN(2)
*fstenv(fpu_addr_modes addr_modes, u_char *d)
{
if ((addr_modes.default_mode == VM86) ||
((addr_modes.default_mode == PM16)
^ (addr_modes.override.operand_size == OP_SIZE_PREFIX)))
{
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_WRITE,d,14);
#ifdef PECULIAR_486
FPU_put_user(control_word & ~0xe080, (u32 *) d);
#else
FPU_put_user(control_word, (u16 *) d);
#endif /* PECULIAR_486 */
FPU_put_user(status_word(), (u16 *) (d+2));
FPU_put_user(fpu_tag_word, (u16 *) (d+4));
FPU_put_user(instruction_address.offset, (u16 *) (d+6));
FPU_put_user(operand_address.offset, (u16 *) (d+0x0a));
if (addr_modes.default_mode == VM86)
{
FPU_put_user((instruction_address.offset & 0xf0000) >> 4,
(u16 *) (d+8));
FPU_put_user((operand_address.offset & 0xf0000) >> 4,
(u16 *) (d+0x0c));
}
else
{
FPU_put_user(instruction_address.selector, (u16 *) (d+8));
FPU_put_user(operand_address.selector, (u16 *) (d+0x0c));
}
RE_ENTRANT_CHECK_ON;
d += 0x0e;
}
else
{
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_WRITE, d, 7*4);
#ifdef PECULIAR_486
control_word &= ~0xe080;
/* An 80486 sets nearly all of the reserved bits to 1. */
control_word |= 0xffff0040;
partial_status = status_word() | 0xffff0000;
fpu_tag_word |= 0xffff0000;
i387.fcs &= ~0xf8000000;
i387.fos |= 0xffff0000;
#endif /* PECULIAR_486 */
FPU_put_user((u32) i387.cwd, (u32*)(((u8 *)d)+0));
FPU_put_user((u32) i387.swd, (u32*)(((u8 *)d)+4));
FPU_put_user((u32) i387.twd, (u32*)(((u8 *)d)+8));
FPU_put_user((u32) i387.fip, (u32*)(((u8 *)d)+12));
FPU_put_user((u32) i387.fcs, (u32*)(((u8 *)d)+16));
FPU_put_user((u32) i387.foo, (u32*)(((u8 *)d)+20));
FPU_put_user((u32) i387.fos, (u32*)(((u8 *)d)+24));
RE_ENTRANT_CHECK_ON;
d += 0x1c;
}
control_word |= CW_Exceptions;
partial_status &= ~(SW_Summary | SW_Backward);
return d;
}
void BX_CPP_AttrRegparmN(2)
fsave(fpu_addr_modes addr_modes, u_char *data_address)
{
u_char *d;
int offset = (top & 7) * sizeof(FPU_REG), other = 8*sizeof(FPU_REG) - offset;
d = fstenv(addr_modes, data_address);
RE_ENTRANT_CHECK_OFF;
FPU_verify_area(VERIFY_WRITE,d,80);
/* Copy all registers in stack order. */
{
FPU_REG *fpu_reg_p;
fpu_reg_p = (FPU_REG *) (register_base+offset);
while (other>0) {
FPU_put_user(fpu_reg_p->sigl, (u32*)(d+0));
FPU_put_user(fpu_reg_p->sigh, (u32*)(d+4));
FPU_put_user(fpu_reg_p->exp, (u16*)(d+8));
fpu_reg_p++;
d += 10;
other -= sizeof(FPU_REG);
}
fpu_reg_p = (FPU_REG *) register_base;
while (offset>0) {
FPU_put_user(fpu_reg_p->sigl, (u32*)(d+0));
FPU_put_user(fpu_reg_p->sigh, (u32*)(d+4));
FPU_put_user(fpu_reg_p->exp, (u16*)(d+8));
fpu_reg_p++;
d += 10;
offset -= sizeof(FPU_REG);
}
}
RE_ENTRANT_CHECK_ON;
finit();
}
/*===========================================================================*/
Reference in New Issue View Git Blame Copy Permalink