#endif
-/* XXX: will be suppressed */
-#define JUMP_TB(opname, tbparam, n, eip)\
-do {\
- GOTO_TB(opname, tbparam, n);\
- T0 = (long)(tbparam) + (n);\
- EIP = (int32_t)eip;\
- EXIT_TB();\
-} while (0)
-
extern CPUWriteMemoryFunc *io_mem_write[IO_MEM_NB_ENTRIES][4];
extern CPUReadMemoryFunc *io_mem_read[IO_MEM_NB_ENTRIES][4];
extern void *io_mem_opaque[IO_MEM_NB_ENTRIES];
FORCE_RET();
}
-void OPPROTO op_jmp0(void)
+void OPPROTO op_goto_tb0(void)
{
- JUMP_TB(op_jmp0, PARAM1, 0, PARAM2);
+ GOTO_TB(op_goto_tb0, PARAM1, 0);
}
-void OPPROTO op_jmp1(void)
+void OPPROTO op_goto_tb1(void)
{
- JUMP_TB(op_jmp1, PARAM1, 1, PARAM2);
+ GOTO_TB(op_goto_tb1, PARAM1, 1);
}
void OPPROTO op_exit_tb(void)
#define DISAS_JUMP_NEXT 4
+#ifdef USE_DIRECT_JUMP
+#define TBPARAM(x)
+#else
+#define TBPARAM(x) (long)(x)
+#endif
+
/* XXX: move that elsewhere */
static uint16_t *gen_opc_ptr;
static uint32_t *gen_opparam_ptr;
return 0;
}
+static inline void gen_jmp_tb(long tb, int n, uint32_t dest)
+{
+ if (n == 0)
+ gen_op_goto_tb0(TBPARAM(tb));
+ else
+ gen_op_goto_tb1(TBPARAM(tb));
+ gen_op_movl_T0_im(dest);
+ gen_op_movl_r15_T0();
+ gen_op_movl_T0_im(tb + n);
+ gen_op_exit_tb();
+}
+
static inline void gen_jmp (DisasContext *s, uint32_t dest)
{
if (__builtin_expect(s->singlestep_enabled, 0)) {
gen_op_movl_T0_im(dest);
gen_bx(s);
} else {
- gen_op_jmp0((long)s->tb, dest);
+ long tb = (long)s->tb;
+ gen_jmp_tb(tb, 0, dest);
s->is_jmp = DISAS_TB_JUMP;
}
}
} else {
switch(dc->is_jmp) {
case DISAS_NEXT:
- gen_op_jmp1((long)dc->tb, (long)dc->pc);
+ gen_jmp_tb((long)dc->tb, 1, dc->pc);
break;
default:
case DISAS_JUMP:
}
if (dc->condjmp) {
gen_set_label(dc->condlabel);
- gen_op_jmp1((long)dc->tb, (long)dc->pc);
+ gen_jmp_tb((long)dc->tb, 1, dc->pc);
dc->condjmp = 0;
}
}
/* Branchs */
//#undef USE_DIRECT_JUMP
-#define EIP env->PC
+
+void OPPROTO op_goto_tb0(void)
+{
+ GOTO_TB(op_goto_tb0, PARAM1, 0);
+}
+
+void OPPROTO op_goto_tb1(void)
+{
+ GOTO_TB(op_goto_tb1, PARAM1, 1);
+}
/* Branch to register */
void op_save_breg_target (void)
RETURN();
}
-/* Unconditional branch */
-void op_branch (void)
-{
- JUMP_TB(branch, PARAM1, 0, PARAM2);
- RETURN();
-}
-
void op_save_btarget (void)
{
env->btarget = PARAM1;
RETURN();
}
-void op_bcond (void)
-{
- if (T2) {
- JUMP_TB(bcond, PARAM1, 0, PARAM2);
- } else {
- JUMP_TB(bcond, PARAM1, 1, PARAM3);
- }
- RETURN();
-}
-
-/* Likely branch (used to skip the delay slot) */
-void op_blikely (void)
+void op_jnz_T2 (void)
{
- /* If the test is false, skip the delay slot */
- if (T2 == 0) {
- env->hflags = PARAM3;
- JUMP_TB(blikely, PARAM1, 1, PARAM2);
- }
+ if (T2)
+ GOTO_LABEL_PARAM(1);
RETURN();
}
#define MIPS_DEBUG_DISAS
//#define MIPS_SINGLE_STEP
+#ifdef USE_DIRECT_JUMP
+#define TBPARAM(x)
+#else
+#define TBPARAM(x) (long)(x)
+#endif
+
enum {
#define DEF(s, n, copy_size) INDEX_op_ ## s,
#include "opc.h"
ctx->bstate = BS_STOP;
}
+static inline void gen_jmp_tb(long tb, int n, uint32_t dest)
+{
+ if (n == 0)
+ gen_op_goto_tb0(TBPARAM(tb));
+ else
+ gen_op_goto_tb1(TBPARAM(tb));
+ gen_op_save_pc(dest);
+ gen_op_set_T0(tb + n);
+ gen_op_exit_tb();
+}
+
/* Branches (before delay slot) */
static void gen_compute_branch (DisasContext *ctx, uint16_t opc,
int rs, int rt, int32_t offset)
case OPC_BLTZL: /* 0 < 0 likely */
/* Skip the instruction in the delay slot */
MIPS_DEBUG("bnever and skip");
- gen_op_branch((long)ctx->tb, ctx->pc + 4);
+ gen_jmp_tb((long)ctx->tb, 0, ctx->pc + 4);
return;
case OPC_J:
ctx->hflags |= MIPS_HFLAG_DS | MIPS_HFLAG_B;
#endif
+static void gen_blikely(DisasContext *ctx)
+{
+ int l1;
+ l1 = gen_new_label();
+ gen_op_jnz_T2(l1);
+ gen_op_save_state(ctx->hflags & ~(MIPS_HFLAG_BMASK | MIPS_HFLAG_DS));
+ gen_jmp_tb((long)ctx->tb, 1, ctx->pc + 4);
+}
+
static void decode_opc (DisasContext *ctx)
{
int32_t offset;
(ctx->hflags & MIPS_HFLAG_BL)) {
/* Handle blikely not taken case */
MIPS_DEBUG("blikely condition (%08x)", ctx->pc + 4);
- gen_op_blikely((long)ctx->tb, ctx->pc + 4,
- ctx->hflags & ~(MIPS_HFLAG_BMASK | MIPS_HFLAG_DS));
+ gen_blikely(ctx);
}
op = ctx->opcode >> 26;
rs = ((ctx->opcode >> 21) & 0x1F);
case MIPS_HFLAG_B:
/* unconditional branch */
MIPS_DEBUG("unconditional branch");
- gen_op_branch((long)ctx->tb, ctx->btarget);
+ gen_jmp_tb((long)ctx->tb, 0, ctx->btarget);
break;
case MIPS_HFLAG_BL:
/* blikely taken case */
MIPS_DEBUG("blikely branch taken");
- gen_op_branch((long)ctx->tb, ctx->btarget);
+ gen_jmp_tb((long)ctx->tb, 0, ctx->btarget);
break;
case MIPS_HFLAG_BC:
/* Conditional branch */
MIPS_DEBUG("conditional branch");
- gen_op_bcond((long)ctx->tb, ctx->btarget, ctx->pc + 4);
+ {
+ int l1;
+ l1 = gen_new_label();
+ gen_op_jnz_T2(l1);
+ gen_jmp_tb((long)ctx->tb, 0, ctx->btarget);
+ gen_set_label(l1);
+ gen_jmp_tb((long)ctx->tb, 1, ctx->pc + 4);
+ }
break;
case MIPS_HFLAG_BR:
/* unconditional branch to register */
gen_opc_ptr = gen_opc_buf;
gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
gen_opparam_ptr = gen_opparam_buf;
+ nb_gen_labels = 0;
ctx.pc = pc_start;
ctx.tb = tb;
ctx.bstate = BS_NONE;
}
if (ctx.bstate != BS_BRANCH && ctx.bstate != BS_EXCP) {
save_cpu_state(ctxp, 0);
- gen_op_branch((long)ctx.tb, ctx.pc);
+ gen_jmp_tb((long)ctx.tb, 0, ctx.pc);
}
gen_op_reset_T0();
/* Generate the return instruction */
regs->lr = PARAM1;
}
-PPC_OP(b)
+PPC_OP(goto_tb0)
{
- JUMP_TB(b1, PARAM1, 0, PARAM2);
+ GOTO_TB(op_goto_tb0, PARAM1, 0);
+}
+
+PPC_OP(goto_tb1)
+{
+ GOTO_TB(op_goto_tb1, PARAM1, 1);
}
PPC_OP(b_T1)
regs->nip = T1 & ~3;
}
-PPC_OP(btest)
+PPC_OP(jz_T0)
{
- if (T0) {
- JUMP_TB(btest, PARAM1, 0, PARAM2);
- } else {
- JUMP_TB(btest, PARAM1, 1, PARAM3);
- }
+ if (!T0)
+ GOTO_LABEL_PARAM(1);
RETURN();
}
//#define DO_SINGLE_STEP
//#define PPC_DEBUG_DISAS
+#ifdef USE_DIRECT_JUMP
+#define TBPARAM(x)
+#else
+#define TBPARAM(x) (long)(x)
+#endif
+
enum {
#define DEF(s, n, copy_size) INDEX_op_ ## s,
#include "opc.h"
/*** Branch ***/
+static inline void gen_jmp_tb(long tb, int n, uint32_t dest)
+{
+ if (n == 0)
+ gen_op_goto_tb0(TBPARAM(tb));
+ else
+ gen_op_goto_tb1(TBPARAM(tb));
+ gen_op_set_T1(dest);
+ gen_op_b_T1();
+ gen_op_set_T0(tb + n);
+ gen_op_exit_tb();
+}
+
/* b ba bl bla */
GEN_HANDLER(b, 0x12, 0xFF, 0xFF, 0x00000000, PPC_FLOW)
{
if (LK(ctx->opcode)) {
gen_op_setlr(ctx->nip);
}
- gen_op_b((long)ctx->tb, target);
+ gen_jmp_tb((long)ctx->tb, 0, target);
ctx->exception = EXCP_BRANCH;
}
case 4:
case 6:
if (type == BCOND_IM) {
- gen_op_b((long)ctx->tb, target);
+ gen_jmp_tb((long)ctx->tb, 0, target);
} else {
gen_op_b_T1();
}
}
}
if (type == BCOND_IM) {
- gen_op_btest((long)ctx->tb, target, ctx->nip);
+ int l1 = gen_new_label();
+ gen_op_jz_T0(l1);
+ gen_jmp_tb((long)ctx->tb, 0, target);
+ gen_set_label(l1);
+ gen_jmp_tb((long)ctx->tb, 1, ctx->nip);
} else {
gen_op_btest_T1(ctx->nip);
}
gen_opc_ptr = gen_opc_buf;
gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
gen_opparam_ptr = gen_opparam_buf;
+ nb_gen_labels = 0;
ctx.nip = pc_start;
ctx.tb = tb;
ctx.exception = EXCP_NONE;
#endif
}
if (ctx.exception == EXCP_NONE) {
- gen_op_b((unsigned long)ctx.tb, ctx.nip);
+ gen_jmp_tb((long)ctx.tb, 0, ctx.nip);
} else if (ctx.exception != EXCP_BRANCH) {
gen_op_set_T0(0);
}