Subversion Repositories or1k

/* Interface with ptrace and core-dumping routines */

#include "fpu_system.h"

#include "exception.h"

#include "reg_constant.h"

#include "fpu_emu.h"

#include "control_w.h"

#include "status_w.h"

#define EXTENDED_Ebias 0x3fff

#define EXTENDED_Emin (-0x3ffe)  /* smallest valid exponent */

#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 */

/* Copy and paste from round_to_int. Original comments maintained */

/*===========================================================================*/

/* 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 */

static int round_to_int_cwd(FPU_REG *r, long int user_control_word)

{

  char     very_big;

  unsigned eax;

  if (r->tag == TW_Zero)

    {

      /* Make sure that zero is returned */

      significand(r) = 0;

      return 0;        /* o.k. */

    }

  if (r->exp > EXP_BIAS + 63)

    {

      r->sigl = r->sigh = ~0;      /* The largest representable number */

      return 1;        /* overflow */

    }

  eax = shrxs(&r->sigl, EXP_BIAS + 63 - r->exp);

  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 & 0x80000001) == 0x80000001)

  switch (user_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 && r->sign)

        {

          if ( very_big ) return 1;        /* overflow */

          significand(r) ++;

          return PRECISION_LOST_UP;

        }

      break;

    case RC_UP:

      if (frac_part && !r->sign)

        {

          if ( very_big ) return 1;        /* overflow */

          significand(r) ++;

          return PRECISION_LOST_UP;

        }

      break;

    case RC_CHOP:

      break;

    }

  return eax ? PRECISION_LOST_DOWN : 0;

}

/* Conver a number in the emulator format to the

 * hardware format.

 * Taken from the emulator sources, function reg_load_extended

 */

/* Get a long double from the debugger */

void hardreg_to_softreg(const char hardreg[10],

                              FPU_REG *soft_reg)

{

        unsigned long sigl, sigh, exp;

        sigl = *((unsigned long *) hardreg);

        sigh = *(1 + (unsigned long *) hardreg);

        exp = *(4 + (unsigned short *) hardreg);

        soft_reg->tag = TW_Valid;   /* Default */

        soft_reg->sigl = sigl;

        soft_reg->sigh = sigh;

        if (exp & 0x8000)

                soft_reg->sign = SIGN_NEG;

        else

                soft_reg->sign = SIGN_POS;

        exp &= 0x7fff;

        soft_reg->exp = exp - EXTENDED_Ebias + EXP_BIAS;

        if ( exp == 0 )

        {

                if ( !(sigh | sigl) )

                {

                        soft_reg->tag = TW_Zero;

                        return;

                }

                /* The number is a de-normal or pseudodenormal. */

                if (sigh & 0x80000000)

                {

                        /* Is a pseudodenormal. */

                        /* Convert it for internal use. */

                        /* This is non-80486 behaviour because the number

                           loses its 'denormal' identity. */

                        soft_reg->exp++;

                        return;

                }

                else

                {

                        /* Is a denormal. */

                        /* Convert it for internal use. */

                        soft_reg->exp++;

                        normalize_nuo(soft_reg);

                        return;

                }

        }

        else if ( exp == 0x7fff )

        {

                if ( !((sigh ^ 0x80000000) | sigl) )

                {

                        /* Matches the bit pattern for Infinity. */

                        soft_reg->exp = EXP_Infinity;

                        soft_reg->tag = TW_Infinity;

                        return;

                }

                soft_reg->exp = EXP_NaN;

                soft_reg->tag = TW_NaN;

                if ( !(sigh & 0x80000000) )

                {

                        /* NaNs have the ms bit set to 1. */

                        /* This is therefore an Unsupported NaN data type. */

                        /* This is non 80486 behaviour */

                        /* This should generate an Invalid Operand exception

                           later, so we convert it to a SNaN */

                        soft_reg->sigh = 0x80000000;

                        soft_reg->sigl = 0x00000001;

                        soft_reg->sign = SIGN_NEG;

                        return;

                }

                return;

        }

        if ( !(sigh & 0x80000000) )

        {

                /* Unsupported data type. */

                /* Valid numbers have the ms bit set to 1. */

                /* Unnormal. */

                /* Convert it for internal use. */

                /* This is non-80486 behaviour */

                /* This should generate an Invalid Operand exception

                   later, so we convert it to a SNaN */

                soft_reg->sigh = 0x80000000;

                soft_reg->sigl = 0x00000001;

                soft_reg->sign = SIGN_NEG;

                soft_reg->exp = EXP_NaN;

                soft_reg->tag = TW_NaN;

                return;

        }

        return;

}

/* Conver a number in the emulator format to the

 * hardware format.

 * Adapted from function write_to_extended

 */

void softreg_to_hardreg(const FPU_REG *rp, char d[10], long int user_control_word)

{

        long e;

        FPU_REG tmp;

        e = rp->exp - EXP_BIAS + EXTENDED_Ebias;

        /*

          All numbers except denormals are stored internally in a

          format which is compatible with the extended real number

          format.

          */

        if (e > 0) {

                *(unsigned long *) d = rp->sigl;

                *(unsigned long *) (d + 4) = rp->sigh;

        } else {

                /*

                  The number is a de-normal stored as a normal using our

                  extra exponent range, or is Zero.

                  Convert it back to a de-normal, or leave it as Zero.

                  */

                reg_move(rp, &tmp);

                tmp.exp += -EXTENDED_Emin + 63;  /* largest exp to be 63 */

                round_to_int_cwd(&tmp, user_control_word);

                e = 0;

                *(unsigned long *) d= tmp.sigl;

                *(unsigned long *) (d + 4) = tmp.sigh;

        }

        e |= rp->sign == SIGN_POS ? 0 : 0x8000;

        *(unsigned short *) (d + 8) = e;

}