darkkirb/old-cross-binutils
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
old-cross-binutils/sim/rx/fpu.c
Joel Brobecker 7b6bb8daac run copyright.sh for 2011.
2011-01-01 15:34:07 +00:00

792 lines
15 KiB
C
Raw Blame History

/* fpu.c --- FPU emulator for stand-alone RX simulator.
Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
This file is part of the GNU simulators.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include "cpu.h"
#include "fpu.h"
/* FPU encodings are as follows:
S EXPONENT MANTISSA
1 12345678 12345678901234567890123
0 00000000 00000000000000000000000 +0
1 00000000 00000000000000000000000 -0
X 00000000 00000000000000000000001 Denormals
X 00000000 11111111111111111111111
X 00000001 XXXXXXXXXXXXXXXXXXXXXXX Normals
X 11111110 XXXXXXXXXXXXXXXXXXXXXXX
0 11111111 00000000000000000000000 +Inf
1 11111111 00000000000000000000000 -Inf
X 11111111 0XXXXXXXXXXXXXXXXXXXXXX SNaN (X != 0)
X 11111111 1XXXXXXXXXXXXXXXXXXXXXX QNaN (X != 0)
*/
#define trace 0
#define tprintf if (trace) printf
/* Some magic numbers. */
#define PLUS_MAX 0x7f7fffffUL
#define MINUS_MAX 0xff7fffffUL
#define PLUS_INF 0x7f800000UL
#define MINUS_INF 0xff800000UL
#define PLUS_ZERO 0x00000000UL
#define MINUS_ZERO 0x80000000UL
#define FP_RAISE(e) fp_raise(FPSWBITS_C##e)
static void
fp_raise (int mask)
{
regs.r_fpsw |= mask;
if (mask != FPSWBITS_CE)
{
if (regs.r_fpsw & (mask << FPSW_CESH))
regs.r_fpsw |= (mask << FPSW_CFSH);
if (regs.r_fpsw & FPSWBITS_FMASK)
regs.r_fpsw |= FPSWBITS_FSUM;
else
regs.r_fpsw &= ~FPSWBITS_FSUM;
}
}
/* We classify all numbers as one of these. They correspond to the
rows/colums in the exception tables. */
typedef enum {
FP_NORMAL,
FP_PZERO,
FP_NZERO,
FP_PINFINITY,
FP_NINFINITY,
FP_DENORMAL,
FP_QNAN,
FP_SNAN
} FP_Type;
#if defined DEBUG0
static const char *fpt_names[] = {
"Normal", "+0", "-0", "+Inf", "-Inf", "Denormal", "QNaN", "SNaN"
};
#endif
#define EXP_BIAS 127
#define EXP_ZERO -127
#define EXP_INF 128
#define MANT_BIAS 0x00080000UL
typedef struct {
int exp;
unsigned int mant; /* 24 bits */
char type;
char sign;
fp_t orig_value;
} FP_Parts;
static void
fp_explode (fp_t f, FP_Parts *p)
{
int exp, mant, sign;
exp = ((f & 0x7f800000UL) >> 23);
mant = f & 0x007fffffUL;
sign = f & 0x80000000UL;
/*printf("explode: %08x %x %2x %6x\n", f, sign, exp, mant);*/
p->sign = sign ? -1 : 1;
p->exp = exp - EXP_BIAS;
p->orig_value = f;
p->mant = mant | 0x00800000UL;
if (p->exp == EXP_ZERO)
{
if (regs.r_fpsw & FPSWBITS_DN)
mant = 0;
if (mant)
p->type = FP_DENORMAL;
else
{
p->mant = 0;
p->type = sign ? FP_NZERO : FP_PZERO;
}
}
else if (p->exp == EXP_INF)
{
if (mant == 0)
p->type = sign ? FP_NINFINITY : FP_PINFINITY;
else if (mant & 0x00400000UL)
p->type = FP_QNAN;
else
p->type = FP_SNAN;
}
else
p->type = FP_NORMAL;
}
static fp_t
fp_implode (FP_Parts *p)
{
int exp, mant;
exp = p->exp + EXP_BIAS;
mant = p->mant;
/*printf("implode: exp %d mant 0x%x\n", exp, mant);*/
if (p->type == FP_NORMAL)
{
while (mant
&& exp > 0
&& mant < 0x00800000UL)
{
mant <<= 1;
exp --;
}
while (mant > 0x00ffffffUL)
{
mant >>= 1;
exp ++;
}
if (exp < 0)
{
/* underflow */
exp = 0;
mant = 0;
FP_RAISE (E);
}
if (exp >= 255)
{
/* overflow */
exp = 255;
mant = 0;
FP_RAISE (O);
}
}
mant &= 0x007fffffUL;
exp &= 0xff;
mant |= exp << 23;
if (p->sign < 0)
mant |= 0x80000000UL;
return mant;
}
typedef union {
unsigned long long ll;
double d;
} U_d_ll;
static int checked_format = 0;
/* We assume a double format like this:
S[1] E[11] M[52]
*/
static double
fp_to_double (FP_Parts *p)
{
U_d_ll u;
if (!checked_format)
{
u.d = 1.5;
if (u.ll != 0x3ff8000000000000ULL)
abort ();
u.d = -225;
if (u.ll != 0xc06c200000000000ULL)
abort ();
u.d = 10.1;
if (u.ll != 0x4024333333333333ULL)
abort ();
checked_format = 1;
}
u.ll = 0;
if (p->sign < 0)
u.ll |= (1ULL << 63);
/* Make sure a zero encoding stays a zero. */
if (p->exp != -EXP_BIAS)
u.ll |= ((unsigned long long)p->exp + 1023ULL) << 52;
u.ll |= (unsigned long long) (p->mant & 0x007fffffUL) << (52 - 23);
return u.d;
}
static void
double_to_fp (double d, FP_Parts *p)
{
int exp;
U_d_ll u;
int sign;
u.d = d;
sign = (u.ll & 0x8000000000000000ULL) ? 1 : 0;
exp = u.ll >> 52;
exp = (exp & 0x7ff);
if (exp == 0)
{
/* A generated denormal should show up as an underflow, not
here. */
if (sign)
fp_explode (MINUS_ZERO, p);
else
fp_explode (PLUS_ZERO, p);
return;
}
exp = exp - 1023;
if ((exp + EXP_BIAS) > 254)
{
FP_RAISE (O);
switch (regs.r_fpsw & FPSWBITS_RM)
{
case FPRM_NEAREST:
if (sign)
fp_explode (MINUS_INF, p);
else
fp_explode (PLUS_INF, p);
break;
case FPRM_ZERO:
if (sign)
fp_explode (MINUS_MAX, p);
else
fp_explode (PLUS_MAX, p);
break;
case FPRM_PINF:
if (sign)
fp_explode (MINUS_MAX, p);
else
fp_explode (PLUS_INF, p);
break;
case FPRM_NINF:
if (sign)
fp_explode (MINUS_INF, p);
else
fp_explode (PLUS_MAX, p);
break;
}
return;
}
if ((exp + EXP_BIAS) < 1)
{
if (sign)
fp_explode (MINUS_ZERO, p);
else
fp_explode (PLUS_ZERO, p);
FP_RAISE (U);
}
p->sign = sign ? -1 : 1;
p->exp = exp;
p->mant = u.ll >> (52-23) & 0x007fffffUL;
p->mant |= 0x00800000UL;
p->type = FP_NORMAL;
if (u.ll & 0x1fffffffULL)
{
switch (regs.r_fpsw & FPSWBITS_RM)
{
case FPRM_NEAREST:
if (u.ll & 0x10000000ULL)
p->mant ++;
break;
case FPRM_ZERO:
break;
case FPRM_PINF:
if (sign == 1)
p->mant ++;
break;
case FPRM_NINF:
if (sign == -1)
p->mant ++;
break;
}
FP_RAISE (X);
}
}
typedef enum {
eNR, /* Use the normal result. */
ePZ, eNZ, /* +- zero */
eSZ, /* signed zero - XOR signs of ops together. */
eRZ, /* +- zero depending on rounding mode. */
ePI, eNI, /* +- Infinity */
eSI, /* signed infinity - XOR signs of ops together. */
eQN, eSN, /* Quiet/Signalling NANs */
eIn, /* Invalid. */
eUn, /* Unimplemented. */
eDZ, /* Divide-by-zero. */
eLT, /* less than */
eGT, /* greater than */
eEQ, /* equal to */
} FP_ExceptionCases;
#if defined DEBUG0
static const char *ex_names[] = {
"NR", "PZ", "NZ", "SZ", "RZ", "PI", "NI", "SI", "QN", "SN", "IN", "Un", "DZ", "LT", "GT", "EQ"
};
#endif
/* This checks for all exceptional cases (not all FP exceptions) and
returns TRUE if it is providing the result in *c. If it returns
FALSE, the caller should do the "normal" operation. */
int
check_exceptions (FP_Parts *a, FP_Parts *b, fp_t *c,
FP_ExceptionCases ex_tab[5][5],
FP_ExceptionCases *case_ret)
{
FP_ExceptionCases fpec;
if (a->type == FP_SNAN
|| b->type == FP_SNAN)
fpec = eIn;
else if (a->type == FP_QNAN
|| b->type == FP_QNAN)
fpec = eQN;
else if (a->type == FP_DENORMAL
|| b->type == FP_DENORMAL)
fpec = eUn;
else
fpec = ex_tab[(int)(a->type)][(int)(b->type)];
/*printf("%s %s -> %s\n", fpt_names[(int)(a->type)], fpt_names[(int)(b->type)], ex_names[(int)(fpec)]);*/
if (case_ret)
*case_ret = fpec;
switch (fpec)
{
case eNR: /* Use the normal result. */
return 0;
case ePZ: /* + zero */
*c = 0x00000000;
return 1;
case eNZ: /* - zero */
*c = 0x80000000;
return 1;
case eSZ: /* signed zero */
*c = (a->sign == b->sign) ? PLUS_ZERO : MINUS_ZERO;
return 1;
case eRZ: /* +- zero depending on rounding mode. */
if ((regs.r_fpsw & FPSWBITS_RM) == FPRM_NINF)
*c = 0x80000000;
else
*c = 0x00000000;
return 1;
case ePI: /* + Infinity */
*c = 0x7F800000;
return 1;
case eNI: /* - Infinity */
*c = 0xFF800000;
return 1;
case eSI: /* sign Infinity */
*c = (a->sign == b->sign) ? PLUS_INF : MINUS_INF;
return 1;
case eQN: /* Quiet NANs */
if (a->type == FP_QNAN)
*c = a->orig_value;
else
*c = b->orig_value;
return 1;
case eSN: /* Signalling NANs */
if (a->type == FP_SNAN)
*c = a->orig_value;
else
*c = b->orig_value;
FP_RAISE (V);
return 1;
case eIn: /* Invalid. */
FP_RAISE (V);
if (a->type == FP_SNAN)
*c = a->orig_value | 0x00400000;
else if (a->type == FP_SNAN)
*c = b->orig_value | 0x00400000;
else
*c = 0x7fc00000;
return 1;
case eUn: /* Unimplemented. */
FP_RAISE (E);
return 1;
case eDZ: /* Division-by-zero. */
*c = (a->sign == b->sign) ? PLUS_INF : MINUS_INF;
FP_RAISE (Z);
return 1;
default:
return 0;
}
}
#define CHECK_EXCEPTIONS(FPPa, FPPb, fpc, ex_tab) \
if (check_exceptions (&FPPa, &FPPb, &fpc, ex_tab, 0)) \
return fpc;
/* For each operation, we have two tables of how nonnormal cases are
handled. The DN=0 case is first, followed by the DN=1 case, with
each table using the following layout: */
static FP_ExceptionCases ex_add_tab[5][5] = {
/* N +0 -0 +In -In */
{ eNR, eNR, eNR, ePI, eNI }, /* Normal */
{ eNR, ePZ, eRZ, ePI, eNI }, /* +0 */
{ eNR, eRZ, eNZ, ePI, eNI }, /* -0 */
{ ePI, ePI, ePI, ePI, eIn }, /* +Inf */
{ eNI, eNI, eNI, eIn, eNI }, /* -Inf */
};
fp_t
rxfp_add (fp_t fa, fp_t fb)
{
FP_Parts a, b, c;
fp_t rv;
double da, db;
fp_explode (fa, &a);
fp_explode (fb, &b);
CHECK_EXCEPTIONS (a, b, rv, ex_add_tab);
da = fp_to_double (&a);
db = fp_to_double (&b);
tprintf("%g + %g = %g\n", da, db, da+db);
double_to_fp (da+db, &c);
rv = fp_implode (&c);
return rv;
}
static FP_ExceptionCases ex_sub_tab[5][5] = {
/* N +0 -0 +In -In */
{ eNR, eNR, eNR, eNI, ePI }, /* Normal */
{ eNR, eRZ, ePZ, eNI, ePI }, /* +0 */
{ eNR, eNZ, eRZ, eNI, ePI }, /* -0 */
{ ePI, ePI, ePI, eIn, ePI }, /* +Inf */
{ eNI, eNI, eNI, eNI, eIn }, /* -Inf */
};
fp_t
rxfp_sub (fp_t fa, fp_t fb)
{
FP_Parts a, b, c;
fp_t rv;
double da, db;
fp_explode (fa, &a);
fp_explode (fb, &b);
CHECK_EXCEPTIONS (a, b, rv, ex_sub_tab);
da = fp_to_double (&a);
db = fp_to_double (&b);
tprintf("%g - %g = %g\n", da, db, da-db);
double_to_fp (da-db, &c);
rv = fp_implode (&c);
return rv;
}
static FP_ExceptionCases ex_mul_tab[5][5] = {
/* N +0 -0 +In -In */
{ eNR, eNR, eNR, eSI, eSI }, /* Normal */
{ eNR, ePZ, eNZ, eIn, eIn }, /* +0 */
{ eNR, eNZ, ePZ, eIn, eIn }, /* -0 */
{ eSI, eIn, eIn, ePI, eNI }, /* +Inf */
{ eSI, eIn, eIn, eNI, ePI }, /* -Inf */
};
fp_t
rxfp_mul (fp_t fa, fp_t fb)
{
FP_Parts a, b, c;
fp_t rv;
double da, db;
fp_explode (fa, &a);
fp_explode (fb, &b);
CHECK_EXCEPTIONS (a, b, rv, ex_mul_tab);
da = fp_to_double (&a);
db = fp_to_double (&b);
tprintf("%g x %g = %g\n", da, db, da*db);
double_to_fp (da*db, &c);
rv = fp_implode (&c);
return rv;
}
static FP_ExceptionCases ex_div_tab[5][5] = {
/* N +0 -0 +In -In */
{ eNR, eDZ, eDZ, eSZ, eSZ }, /* Normal */
{ eSZ, eIn, eIn, ePZ, eNZ }, /* +0 */
{ eSZ, eIn, eIn, eNZ, ePZ }, /* -0 */
{ eSI, ePI, eNI, eIn, eIn }, /* +Inf */
{ eSI, eNI, ePI, eIn, eIn }, /* -Inf */
};
fp_t
rxfp_div (fp_t fa, fp_t fb)
{
FP_Parts a, b, c;
fp_t rv;
double da, db;
fp_explode (fa, &a);
fp_explode (fb, &b);
CHECK_EXCEPTIONS (a, b, rv, ex_div_tab);
da = fp_to_double (&a);
db = fp_to_double (&b);
tprintf("%g / %g = %g\n", da, db, da/db);
double_to_fp (da/db, &c);
rv = fp_implode (&c);
return rv;
}
static FP_ExceptionCases ex_cmp_tab[5][5] = {
/* N +0 -0 +In -In */
{ eNR, eNR, eNR, eLT, eGT }, /* Normal */
{ eNR, eEQ, eEQ, eLT, eGT }, /* +0 */
{ eNR, eEQ, eEQ, eLT, eGT }, /* -0 */
{ eGT, eGT, eGT, eEQ, eGT }, /* +Inf */
{ eLT, eLT, eLT, eLT, eEQ }, /* -Inf */
};
void
rxfp_cmp (fp_t fa, fp_t fb)
{
FP_Parts a, b;
fp_t c;
FP_ExceptionCases reason;
int flags = 0;
double da, db;
fp_explode (fa, &a);
fp_explode (fb, &b);
if (check_exceptions (&a, &b, &c, ex_cmp_tab, &reason))
{
if (reason == eQN)
{
/* Special case - incomparable. */
set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_O, FLAGBIT_O);
return;
}
return;
}
switch (reason)
{
case eEQ:
flags = FLAGBIT_Z;
break;
case eLT:
flags = FLAGBIT_S;
break;
case eGT:
flags = 0;
break;
case eNR:
da = fp_to_double (&a);
db = fp_to_double (&b);
tprintf("fcmp: %g cmp %g\n", da, db);
if (da < db)
flags = FLAGBIT_S;
else if (da == db)
flags = FLAGBIT_Z;
else
flags = 0;
break;
default:
abort();
}
set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_O, flags);
}
long
rxfp_ftoi (fp_t fa, int round_mode)
{
FP_Parts a;
fp_t rv;
int sign;
int whole_bits, frac_bits;
fp_explode (fa, &a);
sign = fa & 0x80000000UL;
switch (a.type)
{
case FP_NORMAL:
break;
case FP_PZERO:
case FP_NZERO:
return 0;
case FP_PINFINITY:
FP_RAISE (V);
return 0x7fffffffL;
case FP_NINFINITY:
FP_RAISE (V);
return 0x80000000L;
case FP_DENORMAL:
FP_RAISE (E);
return 0;
case FP_QNAN:
case FP_SNAN:
FP_RAISE (V);
return sign ? 0x80000000U : 0x7fffffff;
}
if (a.exp >= 31)
{
FP_RAISE (V);
return sign ? 0x80000000U : 0x7fffffff;
}
a.exp -= 23;
if (a.exp <= -25)
{
/* Less than 0.49999 */
frac_bits = a.mant;
whole_bits = 0;
}
else if (a.exp < 0)
{
frac_bits = a.mant << (32 + a.exp);
whole_bits = a.mant >> (-a.exp);
}
else
{
frac_bits = 0;
whole_bits = a.mant << a.exp;
}
if (frac_bits)
{
switch (round_mode & 3)
{
case FPRM_NEAREST:
if (frac_bits & 0x80000000UL)
whole_bits ++;
break;
case FPRM_ZERO:
break;
case FPRM_PINF:
if (!sign)
whole_bits ++;
break;
case FPRM_NINF:
if (sign)
whole_bits ++;
break;
}
}
rv = sign ? -whole_bits : whole_bits;
return rv;
}
fp_t
rxfp_itof (long fa, int round_mode)
{
fp_t rv;
int sign = 0;
unsigned int frac_bits;
volatile unsigned int whole_bits;
FP_Parts a;
if (fa == 0)
return PLUS_ZERO;
if (fa < 0)
{
fa = -fa;
sign = 1;
a.sign = -1;
}
else
a.sign = 1;
whole_bits = fa;
a.exp = 31;
while (! (whole_bits & 0x80000000UL))
{
a.exp --;
whole_bits <<= 1;
}
frac_bits = whole_bits & 0xff;
whole_bits = whole_bits >> 8;
if (frac_bits)
{
/* We must round */
switch (round_mode & 3)
{
case FPRM_NEAREST:
if (frac_bits & 0x80)
whole_bits ++;
break;
case FPRM_ZERO:
break;
case FPRM_PINF:
if (!sign)
whole_bits ++;
break;
case FPRM_NINF:
if (sign)
whole_bits ++;
break;
}
}
a.mant = whole_bits;
if (whole_bits & 0xff000000UL)
{
a.mant >>= 1;
a.exp ++;
}
rv = fp_implode (&a);
return rv;
}
Reference in a new issue View git blame Copy permalink