mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix PowerPC FPSCR update and floating-point exception generation

Browse Source 
in most useful cases.


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3458 c046a42c-6fe2-441c-8c8c-71466251a162
This commit is contained in:
j_mayer 2007-10-27 17:54:30 +00:00
parent a32ff1ad95
commit 7c58044c0a
9 changed files with 1120 additions and 347 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
darwin-user/main.c
View File

@ -224,11 +224,6 @@ void cpu_loop(CPUPPCState *env)
case POWERPC_EXCP_FP: case POWERPC_EXCP_FP:
EXCP_DUMP(env, "Floating point program exception\n"); EXCP_DUMP(env, "Floating point program exception\n");
/* Set FX */ /* Set FX */
env->fpscr[7] |= 0x8;
/* Finally, update FEX */
if ((((env->fpscr[7] & 0x3) << 3) | (env->fpscr[6] >> 1)) &
((env->fpscr[1] << 1) | (env->fpscr[0] >> 3)))
env->fpscr[7] |= 0x4;
info.si_signo = SIGFPE; info.si_signo = SIGFPE;
info.si_errno = 0; info.si_errno = 0;
switch (env->error_code & 0xF) { switch (env->error_code & 0xF) {
@ -248,7 +243,7 @@ void cpu_loop(CPUPPCState *env)
case POWERPC_EXCP_FP_VXSOFT: case POWERPC_EXCP_FP_VXSOFT:
info.si_code = FPE_FLTINV; info.si_code = FPE_FLTINV;
break; break;
case POWERPC_EXCP_FP_VXNAN: case POWERPC_EXCP_FP_VXSNAN:
case POWERPC_EXCP_FP_VXISI: case POWERPC_EXCP_FP_VXISI:
case POWERPC_EXCP_FP_VXIDI: case POWERPC_EXCP_FP_VXIDI:
case POWERPC_EXCP_FP_VXIMZ: case POWERPC_EXCP_FP_VXIMZ:

8
linux-user/main.c
View File

@ -829,12 +829,6 @@ void cpu_loop(CPUPPCState *env)
switch (env->error_code & ~0xF) { switch (env->error_code & ~0xF) {
case POWERPC_EXCP_FP: case POWERPC_EXCP_FP:
EXCP_DUMP(env, "Floating point program exception\n"); EXCP_DUMP(env, "Floating point program exception\n");
/* Set FX */
env->fpscr[7] |= 0x8;
/* Finally, update FEX */
if ((((env->fpscr[7] & 0x3) << 3) | (env->fpscr[6] >> 1)) &
((env->fpscr[1] << 1) | (env->fpscr[0] >> 3)))
env->fpscr[7] |= 0x4;
info.si_signo = TARGET_SIGFPE; info.si_signo = TARGET_SIGFPE;
info.si_errno = 0; info.si_errno = 0;
switch (env->error_code & 0xF) { switch (env->error_code & 0xF) {
@ -854,7 +848,7 @@ void cpu_loop(CPUPPCState *env)
case POWERPC_EXCP_FP_VXSOFT: case POWERPC_EXCP_FP_VXSOFT:
info.si_code = TARGET_FPE_FLTINV; info.si_code = TARGET_FPE_FLTINV;
break; break;
case POWERPC_EXCP_FP_VXNAN: case POWERPC_EXCP_FP_VXSNAN:
case POWERPC_EXCP_FP_VXISI: case POWERPC_EXCP_FP_VXISI:
case POWERPC_EXCP_FP_VXIDI: case POWERPC_EXCP_FP_VXIDI:
case POWERPC_EXCP_FP_VXIMZ: case POWERPC_EXCP_FP_VXIMZ:

78
target-ppc/cpu.h
View File

@ -239,7 +239,7 @@ enum {
POWERPC_EXCP_FP_UX = 0x02, /* FP underflow */ POWERPC_EXCP_FP_UX = 0x02, /* FP underflow */
POWERPC_EXCP_FP_ZX = 0x03, /* FP divide by zero */ POWERPC_EXCP_FP_ZX = 0x03, /* FP divide by zero */
POWERPC_EXCP_FP_XX = 0x04, /* FP inexact */ POWERPC_EXCP_FP_XX = 0x04, /* FP inexact */
POWERPC_EXCP_FP_VXNAN = 0x05, /* FP invalid SNaN op */ POWERPC_EXCP_FP_VXSNAN = 0x05, /* FP invalid SNaN op */
POWERPC_EXCP_FP_VXISI = 0x06, /* FP invalid infinite subtraction */ POWERPC_EXCP_FP_VXISI = 0x06, /* FP invalid infinite subtraction */
POWERPC_EXCP_FP_VXIDI = 0x07, /* FP invalid infinite divide */ POWERPC_EXCP_FP_VXIDI = 0x07, /* FP invalid infinite divide */
POWERPC_EXCP_FP_VXZDZ = 0x08, /* FP invalid zero divide */ POWERPC_EXCP_FP_VXZDZ = 0x08, /* FP invalid zero divide */
@ -433,14 +433,84 @@ enum {
POWERPC_FLAG_PMM = 0x00000400, POWERPC_FLAG_PMM = 0x00000400,
}; };
/*****************************************************************************/
/* Floating point status and control register */
#define FPSCR_FX 31 /* Floating-point exception summary */
#define FPSCR_FEX 30 /* Floating-point enabled exception summary */
#define FPSCR_VX 29 /* Floating-point invalid operation exception summ. */
#define FPSCR_OX 28 /* Floating-point overflow exception */
#define FPSCR_UX 27 /* Floating-point underflow exception */
#define FPSCR_ZX 26 /* Floating-point zero divide exception */
#define FPSCR_XX 25 /* Floating-point inexact exception */
#define FPSCR_VXSNAN 24 /* Floating-point invalid operation exception (sNan) */
#define FPSCR_VXISI 23 /* Floating-point invalid operation exception (inf) */
#define FPSCR_VXIDI 22 /* Floating-point invalid operation exception (inf) */
#define FPSCR_VXZDZ 21 /* Floating-point invalid operation exception (zero) */
#define FPSCR_VXIMZ 20 /* Floating-point invalid operation exception (inf) */
#define FPSCR_VXVC 19 /* Floating-point invalid operation exception (comp) */
#define FPSCR_FR 18 /* Floating-point fraction rounded */
#define FPSCR_FI 17 /* Floating-point fraction inexact */
#define FPSCR_C 16 /* Floating-point result class descriptor */
#define FPSCR_FL 15 /* Floating-point less than or negative */
#define FPSCR_FG 14 /* Floating-point greater than or negative */
#define FPSCR_FE 13 /* Floating-point equal or zero */
#define FPSCR_FU 12 /* Floating-point unordered or NaN */
#define FPSCR_FPCC 12 /* Floating-point condition code */
#define FPSCR_FPRF 12 /* Floating-point result flags */
#define FPSCR_VXSOFT 10 /* Floating-point invalid operation exception (soft) */
#define FPSCR_VXSQRT 9 /* Floating-point invalid operation exception (sqrt) */
#define FPSCR_VXCVI 8 /* Floating-point invalid operation exception (int) */
#define FPSCR_VE 7 /* Floating-point invalid operation exception enable */
#define FPSCR_OE 6 /* Floating-point overflow exception enable */
#define FPSCR_UE 5 /* Floating-point undeflow exception enable */
#define FPSCR_ZE 4 /* Floating-point zero divide exception enable */
#define FPSCR_XE 3 /* Floating-point inexact exception enable */
#define FPSCR_NI 2 /* Floating-point non-IEEE mode */
#define FPSCR_RN1 1
#define FPSCR_RN 0 /* Floating-point rounding control */
#define fpscr_fex (((env->fpscr) >> FPSCR_FEX) & 0x1)
#define fpscr_vx (((env->fpscr) >> FPSCR_VX) & 0x1)
#define fpscr_ox (((env->fpscr) >> FPSCR_OX) & 0x1)
#define fpscr_ux (((env->fpscr) >> FPSCR_UX) & 0x1)
#define fpscr_zx (((env->fpscr) >> FPSCR_ZX) & 0x1)
#define fpscr_xx (((env->fpscr) >> FPSCR_XX) & 0x1)
#define fpscr_vxsnan (((env->fpscr) >> FPSCR_VXSNAN) & 0x1)
#define fpscr_vxisi (((env->fpscr) >> FPSCR_VXISI) & 0x1)
#define fpscr_vxidi (((env->fpscr) >> FPSCR_VXIDI) & 0x1)
#define fpscr_vxzdz (((env->fpscr) >> FPSCR_VXZDZ) & 0x1)
#define fpscr_vximz (((env->fpscr) >> FPSCR_VXIMZ) & 0x1)
#define fpscr_vxvc (((env->fpscr) >> FPSCR_VXVC) & 0x1)
#define fpscr_fpcc (((env->fpscr) >> FPSCR_FPCC) & 0xF)
#define fpscr_vxsoft (((env->fpscr) >> FPSCR_VXSOFT) & 0x1)
#define fpscr_vxsqrt (((env->fpscr) >> FPSCR_VXSQRT) & 0x1)
#define fpscr_vxcvi (((env->fpscr) >> FPSCR_VXCVI) & 0x1)
#define fpscr_ve (((env->fpscr) >> FPSCR_VE) & 0x1)
#define fpscr_oe (((env->fpscr) >> FPSCR_OE) & 0x1)
#define fpscr_ue (((env->fpscr) >> FPSCR_UE) & 0x1)
#define fpscr_ze (((env->fpscr) >> FPSCR_ZE) & 0x1)
#define fpscr_xe (((env->fpscr) >> FPSCR_XE) & 0x1)
#define fpscr_ni (((env->fpscr) >> FPSCR_NI) & 0x1)
#define fpscr_rn (((env->fpscr) >> FPSCR_RN) & 0x3)
/* Invalid operation exception summary */
#define fpscr_ix ((env->fpscr) & ((1 << FPSCR_VXSNAN) | (1 << FPSCR_VXISI) | \
(1 << FPSCR_VXIDI) | (1 << FPSCR_VXZDZ) | \
(1 << FPSCR_VXIMZ) | (1 << FPSCR_VXVC) | \
(1 << FPSCR_VXSOFT) | (1 << FPSCR_VXSQRT) | \
(1 << FPSCR_VXCVI)))
/* exception summary */
#define fpscr_ex (((env->fpscr) >> FPSCR_XX) & 0x1F)
/* enabled exception summary */
#define fpscr_eex (((env->fpscr) >> FPSCR_XX) & ((env->fpscr) >> FPSCR_XE) & \
0x1F)
/*****************************************************************************/
/* The whole PowerPC CPU context */
#if defined(TARGET_PPC64H) #if defined(TARGET_PPC64H)
#define NB_MMU_MODES 3 #define NB_MMU_MODES 3
#else #else
#define NB_MMU_MODES 2 #define NB_MMU_MODES 2
#endif #endif
/*****************************************************************************/
/* The whole PowerPC CPU context */
struct CPUPPCState { struct CPUPPCState {
/* First are the most commonly used resources /* First are the most commonly used resources
* during translated code execution * during translated code execution
@ -482,7 +552,7 @@ struct CPUPPCState {
/* floating point registers */ /* floating point registers */
float64 fpr[32]; float64 fpr[32];
/* floating point status and control register */ /* floating point status and control register */
uint8_t fpscr[8]; uint32_t fpscr;
CPU_COMMON CPU_COMMON

13
target-ppc/helper.c
View File

@ -2130,6 +2130,8 @@ static always_inline void powerpc_excp (CPUState *env,
fprintf(logfile, "Ignore floating point exception\n"); fprintf(logfile, "Ignore floating point exception\n");
} }
#endif #endif
env->exception_index = POWERPC_EXCP_NONE;
env->error_code = 0;
return; return;
} }
new_msr &= ~((target_ulong)1 << MSR_RI); new_msr &= ~((target_ulong)1 << MSR_RI);
@ -2138,12 +2140,6 @@ static always_inline void powerpc_excp (CPUState *env,
new_msr |= (target_ulong)1 << MSR_HV; new_msr |= (target_ulong)1 << MSR_HV;
#endif #endif
msr |= 0x00100000; msr |= 0x00100000;
/* Set FX */
env->fpscr[7] |= 0x8;
/* Finally, update FEX */
if ((((env->fpscr[7] & 0x3) << 3) | (env->fpscr[6] >> 1)) &
((env->fpscr[1] << 1) | (env->fpscr[0] >> 3)))
env->fpscr[7] |= 0x4;
if (msr_fe0 != msr_fe1) { if (msr_fe0 != msr_fe1) {
msr |= 0x00010000; msr |= 0x00010000;
goto store_current; goto store_current;
@ -2199,8 +2195,11 @@ static always_inline void powerpc_excp (CPUState *env,
/* XXX: To be removed */ /* XXX: To be removed */
if (env->gpr[3] == 0x113724fa && env->gpr[4] == 0x77810f9b && if (env->gpr[3] == 0x113724fa && env->gpr[4] == 0x77810f9b &&
env->osi_call) { env->osi_call) {
if (env->osi_call(env) != 0) if (env->osi_call(env) != 0) {
env->exception_index = POWERPC_EXCP_NONE;
env->error_code = 0;
return; return;
}
} }
if (loglevel & CPU_LOG_INT) { if (loglevel & CPU_LOG_INT) {
dump_syscall(env); dump_syscall(env);

130
target-ppc/op.c
View File

@ -135,13 +135,6 @@ void OPPROTO op_set_Rc0 (void)
RETURN(); RETURN();
} }
/* Set Rc1 (for floating point arithmetic) */
void OPPROTO op_set_Rc1 (void)
{
env->crf[1] = env->fpscr[7];
RETURN();
}
/* Constants load */ /* Constants load */
void OPPROTO op_reset_T0 (void) void OPPROTO op_reset_T0 (void)
{ {
@ -552,9 +545,102 @@ void OPPROTO op_store_dbatl (void)
#endif /* !defined(CONFIG_USER_ONLY) */ #endif /* !defined(CONFIG_USER_ONLY) */
/* FPSCR */ /* FPSCR */
void OPPROTO op_load_fpscr (void) #ifdef CONFIG_SOFTFLOAT
void OPPROTO op_reset_fpstatus (void)
{ {
do_load_fpscr(); env->fp_status.float_exception_flags = 0;
RETURN();
}
#endif
void OPPROTO op_compute_fprf (void)
{
do_compute_fprf(PARAM1);
RETURN();
}
#ifdef CONFIG_SOFTFLOAT
void OPPROTO op_float_check_status (void)
{
do_float_check_status();
RETURN();
}
#else
void OPPROTO op_float_check_status (void)
{
if (env->exception_index == POWERPC_EXCP_PROGRAM &&
(env->error_code & POWERPC_EXCP_FP)) {
/* Differred floating-point exception after target FPR update */
if (msr_fe0 != 0 || msr_fe1 != 0)
do_raise_exception_err(env->exception_index, env->error_code);
}
RETURN();
}
#endif
#if defined(WORDS_BIGENDIAN)
#define WORD0 0
#define WORD1 1
#else
#define WORD0 1
#define WORD1 0
#endif
void OPPROTO op_load_fpscr_FT0 (void)
{
/* The 32 MSB of the target fpr are undefined.
* They'll be zero...
*/
union {
float64 d;
struct {
uint32_t u[2];
} s;
} u;
u.s.u[WORD0] = 0;
u.s.u[WORD1] = env->fpscr;
FT0 = u.d;
RETURN();
}
void OPPROTO op_set_FT0 (void)
{
union {
float64 d;
struct {
uint32_t u[2];
} s;
} u;
u.s.u[WORD0] = 0;
u.s.u[WORD1] = PARAM1;
FT0 = u.d;
RETURN();
}
#undef WORD0
#undef WORD1
void OPPROTO op_load_fpscr_T0 (void)
{
T0 = (env->fpscr >> PARAM1) & 0xF;
RETURN();
}
void OPPROTO op_load_fpcc (void)
{
T0 = fpscr_fpcc;
RETURN();
}
void OPPROTO op_fpscr_resetbit (void)
{
env->fpscr &= PARAM1;
RETURN();
}
void OPPROTO op_fpscr_setbit (void)
{
do_fpscr_setbit(PARAM1);
RETURN(); RETURN();
} }
@ -564,12 +650,6 @@ void OPPROTO op_store_fpscr (void)
RETURN(); RETURN();
} }
void OPPROTO op_reset_scrfx (void)
{
env->fpscr[7] &= ~0x8;
RETURN();
}
/* crf operations */ /* crf operations */
void OPPROTO op_getbit_T0 (void) void OPPROTO op_getbit_T0 (void)
{ {
@ -1702,28 +1782,44 @@ void OPPROTO op_srli_T1_64 (void)
/* fadd - fadd. */ /* fadd - fadd. */
void OPPROTO op_fadd (void) void OPPROTO op_fadd (void)
{ {
#if USE_PRECISE_EMULATION
do_fadd();
#else
FT0 = float64_add(FT0, FT1, &env->fp_status); FT0 = float64_add(FT0, FT1, &env->fp_status);
#endif
RETURN(); RETURN();
} }
/* fsub - fsub. */ /* fsub - fsub. */
void OPPROTO op_fsub (void) void OPPROTO op_fsub (void)
{ {
#if USE_PRECISE_EMULATION
do_fsub();
#else
FT0 = float64_sub(FT0, FT1, &env->fp_status); FT0 = float64_sub(FT0, FT1, &env->fp_status);
#endif
RETURN(); RETURN();
} }
/* fmul - fmul. */ /* fmul - fmul. */
void OPPROTO op_fmul (void) void OPPROTO op_fmul (void)
{ {
#if USE_PRECISE_EMULATION
do_fmul();
#else
FT0 = float64_mul(FT0, FT1, &env->fp_status); FT0 = float64_mul(FT0, FT1, &env->fp_status);
#endif
RETURN(); RETURN();
} }
/* fdiv - fdiv. */ /* fdiv - fdiv. */
void OPPROTO op_fdiv (void) void OPPROTO op_fdiv (void)
{ {
#if USE_PRECISE_EMULATION
do_fdiv();
#else
FT0 = float64_div(FT0, FT1, &env->fp_status); FT0 = float64_div(FT0, FT1, &env->fp_status);
#endif
RETURN(); RETURN();
} }
@ -1805,7 +1901,11 @@ void OPPROTO op_fnmsub (void)
/* frsp - frsp. */ /* frsp - frsp. */
void OPPROTO op_frsp (void) void OPPROTO op_frsp (void)
{ {
#if USE_PRECISE_EMULATION
do_frsp();
#else
FT0 = float64_to_float32(FT0, &env->fp_status); FT0 = float64_to_float32(FT0, &env->fp_status);
#endif
RETURN(); RETURN();
} }

911
target-ppc/op_helper.c
View File

File diff suppressed because it is too large Load Diff

15
target-ppc/op_helper.h
View File

@ -60,7 +60,7 @@ void do_store_cr (uint32_t mask);
#if defined(TARGET_PPC64) #if defined(TARGET_PPC64)
void do_store_pri (int prio); void do_store_pri (int prio);
#endif #endif
void do_load_fpscr (void); void do_fpscr_setbit (int bit);
void do_store_fpscr (uint32_t mask); void do_store_fpscr (uint32_t mask);
target_ulong ppc_load_dump_spr (int sprn); target_ulong ppc_load_dump_spr (int sprn);
void ppc_store_dump_spr (int sprn, target_ulong val); void ppc_store_dump_spr (int sprn, target_ulong val);
@ -94,6 +94,16 @@ void do_popcntb_64 (void);
#endif #endif
/* Floating-point arithmetic helpers */ /* Floating-point arithmetic helpers */
void do_compute_fprf (int set_class);
#ifdef CONFIG_SOFTFLOAT
void do_float_check_status (void);
#endif
#if USE_PRECISE_EMULATION
void do_fadd (void);
void do_fsub (void);
void do_fmul (void);
void do_fdiv (void);
#endif
void do_fsqrt (void); void do_fsqrt (void);
void do_fre (void); void do_fre (void);
void do_fres (void); void do_fres (void);
@ -105,6 +115,9 @@ void do_fmsub (void);
#endif #endif
void do_fnmadd (void); void do_fnmadd (void);
void do_fnmsub (void); void do_fnmsub (void);
#if USE_PRECISE_EMULATION
void do_frsp (void);
#endif
void do_fctiw (void); void do_fctiw (void);
void do_fctiwz (void); void do_fctiwz (void);
#if defined(TARGET_PPC64) #if defined(TARGET_PPC64)

33
target-ppc/op_template.h
View File

@ -165,39 +165,6 @@ void OPPROTO glue(op_store_T1_crf_crf, REG) (void)
RETURN(); RETURN();
} }
/* Floating point condition and status register moves */
void OPPROTO glue(op_load_fpscr_T0_fpscr, REG) (void)
{
T0 = env->fpscr[REG];
RETURN();
}
#if REG == 0
void OPPROTO glue(op_store_T0_fpscr_fpscr, REG) (void)
{
env->fpscr[REG] = (env->fpscr[REG] & 0x9) | (T0 & ~0x9);
RETURN();
}
void OPPROTO glue(op_clear_fpscr_fpscr, REG) (void)
{
env->fpscr[REG] = (env->fpscr[REG] & 0x9);
RETURN();
}
#else
void OPPROTO glue(op_store_T0_fpscr_fpscr, REG) (void)
{
env->fpscr[REG] = T0;
RETURN();
}
void OPPROTO glue(op_clear_fpscr_fpscr, REG) (void)
{
env->fpscr[REG] = 0x0;
RETURN();
}
#endif
#endif /* REG <= 7 */ #endif /* REG <= 7 */
/* floating point registers moves */ /* floating point registers moves */

272
target-ppc/translate.c
View File

@ -32,6 +32,7 @@
//#define PPC_DEBUG_DISAS //#define PPC_DEBUG_DISAS
//#define DEBUG_MEMORY_ACCESSES //#define DEBUG_MEMORY_ACCESSES
//#define DO_PPC_STATISTICS //#define DO_PPC_STATISTICS
//#define OPTIMIZE_FPRF_UPDATE
/*****************************************************************************/ /*****************************************************************************/
/* Code translation helpers */ /* Code translation helpers */
@ -50,6 +51,10 @@ enum {
static uint16_t *gen_opc_ptr; static uint16_t *gen_opc_ptr;
static uint32_t *gen_opparam_ptr; static uint32_t *gen_opparam_ptr;
#if defined(OPTIMIZE_FPRF_UPDATE)
static uint16_t *gen_fprf_buf[OPC_BUF_SIZE];
static uint16_t **gen_fprf_ptr;
#endif
#include "gen-op.h" #include "gen-op.h"
@ -117,16 +122,6 @@ GEN8(gen_op_load_crf_T1, gen_op_load_crf_T1_crf);
GEN8(gen_op_store_T0_crf, gen_op_store_T0_crf_crf); GEN8(gen_op_store_T0_crf, gen_op_store_T0_crf_crf);
GEN8(gen_op_store_T1_crf, gen_op_store_T1_crf_crf); GEN8(gen_op_store_T1_crf, gen_op_store_T1_crf_crf);
/* Floating point condition and status register moves */
GEN8(gen_op_load_fpscr_T0, gen_op_load_fpscr_T0_fpscr);
GEN8(gen_op_store_T0_fpscr, gen_op_store_T0_fpscr_fpscr);
GEN8(gen_op_clear_fpscr, gen_op_clear_fpscr_fpscr);
static always_inline void gen_op_store_T0_fpscri (int n, uint8_t param)
{
gen_op_set_T0(param);
gen_op_store_T0_fpscr(n);
}
/* General purpose registers moves */ /* General purpose registers moves */
GEN32(gen_op_load_gpr_T0, gen_op_load_gpr_T0_gpr); GEN32(gen_op_load_gpr_T0, gen_op_load_gpr_T0_gpr);
GEN32(gen_op_load_gpr_T1, gen_op_load_gpr_T1_gpr); GEN32(gen_op_load_gpr_T1, gen_op_load_gpr_T1_gpr);
@ -199,6 +194,44 @@ static always_inline void gen_set_Rc0 (DisasContext *ctx)
gen_op_set_Rc0(); gen_op_set_Rc0();
} }
static always_inline void gen_reset_fpstatus (void)
{
#ifdef CONFIG_SOFTFLOAT
gen_op_reset_fpstatus();
#endif
}
static always_inline void gen_compute_fprf (int set_fprf, int set_rc)
{
if (set_fprf != 0) {
/* This case might be optimized later */
#if defined(OPTIMIZE_FPRF_UPDATE)
*gen_fprf_ptr++ = gen_opc_ptr;
#endif
gen_op_compute_fprf(1);
if (unlikely(set_rc))
gen_op_store_T0_crf(1);
gen_op_float_check_status();
} else if (unlikely(set_rc)) {
/* We always need to compute fpcc */
gen_op_compute_fprf(0);
gen_op_store_T0_crf(1);
if (set_fprf)
gen_op_float_check_status();
}
}
static always_inline void gen_optimize_fprf (void)
{
#if defined(OPTIMIZE_FPRF_UPDATE)
uint16_t **ptr;
for (ptr = gen_fprf_buf; ptr != (gen_fprf_ptr - 1); ptr++)
*ptr = INDEX_op_nop1;
gen_fprf_ptr = gen_fprf_buf;
#endif
}
static always_inline void gen_update_nip (DisasContext *ctx, target_ulong nip) static always_inline void gen_update_nip (DisasContext *ctx, target_ulong nip)
{ {
#if defined(TARGET_PPC64) #if defined(TARGET_PPC64)
@ -497,6 +530,8 @@ enum {
PPC_CACHE_DCBZ = 0x0000400000000000ULL, PPC_CACHE_DCBZ = 0x0000400000000000ULL,
/* dcbz instruction with tunable cache line size */ /* dcbz instruction with tunable cache line size */
PPC_CACHE_DCBZT = 0x0000800000000000ULL, PPC_CACHE_DCBZT = 0x0000800000000000ULL,
/* frsqrtes extension */
PPC_FLOAT_FRSQRTES = 0x0001000000000000ULL,
}; };
/*****************************************************************************/ /*****************************************************************************/
@ -1656,124 +1691,127 @@ __GEN_LOGICAL2(srd, 0x1B, 0x10, PPC_64B);
#endif #endif
/*** Floating-Point arithmetic ***/ /*** Floating-Point arithmetic ***/
#define _GEN_FLOAT_ACB(name, op, op1, op2, isfloat, type) \ #define _GEN_FLOAT_ACB(name, op, op1, op2, isfloat, set_fprf, type) \
GEN_HANDLER(f##name, op1, op2, 0xFF, 0x00000000, type) \ GEN_HANDLER(f##name, op1, op2, 0xFF, 0x00000000, type) \
{ \ { \
if (unlikely(!ctx->fpu_enabled)) { \ if (unlikely(!ctx->fpu_enabled)) { \
GEN_EXCP_NO_FP(ctx); \ GEN_EXCP_NO_FP(ctx); \
return; \ return; \
} \ } \
gen_op_reset_scrfx(); \
gen_op_load_fpr_FT0(rA(ctx->opcode)); \ gen_op_load_fpr_FT0(rA(ctx->opcode)); \
gen_op_load_fpr_FT1(rC(ctx->opcode)); \ gen_op_load_fpr_FT1(rC(ctx->opcode)); \
gen_op_load_fpr_FT2(rB(ctx->opcode)); \ gen_op_load_fpr_FT2(rB(ctx->opcode)); \
gen_reset_fpstatus(); \
gen_op_f##op(); \ gen_op_f##op(); \
if (isfloat) { \ if (isfloat) { \
gen_op_frsp(); \ gen_op_frsp(); \
} \ } \
gen_op_store_FT0_fpr(rD(ctx->opcode)); \ gen_op_store_FT0_fpr(rD(ctx->opcode)); \
if (unlikely(Rc(ctx->opcode) != 0)) \ gen_compute_fprf(set_fprf, Rc(ctx->opcode) != 0); \
gen_op_set_Rc1(); \
} }
#define GEN_FLOAT_ACB(name, op2, type) \ #define GEN_FLOAT_ACB(name, op2, set_fprf, type) \
_GEN_FLOAT_ACB(name, name, 0x3F, op2, 0, type); \ _GEN_FLOAT_ACB(name, name, 0x3F, op2, 0, set_fprf, type); \
_GEN_FLOAT_ACB(name##s, name, 0x3B, op2, 1, type); _GEN_FLOAT_ACB(name##s, name, 0x3B, op2, 1, set_fprf, type);
#define _GEN_FLOAT_AB(name, op, op1, op2, inval, isfloat) \ #define _GEN_FLOAT_AB(name, op, op1, op2, inval, isfloat, set_fprf, type) \
GEN_HANDLER(f##name, op1, op2, 0xFF, inval, PPC_FLOAT) \ GEN_HANDLER(f##name, op1, op2, 0xFF, inval, type) \
{ \ { \
if (unlikely(!ctx->fpu_enabled)) { \ if (unlikely(!ctx->fpu_enabled)) { \
GEN_EXCP_NO_FP(ctx); \ GEN_EXCP_NO_FP(ctx); \
return; \ return; \
} \ } \
gen_op_reset_scrfx(); \
gen_op_load_fpr_FT0(rA(ctx->opcode)); \ gen_op_load_fpr_FT0(rA(ctx->opcode)); \
gen_op_load_fpr_FT1(rB(ctx->opcode)); \ gen_op_load_fpr_FT1(rB(ctx->opcode)); \
gen_reset_fpstatus(); \
gen_op_f##op(); \ gen_op_f##op(); \
if (isfloat) { \ if (isfloat) { \
gen_op_frsp(); \ gen_op_frsp(); \
} \ } \
gen_op_store_FT0_fpr(rD(ctx->opcode)); \ gen_op_store_FT0_fpr(rD(ctx->opcode)); \
if (unlikely(Rc(ctx->opcode) != 0)) \ gen_compute_fprf(set_fprf, Rc(ctx->opcode) != 0); \
gen_op_set_Rc1(); \
} }
#define GEN_FLOAT_AB(name, op2, inval) \ #define GEN_FLOAT_AB(name, op2, inval, set_fprf, type) \
_GEN_FLOAT_AB(name, name, 0x3F, op2, inval, 0); \ _GEN_FLOAT_AB(name, name, 0x3F, op2, inval, 0, set_fprf, type); \
_GEN_FLOAT_AB(name##s, name, 0x3B, op2, inval, 1); _GEN_FLOAT_AB(name##s, name, 0x3B, op2, inval, 1, set_fprf, type);
#define _GEN_FLOAT_AC(name, op, op1, op2, inval, isfloat) \ #define _GEN_FLOAT_AC(name, op, op1, op2, inval, isfloat, set_fprf, type) \
GEN_HANDLER(f##name, op1, op2, 0xFF, inval, PPC_FLOAT) \ GEN_HANDLER(f##name, op1, op2, 0xFF, inval, type) \
{ \ { \
if (unlikely(!ctx->fpu_enabled)) { \ if (unlikely(!ctx->fpu_enabled)) { \
GEN_EXCP_NO_FP(ctx); \ GEN_EXCP_NO_FP(ctx); \
return; \ return; \
} \ } \
gen_op_reset_scrfx(); \
gen_op_load_fpr_FT0(rA(ctx->opcode)); \ gen_op_load_fpr_FT0(rA(ctx->opcode)); \
gen_op_load_fpr_FT1(rC(ctx->opcode)); \ gen_op_load_fpr_FT1(rC(ctx->opcode)); \
gen_reset_fpstatus(); \
gen_op_f##op(); \ gen_op_f##op(); \
if (isfloat) { \ if (isfloat) { \
gen_op_frsp(); \ gen_op_frsp(); \
} \ } \
gen_op_store_FT0_fpr(rD(ctx->opcode)); \ gen_op_store_FT0_fpr(rD(ctx->opcode)); \
if (unlikely(Rc(ctx->opcode) != 0)) \ gen_compute_fprf(set_fprf, Rc(ctx->opcode) != 0); \
gen_op_set_Rc1(); \
} }
#define GEN_FLOAT_AC(name, op2, inval) \ #define GEN_FLOAT_AC(name, op2, inval, set_fprf, type) \
_GEN_FLOAT_AC(name, name, 0x3F, op2, inval, 0); \ _GEN_FLOAT_AC(name, name, 0x3F, op2, inval, 0, set_fprf, type); \
_GEN_FLOAT_AC(name##s, name, 0x3B, op2, inval, 1); _GEN_FLOAT_AC(name##s, name, 0x3B, op2, inval, 1, set_fprf, type);
#define GEN_FLOAT_B(name, op2, op3, type) \ #define GEN_FLOAT_B(name, op2, op3, set_fprf, type) \
GEN_HANDLER(f##name, 0x3F, op2, op3, 0x001F0000, type) \ GEN_HANDLER(f##name, 0x3F, op2, op3, 0x001F0000, type) \
{ \ { \
if (unlikely(!ctx->fpu_enabled)) { \ if (unlikely(!ctx->fpu_enabled)) { \
GEN_EXCP_NO_FP(ctx); \ GEN_EXCP_NO_FP(ctx); \
return; \ return; \
} \ } \
gen_op_reset_scrfx(); \
gen_op_load_fpr_FT0(rB(ctx->opcode)); \ gen_op_load_fpr_FT0(rB(ctx->opcode)); \
gen_reset_fpstatus(); \
gen_op_f##name(); \ gen_op_f##name(); \
gen_op_store_FT0_fpr(rD(ctx->opcode)); \ gen_op_store_FT0_fpr(rD(ctx->opcode)); \
if (unlikely(Rc(ctx->opcode) != 0)) \ gen_compute_fprf(set_fprf, Rc(ctx->opcode) != 0); \
gen_op_set_Rc1(); \
} }
#define GEN_FLOAT_BS(name, op1, op2, type) \ #define GEN_FLOAT_BS(name, op1, op2, set_fprf, type) \
GEN_HANDLER(f##name, op1, op2, 0xFF, 0x001F07C0, type) \ GEN_HANDLER(f##name, op1, op2, 0xFF, 0x001F07C0, type) \
{ \ { \
if (unlikely(!ctx->fpu_enabled)) { \ if (unlikely(!ctx->fpu_enabled)) { \
GEN_EXCP_NO_FP(ctx); \ GEN_EXCP_NO_FP(ctx); \
return; \ return; \
} \ } \
gen_op_reset_scrfx(); \
gen_op_load_fpr_FT0(rB(ctx->opcode)); \ gen_op_load_fpr_FT0(rB(ctx->opcode)); \
gen_reset_fpstatus(); \
gen_op_f##name(); \ gen_op_f##name(); \
gen_op_store_FT0_fpr(rD(ctx->opcode)); \ gen_op_store_FT0_fpr(rD(ctx->opcode)); \
if (unlikely(Rc(ctx->opcode) != 0)) \ gen_compute_fprf(set_fprf, Rc(ctx->opcode) != 0); \
gen_op_set_Rc1(); \
} }
/* fadd - fadds */ /* fadd - fadds */
GEN_FLOAT_AB(add, 0x15, 0x000007C0); GEN_FLOAT_AB(add, 0x15, 0x000007C0, 1, PPC_FLOAT);
/* fdiv - fdivs */ /* fdiv - fdivs */
GEN_FLOAT_AB(div, 0x12, 0x000007C0); GEN_FLOAT_AB(div, 0x12, 0x000007C0, 1, PPC_FLOAT);
/* fmul - fmuls */ /* fmul - fmuls */
GEN_FLOAT_AC(mul, 0x19, 0x0000F800); GEN_FLOAT_AC(mul, 0x19, 0x0000F800, 1, PPC_FLOAT);
/* fre */ /* fre */
GEN_FLOAT_BS(re, 0x3F, 0x18, PPC_FLOAT_EXT); GEN_FLOAT_BS(re, 0x3F, 0x18, 1, PPC_FLOAT_EXT);
/* fres */ /* fres */
GEN_FLOAT_BS(res, 0x3B, 0x18, PPC_FLOAT_FRES); GEN_FLOAT_BS(res, 0x3B, 0x18, 1, PPC_FLOAT_FRES);
/* frsqrte */ /* frsqrte */
GEN_FLOAT_BS(rsqrte, 0x3F, 0x1A, PPC_FLOAT_FRSQRTE); GEN_FLOAT_BS(rsqrte, 0x3F, 0x1A, 1, PPC_FLOAT_FRSQRTE);
/* frsqrtes */
static always_inline void gen_op_frsqrtes (void)
{
gen_op_frsqrte();
gen_op_frsp();
}
GEN_FLOAT_BS(rsqrtes, 0x3F, 0x1A, 1, PPC_FLOAT_FRSQRTES);
/* fsel */ /* fsel */
_GEN_FLOAT_ACB(sel, sel, 0x3F, 0x17, 0, PPC_FLOAT_FSEL); _GEN_FLOAT_ACB(sel, sel, 0x3F, 0x17, 0, 0, PPC_FLOAT_FSEL);
/* fsub - fsubs */ /* fsub - fsubs */
GEN_FLOAT_AB(sub, 0x14, 0x000007C0); GEN_FLOAT_AB(sub, 0x14, 0x000007C0, 1, PPC_FLOAT);
/* Optional: */ /* Optional: */
/* fsqrt */ /* fsqrt */
GEN_HANDLER(fsqrt, 0x3F, 0x16, 0xFF, 0x001F07C0, PPC_FLOAT_FSQRT) GEN_HANDLER(fsqrt, 0x3F, 0x16, 0xFF, 0x001F07C0, PPC_FLOAT_FSQRT)
@ -1782,12 +1820,11 @@ GEN_HANDLER(fsqrt, 0x3F, 0x16, 0xFF, 0x001F07C0, PPC_FLOAT_FSQRT)
GEN_EXCP_NO_FP(ctx); GEN_EXCP_NO_FP(ctx);
return; return;
} }
gen_op_reset_scrfx();
gen_op_load_fpr_FT0(rB(ctx->opcode)); gen_op_load_fpr_FT0(rB(ctx->opcode));
gen_reset_fpstatus();
gen_op_fsqrt(); gen_op_fsqrt();
gen_op_store_FT0_fpr(rD(ctx->opcode)); gen_op_store_FT0_fpr(rD(ctx->opcode));
if (unlikely(Rc(ctx->opcode) != 0)) gen_compute_fprf(1, Rc(ctx->opcode) != 0);
gen_op_set_Rc1();
} }
GEN_HANDLER(fsqrts, 0x3B, 0x16, 0xFF, 0x001F07C0, PPC_FLOAT_FSQRT) GEN_HANDLER(fsqrts, 0x3B, 0x16, 0xFF, 0x001F07C0, PPC_FLOAT_FSQRT)
@ -1796,49 +1833,48 @@ GEN_HANDLER(fsqrts, 0x3B, 0x16, 0xFF, 0x001F07C0, PPC_FLOAT_FSQRT)
GEN_EXCP_NO_FP(ctx); GEN_EXCP_NO_FP(ctx);
return; return;
} }
gen_op_reset_scrfx();
gen_op_load_fpr_FT0(rB(ctx->opcode)); gen_op_load_fpr_FT0(rB(ctx->opcode));
gen_reset_fpstatus();
gen_op_fsqrt(); gen_op_fsqrt();
gen_op_frsp(); gen_op_frsp();
gen_op_store_FT0_fpr(rD(ctx->opcode)); gen_op_store_FT0_fpr(rD(ctx->opcode));
if (unlikely(Rc(ctx->opcode) != 0)) gen_compute_fprf(1, Rc(ctx->opcode) != 0);
gen_op_set_Rc1();
} }
/*** Floating-Point multiply-and-add ***/ /*** Floating-Point multiply-and-add ***/
/* fmadd - fmadds */ /* fmadd - fmadds */
GEN_FLOAT_ACB(madd, 0x1D, PPC_FLOAT); GEN_FLOAT_ACB(madd, 0x1D, 1, PPC_FLOAT);
/* fmsub - fmsubs */ /* fmsub - fmsubs */
GEN_FLOAT_ACB(msub, 0x1C, PPC_FLOAT); GEN_FLOAT_ACB(msub, 0x1C, 1, PPC_FLOAT);
/* fnmadd - fnmadds */ /* fnmadd - fnmadds */
GEN_FLOAT_ACB(nmadd, 0x1F, PPC_FLOAT); GEN_FLOAT_ACB(nmadd, 0x1F, 1, PPC_FLOAT);
/* fnmsub - fnmsubs */ /* fnmsub - fnmsubs */
GEN_FLOAT_ACB(nmsub, 0x1E, PPC_FLOAT); GEN_FLOAT_ACB(nmsub, 0x1E, 1, PPC_FLOAT);
/*** Floating-Point round & convert ***/ /*** Floating-Point round & convert ***/
/* fctiw */ /* fctiw */
GEN_FLOAT_B(ctiw, 0x0E, 0x00, PPC_FLOAT); GEN_FLOAT_B(ctiw, 0x0E, 0x00, 0, PPC_FLOAT);
/* fctiwz */ /* fctiwz */
GEN_FLOAT_B(ctiwz, 0x0F, 0x00, PPC_FLOAT); GEN_FLOAT_B(ctiwz, 0x0F, 0x00, 0, PPC_FLOAT);
/* frsp */ /* frsp */
GEN_FLOAT_B(rsp, 0x0C, 0x00, PPC_FLOAT); GEN_FLOAT_B(rsp, 0x0C, 0x00, 1, PPC_FLOAT);
#if defined(TARGET_PPC64) #if defined(TARGET_PPC64)
/* fcfid */ /* fcfid */
GEN_FLOAT_B(cfid, 0x0E, 0x1A, PPC_64B); GEN_FLOAT_B(cfid, 0x0E, 0x1A, 1, PPC_64B);
/* fctid */ /* fctid */
GEN_FLOAT_B(ctid, 0x0E, 0x19, PPC_64B); GEN_FLOAT_B(ctid, 0x0E, 0x19, 0, PPC_64B);
/* fctidz */ /* fctidz */
GEN_FLOAT_B(ctidz, 0x0F, 0x19, PPC_64B); GEN_FLOAT_B(ctidz, 0x0F, 0x19, 0, PPC_64B);
#endif #endif
/* frin */ /* frin */
GEN_FLOAT_B(rin, 0x08, 0x0C, PPC_FLOAT_EXT); GEN_FLOAT_B(rin, 0x08, 0x0C, 1, PPC_FLOAT_EXT);
/* friz */ /* friz */
GEN_FLOAT_B(riz, 0x08, 0x0D, PPC_FLOAT_EXT); GEN_FLOAT_B(riz, 0x08, 0x0D, 1, PPC_FLOAT_EXT);
/* frip */ /* frip */
GEN_FLOAT_B(rip, 0x08, 0x0E, PPC_FLOAT_EXT); GEN_FLOAT_B(rip, 0x08, 0x0E, 1, PPC_FLOAT_EXT);
/* frim */ /* frim */
GEN_FLOAT_B(rim, 0x08, 0x0F, PPC_FLOAT_EXT); GEN_FLOAT_B(rim, 0x08, 0x0F, 1, PPC_FLOAT_EXT);
/*** Floating-Point compare ***/ /*** Floating-Point compare ***/
/* fcmpo */ /* fcmpo */
@ -1848,11 +1884,12 @@ GEN_HANDLER(fcmpo, 0x3F, 0x00, 0x01, 0x00600001, PPC_FLOAT)
GEN_EXCP_NO_FP(ctx); GEN_EXCP_NO_FP(ctx);
return; return;
} }
gen_op_reset_scrfx();
gen_op_load_fpr_FT0(rA(ctx->opcode)); gen_op_load_fpr_FT0(rA(ctx->opcode));
gen_op_load_fpr_FT1(rB(ctx->opcode)); gen_op_load_fpr_FT1(rB(ctx->opcode));
gen_reset_fpstatus();
gen_op_fcmpo(); gen_op_fcmpo();
gen_op_store_T0_crf(crfD(ctx->opcode)); gen_op_store_T0_crf(crfD(ctx->opcode));
gen_op_float_check_status();
} }
/* fcmpu */ /* fcmpu */
@ -1862,47 +1899,54 @@ GEN_HANDLER(fcmpu, 0x3F, 0x00, 0x00, 0x00600001, PPC_FLOAT)
GEN_EXCP_NO_FP(ctx); GEN_EXCP_NO_FP(ctx);
return; return;
} }
gen_op_reset_scrfx();
gen_op_load_fpr_FT0(rA(ctx->opcode)); gen_op_load_fpr_FT0(rA(ctx->opcode));
gen_op_load_fpr_FT1(rB(ctx->opcode)); gen_op_load_fpr_FT1(rB(ctx->opcode));
gen_reset_fpstatus();
gen_op_fcmpu(); gen_op_fcmpu();
gen_op_store_T0_crf(crfD(ctx->opcode)); gen_op_store_T0_crf(crfD(ctx->opcode));
gen_op_float_check_status();
} }
/*** Floating-point move ***/ /*** Floating-point move ***/
/* fabs */ /* fabs */
GEN_FLOAT_B(abs, 0x08, 0x08, PPC_FLOAT); /* XXX: beware that fabs never checks for NaNs nor update FPSCR */
GEN_FLOAT_B(abs, 0x08, 0x08, 0, PPC_FLOAT);
/* fmr - fmr. */ /* fmr - fmr. */
/* XXX: beware that fmr never checks for NaNs nor update FPSCR */
GEN_HANDLER(fmr, 0x3F, 0x08, 0x02, 0x001F0000, PPC_FLOAT) GEN_HANDLER(fmr, 0x3F, 0x08, 0x02, 0x001F0000, PPC_FLOAT)
{ {
if (unlikely(!ctx->fpu_enabled)) { if (unlikely(!ctx->fpu_enabled)) {
GEN_EXCP_NO_FP(ctx); GEN_EXCP_NO_FP(ctx);
return; return;
} }
gen_op_reset_scrfx();
gen_op_load_fpr_FT0(rB(ctx->opcode)); gen_op_load_fpr_FT0(rB(ctx->opcode));
gen_op_store_FT0_fpr(rD(ctx->opcode)); gen_op_store_FT0_fpr(rD(ctx->opcode));
if (unlikely(Rc(ctx->opcode) != 0)) gen_compute_fprf(0, Rc(ctx->opcode) != 0);
gen_op_set_Rc1();
} }
/* fnabs */ /* fnabs */
GEN_FLOAT_B(nabs, 0x08, 0x04, PPC_FLOAT); /* XXX: beware that fnabs never checks for NaNs nor update FPSCR */
GEN_FLOAT_B(nabs, 0x08, 0x04, 0, PPC_FLOAT);
/* fneg */ /* fneg */
GEN_FLOAT_B(neg, 0x08, 0x01, PPC_FLOAT); /* XXX: beware that fneg never checks for NaNs nor update FPSCR */
GEN_FLOAT_B(neg, 0x08, 0x01, 0, PPC_FLOAT);
/*** Floating-Point status & ctrl register ***/ /*** Floating-Point status & ctrl register ***/
/* mcrfs */ /* mcrfs */
GEN_HANDLER(mcrfs, 0x3F, 0x00, 0x02, 0x0063F801, PPC_FLOAT) GEN_HANDLER(mcrfs, 0x3F, 0x00, 0x02, 0x0063F801, PPC_FLOAT)
{ {
int bfa;
if (unlikely(!ctx->fpu_enabled)) { if (unlikely(!ctx->fpu_enabled)) {
GEN_EXCP_NO_FP(ctx); GEN_EXCP_NO_FP(ctx);
return; return;
} }
gen_op_load_fpscr_T0(crfS(ctx->opcode)); gen_optimize_fprf();
bfa = 4 * (7 - crfS(ctx->opcode));
gen_op_load_fpscr_T0(bfa);
gen_op_store_T0_crf(crfD(ctx->opcode)); gen_op_store_T0_crf(crfD(ctx->opcode));
gen_op_clear_fpscr(crfS(ctx->opcode)); gen_op_fpscr_resetbit(~(0xF << bfa));
} }
/* mffs */ /* mffs */
@ -1912,10 +1956,11 @@ GEN_HANDLER(mffs, 0x3F, 0x07, 0x12, 0x001FF800, PPC_FLOAT)
GEN_EXCP_NO_FP(ctx); GEN_EXCP_NO_FP(ctx);
return; return;
} }
gen_op_load_fpscr(); gen_optimize_fprf();
gen_reset_fpstatus();
gen_op_load_fpscr_FT0();
gen_op_store_FT0_fpr(rD(ctx->opcode)); gen_op_store_FT0_fpr(rD(ctx->opcode));
if (unlikely(Rc(ctx->opcode) != 0)) gen_compute_fprf(0, Rc(ctx->opcode) != 0);
gen_op_set_Rc1();
} }
/* mtfsb0 */ /* mtfsb0 */
@ -1927,12 +1972,15 @@ GEN_HANDLER(mtfsb0, 0x3F, 0x06, 0x02, 0x001FF800, PPC_FLOAT)
GEN_EXCP_NO_FP(ctx); GEN_EXCP_NO_FP(ctx);
return; return;
} }
crb = crbD(ctx->opcode) >> 2; crb = 32 - (crbD(ctx->opcode) >> 2);
gen_op_load_fpscr_T0(crb); gen_optimize_fprf();
gen_op_andi_T0(~(1 << (crbD(ctx->opcode) & 0x03))); gen_reset_fpstatus();
gen_op_store_T0_fpscr(crb); if (likely(crb != 30 && crb != 29))
if (unlikely(Rc(ctx->opcode) != 0)) gen_op_fpscr_resetbit(~(1 << crb));
gen_op_set_Rc1(); if (unlikely(Rc(ctx->opcode) != 0)) {
gen_op_load_fpcc();
gen_op_set_Rc0();
}
} }
/* mtfsb1 */ /* mtfsb1 */
@ -1944,12 +1992,18 @@ GEN_HANDLER(mtfsb1, 0x3F, 0x06, 0x01, 0x001FF800, PPC_FLOAT)
GEN_EXCP_NO_FP(ctx); GEN_EXCP_NO_FP(ctx);
return; return;
} }
crb = crbD(ctx->opcode) >> 2; crb = 32 - (crbD(ctx->opcode) >> 2);
gen_op_load_fpscr_T0(crb); gen_optimize_fprf();
gen_op_ori(1 << (crbD(ctx->opcode) & 0x03)); gen_reset_fpstatus();
gen_op_store_T0_fpscr(crb); /* XXX: we pretend we can only do IEEE floating-point computations */
if (unlikely(Rc(ctx->opcode) != 0)) if (likely(crb != FPSCR_FEX && crb != FPSCR_VX && crb != FPSCR_NI))
gen_op_set_Rc1(); gen_op_fpscr_setbit(crb);
if (unlikely(Rc(ctx->opcode) != 0)) {
gen_op_load_fpcc();
gen_op_set_Rc0();
}
/* We can raise a differed exception */
gen_op_float_check_status();
} }
/* mtfsf */ /* mtfsf */
@ -1959,22 +2013,39 @@ GEN_HANDLER(mtfsf, 0x3F, 0x07, 0x16, 0x02010000, PPC_FLOAT)
GEN_EXCP_NO_FP(ctx); GEN_EXCP_NO_FP(ctx);
return; return;
} }
gen_optimize_fprf();
gen_op_load_fpr_FT0(rB(ctx->opcode)); gen_op_load_fpr_FT0(rB(ctx->opcode));
gen_reset_fpstatus();
gen_op_store_fpscr(FM(ctx->opcode)); gen_op_store_fpscr(FM(ctx->opcode));
if (unlikely(Rc(ctx->opcode) != 0)) if (unlikely(Rc(ctx->opcode) != 0)) {
gen_op_set_Rc1(); gen_op_load_fpcc();
gen_op_set_Rc0();
}
/* We can raise a differed exception */
gen_op_float_check_status();
} }
/* mtfsfi */ /* mtfsfi */
GEN_HANDLER(mtfsfi, 0x3F, 0x06, 0x04, 0x006f0800, PPC_FLOAT) GEN_HANDLER(mtfsfi, 0x3F, 0x06, 0x04, 0x006f0800, PPC_FLOAT)
{ {
int bf, sh;
if (unlikely(!ctx->fpu_enabled)) { if (unlikely(!ctx->fpu_enabled)) {
GEN_EXCP_NO_FP(ctx); GEN_EXCP_NO_FP(ctx);
return; return;
} }
gen_op_store_T0_fpscri(crbD(ctx->opcode) >> 2, FPIMM(ctx->opcode)); bf = crbD(ctx->opcode) >> 2;
if (unlikely(Rc(ctx->opcode) != 0)) sh = 7 - bf;
gen_op_set_Rc1(); gen_optimize_fprf();
gen_op_set_FT0(FPIMM(ctx->opcode) << (4 * sh));
gen_reset_fpstatus();
gen_op_store_fpscr(1 << sh);
if (unlikely(Rc(ctx->opcode) != 0)) {
gen_op_load_fpcc();
gen_op_set_Rc0();
}
/* We can raise a differed exception */
gen_op_float_check_status();
} }
/*** Addressing modes ***/ /*** Addressing modes ***/
@ -6717,6 +6788,9 @@ static always_inline int gen_intermediate_code_internal (CPUState *env,
gen_opc_ptr = gen_opc_buf; gen_opc_ptr = gen_opc_buf;
gen_opc_end = gen_opc_buf + OPC_MAX_SIZE; gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
gen_opparam_ptr = gen_opparam_buf; gen_opparam_ptr = gen_opparam_buf;
#if defined(OPTIMIZE_FPRF_UPDATE)
gen_fprf_ptr = gen_fprf_buf;
#endif
nb_gen_labels = 0; nb_gen_labels = 0;
ctx.nip = pc_start; ctx.nip = pc_start;
ctx.tb = tb; ctx.tb = tb;