static int gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, struct mem_attrib *attrib, struct target_ops *target) { if (!program_loaded) error ("No program loaded."); if (sr_get_debug ()) { /* FIXME: Send to something other than STDOUT? */ printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x"); gdb_print_host_address (myaddr, gdb_stdout); printf_filtered (", memaddr 0x%s, len %d, write %d\n", paddr_nz (memaddr), len, write); if (sr_get_debug () && write) dump_mem (myaddr, len); } if (write) { len = sim_write (gdbsim_desc, memaddr, myaddr, len); } else { len = sim_read (gdbsim_desc, memaddr, myaddr, len); if (sr_get_debug () && len > 0) dump_mem (myaddr, len); } return len; }
static void gdbsim_store_register (int regno) { if (regno == -1) { for (regno = 0; regno < NUM_REGS; regno++) gdbsim_store_register (regno); return; } else if (REGISTER_SIM_REGNO (regno) >= 0) { char tmp[MAX_REGISTER_SIZE]; int nr_bytes; deprecated_read_register_gen (regno, tmp); nr_bytes = sim_store_register (gdbsim_desc, REGISTER_SIM_REGNO (regno), tmp, register_size (current_gdbarch, regno)); if (nr_bytes > 0 && nr_bytes != register_size (current_gdbarch, regno)) internal_error (__FILE__, __LINE__, "Register size different to expected"); /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0' indicating that GDB and the SIM have different ideas about which registers are fetchable. */ if (sr_get_debug ()) { printf_filtered ("gdbsim_store_register: %d", regno); /* FIXME: We could print something more intelligible. */ dump_mem (tmp, register_size (current_gdbarch, regno)); } } }
static void gdbsim_fetch_register (int regno) { if (regno == -1) { for (regno = 0; regno < NUM_REGS; regno++) gdbsim_fetch_register (regno); return; } switch (REGISTER_SIM_REGNO (regno)) { case LEGACY_SIM_REGNO_IGNORE: break; case SIM_REGNO_DOES_NOT_EXIST: { /* For moment treat a `does not exist' register the same way as an ``unavailable'' register. */ char buf[MAX_REGISTER_SIZE]; int nr_bytes; memset (buf, 0, MAX_REGISTER_SIZE); regcache_raw_supply (current_regcache, regno, buf); set_register_cached (regno, -1); break; } default: { static int warn_user = 1; char buf[MAX_REGISTER_SIZE]; int nr_bytes; gdb_assert (regno >= 0 && regno < NUM_REGS); memset (buf, 0, MAX_REGISTER_SIZE); nr_bytes = sim_fetch_register (gdbsim_desc, REGISTER_SIM_REGNO (regno), buf, register_size (current_gdbarch, regno)); if (nr_bytes > 0 && nr_bytes != register_size (current_gdbarch, regno) && warn_user) { fprintf_unfiltered (gdb_stderr, "Size of register %s (%d/%d) incorrect (%d instead of %d))", REGISTER_NAME (regno), regno, REGISTER_SIM_REGNO (regno), nr_bytes, register_size (current_gdbarch, regno)); warn_user = 0; } /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0' indicating that GDB and the SIM have different ideas about which registers are fetchable. */ /* Else if (nr_bytes < 0): an old simulator, that doesn't think to return the register size. Just assume all is ok. */ regcache_raw_supply (current_regcache, regno, buf); if (sr_get_debug ()) { printf_filtered ("gdbsim_fetch_register: %d", regno); /* FIXME: We could print something more intelligible. */ dump_mem (buf, register_size (current_gdbarch, regno)); } break; } } }
static ptid_t gdbsim_wait (ptid_t ptid, struct target_waitstatus *status) { static RETSIGTYPE (*prev_sigint) (); int sigrc = 0; enum sim_stop reason = sim_running; if (sr_get_debug ()) printf_filtered ("gdbsim_wait\n"); #if defined (HAVE_SIGACTION) && defined (SA_RESTART) { struct sigaction sa, osa; sa.sa_handler = gdbsim_cntrl_c; sigemptyset (&sa.sa_mask); sa.sa_flags = 0; sigaction (SIGINT, &sa, &osa); prev_sigint = osa.sa_handler; } #else prev_sigint = signal (SIGINT, gdbsim_cntrl_c); #endif sim_resume (gdbsim_desc, resume_step, resume_siggnal); signal (SIGINT, prev_sigint); resume_step = 0; sim_stop_reason (gdbsim_desc, &reason, &sigrc); switch (reason) { case sim_exited: status->kind = TARGET_WAITKIND_EXITED; status->value.integer = sigrc; break; case sim_stopped: switch (sigrc) { case TARGET_SIGNAL_ABRT: quit (); break; case TARGET_SIGNAL_INT: case TARGET_SIGNAL_TRAP: default: status->kind = TARGET_WAITKIND_STOPPED; status->value.sig = sigrc; break; } break; case sim_signalled: status->kind = TARGET_WAITKIND_SIGNALLED; status->value.sig = sigrc; break; case sim_running: case sim_polling: /* FIXME: Is this correct? */ break; } return inferior_ptid; }
static void gdbsim_load (char *args, int fromtty) { char **argv = buildargv (args); char *prog; if (argv == NULL) nomem (0); make_cleanup_freeargv (argv); prog = tilde_expand (argv[0]); if (argv[1] != NULL) error (_("GDB sim does not yet support a load offset.")); if (sr_get_debug ()) printf_filtered ("gdbsim_load: prog \"%s\"\n", prog); /* FIXME: We will print two messages on error. Need error to either not print anything if passed NULL or need another routine that doesn't take any arguments. */ if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL) error (_("unable to load program")); /* FIXME: If a load command should reset the targets registers then a call to sim_create_inferior() should go here. */ program_loaded = 1; }
static void gdbsim_mourn_inferior (void) { if (sr_get_debug ()) printf_filtered ("gdbsim_mourn_inferior:\n"); remove_breakpoints (); generic_mourn_inferior (); }
static void gdbsim_detach (char *args, int from_tty) { if (sr_get_debug ()) printf_filtered ("gdbsim_detach: args \"%s\"\n", args); pop_target (); /* calls gdbsim_close to do the real work */ if (from_tty) printf_filtered ("Ending simulator %s debugging\n", target_shortname); }
static void gdbsim_kill (void) { if (sr_get_debug ()) printf_filtered ("gdbsim_kill\n"); /* There is no need to `kill' running simulator - the simulator is not running */ inferior_ptid = null_ptid; }
static void gdbsim_kill (void) { if (sr_get_debug ()) printf_filtered ("gdbsim_kill\n"); /* There is no need to `kill' running simulator - the simulator is not running. Mourning it is enough. */ target_mourn_inferior (); }
static void gdbsim_resume (ptid_t ptid, int step, enum target_signal siggnal) { if (PIDGET (inferior_ptid) != 42) error ("The program is not being run."); if (sr_get_debug ()) printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal); resume_siggnal = siggnal; resume_step = step; }
static int gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write, struct mem_attrib *attrib, struct target_ops *target) { /* If no program is running yet, then ignore the simulator for memory. Pass the request down to the next target, hopefully an exec file. */ if (!target_has_execution) return 0; if (!program_loaded) error (_("No program loaded.")); if (sr_get_debug ()) { /* FIXME: Send to something other than STDOUT? */ printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x"); gdb_print_host_address (myaddr, gdb_stdout); printf_filtered (", memaddr 0x%s, len %d, write %d\n", paddr_nz (memaddr), len, write); if (sr_get_debug () && write) dump_mem (myaddr, len); } if (write) { len = sim_write (gdbsim_desc, memaddr, myaddr, len); } else { len = sim_read (gdbsim_desc, memaddr, myaddr, len); if (sr_get_debug () && len > 0) dump_mem (myaddr, len); } return len; }
static void gdbsim_close (int quitting) { if (sr_get_debug ()) printf_filtered ("gdbsim_close: quitting %d\n", quitting); program_loaded = 0; if (gdbsim_desc != NULL) { sim_close (gdbsim_desc, quitting); gdbsim_desc = NULL; } end_callbacks (); generic_mourn_inferior (); }
static void gdbsim_files_info (struct target_ops *target) { char *file = "nothing"; if (exec_bfd) file = bfd_get_filename (exec_bfd); if (sr_get_debug ()) printf_filtered ("gdbsim_files_info: file \"%s\"\n", file); if (exec_bfd) { printf_filtered ("\tAttached to %s running program %s\n", target_shortname, file); sim_info (gdbsim_desc, 0); } }
static void gdbsim_create_inferior (char *exec_file, char *args, char **env, int from_tty) { int len; char *arg_buf, **argv; if (exec_file == 0 || exec_bfd == 0) warning ("No executable file specified."); if (!program_loaded) warning ("No program loaded."); if (sr_get_debug ()) printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n", (exec_file ? exec_file : "(NULL)"), args); gdbsim_kill (); remove_breakpoints (); init_wait_for_inferior (); if (exec_file != NULL) { len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10; arg_buf = (char *) alloca (len); arg_buf[0] = '\0'; strcat (arg_buf, exec_file); strcat (arg_buf, " "); strcat (arg_buf, args); argv = buildargv (arg_buf); make_cleanup_freeargv (argv); } else argv = NULL; sim_create_inferior (gdbsim_desc, exec_bfd, argv, env); inferior_ptid = pid_to_ptid (42); insert_breakpoints (); /* Needed to get correct instruction in cache */ clear_proceed_status (); /* NB: Entry point already set by sim_create_inferior. */ proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0); }
static void gdbsim_load (char *prog, int fromtty) { if (sr_get_debug ()) printf_filtered ("gdbsim_load: prog \"%s\"\n", prog); inferior_ptid = null_ptid; /* FIXME: We will print two messages on error. Need error to either not print anything if passed NULL or need another routine that doesn't take any arguments. */ if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL) error ("unable to load program"); /* FIXME: If a load command should reset the targets registers then a call to sim_create_inferior() should go here. */ program_loaded = 1; }
static void gdbsim_open (char *args, int from_tty) { int len; char *arg_buf; char **argv; if (sr_get_debug ()) printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)"); /* Remove current simulator if one exists. Only do this if the simulator has been opened because sim_close requires it. This is important because the call to push_target below will cause sim_close to be called if the simulator is already open, but push_target is called after sim_open! We can't move the call to push_target before the call to sim_open because sim_open may invoke `error'. */ if (gdbsim_desc != NULL) unpush_target (&gdbsim_ops); len = (7 + 1 /* gdbsim */ + strlen (" -E little") + strlen (" --architecture=xxxxxxxxxx") + (args ? strlen (args) : 0) + 50) /* slack */ ; arg_buf = (char *) alloca (len); strcpy (arg_buf, "gdbsim"); /* 7 */ /* Specify the byte order for the target when it is both selectable and explicitly specified by the user (not auto detected). */ switch (selected_byte_order ()) { case BFD_ENDIAN_BIG: strcat (arg_buf, " -E big"); break; case BFD_ENDIAN_LITTLE: strcat (arg_buf, " -E little"); break; case BFD_ENDIAN_UNKNOWN: break; } /* Specify the architecture of the target when it has been explicitly specified */ if (selected_architecture_name () != NULL) { strcat (arg_buf, " --architecture="); strcat (arg_buf, selected_architecture_name ()); } /* finally, any explicit args */ if (args) { strcat (arg_buf, " "); /* 1 */ strcat (arg_buf, args); } argv = buildargv (arg_buf); if (argv == NULL) error ("Insufficient memory available to allocate simulator arg list."); make_cleanup_freeargv (argv); init_callbacks (); gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv); if (gdbsim_desc == 0) error ("unable to create simulator instance"); push_target (&gdbsim_ops); target_fetch_registers (-1); printf_filtered ("Connected to the simulator.\n"); }