mii/qemu
1
0
Fork 0
mirror of https://github.com/mii443/qemu.git synced 2025-08-30 19:09:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

target/nios2: Convert to TranslatorOps

Browse Source 
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
This commit is contained in:
Richard Henderson
2021-06-19 22:12:17 -07:00
parent e9150ea523
commit d67cbd9321
1 changed files with 65 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
target/nios2/translate.c
View File

@ -803,74 +803,69 @@ static void gen_exception(DisasContext *dc, uint32_t excp)
} }
/* generate intermediate code for basic block 'tb'. */ /* generate intermediate code for basic block 'tb'. */
void gen_intermediate_code(CPUState *cs, TranslationBlock *tb, int max_insns) static void nios2_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs)
{ {
DisasContext *dc = container_of(dcbase, DisasContext, base);
CPUNios2State *env = cs->env_ptr; CPUNios2State *env = cs->env_ptr;
DisasContext dc1, *dc = &dc1; int page_insns;
int num_insns;
/* Initialize DC */
dc->base.tb = tb;
dc->base.singlestep_enabled = cs->singlestep_enabled;
dc->base.is_jmp = DISAS_NEXT;
dc->base.pc_first = tb->pc;
dc->base.pc_next = tb->pc;
dc->mem_idx = cpu_mmu_index(env, false); dc->mem_idx = cpu_mmu_index(env, false);
/* Set up instruction counts */ /* Bound the number of insns to execute to those left on the page. */
num_insns = 0; page_insns = -(dc->base.pc_first | TARGET_PAGE_MASK) / 4;
if (max_insns > 1) { dc->base.max_insns = MIN(page_insns, dc->base.max_insns);
int page_insns = (TARGET_PAGE_SIZE - (tb->pc & ~TARGET_PAGE_MASK)) / 4; }
if (max_insns > page_insns) {
max_insns = page_insns;
}
}
gen_tb_start(tb); static void nios2_tr_tb_start(DisasContextBase *db, CPUState *cs)
do { {
tcg_gen_insn_start(dc->base.pc_next); }
num_insns++;
if (unlikely(cpu_breakpoint_test(cs, dc->base.pc_next, BP_ANY))) { static void nios2_tr_insn_start(DisasContextBase *dcbase, CPUState *cs)
gen_exception(dc, EXCP_DEBUG); {
/* The address covered by the breakpoint must be included in tcg_gen_insn_start(dcbase->pc_next);
[tb->pc, tb->pc + tb->size) in order to for it to be }
properly cleared -- thus we increment the PC here so that
the logic setting tb->size below does the right thing. */
dc->pc += 4;
break;
}
if (num_insns == max_insns && (tb_cflags(tb) & CF_LAST_IO)) { static bool nios2_tr_breakpoint_check(DisasContextBase *dcbase, CPUState *cs,
gen_io_start(); const CPUBreakpoint *bp)
} {
DisasContext *dc = container_of(dcbase, DisasContext, base);
dc->pc = dc->base.pc_next; gen_exception(dc, EXCP_DEBUG);
dc->base.pc_next += 4; /*
* The address covered by the breakpoint must be included in
* [tb->pc, tb->pc + tb->size) in order to for it to be
* properly cleared -- thus we increment the PC here so that
* the logic setting tb->size below does the right thing.
*/
dc->base.pc_next += 4;
return true;
}
/* Decode an instruction */ static void nios2_tr_translate_insn(DisasContextBase *dcbase, CPUState *cs)
handle_instruction(dc, env); {
DisasContext *dc = container_of(dcbase, DisasContext, base);
CPUNios2State *env = cs->env_ptr;
/* Translation stops when a conditional branch is encountered. dc->pc = dc->base.pc_next;
* Otherwise the subsequent code could get translated several times. dc->base.pc_next += 4;
* Also stop translation when a page boundary is reached. This
* ensures prefetch aborts occur at the right place. */ /* Decode an instruction */
} while (!dc->base.is_jmp && handle_instruction(dc, env);
!tcg_op_buf_full() && }
num_insns < max_insns);
static void nios2_tr_tb_stop(DisasContextBase *dcbase, CPUState *cs)
{
DisasContext *dc = container_of(dcbase, DisasContext, base);
/* Indicate where the next block should start */ /* Indicate where the next block should start */
switch (dc->base.is_jmp) { switch (dc->base.is_jmp) {
case DISAS_NEXT: case DISAS_TOO_MANY:
case DISAS_UPDATE: case DISAS_UPDATE:
/* Save the current PC back into the CPU register */ /* Save the current PC back into the CPU register */
tcg_gen_movi_tl(cpu_R[R_PC], dc->base.pc_next); tcg_gen_movi_tl(cpu_R[R_PC], dc->base.pc_next);
tcg_gen_exit_tb(NULL, 0); tcg_gen_exit_tb(NULL, 0);
break; break;
default:
case DISAS_JUMP: case DISAS_JUMP:
/* The jump will already have updated the PC register */ /* The jump will already have updated the PC register */
tcg_gen_exit_tb(NULL, 0); tcg_gen_exit_tb(NULL, 0);
@ -879,25 +874,32 @@ void gen_intermediate_code(CPUState *cs, TranslationBlock *tb, int max_insns)
case DISAS_NORETURN: case DISAS_NORETURN:
/* nothing more to generate */ /* nothing more to generate */
break; break;
default:
g_assert_not_reached();
} }
}
/* End off the block */ static void nios2_tr_disas_log(const DisasContextBase *dcbase, CPUState *cpu)
gen_tb_end(tb, num_insns); {
qemu_log("IN: %s\n", lookup_symbol(dcbase->pc_first));
log_target_disas(cpu, dcbase->pc_first, dcbase->tb->size);
}
/* Mark instruction starts for the final generated instruction */ static const TranslatorOps nios2_tr_ops = {
tb->size = dc->base.pc_next - dc->base.pc_first; .init_disas_context = nios2_tr_init_disas_context,
tb->icount = num_insns; .tb_start = nios2_tr_tb_start,
.insn_start = nios2_tr_insn_start,
.breakpoint_check = nios2_tr_breakpoint_check,
.translate_insn = nios2_tr_translate_insn,
.tb_stop = nios2_tr_tb_stop,
.disas_log = nios2_tr_disas_log,
};
#ifdef DEBUG_DISAS void gen_intermediate_code(CPUState *cs, TranslationBlock *tb, int max_insns)
if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM) {
&& qemu_log_in_addr_range(dc->base.pc_first)) { DisasContext dc;
FILE *logfile = qemu_log_lock(); translator_loop(&nios2_tr_ops, &dc.base, cs, tb, max_insns);
qemu_log("IN: %s\n", lookup_symbol(dc->base.pc_first));
log_target_disas(cs, tb->pc, tb->size);
qemu_log("\n");
qemu_log_unlock(logfile);
}
#endif
} }
void nios2_cpu_dump_state(CPUState *cs, FILE *f, int flags) void nios2_cpu_dump_state(CPUState *cs, FILE *f, int flags)