/* Remote debugging interface for MIPS remote debugging protocol.
Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
- 2003, 2004, 2006, 2007, 2008 Free Software Foundation, Inc.
+ 2003, 2004, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
Contributed by Cygnus Support. Written by Ian Lance Taylor
<ian@cygnus.com>.
static void mips_close (int quitting);
-static void mips_detach (char *args, int from_tty);
-
-static void mips_resume (ptid_t ptid, int step,
- enum target_signal siggnal);
-
-static ptid_t mips_wait (ptid_t ptid,
- struct target_waitstatus *status);
+static void mips_detach (struct target_ops *ops, char *args, int from_tty);
static int mips_map_regno (struct gdbarch *, int);
-static void mips_fetch_registers (struct regcache *regcache, int regno);
-
static void mips_prepare_to_store (struct regcache *regcache);
-static void mips_store_registers (struct regcache *regcache, int regno);
-
static unsigned int mips_fetch_word (CORE_ADDR addr);
static int mips_store_word (CORE_ADDR addr, unsigned int value,
static void mips_files_info (struct target_ops *ignore);
-static void mips_mourn_inferior (void);
+static void mips_mourn_inferior (struct target_ops *ops);
static int pmon_makeb64 (unsigned long v, char *p, int n, int *chksum);
reinit_frame_cache ();
registers_changed ();
- stop_pc = read_pc ();
+ stop_pc = regcache_read_pc (get_current_regcache ());
print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC);
xfree (serial_port_name);
}
/* Detach from the remote board. */
static void
-mips_detach (char *args, int from_tty)
+mips_detach (struct target_ops *ops, char *args, int from_tty)
{
if (args)
error ("Argument given to \"detach\" when remotely debugging.");
where PMON does return a reply. */
static void
-mips_resume (ptid_t ptid, int step, enum target_signal siggnal)
+mips_resume (struct target_ops *ops,
+ ptid_t ptid, int step, enum target_signal siggnal)
{
int err;
/* Wait until the remote stops, and return a wait status. */
static ptid_t
-mips_wait (ptid_t ptid, struct target_waitstatus *status)
+mips_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
int rstatus;
int err;
fetch breakpoint, not a data watchpoint. FIXME when PMON
provides some way to tell us what type of breakpoint it is. */
int i;
- CORE_ADDR pc = read_pc ();
+ CORE_ADDR pc = regcache_read_pc (get_current_regcache ());
hit_watchpoint = 1;
for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
{
char *func_name;
CORE_ADDR func_start;
- CORE_ADDR pc = read_pc ();
+ CORE_ADDR pc = regcache_read_pc (get_current_regcache ());
find_pc_partial_function (pc, &func_name, &func_start, NULL);
if (func_name != NULL && strcmp (func_name, "_exit") == 0
/* Fetch the remote registers. */
static void
-mips_fetch_registers (struct regcache *regcache, int regno)
+mips_fetch_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
unsigned LONGEST val;
if (regno == -1)
{
for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
- mips_fetch_registers (regcache, regno);
+ mips_fetch_registers (ops, regcache, regno);
return;
}
/* Store remote register(s). */
static void
-mips_store_registers (struct regcache *regcache, int regno)
+mips_store_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
ULONGEST val;
if (regno == -1)
{
for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
- mips_store_registers (regcache, regno);
+ mips_store_registers (ops, regcache, regno);
return;
}
right port, we could interrupt the process with a break signal. */
static void
-mips_kill (void)
+mips_kill (struct target_ops *ops)
{
if (!mips_wait_flag)
return;
target_terminal_ours ();
- if (query ("Interrupted while waiting for the program.\n\
-Give up (and stop debugging it)? "))
+ if (query (_("Interrupted while waiting for the program.\n\
+Give up (and stop debugging it)? ")))
{
/* Clean up in such a way that mips_close won't try to talk to the
board (it almost surely won't work since we weren't able to talk to
/* Start running on the target board. */
static void
-mips_create_inferior (char *execfile, char *args, char **env, int from_tty)
+mips_create_inferior (struct target_ops *ops, char *execfile,
+ char *args, char **env, int from_tty)
{
CORE_ADDR entry_pt;
/* FIXME: Should we set inferior_ptid here? */
- write_pc (entry_pt);
+ regcache_write_pc (get_current_regcache (), entry_pt);
}
/* Clean up after a process. Actually nothing to do. */
static void
-mips_mourn_inferior (void)
+mips_mourn_inferior (struct target_ops *ops)
{
if (current_ops != NULL)
unpush_target (current_ops);
static void
mips_load (char *file, int from_tty)
{
+ struct regcache *regcache;
+
/* Get the board out of remote debugging mode. */
if (mips_exit_debug ())
error ("mips_load: Couldn't get into monitor mode.");
mips_initialize ();
/* Finally, make the PC point at the start address */
+ regcache = get_current_regcache ();
if (mips_monitor != MON_IDT)
{
/* Work around problem where PMON monitor updates the PC after a load
to a different value than GDB thinks it has. The following ensures
- that the write_pc() WILL update the PC value: */
- struct regcache *regcache = get_current_regcache ();
- regcache_set_valid_p (regcache,
- gdbarch_pc_regnum (get_regcache_arch (regcache)),
- 0);
+ that the regcache_write_pc() WILL update the PC value: */
+ regcache_invalidate (regcache,
+ gdbarch_pc_regnum (get_regcache_arch (regcache)));
}
if (exec_bfd)
- write_pc (bfd_get_start_address (exec_bfd));
+ regcache_write_pc (regcache, bfd_get_start_address (exec_bfd));
inferior_ptid = null_ptid; /* No process now */
projects / deliverable / binutils-gdb.git / blobdiff