motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-23 10:01:59 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

soft float support

Browse source 
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@1336 c046a42c-6fe2-441c-8c8c-71466251a162
This commit is contained in:
bellard 2005-03-13 17:01:47 +00:00
parent 4ecc31906d
commit 7a0e1f41ce
9 changed files with 139 additions and 231 deletions
Download patch file Download diff file Expand all files Collapse all files

11
dyngen-exec.h
View file

@ -62,17 +62,6 @@ extern int fprintf(FILE *, const char *, ...);
extern int printf(const char *, ...); extern int printf(const char *, ...);
#undef NULL #undef NULL
#define NULL 0 #define NULL 0
#if defined(_BSD) && !defined(__APPLE__)
#include <ieeefp.h>
#define FE_TONEAREST FP_RN
#define FE_DOWNWARD FP_RM
#define FE_UPWARD FP_RP
#define FE_TOWARDZERO FP_RZ
#define fesetround(x) fpsetround(x)
#else
#include <fenv.h>
#endif
#ifdef __i386__ #ifdef __i386__
#define AREG0 "ebp" #define AREG0 "ebp"

14
target-i386/cpu.h
View file

@ -36,6 +36,8 @@
#include "cpu-defs.h" #include "cpu-defs.h"
#include "softfloat.h"
#if defined(__i386__) && !defined(CONFIG_SOFTMMU) #if defined(__i386__) && !defined(CONFIG_SOFTMMU)
#define USE_CODE_COPY #define USE_CODE_COPY
#endif #endif
@ -332,14 +334,14 @@ enum {
CC_OP_NB, CC_OP_NB,
}; };
#if (defined(__i386__) || defined(__x86_64__)) && !defined(_BSD) #ifdef FLOATX80
#define USE_X86LDOUBLE #define USE_X86LDOUBLE
#endif #endif
#ifdef USE_X86LDOUBLE #ifdef USE_X86LDOUBLE
typedef long double CPU86_LDouble; typedef floatx80 CPU86_LDouble;
#else #else
typedef double CPU86_LDouble; typedef float64 CPU86_LDouble;
#endif #endif
typedef struct SegmentCache { typedef struct SegmentCache {
@ -354,8 +356,8 @@ typedef union {
uint16_t _w[8]; uint16_t _w[8];
uint32_t _l[4]; uint32_t _l[4];
uint64_t _q[2]; uint64_t _q[2];
float _s[4]; float32 _s[4];
double _d[2]; float64 _d[2];
} XMMReg; } XMMReg;
typedef union { typedef union {
@ -441,6 +443,7 @@ typedef struct CPUX86State {
} fpregs[8]; } fpregs[8];
/* emulator internal variables */ /* emulator internal variables */
float_status fp_status;
CPU86_LDouble ft0; CPU86_LDouble ft0;
union { union {
float f; float f;
@ -449,6 +452,7 @@ typedef struct CPUX86State {
int64_t i64; int64_t i64;
} fp_convert; } fp_convert;
float_status sse_status;
uint32_t mxcsr; uint32_t mxcsr;
XMMReg xmm_regs[CPU_NB_REGS]; XMMReg xmm_regs[CPU_NB_REGS];
XMMReg xmm_t0; XMMReg xmm_t0;

70
target-i386/exec.h
View file

@ -139,44 +139,6 @@ extern int loglevel;
#include "cpu.h" #include "cpu.h"
#include "exec-all.h" #include "exec-all.h"
/* XXX: add a generic FPU library */
static inline double float32_to_float64(float a)
{
return a;
}
static inline float float64_to_float32(double a)
{
return a;
}
#if defined(__powerpc__)
/* better to call an helper on ppc */
float int32_to_float32(int32_t a);
double int32_to_float64(int32_t a);
#else
static inline float int32_to_float32(int32_t a)
{
return (float)a;
}
static inline double int32_to_float64(int32_t a)
{
return (double)a;
}
#endif
static inline float int64_to_float32(int64_t a)
{
return (float)a;
}
static inline double int64_to_float64(int64_t a)
{
return (double)a;
}
typedef struct CCTable { typedef struct CCTable {
int (*compute_all)(void); /* return all the flags */ int (*compute_all)(void); /* return all the flags */
int (*compute_c)(void); /* return the C flag */ int (*compute_c)(void); /* return the C flag */
@ -358,9 +320,11 @@ static inline void stfl(target_ulong ptr, float v)
#ifdef USE_X86LDOUBLE #ifdef USE_X86LDOUBLE
/* use long double functions */ /* use long double functions */
#define lrint lrintl #define floatx_to_int32 floatx80_to_int32
#define llrint llrintl #define floatx_to_int64 floatx80_to_int64
#define fabs fabsl #define floatx_abs floatx80_abs
#define floatx_chs floatx80_chs
#define floatx_round_to_int floatx80_round_to_int
#define sin sinl #define sin sinl
#define cos cosl #define cos cosl
#define sqrt sqrtl #define sqrt sqrtl
@ -370,17 +334,14 @@ static inline void stfl(target_ulong ptr, float v)
#define atan2 atan2l #define atan2 atan2l
#define floor floorl #define floor floorl
#define ceil ceill #define ceil ceill
#define rint rintl #else
#define floatx_to_int32 float64_to_int32
#define floatx_to_int64 float64_to_int64
#define floatx_abs float64_abs
#define floatx_chs float64_chs
#define floatx_round_to_int float64_round_to_int
#endif #endif
#if !defined(_BSD)
extern int lrint(CPU86_LDouble x);
extern int64_t llrint(CPU86_LDouble x);
#else
#define lrint(d) ((int)rint(d))
#define llrint(d) ((int)rint(d))
#endif
extern CPU86_LDouble fabs(CPU86_LDouble x);
extern CPU86_LDouble sin(CPU86_LDouble x); extern CPU86_LDouble sin(CPU86_LDouble x);
extern CPU86_LDouble cos(CPU86_LDouble x); extern CPU86_LDouble cos(CPU86_LDouble x);
extern CPU86_LDouble sqrt(CPU86_LDouble x); extern CPU86_LDouble sqrt(CPU86_LDouble x);
@ -390,7 +351,6 @@ extern CPU86_LDouble tan(CPU86_LDouble x);
extern CPU86_LDouble atan2(CPU86_LDouble, CPU86_LDouble); extern CPU86_LDouble atan2(CPU86_LDouble, CPU86_LDouble);
extern CPU86_LDouble floor(CPU86_LDouble x); extern CPU86_LDouble floor(CPU86_LDouble x);
extern CPU86_LDouble ceil(CPU86_LDouble x); extern CPU86_LDouble ceil(CPU86_LDouble x);
extern CPU86_LDouble rint(CPU86_LDouble x);
#define RC_MASK 0xc00 #define RC_MASK 0xc00
#define RC_NEAR 0x000 #define RC_NEAR 0x000
@ -400,13 +360,6 @@ extern CPU86_LDouble rint(CPU86_LDouble x);
#define MAXTAN 9223372036854775808.0 #define MAXTAN 9223372036854775808.0
#ifdef __arm__
/* we have no way to do correct rounding - a FPU emulator is needed */
#define FE_DOWNWARD FE_TONEAREST
#define FE_UPWARD FE_TONEAREST
#define FE_TOWARDZERO FE_TONEAREST
#endif
#ifdef USE_X86LDOUBLE #ifdef USE_X86LDOUBLE
/* only for x86 */ /* only for x86 */
@ -596,6 +549,7 @@ float approx_rsqrt(float a);
float approx_rcp(float a); float approx_rcp(float a);
double helper_sqrt(double a); double helper_sqrt(double a);
int fpu_isnan(double a); int fpu_isnan(double a);
void update_fp_status(void);
extern const uint8_t parity_table[256]; extern const uint8_t parity_table[256];
extern const uint8_t rclw_table[32]; extern const uint8_t rclw_table[32];

78
target-i386/helper.c
View file

@ -2541,13 +2541,11 @@ void helper_fbld_ST0_A0(void)
void helper_fbst_ST0_A0(void) void helper_fbst_ST0_A0(void)
{ {
CPU86_LDouble tmp;
int v; int v;
target_ulong mem_ref, mem_end; target_ulong mem_ref, mem_end;
int64_t val; int64_t val;
tmp = rint(ST0); val = floatx_to_int64(ST0, &env->fp_status);
val = (int64_t)tmp;
mem_ref = A0; mem_ref = A0;
mem_end = mem_ref + 9; mem_end = mem_ref + 9;
if (val < 0) { if (val < 0) {
@ -2740,29 +2738,7 @@ void helper_fsincos(void)
void helper_frndint(void) void helper_frndint(void)
{ {
CPU86_LDouble a; ST0 = floatx_round_to_int(ST0, &env->fp_status);
a = ST0;
#ifdef __arm__
switch(env->fpuc & RC_MASK) {
default:
case RC_NEAR:
asm("rndd %0, %1" : "=f" (a) : "f"(a));
break;
case RC_DOWN:
asm("rnddm %0, %1" : "=f" (a) : "f"(a));
break;
case RC_UP:
asm("rnddp %0, %1" : "=f" (a) : "f"(a));
break;
case RC_CHOP:
asm("rnddz %0, %1" : "=f" (a) : "f"(a));
break;
}
#else
a = rint(a);
#endif
ST0 = a;
} }
void helper_fscale(void) void helper_fscale(void)
@ -3263,25 +3239,43 @@ float approx_rcp(float a)
return 1.0 / a; return 1.0 / a;
} }
/* XXX: find a better solution */ void update_fp_status(void)
double helper_sqrt(double a)
{ {
return sqrt(a); int rnd_type;
}
/* XXX: move that to another file */ /* set rounding mode */
#if defined(__powerpc__) switch(env->fpuc & RC_MASK) {
/* better to call an helper on ppc */ default:
float int32_to_float32(int32_t a) case RC_NEAR:
{ rnd_type = float_round_nearest_even;
return (float)a; break;
} case RC_DOWN:
rnd_type = float_round_down;
double int32_to_float64(int32_t a) break;
{ case RC_UP:
return (double)a; rnd_type = float_round_up;
} break;
case RC_CHOP:
rnd_type = float_round_to_zero;
break;
}
set_float_rounding_mode(rnd_type, &env->fp_status);
#ifdef FLOATX80
switch((env->fpuc >> 8) & 3) {
case 0:
rnd_type = 32;
break;
case 2:
rnd_type = 64;
break;
case 3:
default:
rnd_type = 80;
break;
}
set_floatx80_rounding_precision(rnd_type, &env->fp_status);
#endif #endif
}
#if !defined(CONFIG_USER_ONLY) #if !defined(CONFIG_USER_ONLY)

49
target-i386/op.c
View file

@ -1598,26 +1598,6 @@ CCTable cc_table[CC_OP_NB] = {
functions comes from the LGPL'ed x86 emulator found in the Willows functions comes from the LGPL'ed x86 emulator found in the Willows
TWIN windows emulator. */ TWIN windows emulator. */
#if defined(__powerpc__)
extern CPU86_LDouble copysign(CPU86_LDouble, CPU86_LDouble);
/* correct (but slow) PowerPC rint() (glibc version is incorrect) */
double qemu_rint(double x)
{
double y = 4503599627370496.0;
if (fabs(x) >= y)
return x;
if (x < 0)
y = -y;
y = (x + y) - y;
if (y == 0.0)
y = copysign(y, x);
return y;
}
#define rint qemu_rint
#endif
/* fp load FT0 */ /* fp load FT0 */
void OPPROTO op_flds_FT0_A0(void) void OPPROTO op_flds_FT0_A0(void)
@ -1866,7 +1846,7 @@ void OPPROTO op_fist_ST0_A0(void)
int val; int val;
d = ST0; d = ST0;
val = lrint(d); val = floatx_to_int32(d, &env->fp_status);
if (val != (int16_t)val) if (val != (int16_t)val)
val = -32768; val = -32768;
stw(A0, val); stw(A0, val);
@ -1883,7 +1863,7 @@ void OPPROTO op_fistl_ST0_A0(void)
int val; int val;
d = ST0; d = ST0;
val = lrint(d); val = floatx_to_int32(d, &env->fp_status);
stl(A0, val); stl(A0, val);
FORCE_RET(); FORCE_RET();
} }
@ -1898,7 +1878,7 @@ void OPPROTO op_fistll_ST0_A0(void)
int64_t val; int64_t val;
d = ST0; d = ST0;
val = llrint(d); val = floatx_to_int64(d, &env->fp_status);
stq(A0, val); stq(A0, val);
FORCE_RET(); FORCE_RET();
} }
@ -2101,12 +2081,12 @@ void OPPROTO op_fdivr_STN_ST0(void)
/* misc FPU operations */ /* misc FPU operations */
void OPPROTO op_fchs_ST0(void) void OPPROTO op_fchs_ST0(void)
{ {
ST0 = -ST0; ST0 = floatx_chs(ST0);
} }
void OPPROTO op_fabs_ST0(void) void OPPROTO op_fabs_ST0(void)
{ {
ST0 = fabs(ST0); ST0 = floatx_abs(ST0);
} }
void OPPROTO op_fxam_ST0(void) void OPPROTO op_fxam_ST0(void)
@ -2251,25 +2231,8 @@ void OPPROTO op_fnstcw_A0(void)
void OPPROTO op_fldcw_A0(void) void OPPROTO op_fldcw_A0(void)
{ {
int rnd_type;
env->fpuc = lduw(A0); env->fpuc = lduw(A0);
/* set rounding mode */ update_fp_status();
switch(env->fpuc & RC_MASK) {
default:
case RC_NEAR:
rnd_type = FE_TONEAREST;
break;
case RC_DOWN:
rnd_type = FE_DOWNWARD;
break;
case RC_UP:
rnd_type = FE_UPWARD;
break;
case RC_CHOP:
rnd_type = FE_TOWARDZERO;
break;
}
fesetround(rnd_type);
} }
void OPPROTO op_fclex(void) void OPPROTO op_fclex(void)

126
target-i386/ops_sse.h
View file

@ -654,10 +654,10 @@ void OPPROTO op_ ## name ## ps (void)\
Reg *d, *s;\ Reg *d, *s;\
d = (Reg *)((char *)env + PARAM1);\ d = (Reg *)((char *)env + PARAM1);\
s = (Reg *)((char *)env + PARAM2);\ s = (Reg *)((char *)env + PARAM2);\
d->XMM_S(0) = F(d->XMM_S(0), s->XMM_S(0));\ d->XMM_S(0) = F(32, d->XMM_S(0), s->XMM_S(0));\
d->XMM_S(1) = F(d->XMM_S(1), s->XMM_S(1));\ d->XMM_S(1) = F(32, d->XMM_S(1), s->XMM_S(1));\
d->XMM_S(2) = F(d->XMM_S(2), s->XMM_S(2));\ d->XMM_S(2) = F(32, d->XMM_S(2), s->XMM_S(2));\
d->XMM_S(3) = F(d->XMM_S(3), s->XMM_S(3));\ d->XMM_S(3) = F(32, d->XMM_S(3), s->XMM_S(3));\
}\ }\
\ \
void OPPROTO op_ ## name ## ss (void)\ void OPPROTO op_ ## name ## ss (void)\
@ -665,15 +665,15 @@ void OPPROTO op_ ## name ## ss (void)\
Reg *d, *s;\ Reg *d, *s;\
d = (Reg *)((char *)env + PARAM1);\ d = (Reg *)((char *)env + PARAM1);\
s = (Reg *)((char *)env + PARAM2);\ s = (Reg *)((char *)env + PARAM2);\
d->XMM_S(0) = F(d->XMM_S(0), s->XMM_S(0));\ d->XMM_S(0) = F(32, d->XMM_S(0), s->XMM_S(0));\
}\ }\
void OPPROTO op_ ## name ## pd (void)\ void OPPROTO op_ ## name ## pd (void)\
{\ {\
Reg *d, *s;\ Reg *d, *s;\
d = (Reg *)((char *)env + PARAM1);\ d = (Reg *)((char *)env + PARAM1);\
s = (Reg *)((char *)env + PARAM2);\ s = (Reg *)((char *)env + PARAM2);\
d->XMM_D(0) = F(d->XMM_D(0), s->XMM_D(0));\ d->XMM_D(0) = F(64, d->XMM_D(0), s->XMM_D(0));\
d->XMM_D(1) = F(d->XMM_D(1), s->XMM_D(1));\ d->XMM_D(1) = F(64, d->XMM_D(1), s->XMM_D(1));\
}\ }\
\ \
void OPPROTO op_ ## name ## sd (void)\ void OPPROTO op_ ## name ## sd (void)\
@ -681,16 +681,16 @@ void OPPROTO op_ ## name ## sd (void)\
Reg *d, *s;\ Reg *d, *s;\
d = (Reg *)((char *)env + PARAM1);\ d = (Reg *)((char *)env + PARAM1);\
s = (Reg *)((char *)env + PARAM2);\ s = (Reg *)((char *)env + PARAM2);\
d->XMM_D(0) = F(d->XMM_D(0), s->XMM_D(0));\ d->XMM_D(0) = F(64, d->XMM_D(0), s->XMM_D(0));\
} }
#define FPU_ADD(a, b) (a) + (b) #define FPU_ADD(size, a, b) float ## size ## _add(a, b, &env->sse_status)
#define FPU_SUB(a, b) (a) - (b) #define FPU_SUB(size, a, b) float ## size ## _sub(a, b, &env->sse_status)
#define FPU_MUL(a, b) (a) * (b) #define FPU_MUL(size, a, b) float ## size ## _mul(a, b, &env->sse_status)
#define FPU_DIV(a, b) (a) / (b) #define FPU_DIV(size, a, b) float ## size ## _div(a, b, &env->sse_status)
#define FPU_MIN(a, b) (a) < (b) ? (a) : (b) #define FPU_MIN(size, a, b) (a) < (b) ? (a) : (b)
#define FPU_MAX(a, b) (a) > (b) ? (a) : (b) #define FPU_MAX(size, a, b) (a) > (b) ? (a) : (b)
#define FPU_SQRT(a, b) helper_sqrt(b) #define FPU_SQRT(size, a, b) float ## size ## _sqrt(b, &env->sse_status)
SSE_OP_S(add, FPU_ADD) SSE_OP_S(add, FPU_ADD)
SSE_OP_S(sub, FPU_SUB) SSE_OP_S(sub, FPU_SUB)
@ -710,8 +710,8 @@ void OPPROTO op_cvtps2pd(void)
s = (Reg *)((char *)env + PARAM2); s = (Reg *)((char *)env + PARAM2);
s0 = s->XMM_S(0); s0 = s->XMM_S(0);
s1 = s->XMM_S(1); s1 = s->XMM_S(1);
d->XMM_D(0) = float32_to_float64(s0); d->XMM_D(0) = float32_to_float64(s0, &env->sse_status);
d->XMM_D(1) = float32_to_float64(s1); d->XMM_D(1) = float32_to_float64(s1, &env->sse_status);
} }
void OPPROTO op_cvtpd2ps(void) void OPPROTO op_cvtpd2ps(void)
@ -719,8 +719,8 @@ void OPPROTO op_cvtpd2ps(void)
Reg *d, *s; Reg *d, *s;
d = (Reg *)((char *)env + PARAM1); d = (Reg *)((char *)env + PARAM1);
s = (Reg *)((char *)env + PARAM2); s = (Reg *)((char *)env + PARAM2);
d->XMM_S(0) = float64_to_float32(s->XMM_D(0)); d->XMM_S(0) = float64_to_float32(s->XMM_D(0), &env->sse_status);
d->XMM_S(1) = float64_to_float32(s->XMM_D(1)); d->XMM_S(1) = float64_to_float32(s->XMM_D(1), &env->sse_status);
d->Q(1) = 0; d->Q(1) = 0;
} }
@ -729,7 +729,7 @@ void OPPROTO op_cvtss2sd(void)
Reg *d, *s; Reg *d, *s;
d = (Reg *)((char *)env + PARAM1); d = (Reg *)((char *)env + PARAM1);
s = (Reg *)((char *)env + PARAM2); s = (Reg *)((char *)env + PARAM2);
d->XMM_D(0) = float32_to_float64(s->XMM_S(0)); d->XMM_D(0) = float32_to_float64(s->XMM_S(0), &env->sse_status);
} }
void OPPROTO op_cvtsd2ss(void) void OPPROTO op_cvtsd2ss(void)
@ -737,7 +737,7 @@ void OPPROTO op_cvtsd2ss(void)
Reg *d, *s; Reg *d, *s;
d = (Reg *)((char *)env + PARAM1); d = (Reg *)((char *)env + PARAM1);
s = (Reg *)((char *)env + PARAM2); s = (Reg *)((char *)env + PARAM2);
d->XMM_S(0) = float64_to_float32(s->XMM_D(0)); d->XMM_S(0) = float64_to_float32(s->XMM_D(0), &env->sse_status);
} }
/* integer to float */ /* integer to float */
@ -745,10 +745,10 @@ void OPPROTO op_cvtdq2ps(void)
{ {
XMMReg *d = (XMMReg *)((char *)env + PARAM1); XMMReg *d = (XMMReg *)((char *)env + PARAM1);
XMMReg *s = (XMMReg *)((char *)env + PARAM2); XMMReg *s = (XMMReg *)((char *)env + PARAM2);
d->XMM_S(0) = int32_to_float32(s->XMM_L(0)); d->XMM_S(0) = int32_to_float32(s->XMM_L(0), &env->sse_status);
d->XMM_S(1) = int32_to_float32(s->XMM_L(1)); d->XMM_S(1) = int32_to_float32(s->XMM_L(1), &env->sse_status);
d->XMM_S(2) = int32_to_float32(s->XMM_L(2)); d->XMM_S(2) = int32_to_float32(s->XMM_L(2), &env->sse_status);
d->XMM_S(3) = int32_to_float32(s->XMM_L(3)); d->XMM_S(3) = int32_to_float32(s->XMM_L(3), &env->sse_status);
} }
void OPPROTO op_cvtdq2pd(void) void OPPROTO op_cvtdq2pd(void)
@ -758,49 +758,49 @@ void OPPROTO op_cvtdq2pd(void)
int32_t l0, l1; int32_t l0, l1;
l0 = (int32_t)s->XMM_L(0); l0 = (int32_t)s->XMM_L(0);
l1 = (int32_t)s->XMM_L(1); l1 = (int32_t)s->XMM_L(1);
d->XMM_D(0) = int32_to_float64(l0); d->XMM_D(0) = int32_to_float64(l0, &env->sse_status);
d->XMM_D(1) = int32_to_float64(l1); d->XMM_D(1) = int32_to_float64(l1, &env->sse_status);
} }
void OPPROTO op_cvtpi2ps(void) void OPPROTO op_cvtpi2ps(void)
{ {
XMMReg *d = (Reg *)((char *)env + PARAM1); XMMReg *d = (Reg *)((char *)env + PARAM1);
MMXReg *s = (MMXReg *)((char *)env + PARAM2); MMXReg *s = (MMXReg *)((char *)env + PARAM2);
d->XMM_S(0) = int32_to_float32(s->MMX_L(0)); d->XMM_S(0) = int32_to_float32(s->MMX_L(0), &env->sse_status);
d->XMM_S(1) = int32_to_float32(s->MMX_L(1)); d->XMM_S(1) = int32_to_float32(s->MMX_L(1), &env->sse_status);
} }
void OPPROTO op_cvtpi2pd(void) void OPPROTO op_cvtpi2pd(void)
{ {
XMMReg *d = (Reg *)((char *)env + PARAM1); XMMReg *d = (Reg *)((char *)env + PARAM1);
MMXReg *s = (MMXReg *)((char *)env + PARAM2); MMXReg *s = (MMXReg *)((char *)env + PARAM2);
d->XMM_D(0) = int32_to_float64(s->MMX_L(0)); d->XMM_D(0) = int32_to_float64(s->MMX_L(0), &env->sse_status);
d->XMM_D(1) = int32_to_float64(s->MMX_L(1)); d->XMM_D(1) = int32_to_float64(s->MMX_L(1), &env->sse_status);
} }
void OPPROTO op_cvtsi2ss(void) void OPPROTO op_cvtsi2ss(void)
{ {
XMMReg *d = (Reg *)((char *)env + PARAM1); XMMReg *d = (Reg *)((char *)env + PARAM1);
d->XMM_S(0) = int32_to_float32(T0); d->XMM_S(0) = int32_to_float32(T0, &env->sse_status);
} }
void OPPROTO op_cvtsi2sd(void) void OPPROTO op_cvtsi2sd(void)
{ {
XMMReg *d = (Reg *)((char *)env + PARAM1); XMMReg *d = (Reg *)((char *)env + PARAM1);
d->XMM_D(0) = int32_to_float64(T0); d->XMM_D(0) = int32_to_float64(T0, &env->sse_status);
} }
#ifdef TARGET_X86_64 #ifdef TARGET_X86_64
void OPPROTO op_cvtsq2ss(void) void OPPROTO op_cvtsq2ss(void)
{ {
XMMReg *d = (Reg *)((char *)env + PARAM1); XMMReg *d = (Reg *)((char *)env + PARAM1);
d->XMM_S(0) = int64_to_float32(T0); d->XMM_S(0) = int64_to_float32(T0, &env->sse_status);
} }
void OPPROTO op_cvtsq2sd(void) void OPPROTO op_cvtsq2sd(void)
{ {
XMMReg *d = (Reg *)((char *)env + PARAM1); XMMReg *d = (Reg *)((char *)env + PARAM1);
d->XMM_D(0) = int64_to_float64(T0); d->XMM_D(0) = int64_to_float64(T0, &env->sse_status);
} }
#endif #endif
@ -809,18 +809,18 @@ void OPPROTO op_cvtps2dq(void)
{ {
XMMReg *d = (XMMReg *)((char *)env + PARAM1); XMMReg *d = (XMMReg *)((char *)env + PARAM1);
XMMReg *s = (XMMReg *)((char *)env + PARAM2); XMMReg *s = (XMMReg *)((char *)env + PARAM2);
d->XMM_L(0) = lrint(s->XMM_S(0)); d->XMM_L(0) = float32_to_int32(s->XMM_S(0), &env->sse_status);
d->XMM_L(1) = lrint(s->XMM_S(1)); d->XMM_L(1) = float32_to_int32(s->XMM_S(1), &env->sse_status);
d->XMM_L(2) = lrint(s->XMM_S(2)); d->XMM_L(2) = float32_to_int32(s->XMM_S(2), &env->sse_status);
d->XMM_L(3) = lrint(s->XMM_S(3)); d->XMM_L(3) = float32_to_int32(s->XMM_S(3), &env->sse_status);
} }
void OPPROTO op_cvtpd2dq(void) void OPPROTO op_cvtpd2dq(void)
{ {
XMMReg *d = (XMMReg *)((char *)env + PARAM1); XMMReg *d = (XMMReg *)((char *)env + PARAM1);
XMMReg *s = (XMMReg *)((char *)env + PARAM2); XMMReg *s = (XMMReg *)((char *)env + PARAM2);
d->XMM_L(0) = lrint(s->XMM_D(0)); d->XMM_L(0) = float64_to_int32(s->XMM_D(0), &env->sse_status);
d->XMM_L(1) = lrint(s->XMM_D(1)); d->XMM_L(1) = float64_to_int32(s->XMM_D(1), &env->sse_status);
d->XMM_Q(1) = 0; d->XMM_Q(1) = 0;
} }
@ -828,41 +828,41 @@ void OPPROTO op_cvtps2pi(void)
{ {
MMXReg *d = (MMXReg *)((char *)env + PARAM1); MMXReg *d = (MMXReg *)((char *)env + PARAM1);
XMMReg *s = (XMMReg *)((char *)env + PARAM2); XMMReg *s = (XMMReg *)((char *)env + PARAM2);
d->MMX_L(0) = lrint(s->XMM_S(0)); d->MMX_L(0) = float32_to_int32(s->XMM_S(0), &env->sse_status);
d->MMX_L(1) = lrint(s->XMM_S(1)); d->MMX_L(1) = float32_to_int32(s->XMM_S(1), &env->sse_status);
} }
void OPPROTO op_cvtpd2pi(void) void OPPROTO op_cvtpd2pi(void)
{ {
MMXReg *d = (MMXReg *)((char *)env + PARAM1); MMXReg *d = (MMXReg *)((char *)env + PARAM1);
XMMReg *s = (XMMReg *)((char *)env + PARAM2); XMMReg *s = (XMMReg *)((char *)env + PARAM2);
d->MMX_L(0) = lrint(s->XMM_D(0)); d->MMX_L(0) = float64_to_int32(s->XMM_D(0), &env->sse_status);
d->MMX_L(1) = lrint(s->XMM_D(1)); d->MMX_L(1) = float64_to_int32(s->XMM_D(1), &env->sse_status);
} }
void OPPROTO op_cvtss2si(void) void OPPROTO op_cvtss2si(void)
{ {
XMMReg *s = (XMMReg *)((char *)env + PARAM1); XMMReg *s = (XMMReg *)((char *)env + PARAM1);
T0 = (int32_t)lrint(s->XMM_S(0)); T0 = float32_to_int32(s->XMM_S(0), &env->sse_status);
} }
void OPPROTO op_cvtsd2si(void) void OPPROTO op_cvtsd2si(void)
{ {
XMMReg *s = (XMMReg *)((char *)env + PARAM1); XMMReg *s = (XMMReg *)((char *)env + PARAM1);
T0 = (int32_t)lrint(s->XMM_D(0)); T0 = float64_to_int32(s->XMM_D(0), &env->sse_status);
} }
#ifdef TARGET_X86_64 #ifdef TARGET_X86_64
void OPPROTO op_cvtss2sq(void) void OPPROTO op_cvtss2sq(void)
{ {
XMMReg *s = (XMMReg *)((char *)env + PARAM1); XMMReg *s = (XMMReg *)((char *)env + PARAM1);
T0 = llrint(s->XMM_S(0)); T0 = float32_to_int64(s->XMM_S(0), &env->sse_status);
} }
void OPPROTO op_cvtsd2sq(void) void OPPROTO op_cvtsd2sq(void)
{ {
XMMReg *s = (XMMReg *)((char *)env + PARAM1); XMMReg *s = (XMMReg *)((char *)env + PARAM1);
T0 = llrint(s->XMM_D(0)); T0 = float64_to_int64(s->XMM_D(0), &env->sse_status);
} }
#endif #endif
@ -871,18 +871,18 @@ void OPPROTO op_cvttps2dq(void)
{ {
XMMReg *d = (XMMReg *)((char *)env + PARAM1); XMMReg *d = (XMMReg *)((char *)env + PARAM1);
XMMReg *s = (XMMReg *)((char *)env + PARAM2); XMMReg *s = (XMMReg *)((char *)env + PARAM2);
d->XMM_L(0) = (int32_t)s->XMM_S(0); d->XMM_L(0) = float32_to_int32_round_to_zero(s->XMM_S(0), &env->sse_status);
d->XMM_L(1) = (int32_t)s->XMM_S(1); d->XMM_L(1) = float32_to_int32_round_to_zero(s->XMM_S(1), &env->sse_status);
d->XMM_L(2) = (int32_t)s->XMM_S(2); d->XMM_L(2) = float32_to_int32_round_to_zero(s->XMM_S(2), &env->sse_status);
d->XMM_L(3) = (int32_t)s->XMM_S(3); d->XMM_L(3) = float32_to_int32_round_to_zero(s->XMM_S(3), &env->sse_status);
} }
void OPPROTO op_cvttpd2dq(void) void OPPROTO op_cvttpd2dq(void)
{ {
XMMReg *d = (XMMReg *)((char *)env + PARAM1); XMMReg *d = (XMMReg *)((char *)env + PARAM1);
XMMReg *s = (XMMReg *)((char *)env + PARAM2); XMMReg *s = (XMMReg *)((char *)env + PARAM2);
d->XMM_L(0) = (int32_t)s->XMM_D(0); d->XMM_L(0) = float64_to_int32_round_to_zero(s->XMM_D(0), &env->sse_status);
d->XMM_L(1) = (int32_t)s->XMM_D(1); d->XMM_L(1) = float64_to_int32_round_to_zero(s->XMM_D(1), &env->sse_status);
d->XMM_Q(1) = 0; d->XMM_Q(1) = 0;
} }
@ -890,41 +890,41 @@ void OPPROTO op_cvttps2pi(void)
{ {
MMXReg *d = (MMXReg *)((char *)env + PARAM1); MMXReg *d = (MMXReg *)((char *)env + PARAM1);
XMMReg *s = (XMMReg *)((char *)env + PARAM2); XMMReg *s = (XMMReg *)((char *)env + PARAM2);
d->MMX_L(0) = (int32_t)(s->XMM_S(0)); d->MMX_L(0) = float32_to_int32_round_to_zero(s->XMM_S(0), &env->sse_status);
d->MMX_L(1) = (int32_t)(s->XMM_S(1)); d->MMX_L(1) = float32_to_int32_round_to_zero(s->XMM_S(1), &env->sse_status);
} }
void OPPROTO op_cvttpd2pi(void) void OPPROTO op_cvttpd2pi(void)
{ {
MMXReg *d = (MMXReg *)((char *)env + PARAM1); MMXReg *d = (MMXReg *)((char *)env + PARAM1);
XMMReg *s = (XMMReg *)((char *)env + PARAM2); XMMReg *s = (XMMReg *)((char *)env + PARAM2);
d->MMX_L(0) = (int32_t)(s->XMM_D(0)); d->MMX_L(0) = float64_to_int32_round_to_zero(s->XMM_D(0), &env->sse_status);
d->MMX_L(1) = (int32_t)(s->XMM_D(1)); d->MMX_L(1) = float64_to_int32_round_to_zero(s->XMM_D(1), &env->sse_status);
} }
void OPPROTO op_cvttss2si(void) void OPPROTO op_cvttss2si(void)
{ {
XMMReg *s = (XMMReg *)((char *)env + PARAM1); XMMReg *s = (XMMReg *)((char *)env + PARAM1);
T0 = (int32_t)(s->XMM_S(0)); T0 = float32_to_int32_round_to_zero(s->XMM_S(0), &env->sse_status);
} }
void OPPROTO op_cvttsd2si(void) void OPPROTO op_cvttsd2si(void)
{ {
XMMReg *s = (XMMReg *)((char *)env + PARAM1); XMMReg *s = (XMMReg *)((char *)env + PARAM1);
T0 = (int32_t)(s->XMM_D(0)); T0 = float64_to_int32_round_to_zero(s->XMM_D(0), &env->sse_status);
} }
#ifdef TARGET_X86_64 #ifdef TARGET_X86_64
void OPPROTO op_cvttss2sq(void) void OPPROTO op_cvttss2sq(void)
{ {
XMMReg *s = (XMMReg *)((char *)env + PARAM1); XMMReg *s = (XMMReg *)((char *)env + PARAM1);
T0 = (int64_t)(s->XMM_S(0)); T0 = float32_to_int64_round_to_zero(s->XMM_S(0), &env->sse_status);
} }
void OPPROTO op_cvttsd2sq(void) void OPPROTO op_cvttsd2sq(void)
{ {
XMMReg *s = (XMMReg *)((char *)env + PARAM1); XMMReg *s = (XMMReg *)((char *)env + PARAM1);
T0 = (int64_t)(s->XMM_D(0)); T0 = float64_to_int64_round_to_zero(s->XMM_D(0), &env->sse_status);
} }
#endif #endif

3
target-sparc/cpu.h
View file

@ -15,6 +15,8 @@
#include "cpu-defs.h" #include "cpu-defs.h"
#include "softfloat.h"
/*#define EXCP_INTERRUPT 0x100*/ /*#define EXCP_INTERRUPT 0x100*/
/* trap definitions */ /* trap definitions */
@ -150,6 +152,7 @@ typedef struct CPUSPARCState {
/* temporary float registers */ /* temporary float registers */
float ft0, ft1, ft2; float ft0, ft1, ft2;
double dt0, dt1, dt2; double dt0, dt1, dt2;
float_status fp_status;
#if defined(TARGET_SPARC64) #if defined(TARGET_SPARC64)
target_ulong t0, t1, t2; target_ulong t0, t1, t2;
#endif #endif

18
target-sparc/op_helper.c
View file

@ -1,5 +1,3 @@
#include <math.h>
#include <fenv.h>
#include "exec.h" #include "exec.h"
//#define DEBUG_MMU //#define DEBUG_MMU
@ -24,17 +22,17 @@ void do_fitod(void)
void do_fabss(void) void do_fabss(void)
{ {
FT0 = fabsf(FT1); FT0 = float32_abs(FT1);
} }
void do_fsqrts(void) void do_fsqrts(void)
{ {
FT0 = sqrtf(FT1); FT0 = float32_sqrt(FT1, &env->fp_status);
} }
void do_fsqrtd(void) void do_fsqrtd(void)
{ {
DT0 = sqrt(DT1); DT0 = float64_sqrt(DT1, &env->fp_status);
} }
void do_fcmps (void) void do_fcmps (void)
@ -252,20 +250,22 @@ void helper_rett()
void helper_ldfsr(void) void helper_ldfsr(void)
{ {
int rnd_mode;
switch (env->fsr & FSR_RD_MASK) { switch (env->fsr & FSR_RD_MASK) {
case FSR_RD_NEAREST: case FSR_RD_NEAREST:
fesetround(FE_TONEAREST); rnd_mode = float_round_nearest_even;
break; break;
case FSR_RD_ZERO: case FSR_RD_ZERO:
fesetround(FE_TOWARDZERO); rnd_mode = float_round_to_zero;
break; break;
case FSR_RD_POS: case FSR_RD_POS:
fesetround(FE_UPWARD); rnd_mode = float_round_up;
break; break;
case FSR_RD_NEG: case FSR_RD_NEG:
fesetround(FE_DOWNWARD); rnd_mode = float_round_down;
break; break;
} }
set_float_rounding_mode(rnd_mode, &env->fp_status);
} }
void cpu_get_fp64(uint64_t *pmant, uint16_t *pexp, double f) void cpu_get_fp64(uint64_t *pmant, uint16_t *pexp, double f)

1
vl.c
View file

@ -2271,6 +2271,7 @@ int cpu_load(QEMUFile *f, void *opaque, int version_id)
} }
env->fpuc = fpuc; env->fpuc = fpuc;
/* XXX: restore FPU round state */
env->fpstt = (fpus >> 11) & 7; env->fpstt = (fpus >> 11) & 7;
env->fpus = fpus & ~0x3800; env->fpus = fpus & ~0x3800;
fptag ^= 0xff; fptag ^= 0xff;