/* Generic remote debugging interface for simulators.
Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
- 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Contributed by Cygnus Support.
Steve Chamberlain (sac@cygnus.com).
static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
-static void gdb_os_error (host_callback *, const char *, ...) ATTR_NORETURN;
+static void gdb_os_error (host_callback *, const char *, ...)
+ ATTRIBUTE_NORETURN;
-static void gdbsim_fetch_register (struct regcache *regcache, int regno);
-
-static void gdbsim_store_register (struct regcache *regcache, int regno);
-
-static void gdbsim_kill (void);
+static void gdbsim_kill (struct target_ops *);
static void gdbsim_load (char *prog, int fromtty);
static void gdbsim_detach (struct target_ops *ops, char *args, int from_tty);
-static void gdbsim_resume (ptid_t ptid, int step, enum target_signal siggnal);
-
-static ptid_t gdbsim_wait (ptid_t ptid, struct target_waitstatus *status);
-
static void gdbsim_prepare_to_store (struct regcache *regcache);
static void gdbsim_files_info (struct target_ops *target);
if (len == 8 || len == 4)
{
long l[2];
+
memcpy (l, buf, len);
printf_filtered ("\t0x%lx", l[0]);
if (len == 8)
else
{
int i;
+
printf_filtered ("\t");
for (i = 0; i < len; i++)
printf_filtered ("0x%x ", buf[i]);
gdb_os_printf_filtered (host_callback * p, const char *format,...)
{
va_list args;
- va_start (args, format);
+ va_start (args, format);
vfprintf_filtered (gdb_stdout, format, args);
-
va_end (args);
}
/* GDB version of error callback. */
static void
-gdb_os_error (host_callback * p, const char *format,...)
+gdb_os_error (host_callback * p, const char *format, ...)
{
- if (deprecated_error_hook)
- (*deprecated_error_hook) ();
- else
- {
- va_list args;
- va_start (args, format);
- verror (format, args);
- va_end (args);
- }
- exit (1);
+ va_list args;
+
+ va_start (args, format);
+ verror (format, args);
+ va_end (args);
}
int
}
static void
-gdbsim_fetch_register (struct regcache *regcache, int regno)
+gdbsim_fetch_register (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
+
if (regno == -1)
{
for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
- gdbsim_fetch_register (regcache, regno);
+ gdbsim_fetch_register (ops, regcache, regno);
return;
}
as an ``unavailable'' register. */
char buf[MAX_REGISTER_SIZE];
int nr_bytes;
+
memset (buf, 0, MAX_REGISTER_SIZE);
regcache_raw_supply (regcache, regno, buf);
break;
static int warn_user = 1;
char buf[MAX_REGISTER_SIZE];
int nr_bytes;
+
gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
memset (buf, 0, MAX_REGISTER_SIZE);
nr_bytes = sim_fetch_register (gdbsim_desc,
static void
-gdbsim_store_register (struct regcache *regcache, int regno)
+gdbsim_store_register (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
if (regno == -1)
{
for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
- gdbsim_store_register (regcache, regno);
+ gdbsim_store_register (ops, regcache, regno);
return;
}
else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
{
char tmp[MAX_REGISTER_SIZE];
int nr_bytes;
+
regcache_cooked_read (regcache, regno, tmp);
nr_bytes = sim_store_register (gdbsim_desc,
gdbarch_register_sim_regno
and releasing other resources acquired by the simulated program. */
static void
-gdbsim_kill (void)
+gdbsim_kill (struct target_ops *ops)
{
if (remote_debug)
printf_filtered ("gdbsim_kill\n");
args);
if (ptid_equal (inferior_ptid, remote_sim_ptid))
- gdbsim_kill ();
+ gdbsim_kill (target);
remove_breakpoints ();
init_wait_for_inferior ();
sim_create_inferior (gdbsim_desc, exec_bfd, argv, env);
inferior_ptid = remote_sim_ptid;
- add_inferior_silent (ptid_get_pid (inferior_ptid));
+ inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
add_thread_silent (inferior_ptid);
- target_mark_running (&gdbsim_ops);
insert_breakpoints (); /* Needed to get correct instruction in cache */
clear_proceed_status ();
/* There's nothing running after "target sim" or "load"; not until
"run". */
inferior_ptid = null_ptid;
- target_mark_exited (&gdbsim_ops);
}
/* Does whatever cleanup is required for a target that we are no longer
static int resume_step;
static void
-gdbsim_resume (ptid_t ptid, int step, enum target_signal siggnal)
+gdbsim_resume (struct target_ops *ops,
+ ptid_t ptid, int step, enum target_signal siggnal)
{
if (!ptid_equal (inferior_ptid, remote_sim_ptid))
error (_("The program is not being run."));
}
static ptid_t
-gdbsim_wait (ptid_t ptid, struct target_waitstatus *status)
+gdbsim_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status, int options)
{
static RETSIGTYPE (*prev_sigint) ();
int sigrc = 0;
/* 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);
+ printf_filtered (", memaddr %s, len %d, write %d\n",
+ paddress (target_gdbarch, memaddr), len, write);
if (remote_debug && write)
dump_mem (myaddr, len);
}
static void
gdbsim_files_info (struct target_ops *target)
{
- char *file = "nothing";
+ const char *file = "nothing";
if (exec_bfd)
file = bfd_get_filename (exec_bfd);
printf_filtered ("gdbsim_mourn_inferior:\n");
remove_breakpoints ();
- target_mark_exited (target);
generic_mourn_inferior ();
delete_thread_silent (remote_sim_ptid);
}
/* Check to see if a thread is still alive. */
static int
-gdbsim_thread_alive (ptid_t ptid)
+gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
{
if (ptid_equal (ptid, remote_sim_ptid))
/* The simulators' task is always alive. */
buffer. */
static char *
-gdbsim_pid_to_str (ptid_t ptid)
+gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[64];
gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
gdbsim_ops.to_stratum = process_stratum;
- gdbsim_ops.to_has_all_memory = 1;
- gdbsim_ops.to_has_memory = 1;
- gdbsim_ops.to_has_stack = 1;
- gdbsim_ops.to_has_registers = 1;
- gdbsim_ops.to_has_execution = 1;
+ gdbsim_ops.to_has_all_memory = default_child_has_all_memory;
+ gdbsim_ops.to_has_memory = default_child_has_memory;
+ gdbsim_ops.to_has_stack = default_child_has_stack;
+ gdbsim_ops.to_has_registers = default_child_has_registers;
+ gdbsim_ops.to_has_execution = default_child_has_execution;
gdbsim_ops.to_magic = OPS_MAGIC;
}