void sim_engine_vabort (SIM_DESC sd, sim_cpu *cpu, sim_cia cia, const char *fmt, va_list ap) { ASSERT (sd == NULL || STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); if (sd == NULL) { vfprintf (stderr, fmt, ap); fprintf (stderr, "\nQuit\n"); abort (); } else if (STATE_ENGINE (sd)->jmpbuf == NULL) { sim_io_evprintf (sd, fmt, ap); sim_io_eprintf (sd, "\n"); sim_io_error (sd, "Quit Simulator"); abort (); } else { sim_io_evprintf (sd, fmt, ap); sim_io_eprintf (sd, "\n"); sim_engine_halt (sd, cpu, NULL, cia, sim_stopped, SIM_SIGABRT); } }
SIM_RC sim_engine_install (SIM_DESC sd) { SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); sim_module_add_init_fn (sd, sim_engine_init); return SIM_RC_OK; }
static void control_c_simulation (SIM_DESC sd, void *data) { ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); sim_engine_halt (sd, NULL, NULL, NULL_CIA, sim_stopped, SIM_SIGINT); }
SIM_RC sim_pre_argv_init (SIM_DESC sd, const char *myname) { SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); SIM_ASSERT (STATE_MODULES (sd) == NULL); STATE_MY_NAME (sd) = lbasename (myname); /* Set the cpu names to default values. */ { int i; for (i = 0; i < MAX_NR_PROCESSORS; ++i) { char *name; if (asprintf (&name, "cpu%d", i) < 0) return SIM_RC_FAIL; CPU_NAME (STATE_CPU (sd, i)) = name; } } sim_config_default (sd); /* Install all configured in modules. */ if (sim_module_install (sd) != SIM_RC_OK) return SIM_RC_FAIL; return SIM_RC_OK; }
int sim_read (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length) { SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); return sim_core_read_buffer (sd, NULL, read_map, buf, mem, length); }
void sim_engine_halt (SIM_DESC sd, sim_cpu *last_cpu, sim_cpu *next_cpu, /* NULL - use default */ sim_cia cia, enum sim_stop reason, int sigrc) { sim_engine *engine = STATE_ENGINE (sd); ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); if (engine->jmpbuf != NULL) { jmp_buf *halt_buf = engine->jmpbuf; engine->last_cpu = last_cpu; engine->next_cpu = next_cpu; engine->reason = reason; engine->sigrc = sigrc; SIM_ENGINE_HALT_HOOK (sd, last_cpu, cia); #ifdef SIM_CPU_EXCEPTION_SUSPEND if (last_cpu != NULL && reason != sim_exited) SIM_CPU_EXCEPTION_SUSPEND (sd, last_cpu, sim_signal_to_host (sd, sigrc)); #endif longjmp (*halt_buf, sim_engine_halt_jmpval); } else { sim_io_error (sd, "sim_halt - bad long jump"); abort (); } }
int sim_write (SIM_DESC sd, SIM_ADDR mem, const unsigned char *buf, int length) { SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); return sim_core_write_buffer (sd, NULL, write_map, buf, mem, length); }
void sim_stop_reason (SIM_DESC sd, enum sim_stop *reason, int *sigrc) { sim_engine *engine = NULL; SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); engine = STATE_ENGINE (sd); *reason = engine->reason; switch (*reason) { case sim_exited : *sigrc = engine->sigrc; break; case sim_signalled : /* ??? See the comment below case `sim_signalled' in gdb/remote-sim.c:gdbsim_wait. ??? Consider the case of the target requesting that it kill(2) itself with SIGNAL. That SIGNAL, being target specific, will not correspond to either of the SIM_SIGNAL enum nor the HOST_SIGNAL. A mapping from TARGET_SIGNAL to HOST_SIGNAL is needed. */ *sigrc = sim_signal_to_host (sd, engine->sigrc); break; case sim_stopped : /* The gdb/simulator interface calls for us to return the host version of the signal which gdb then converts into the target's version. This is obviously a bit clumsy. */ *sigrc = sim_signal_to_host (sd, engine->sigrc); break; default : abort (); } }
void sim_engine_abort (SIM_DESC sd, sim_cpu *cpu, sim_cia cia, const char *fmt, ...) { ASSERT (sd == NULL || STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); if (sd != NULL) { va_list ap; va_start (ap, fmt); sim_io_evprintf (sd, fmt, ap); va_end (ap); sim_io_error (sd, "\n"); } else { va_list ap; va_start (ap, fmt); vfprintf (stderr, fmt, ap); va_end (ap); fprintf (stderr, "\n"); abort (); } }
static void has_stepped (SIM_DESC sd, void *data) { ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); sim_engine_halt (sd, NULL, NULL, NULL_CIA, sim_stopped, SIM_SIGTRAP); }
void sim_resume (SIM_DESC sd, int step, int siggnal) { sim_engine *engine = STATE_ENGINE (sd); jmp_buf buf; int jmpval; ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); /* we only want to be single stepping the simulator once */ if (engine->stepper != NULL) { sim_events_deschedule (sd, engine->stepper); engine->stepper = NULL; } if (step) engine->stepper = sim_events_schedule (sd, 1, has_stepped, sd); sim_module_resume (sd); /* run/resume the simulator */ engine->jmpbuf = &buf; jmpval = setjmp (buf); if (jmpval == sim_engine_start_jmpval || jmpval == sim_engine_restart_jmpval) { int last_cpu_nr = sim_engine_last_cpu_nr (sd); int next_cpu_nr = sim_engine_next_cpu_nr (sd); int nr_cpus = sim_engine_nr_cpus (sd); int sig_to_deliver; sim_events_preprocess (sd, last_cpu_nr >= nr_cpus, next_cpu_nr >= nr_cpus); if (next_cpu_nr >= nr_cpus) next_cpu_nr = 0; /* Only deliver the SIGGNAL [sic] the first time through - don't re-deliver any SIGGNAL during a restart. NOTE: A new local variable is used to avoid problems with the automatic variable ``siggnal'' being trashed by a long jump. */ if (jmpval == sim_engine_start_jmpval) sig_to_deliver = siggnal; else sig_to_deliver = 0; #ifdef SIM_CPU_EXCEPTION_RESUME { sim_cpu* cpu = STATE_CPU (sd, next_cpu_nr); SIM_CPU_EXCEPTION_RESUME(sd, cpu, sig_to_deliver); } #endif sim_engine_run (sd, next_cpu_nr, nr_cpus, sig_to_deliver); } engine->jmpbuf = NULL; sim_module_suspend (sd); }
int sim_store_register (SIM_DESC sd, int rn, unsigned char *buf, int length) { SIM_CPU *cpu = STATE_CPU (sd, 0); SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); return (* CPU_REG_STORE (cpu)) (cpu, rn, buf, length); }
SIM_RC cris_option_install (SIM_DESC sd) { SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); if (sim_add_option_table (sd, NULL, cris_options) != SIM_RC_OK) return SIM_RC_FAIL; return SIM_RC_OK; }
void sim_engine_set_run_state (SIM_DESC sd, enum sim_stop reason, int sigrc) { sim_engine *engine = STATE_ENGINE (sd); ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); engine->reason = reason; engine->sigrc = sigrc; }
SIM_RC sim_memopt_install (SIM_DESC sd) { SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); sim_add_option_table (sd, NULL, memory_options); sim_module_add_uninstall_fn (sd, sim_memory_uninstall); sim_module_add_init_fn (sd, sim_memory_init); return SIM_RC_OK; }
int sim_stop (SIM_DESC sd) { ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); sim_events_schedule_after_signal (sd, 0 /*NOW*/, control_c_simulation, sd /*data*/); return 1; }
SIM_RC dv_sockser_install (SIM_DESC sd) { SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); if (sim_add_option_table (sd, NULL, sockser_options) != SIM_RC_OK) return SIM_RC_FAIL; sim_module_add_init_fn (sd, dv_sockser_init); sim_module_add_uninstall_fn (sd, dv_sockser_uninstall); return SIM_RC_OK; }
SIM_RC standard_install (SIM_DESC sd) { SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); if (sim_add_option_table (sd, NULL, standard_options) != SIM_RC_OK) return SIM_RC_FAIL; #ifdef SIM_HANDLES_LMA STATE_LOAD_AT_LMA_P (sd) = SIM_HANDLES_LMA; #endif return SIM_RC_OK; }
SIM_RC sim_hw_install (struct sim_state *sd) { SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); sim_add_option_table (sd, NULL, hw_options); sim_module_add_uninstall_fn (sd, sim_hw_uninstall); sim_module_add_init_fn (sd, sim_hw_init); STATE_HW (sd) = ZALLOC (struct sim_hw); STATE_HW (sd)->tree = hw_tree_create (sd, "core"); return SIM_RC_OK; }
SIM_RC sim_core_install (SIM_DESC sd) { SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); /* establish the other handlers */ sim_module_add_uninstall_fn (sd, sim_core_uninstall); sim_module_add_init_fn (sd, sim_core_init); /* establish any initial data structures - none */ return SIM_RC_OK; }
void sim_module_add_uninstall_fn (SIM_DESC sd, MODULE_UNINSTALL_FN fn) { struct module_list *modules = STATE_MODULES (sd); MODULE_UNINSTALL_LIST *l = ZALLOC (MODULE_UNINSTALL_LIST); SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); SIM_ASSERT (STATE_MODULES (sd) != NULL); l->fn = fn; l->next = modules->uninstall_list; modules->uninstall_list = l; }
void sim_engine_abort (SIM_DESC sd, sim_cpu *cpu, sim_cia cia, const char *fmt, ...) { va_list ap; ASSERT (sd == NULL || STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); va_start (ap, fmt); sim_engine_vabort (sd, cpu, cia, fmt, ap); va_end (ap); }
void sim_module_info (SIM_DESC sd, int verbose) { struct module_list *modules = STATE_MODULES (sd); MODULE_INFO_LIST *modp; SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); SIM_ASSERT (STATE_MODULES (sd) != NULL); for (modp = modules->info_list; modp != NULL; modp = modp->next) { (*modp->fn) (sd, verbose); } }
SIM_RC sim_module_suspend (SIM_DESC sd) { struct module_list *modules = STATE_MODULES (sd); MODULE_SUSPEND_LIST *modp; SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); SIM_ASSERT (STATE_MODULES (sd) != NULL); for (modp = modules->suspend_list; modp != NULL; modp = modp->next) { if ((*modp->fn) (sd) != SIM_RC_OK) return SIM_RC_FAIL; } return SIM_RC_OK; }
void sim_module_add_suspend_fn (SIM_DESC sd, MODULE_SUSPEND_FN fn) { struct module_list *modules = STATE_MODULES (sd); MODULE_SUSPEND_LIST *l = ZALLOC (MODULE_SUSPEND_LIST); MODULE_SUSPEND_LIST **last; SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); SIM_ASSERT (STATE_MODULES (sd) != NULL); last = &modules->suspend_list; while (*last != NULL) last = &((*last)->next); l->fn = fn; l->next = modules->suspend_list; modules->suspend_list = l; }
void sim_module_add_info_fn (SIM_DESC sd, MODULE_INFO_FN fn) { struct module_list *modules = STATE_MODULES (sd); MODULE_INFO_LIST *l = ZALLOC (MODULE_INFO_LIST); MODULE_INFO_LIST **last; SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); SIM_ASSERT (STATE_MODULES (sd) != NULL); last = &modules->info_list; while (*last != NULL) last = &((*last)->next); l->fn = fn; l->next = NULL; *last = l; }
void sim_engine_restart (SIM_DESC sd, sim_cpu *last_cpu, sim_cpu *next_cpu, sim_cia cia) { sim_engine *engine = STATE_ENGINE (sd); ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); if (engine->jmpbuf != NULL) { jmp_buf *halt_buf = engine->jmpbuf; engine->last_cpu = last_cpu; engine->next_cpu = next_cpu; SIM_ENGINE_RESTART_HOOK (sd, last_cpu, cia); longjmp (*halt_buf, sim_engine_restart_jmpval); } else sim_io_error (sd, "sim_restart - bad long jump"); }
SIM_RC sim_post_argv_init (SIM_DESC sd) { int i; SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); SIM_ASSERT (STATE_MODULES (sd) != NULL); /* Set the cpu->state backlinks for each cpu. */ for (i = 0; i < MAX_NR_PROCESSORS; ++i) { CPU_STATE (STATE_CPU (sd, i)) = sd; CPU_INDEX (STATE_CPU (sd, i)) = i; } if (sim_module_init (sd) != SIM_RC_OK) return SIM_RC_FAIL; return SIM_RC_OK; }
SIM_RC sim_module_install (SIM_DESC sd) { MODULE_INSTALL_FN * const *modp; SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); SIM_ASSERT (STATE_MODULES (sd) == NULL); STATE_MODULES (sd) = ZALLOC (struct module_list); for (modp = modules; *modp != NULL; ++modp) { if ((*modp) (sd) != SIM_RC_OK) { sim_module_uninstall (sd); SIM_ASSERT (STATE_MODULES (sd) == NULL); return SIM_RC_FAIL; } } return SIM_RC_OK; }
void sim_stop_reason (SIM_DESC sd, enum sim_stop *reason, int *sigrc) { sim_engine *engine = NULL; SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); engine = STATE_ENGINE (sd); *reason = engine->reason; switch (*reason) { case sim_exited : *sigrc = engine->sigrc; break; case sim_stopped : case sim_signalled : *sigrc = sim_signal_to_gdb_signal (sd, engine->sigrc); break; default : abort (); } }