lightrec_jump_to_eob(state, _jit);
}
-void lightrec_emit_eob(struct lightrec_cstate *state, const struct block *block,
- u16 offset, bool after_op)
+void lightrec_emit_eob(struct lightrec_cstate *state,
+ const struct block *block, u16 offset)
{
struct regcache *reg_cache = state->reg_cache;
jit_state_t *_jit = block->_jit;
- union code c = block->opcode_list[offset].c;
- u32 cycles = state->cycles;
-
- if (after_op)
- cycles += lightrec_cycles_of_opcode(c);
lightrec_clean_regs(reg_cache, _jit);
jit_movi(JIT_V0, block->pc + (offset << 2));
- jit_subi(LIGHTREC_REG_CYCLE, LIGHTREC_REG_CYCLE, cycles);
+ jit_subi(LIGHTREC_REG_CYCLE, LIGHTREC_REG_CYCLE, state->cycles);
lightrec_jump_to_eob(state, _jit);
}
if (op_flag_local_branch(op->flags)) {
/* Recompile the delay slot */
- if (next && next->opcode && !op_flag_no_ds(op->flags))
+ if (!op_flag_no_ds(op->flags) && next->opcode)
lightrec_rec_opcode(state, block, offset + 1);
if (link) {
return (RAM_SIZE << (state->mirrors_mapped * 2)) - 1;
}
+static u32 rec_io_mask(const struct lightrec_state *state)
+{
+ u32 length = state->maps[PSX_MAP_HW_REGISTERS].length;
+
+ return GENMASK(31 - clz32(length - 1), 0);
+}
+
static void rec_store_memory(struct lightrec_cstate *cstate,
const struct block *block,
u16 offset, jit_code_t code,
return rec_store_memory(cstate, block, offset, code, swap_code,
cstate->state->offset_io,
- 0x1fffffff, false);
+ rec_io_mask(cstate->state), false);
}
static void rec_store_direct_no_invalidate(struct lightrec_cstate *cstate,
_jit_note(block->_jit, __FILE__, __LINE__);
rec_load_memory(cstate, block, offset, code, swap_code, is_unsigned,
- cstate->state->offset_io, 0x1fffffff);
+ cstate->state->offset_io, rec_io_mask(cstate->state));
}
static void rec_load_direct(struct lightrec_cstate *cstate,
rec_break_syscall(state, block, offset, LIGHTREC_EXIT_BREAK);
}
+static void rec_mfc(struct lightrec_cstate *state, const struct block *block, u16 offset)
+{
+ struct regcache *reg_cache = state->reg_cache;
+ union code c = block->opcode_list[offset].c;
+ jit_state_t *_jit = block->_jit;
+
+ jit_note(__FILE__, __LINE__);
+ lightrec_clean_reg_if_loaded(reg_cache, _jit, c.i.rt, true);
+
+ call_to_c_wrapper(state, block, c.opcode, C_WRAPPER_MFC);
+}
+
static void rec_mtc(struct lightrec_cstate *state, const struct block *block, u16 offset)
{
struct regcache *reg_cache = state->reg_cache;
lightrec_free_reg(reg_cache, rt);
if (!op_flag_no_ds(block->opcode_list[offset].flags) &&
- (c.r.rd == 12 || c.r.rd == 13))
- lightrec_emit_eob(state, block, offset + 1, true);
+ (c.r.rd == 12 || c.r.rd == 13)) {
+ state->cycles += lightrec_cycles_of_opcode(c);
+ lightrec_emit_eob(state, block, offset + 1);
+ }
}
static void rec_cp0_MFC0(struct lightrec_cstate *state,
_jit_name(block->_jit, __func__);
+ if (state->state->ops.cop2_notify) {
+ /* We must call cop2_notify, handle that in C. */
+ rec_mfc(state, block, offset);
+ return;
+ }
+
flags = (zext_regs & BIT(reg)) ? REG_ZEXT : REG_EXT;
rt = lightrec_alloc_reg_out(reg_cache, _jit, c.r.rt, flags);
_jit_name(block->_jit, __func__);
+ if (state->state->ops.cop2_notify) {
+ /* We must call cop2_notify, handle that in C. */
+ rec_mfc(state, block, offset);
+ return;
+ }
+
switch (c.r.rd) {
case 4:
case 12:
_jit_name(block->_jit, __func__);
+ if (state->state->ops.cop2_notify) {
+ /* We must call cop2_notify, handle that in C. */
+ rec_mtc(state, block, offset);
+ return;
+ }
+
if (c.r.rd == 31)
return;
_jit_name(block->_jit, __func__);
+ if (state->state->ops.cop2_notify) {
+ /* We must call cop2_notify, handle that in C. */
+ rec_mtc(state, block, offset);
+ return;
+ }
+
rt = lightrec_alloc_reg_in(reg_cache, _jit, c.r.rt, 0);
switch (c.r.rd) {