ShuriZma
/
xqemu
mirror of https://github.com/xqemu/xqemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

CRIS: More TCG conversion. 

* Convert moves to/from support function regs (including TLB updates) to TCG.
* SCC no longer requires T0 to strictly be 0 or 1, relaxed to 0 or non-zero.
* Convert the the condition code evaluation to TCG.
* Convert rfe into a helper and TCG.
* Convert evaluate_bcc and setf to TCG.
* Convert clrf to TCG.
* Convert CRIS exception raising to TCG.
* Convert btst to TCG.


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@4376 c046a42c-6fe2-441c-8c8c-71466251a162
This commit is contained in:
edgar_igl 2008-05-07 15:24:53 +00:00
parent 069de56277
commit dceaf39458
5 changed files with 332 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
target-cris/helper.h
View File

@ -1,11 +1,15 @@
#define TCG_HELPER_PROTO #define TCG_HELPER_PROTO
void TCG_HELPER_PROTO helper_tlb_update(uint32_t T0);
void TCG_HELPER_PROTO helper_raise_exception(uint32_t index);
void TCG_HELPER_PROTO helper_tlb_flush(void); void TCG_HELPER_PROTO helper_tlb_flush(void);
void TCG_HELPER_PROTO helper_dump(uint32_t a0, uint32_t a1, uint32_t a2); void TCG_HELPER_PROTO helper_dump(uint32_t a0, uint32_t a1, uint32_t a2);
void TCG_HELPER_PROTO helper_dummy(void); void TCG_HELPER_PROTO helper_dummy(void);
void TCG_HELPER_PROTO helper_rfe(void); void TCG_HELPER_PROTO helper_rfe(void);
void TCG_HELPER_PROTO helper_store(uint32_t a0); void TCG_HELPER_PROTO helper_store(uint32_t a0);
void TCG_HELPER_PROTO helper_movl_sreg_reg (uint32_t sreg, uint32_t reg);
void TCG_HELPER_PROTO helper_movl_reg_sreg (uint32_t reg, uint32_t sreg);
void TCG_HELPER_PROTO helper_evaluate_flags_muls(void); void TCG_HELPER_PROTO helper_evaluate_flags_muls(void);
void TCG_HELPER_PROTO helper_evaluate_flags_mulu(void); void TCG_HELPER_PROTO helper_evaluate_flags_mulu(void);
void TCG_HELPER_PROTO helper_evaluate_flags_mcp(void); void TCG_HELPER_PROTO helper_evaluate_flags_mcp(void);

2
target-cris/mmu.c
View File

@ -265,7 +265,7 @@ static int cris_mmu_translate_page(struct cris_mmu_result_t *res,
} }
/* Give us the vaddr corresponding to the latest TLB update. */ /* Give us the vaddr corresponding to the latest TLB update. */
target_ulong cris_mmu_tlb_latest_update(CPUState *env, uint32_t new_lo) target_ulong cris_mmu_tlb_latest_update(CPUState *env)
{ {
uint32_t sel = env->sregs[SFR_RW_MM_TLB_SEL]; uint32_t sel = env->sregs[SFR_RW_MM_TLB_SEL];
uint32_t vaddr; uint32_t vaddr;

2
target-cris/mmu.h
View File

@ -11,7 +11,7 @@ struct cris_mmu_result_t
int bf_vec; int bf_vec;
}; };
target_ulong cris_mmu_tlb_latest_update(CPUState *env, uint32_t new_lo); target_ulong cris_mmu_tlb_latest_update(CPUState *env);
int cris_mmu_translate(struct cris_mmu_result_t *res, int cris_mmu_translate(struct cris_mmu_result_t *res,
CPUState *env, uint32_t vaddr, CPUState *env, uint32_t vaddr,
int rw, int mmu_idx); int rw, int mmu_idx);

138
target-cris/op_helper.c
View File

@ -79,20 +79,10 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
env = saved_env; env = saved_env;
} }
void helper_tlb_update(uint32_t T0) void helper_raise_exception(uint32_t index)
{ {
#if !defined(CONFIG_USER_ONLY) env->exception_index = index;
uint32_t vaddr; cpu_loop_exit();
uint32_t srs = env->pregs[PR_SRS];
if (srs != 1 && srs != 2)
return;
vaddr = cris_mmu_tlb_latest_update(env, T0);
D(fprintf(logfile, "flush old_vaddr=%x vaddr=%x T0=%x\n", vaddr,
env->sregs[SFR_R_MM_CAUSE] & TARGET_PAGE_MASK, T0));
tlb_flush_page(env, vaddr);
#endif
} }
void helper_tlb_flush(void) void helper_tlb_flush(void)
@ -110,13 +100,105 @@ void helper_dummy(void)
} }
/* Only used for debugging at the moment. */ void helper_movl_sreg_reg (uint32_t sreg, uint32_t reg)
{
uint32_t srs;
srs = env->pregs[PR_SRS];
srs &= 3;
env->sregs[srs][sreg] = env->regs[reg];
#if !defined(CONFIG_USER_ONLY)
if (srs == 1 || srs == 2) {
if (sreg == 6) {
/* Writes to tlb-hi write to mm_cause as a side
effect. */
env->sregs[SFR_RW_MM_TLB_HI] = T0;
env->sregs[SFR_R_MM_CAUSE] = T0;
}
else if (sreg == 5) {
uint32_t set;
uint32_t idx;
uint32_t lo, hi;
uint32_t vaddr;
vaddr = cris_mmu_tlb_latest_update(env);
D(fprintf(logfile, "tlb flush vaddr=%x\n", vaddr));
tlb_flush_page(env, vaddr);
idx = set = env->sregs[SFR_RW_MM_TLB_SEL];
set >>= 4;
set &= 3;
idx &= 15;
/* We've just made a write to tlb_lo. */
lo = env->sregs[SFR_RW_MM_TLB_LO];
/* Writes are done via r_mm_cause. */
hi = env->sregs[SFR_R_MM_CAUSE];
env->tlbsets[srs - 1][set][idx].lo = lo;
env->tlbsets[srs - 1][set][idx].hi = hi;
}
}
#endif
}
void helper_movl_reg_sreg (uint32_t reg, uint32_t sreg)
{
uint32_t srs;
env->pregs[PR_SRS] &= 3;
srs = env->pregs[PR_SRS];
#if !defined(CONFIG_USER_ONLY)
if (srs == 1 || srs == 2)
{
uint32_t set;
uint32_t idx;
uint32_t lo, hi;
idx = set = env->sregs[SFR_RW_MM_TLB_SEL];
set >>= 4;
set &= 3;
idx &= 15;
/* Update the mirror regs. */
hi = env->tlbsets[srs - 1][set][idx].hi;
lo = env->tlbsets[srs - 1][set][idx].lo;
env->sregs[SFR_RW_MM_TLB_HI] = hi;
env->sregs[SFR_RW_MM_TLB_LO] = lo;
}
#endif
env->regs[reg] = env->sregs[srs][sreg];
RETURN();
}
static void cris_ccs_rshift(CPUState *env)
{
uint32_t ccs;
/* Apply the ccs shift. */
ccs = env->pregs[PR_CCS];
ccs = (ccs & 0xc0000000) | ((ccs & 0x0fffffff) >> 10);
if (ccs & U_FLAG)
{
/* Enter user mode. */
env->ksp = env->regs[R_SP];
env->regs[R_SP] = env->pregs[PR_USP];
}
env->pregs[PR_CCS] = ccs;
}
void helper_rfe(void) void helper_rfe(void)
{ {
D(fprintf(logfile, "rfe: erp=%x pid=%x ccs=%x btarget=%x\n", D(fprintf(logfile, "rfe: erp=%x pid=%x ccs=%x btarget=%x\n",
env->pregs[PR_ERP], env->pregs[PR_PID], env->pregs[PR_ERP], env->pregs[PR_PID],
env->pregs[PR_CCS], env->pregs[PR_CCS],
env->btarget)); env->btarget));
cris_ccs_rshift(env);
/* RFE sets the P_FLAG only if the R_FLAG is not set. */
if (!(env->pregs[PR_CCS] & R_FLAG))
env->pregs[PR_CCS] |= P_FLAG;
} }
void helper_store(uint32_t a0) void helper_store(uint32_t a0)
@ -155,7 +237,6 @@ static void evaluate_flags_writeback(uint32_t flags)
env->pregs[PR_CCS] &= ~(env->cc_mask | X_FLAG); env->pregs[PR_CCS] &= ~(env->cc_mask | X_FLAG);
flags &= env->cc_mask; flags &= env->cc_mask;
env->pregs[PR_CCS] |= flags; env->pregs[PR_CCS] |= flags;
RETURN();
} }
void helper_evaluate_flags_muls(void) void helper_evaluate_flags_muls(void)
@ -164,8 +245,7 @@ void helper_evaluate_flags_muls(void)
uint32_t dst; uint32_t dst;
uint32_t res; uint32_t res;
uint32_t flags = 0; uint32_t flags = 0;
/* were gonna have to redo the muls. */ int64_t tmp;
int64_t tmp, t0 ,t1;
int32_t mof; int32_t mof;
int dneg; int dneg;
@ -173,14 +253,12 @@ void helper_evaluate_flags_muls(void)
dst = env->cc_dest; dst = env->cc_dest;
res = env->cc_result; res = env->cc_result;
/* cast into signed values to make GCC sign extend. */
t0 = (int32_t)src;
t1 = (int32_t)dst;
dneg = ((int32_t)res) < 0; dneg = ((int32_t)res) < 0;
tmp = t0 * t1; mof = env->pregs[PR_MOF];
mof = tmp >> 32; tmp = mof;
tmp <<= 32;
tmp |= res;
if (tmp == 0) if (tmp == 0)
flags |= Z_FLAG; flags |= Z_FLAG;
else if (tmp < 0) else if (tmp < 0)
@ -197,21 +275,17 @@ void helper_evaluate_flags_mulu(void)
uint32_t dst; uint32_t dst;
uint32_t res; uint32_t res;
uint32_t flags = 0; uint32_t flags = 0;
/* were gonna have to redo the muls. */ uint64_t tmp;
uint64_t tmp, t0 ,t1;
uint32_t mof; uint32_t mof;
src = env->cc_src; src = env->cc_src;
dst = env->cc_dest; dst = env->cc_dest;
res = env->cc_result; res = env->cc_result;
mof = env->pregs[PR_MOF];
/* cast into signed values to make GCC sign extend. */ tmp = mof;
t0 = src; tmp <<= 32;
t1 = dst; tmp |= res;
tmp = t0 * t1;
mof = tmp >> 32;
if (tmp == 0) if (tmp == 0)
flags |= Z_FLAG; flags |= Z_FLAG;
else if (tmp >> 63) else if (tmp >> 63)

287
target-cris/translate.c
View File

@ -223,9 +223,9 @@ static inline void t_gen_mov_preg_TN(int r, TCGv tn)
} }
} }
static inline void t_gen_mov_TN_im(TCGv tn, int32_t val) static inline void t_gen_raise_exception(uint32_t index)
{ {
tcg_gen_movi_tl(tn, val); tcg_gen_helper_0_1(helper_raise_exception, tcg_const_tl(index));
} }
static void t_gen_lsl(TCGv d, TCGv a, TCGv b) static void t_gen_lsl(TCGv d, TCGv a, TCGv b)
@ -375,6 +375,62 @@ static void t_gen_lz_i32(TCGv d, TCGv x)
tcg_gen_discard_i32(n); tcg_gen_discard_i32(n);
} }
static void t_gen_btst(TCGv d, TCGv s)
{
TCGv sbit;
TCGv bset;
int l1;
/* des ref:
The N flag is set according to the selected bit in the dest reg.
The Z flag is set if the selected bit and all bits to the right are
zero.
The X flag is cleared.
Other flags are left untouched.
The destination reg is not affected.
unsigned int fz, sbit, bset, mask, masked_t0;
sbit = T1 & 31;
bset = !!(T0 & (1 << sbit));
mask = sbit == 31 ? -1 : (1 << (sbit + 1)) - 1;
masked_t0 = T0 & mask;
fz = !(masked_t0 | bset);
// Clear the X, N and Z flags.
T0 = env->pregs[PR_CCS] & ~(X_FLAG | N_FLAG | Z_FLAG);
// Set the N and Z flags accordingly.
T0 |= (bset << 3) | (fz << 2);
*/
l1 = gen_new_label();
sbit = tcg_temp_new(TCG_TYPE_TL);
bset = tcg_temp_new(TCG_TYPE_TL);
/* Compute bset and sbit. */
tcg_gen_andi_tl(sbit, s, 31);
tcg_gen_shl_tl(s, tcg_const_tl(1), sbit);
tcg_gen_and_tl(bset, d, s);
tcg_gen_shr_tl(bset, bset, sbit);
/* Displace to N_FLAG. */
tcg_gen_shli_tl(bset, bset, 3);
tcg_gen_shl_tl(sbit, tcg_const_tl(2), sbit);
tcg_gen_subi_tl(sbit, sbit, 1);
tcg_gen_and_tl(sbit, d, sbit);
tcg_gen_andi_tl(d, cpu_PR[PR_CCS], ~(X_FLAG | N_FLAG | Z_FLAG));
/* or in the N_FLAG. */
tcg_gen_or_tl(d, d, bset);
tcg_gen_brcond_tl(TCG_COND_NE, sbit, tcg_const_tl(0), l1);
/* or in the Z_FLAG. */
tcg_gen_ori_tl(d, d, Z_FLAG);
gen_set_label(l1);
tcg_gen_discard_tl(sbit);
tcg_gen_discard_tl(bset);
}
static void t_gen_cris_dstep(TCGv d, TCGv s) static void t_gen_cris_dstep(TCGv d, TCGv s)
{ {
int l1; int l1;
@ -738,7 +794,7 @@ static void crisv32_alu_op(DisasContext *dc, int op, int rd, int size)
t_gen_lz_i32(cpu_T[0], cpu_T[1]); t_gen_lz_i32(cpu_T[0], cpu_T[1]);
break; break;
case CC_OP_BTST: case CC_OP_BTST:
gen_op_btst_T0_T1(); t_gen_btst(cpu_T[0], cpu_T[1]);
writeback = 0; writeback = 0;
break; break;
case CC_OP_MULS: case CC_OP_MULS:
@ -846,83 +902,172 @@ static void gen_tst_cc (DisasContext *dc, int cond)
int arith_opt; int arith_opt;
/* TODO: optimize more condition codes. */ /* TODO: optimize more condition codes. */
/*
* If the flags are live, we've gotta look into the bits of CCS.
* Otherwise, if we just did an arithmetic operation we try to
* evaluate the condition code faster.
*
* When this function is done, T0 should be non-zero if the condition
* code is true.
*/
arith_opt = arith_cc(dc) && !dc->flags_live; arith_opt = arith_cc(dc) && !dc->flags_live;
switch (cond) { switch (cond) {
case CC_EQ: case CC_EQ:
if (arith_opt) if (arith_opt) {
gen_op_tst_cc_eq_fast (); /* If cc_result is zero, T0 should be
non-zero otherwise T0 should be zero. */
int l1;
l1 = gen_new_label();
tcg_gen_movi_tl(cpu_T[0], 0);
tcg_gen_brcond_tl(TCG_COND_NE, cc_result,
tcg_const_tl(0), l1);
tcg_gen_movi_tl(cpu_T[0], 1);
gen_set_label(l1);
}
else { else {
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_eq (); tcg_gen_andi_tl(cpu_T[0],
cpu_PR[PR_CCS], Z_FLAG);
} }
break; break;
case CC_NE: case CC_NE:
if (arith_opt) if (arith_opt)
gen_op_tst_cc_ne_fast (); tcg_gen_mov_tl(cpu_T[0], cc_result);
else { else {
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_ne (); tcg_gen_xori_tl(cpu_T[0], cpu_PR[PR_CCS],
Z_FLAG);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], Z_FLAG);
} }
break; break;
case CC_CS: case CC_CS:
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_cs (); tcg_gen_andi_tl(cpu_T[0], cpu_PR[PR_CCS], C_FLAG);
break; break;
case CC_CC: case CC_CC:
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_cc (); tcg_gen_xori_tl(cpu_T[0], cpu_PR[PR_CCS],
C_FLAG);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], C_FLAG);
break; break;
case CC_VS: case CC_VS:
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_vs (); tcg_gen_andi_tl(cpu_T[0], cpu_PR[PR_CCS], V_FLAG);
break; break;
case CC_VC: case CC_VC:
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_vc (); tcg_gen_xori_tl(cpu_T[0], cpu_PR[PR_CCS],
V_FLAG);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], V_FLAG);
break; break;
case CC_PL: case CC_PL:
if (arith_opt) if (arith_opt)
gen_op_tst_cc_pl_fast (); tcg_gen_shli_tl(cpu_T[0], cc_result, 31);
else { else {
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_pl (); tcg_gen_xori_tl(cpu_T[0], cpu_PR[PR_CCS],
N_FLAG);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], N_FLAG);
} }
break; break;
case CC_MI: case CC_MI:
if (arith_opt) if (arith_opt) {
gen_op_tst_cc_mi_fast (); tcg_gen_shli_tl(cpu_T[0], cc_result, 31);
tcg_gen_xori_tl(cpu_T[0], cpu_T[0], 1);
}
else { else {
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_mi (); tcg_gen_andi_tl(cpu_T[0], cpu_PR[PR_CCS],
N_FLAG);
} }
break; break;
case CC_LS: case CC_LS:
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_ls (); tcg_gen_andi_tl(cpu_T[0], cpu_PR[PR_CCS],
C_FLAG | Z_FLAG);
break; break;
case CC_HI: case CC_HI:
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_hi (); {
TCGv tmp;
tmp = tcg_temp_new(TCG_TYPE_TL);
tcg_gen_xori_tl(tmp, cpu_PR[PR_CCS],
C_FLAG | Z_FLAG);
/* Overlay the C flag on top of the Z. */
tcg_gen_shli_tl(cpu_T[0], tmp, 2);
tcg_gen_and_tl(cpu_T[0], tmp, cpu_T[0]);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], Z_FLAG);
tcg_gen_discard_tl(tmp);
}
break; break;
case CC_GE: case CC_GE:
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_ge (); /* Overlay the V flag on top of the N. */
tcg_gen_shli_tl(cpu_T[0], cpu_PR[PR_CCS], 2);
tcg_gen_xor_tl(cpu_T[0],
cpu_PR[PR_CCS], cpu_T[0]);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], N_FLAG);
tcg_gen_xori_tl(cpu_T[0], cpu_T[0], N_FLAG);
break; break;
case CC_LT: case CC_LT:
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_lt (); /* Overlay the V flag on top of the N. */
tcg_gen_shli_tl(cpu_T[0], cpu_PR[PR_CCS], 2);
tcg_gen_xor_tl(cpu_T[0],
cpu_PR[PR_CCS], cpu_T[0]);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], N_FLAG);
break; break;
case CC_GT: case CC_GT:
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_gt (); {
TCGv n, z;
n = tcg_temp_new(TCG_TYPE_TL);
z = tcg_temp_new(TCG_TYPE_TL);
/* To avoid a shift we overlay everything on
the V flag. */
tcg_gen_shri_tl(n, cpu_PR[PR_CCS], 2);
tcg_gen_shri_tl(z, cpu_PR[PR_CCS], 1);
/* invert Z. */
tcg_gen_xori_tl(z, z, 2);
tcg_gen_xor_tl(n, n, cpu_PR[PR_CCS]);
tcg_gen_xori_tl(n, n, 2);
tcg_gen_and_tl(cpu_T[0], z, n);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 2);
tcg_gen_discard_tl(n);
tcg_gen_discard_tl(z);
}
break; break;
case CC_LE: case CC_LE:
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_le (); {
TCGv n, z;
n = tcg_temp_new(TCG_TYPE_TL);
z = tcg_temp_new(TCG_TYPE_TL);
/* To avoid a shift we overlay everything on
the V flag. */
tcg_gen_shri_tl(n, cpu_PR[PR_CCS], 2);
tcg_gen_shri_tl(z, cpu_PR[PR_CCS], 1);
tcg_gen_xor_tl(n, n, cpu_PR[PR_CCS]);
tcg_gen_or_tl(cpu_T[0], z, n);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 2);
tcg_gen_discard_tl(n);
tcg_gen_discard_tl(z);
}
break; break;
case CC_P: case CC_P:
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_tst_cc_p (); tcg_gen_andi_tl(cpu_T[0], cpu_PR[PR_CCS], P_FLAG);
break; break;
case CC_A: case CC_A:
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
@ -944,7 +1089,7 @@ static void cris_prepare_cc_branch (DisasContext *dc, int offset, int cond)
if (cond != CC_A) if (cond != CC_A)
{ {
gen_tst_cc (dc, cond); gen_tst_cc (dc, cond);
gen_op_evaluate_bcc (); t_gen_mov_env_TN(btaken, cpu_T[0]);
} }
tcg_gen_movi_tl(env_btarget, dc->delayed_pc); tcg_gen_movi_tl(env_btarget, dc->delayed_pc);
} }
@ -1225,7 +1370,7 @@ static unsigned int dec_subq(DisasContext *dc)
cris_cc_mask(dc, CC_MASK_NZVC); cris_cc_mask(dc, CC_MASK_NZVC);
/* Fetch register operand, */ /* Fetch register operand, */
t_gen_mov_TN_reg(cpu_T[0], dc->op2); t_gen_mov_TN_reg(cpu_T[0], dc->op2);
t_gen_mov_TN_im(cpu_T[1], dc->op1); tcg_gen_movi_tl(cpu_T[1], dc->op1);
crisv32_alu_op(dc, CC_OP_SUB, dc->op2, 4); crisv32_alu_op(dc, CC_OP_SUB, dc->op2, 4);
return 2; return 2;
} }
@ -1238,7 +1383,7 @@ static unsigned int dec_cmpq(DisasContext *dc)
DIS(fprintf (logfile, "cmpq %d, $r%d\n", imm, dc->op2)); DIS(fprintf (logfile, "cmpq %d, $r%d\n", imm, dc->op2));
cris_cc_mask(dc, CC_MASK_NZVC); cris_cc_mask(dc, CC_MASK_NZVC);
t_gen_mov_TN_reg(cpu_T[0], dc->op2); t_gen_mov_TN_reg(cpu_T[0], dc->op2);
t_gen_mov_TN_im(cpu_T[1], imm); tcg_gen_movi_tl(cpu_T[1], imm);
crisv32_alu_op(dc, CC_OP_CMP, dc->op2, 4); crisv32_alu_op(dc, CC_OP_CMP, dc->op2, 4);
return 2; return 2;
} }
@ -1251,7 +1396,7 @@ static unsigned int dec_andq(DisasContext *dc)
DIS(fprintf (logfile, "andq %d, $r%d\n", imm, dc->op2)); DIS(fprintf (logfile, "andq %d, $r%d\n", imm, dc->op2));
cris_cc_mask(dc, CC_MASK_NZ); cris_cc_mask(dc, CC_MASK_NZ);
t_gen_mov_TN_reg(cpu_T[0], dc->op2); t_gen_mov_TN_reg(cpu_T[0], dc->op2);
t_gen_mov_TN_im(cpu_T[1], imm); tcg_gen_movi_tl(cpu_T[1], imm);
crisv32_alu_op(dc, CC_OP_AND, dc->op2, 4); crisv32_alu_op(dc, CC_OP_AND, dc->op2, 4);
return 2; return 2;
} }
@ -1263,7 +1408,7 @@ static unsigned int dec_orq(DisasContext *dc)
DIS(fprintf (logfile, "orq %d, $r%d\n", imm, dc->op2)); DIS(fprintf (logfile, "orq %d, $r%d\n", imm, dc->op2));
cris_cc_mask(dc, CC_MASK_NZ); cris_cc_mask(dc, CC_MASK_NZ);
t_gen_mov_TN_reg(cpu_T[0], dc->op2); t_gen_mov_TN_reg(cpu_T[0], dc->op2);
t_gen_mov_TN_im(cpu_T[1], imm); tcg_gen_movi_tl(cpu_T[1], imm);
crisv32_alu_op(dc, CC_OP_OR, dc->op2, 4); crisv32_alu_op(dc, CC_OP_OR, dc->op2, 4);
return 2; return 2;
} }
@ -1272,10 +1417,9 @@ static unsigned int dec_btstq(DisasContext *dc)
dc->op1 = EXTRACT_FIELD(dc->ir, 0, 4); dc->op1 = EXTRACT_FIELD(dc->ir, 0, 4);
DIS(fprintf (logfile, "btstq %u, $r%d\n", dc->op1, dc->op2)); DIS(fprintf (logfile, "btstq %u, $r%d\n", dc->op1, dc->op2));
cris_evaluate_flags(dc);
cris_cc_mask(dc, CC_MASK_NZ); cris_cc_mask(dc, CC_MASK_NZ);
t_gen_mov_TN_reg(cpu_T[0], dc->op2); t_gen_mov_TN_reg(cpu_T[0], dc->op2);
t_gen_mov_TN_im(cpu_T[1], dc->op1); tcg_gen_movi_tl(cpu_T[1], dc->op1);
crisv32_alu_op(dc, CC_OP_BTST, dc->op2, 4); crisv32_alu_op(dc, CC_OP_BTST, dc->op2, 4);
cris_update_cc_op(dc, CC_OP_FLAGS, 4); cris_update_cc_op(dc, CC_OP_FLAGS, 4);
@ -1289,7 +1433,7 @@ static unsigned int dec_asrq(DisasContext *dc)
DIS(fprintf (logfile, "asrq %u, $r%d\n", dc->op1, dc->op2)); DIS(fprintf (logfile, "asrq %u, $r%d\n", dc->op1, dc->op2));
cris_cc_mask(dc, CC_MASK_NZ); cris_cc_mask(dc, CC_MASK_NZ);
t_gen_mov_TN_reg(cpu_T[0], dc->op2); t_gen_mov_TN_reg(cpu_T[0], dc->op2);
t_gen_mov_TN_im(cpu_T[1], dc->op1); tcg_gen_movi_tl(cpu_T[1], dc->op1);
crisv32_alu_op(dc, CC_OP_ASR, dc->op2, 4); crisv32_alu_op(dc, CC_OP_ASR, dc->op2, 4);
return 2; return 2;
} }
@ -1300,7 +1444,7 @@ static unsigned int dec_lslq(DisasContext *dc)
cris_cc_mask(dc, CC_MASK_NZ); cris_cc_mask(dc, CC_MASK_NZ);
t_gen_mov_TN_reg(cpu_T[0], dc->op2); t_gen_mov_TN_reg(cpu_T[0], dc->op2);
t_gen_mov_TN_im(cpu_T[1], dc->op1); tcg_gen_movi_tl(cpu_T[1], dc->op1);
crisv32_alu_op(dc, CC_OP_LSL, dc->op2, 4); crisv32_alu_op(dc, CC_OP_LSL, dc->op2, 4);
return 2; return 2;
} }
@ -1311,7 +1455,7 @@ static unsigned int dec_lsrq(DisasContext *dc)
cris_cc_mask(dc, CC_MASK_NZ); cris_cc_mask(dc, CC_MASK_NZ);
t_gen_mov_TN_reg(cpu_T[0], dc->op2); t_gen_mov_TN_reg(cpu_T[0], dc->op2);
t_gen_mov_TN_im(cpu_T[1], dc->op1); tcg_gen_movi_tl(cpu_T[1], dc->op1);
crisv32_alu_op(dc, CC_OP_LSR, dc->op2, 4); crisv32_alu_op(dc, CC_OP_LSR, dc->op2, 4);
return 2; return 2;
} }
@ -1338,14 +1482,20 @@ static unsigned int dec_scc_r(DisasContext *dc)
if (cond != CC_A) if (cond != CC_A)
{ {
int l1;
gen_tst_cc (dc, cond); gen_tst_cc (dc, cond);
tcg_gen_mov_tl(cpu_T[1], cpu_T[0]);
l1 = gen_new_label();
tcg_gen_movi_tl(cpu_R[dc->op1], 0);
tcg_gen_brcond_tl(TCG_COND_EQ, cpu_T[0], tcg_const_tl(0), l1);
tcg_gen_movi_tl(cpu_R[dc->op1], 1);
gen_set_label(l1);
} }
else else
tcg_gen_movi_tl(cpu_T[1], 1); tcg_gen_movi_tl(cpu_R[dc->op1], 1);
cris_cc_mask(dc, 0); cris_cc_mask(dc, 0);
crisv32_alu_op(dc, CC_OP_MOVE, dc->op1, 4);
return 2; return 2;
} }
@ -1624,7 +1774,6 @@ static unsigned int dec_btst_r(DisasContext *dc)
{ {
DIS(fprintf (logfile, "btst $r%u, $r%u\n", DIS(fprintf (logfile, "btst $r%u, $r%u\n",
dc->op1, dc->op2)); dc->op1, dc->op2));
cris_evaluate_flags(dc);
cris_cc_mask(dc, CC_MASK_NZ); cris_cc_mask(dc, CC_MASK_NZ);
dec_prep_alu_r(dc, dc->op1, dc->op2, 4, 0); dec_prep_alu_r(dc, dc->op1, dc->op2, 4, 0);
crisv32_alu_op(dc, CC_OP_BTST, dc->op2, 4); crisv32_alu_op(dc, CC_OP_BTST, dc->op2, 4);
@ -1772,10 +1921,18 @@ static unsigned int dec_setclrf(DisasContext *dc)
cris_update_cc_op(dc, CC_OP_FLAGS, 4); cris_update_cc_op(dc, CC_OP_FLAGS, 4);
tcg_gen_movi_tl(cc_op, dc->cc_op); tcg_gen_movi_tl(cc_op, dc->cc_op);
if (set) if (set) {
gen_op_setf(flags); if (!dc->user && (flags & U_FLAG)) {
/* Enter user mode. */
t_gen_mov_env_TN(ksp, cpu_R[R_SP]);
tcg_gen_mov_tl(cpu_R[R_SP], cpu_PR[PR_USP]);
dc->is_jmp = DISAS_UPDATE;
}
tcg_gen_ori_tl(cpu_PR[PR_CCS], cpu_PR[PR_CCS], flags);
}
else else
gen_op_clrf(flags); tcg_gen_andi_tl(cpu_PR[PR_CCS], cpu_PR[PR_CCS], ~flags);
dc->flags_live = 1; dc->flags_live = 1;
dc->clear_x = 0; dc->clear_x = 0;
return 2; return 2;
@ -1785,28 +1942,19 @@ static unsigned int dec_move_rs(DisasContext *dc)
{ {
DIS(fprintf (logfile, "move $r%u, $s%u\n", dc->op1, dc->op2)); DIS(fprintf (logfile, "move $r%u, $s%u\n", dc->op1, dc->op2));
cris_cc_mask(dc, 0); cris_cc_mask(dc, 0);
t_gen_mov_TN_reg(cpu_T[0], dc->op1); tcg_gen_helper_0_2(helper_movl_sreg_reg,
gen_op_movl_sreg_T0(dc->op2); tcg_const_tl(dc->op2), tcg_const_tl(dc->op1));
#if !defined(CONFIG_USER_ONLY)
if (dc->op2 == 6)
gen_op_movl_tlb_hi_T0();
else if (dc->op2 == 5) { /* srs is checked at runtime. */
tcg_gen_helper_0_1(helper_tlb_update, cpu_T[0]);
gen_op_movl_tlb_lo_T0();
}
#endif
return 2; return 2;
} }
static unsigned int dec_move_sr(DisasContext *dc) static unsigned int dec_move_sr(DisasContext *dc)
{ {
DIS(fprintf (logfile, "move $s%u, $r%u\n", dc->op2, dc->op1)); DIS(fprintf (logfile, "move $s%u, $r%u\n", dc->op2, dc->op1));
cris_cc_mask(dc, 0); cris_cc_mask(dc, 0);
gen_op_movl_T0_sreg(dc->op2); tcg_gen_helper_0_2(helper_movl_reg_sreg,
tcg_gen_mov_tl(cpu_T[1], cpu_T[0]); tcg_const_tl(dc->op1), tcg_const_tl(dc->op2));
crisv32_alu_op(dc, CC_OP_MOVE, dc->op1, 4);
return 2; return 2;
} }
static unsigned int dec_move_rp(DisasContext *dc) static unsigned int dec_move_rp(DisasContext *dc)
{ {
DIS(fprintf (logfile, "move $r%u, $p%u\n", dc->op1, dc->op2)); DIS(fprintf (logfile, "move $r%u, $p%u\n", dc->op1, dc->op2));
@ -2024,9 +2172,11 @@ static unsigned int dec_test_m(DisasContext *dc)
dc->op1, dc->postinc ? "+]" : "]", dc->op1, dc->postinc ? "+]" : "]",
dc->op2)); dc->op2));
cris_evaluate_flags(dc);
insn_len = dec_prep_alu_m(dc, 0, memsize); insn_len = dec_prep_alu_m(dc, 0, memsize);
cris_cc_mask(dc, CC_MASK_NZ); cris_cc_mask(dc, CC_MASK_NZ);
gen_op_clrf(3); tcg_gen_andi_tl(cpu_PR[PR_CCS], cpu_PR[PR_CCS], ~3);
tcg_gen_mov_tl(cpu_T[0], cpu_T[1]); tcg_gen_mov_tl(cpu_T[0], cpu_T[1]);
tcg_gen_movi_tl(cpu_T[1], 0); tcg_gen_movi_tl(cpu_T[1], 0);
@ -2444,10 +2594,6 @@ static unsigned int dec_rfe_etc(DisasContext *dc)
case 2: case 2:
/* rfe. */ /* rfe. */
cris_evaluate_flags(dc); cris_evaluate_flags(dc);
gen_op_ccs_rshift();
/* FIXME: don't set the P-FLAG if R is set. */
tcg_gen_ori_tl(cpu_PR[PR_CCS], cpu_PR[PR_CCS], P_FLAG);
/* Debug helper. */
tcg_gen_helper_0_0(helper_rfe); tcg_gen_helper_0_0(helper_rfe);
dc->is_jmp = DISAS_UPDATE; dc->is_jmp = DISAS_UPDATE;
break; break;
@ -2460,7 +2606,9 @@ static unsigned int dec_rfe_etc(DisasContext *dc)
tcg_gen_movi_tl(cpu_T[0], dc->pc); tcg_gen_movi_tl(cpu_T[0], dc->pc);
t_gen_mov_env_TN(pc, cpu_T[0]); t_gen_mov_env_TN(pc, cpu_T[0]);
/* Breaks start at 16 in the exception vector. */ /* Breaks start at 16 in the exception vector. */
gen_op_break_im(dc->op1 + 16); t_gen_mov_env_TN(trap_vector,
tcg_const_tl(dc->op1 + 16));
t_gen_raise_exception(EXCP_BREAK);
dc->is_jmp = DISAS_UPDATE; dc->is_jmp = DISAS_UPDATE;
break; break;
default: default:
@ -2642,7 +2790,7 @@ static void check_breakpoint(CPUState *env, DisasContext *dc)
cris_evaluate_flags (dc); cris_evaluate_flags (dc);
tcg_gen_movi_tl(cpu_T[0], dc->pc); tcg_gen_movi_tl(cpu_T[0], dc->pc);
t_gen_mov_env_TN(pc, cpu_T[0]); t_gen_mov_env_TN(pc, cpu_T[0]);
gen_op_debug(); t_gen_raise_exception(EXCP_DEBUG);
dc->is_jmp = DISAS_UPDATE; dc->is_jmp = DISAS_UPDATE;
} }
} }
@ -2689,13 +2837,14 @@ gen_intermediate_code_internal(CPUState *env, TranslationBlock *tb,
if (loglevel & CPU_LOG_TB_IN_ASM) { if (loglevel & CPU_LOG_TB_IN_ASM) {
fprintf(logfile, fprintf(logfile,
"search=%d pc=%x ccs=%x pid=%x usp=%x\n" "search=%d pc=%x ccs=%x pid=%x usp=%x dbg=%x %x %x\n"
"%x.%x.%x.%x\n" "%x.%x.%x.%x\n"
"%x.%x.%x.%x\n" "%x.%x.%x.%x\n"
"%x.%x.%x.%x\n" "%x.%x.%x.%x\n"
"%x.%x.%x.%x\n", "%x.%x.%x.%x\n",
search_pc, env->pc, env->pregs[PR_CCS], search_pc, env->pc, env->pregs[PR_CCS],
env->pregs[PR_PID], env->pregs[PR_USP], env->pregs[PR_PID], env->pregs[PR_USP],
env->debug1, env->debug2, env->debug3,
env->regs[0], env->regs[1], env->regs[2], env->regs[3], env->regs[0], env->regs[1], env->regs[2], env->regs[3],
env->regs[4], env->regs[5], env->regs[6], env->regs[7], env->regs[4], env->regs[5], env->regs[6], env->regs[7],
env->regs[8], env->regs[9], env->regs[8], env->regs[9],
@ -2733,7 +2882,6 @@ gen_intermediate_code_internal(CPUState *env, TranslationBlock *tb,
dc->clear_x = 1; dc->clear_x = 1;
insn_len = cris_decoder(dc); insn_len = cris_decoder(dc);
STATS(gen_op_exec_insn());
dc->ppc = dc->pc; dc->ppc = dc->pc;
dc->pc += insn_len; dc->pc += insn_len;
if (dc->clear_x) if (dc->clear_x)
@ -2778,7 +2926,7 @@ gen_intermediate_code_internal(CPUState *env, TranslationBlock *tb,
cris_evaluate_flags (dc); cris_evaluate_flags (dc);
done: done:
if (__builtin_expect(env->singlestep_enabled, 0)) { if (__builtin_expect(env->singlestep_enabled, 0)) {
gen_op_debug(); t_gen_raise_exception(EXCP_DEBUG);
} else { } else {
switch(dc->is_jmp) { switch(dc->is_jmp) {
case DISAS_NEXT: case DISAS_NEXT:
@ -2933,13 +3081,16 @@ CPUCRISState *cpu_cris_init (const char *cpu_model)
pregnames[i]); pregnames[i]);
} }
TCG_HELPER(helper_tlb_update); TCG_HELPER(helper_raise_exception);
TCG_HELPER(helper_tlb_flush);
TCG_HELPER(helper_rfe);
TCG_HELPER(helper_store); TCG_HELPER(helper_store);
TCG_HELPER(helper_dump); TCG_HELPER(helper_dump);
TCG_HELPER(helper_dummy); TCG_HELPER(helper_dummy);
TCG_HELPER(helper_tlb_flush);
TCG_HELPER(helper_movl_sreg_reg);
TCG_HELPER(helper_movl_reg_sreg);
TCG_HELPER(helper_rfe);
TCG_HELPER(helper_evaluate_flags_muls); TCG_HELPER(helper_evaluate_flags_muls);
TCG_HELPER(helper_evaluate_flags_mulu); TCG_HELPER(helper_evaluate_flags_mulu);
TCG_HELPER(helper_evaluate_flags_mcp); TCG_HELPER(helper_evaluate_flags_mcp);