/* 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_detach (struct target_ops *ops, 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 int mips_map_regno (int regno);
-
-static void mips_fetch_registers (struct regcache *regcache, int regno);
+static int mips_map_regno (struct gdbarch *, int);
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);
/* Parse the serial port name, the optional TFTP name, and the
optional local TFTP name. */
- if ((argv = buildargv (name)) == NULL)
- nomem (0);
+ argv = gdb_buildargv (name);
make_cleanup_freeargv (argv);
serial_port_name = xstrdup (argv[0]);
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);
}
mips_open (char *name, int from_tty)
{
const char *monitor_prompt = NULL;
- if (gdbarch_bfd_arch_info (current_gdbarch) != NULL
- && gdbarch_bfd_arch_info (current_gdbarch)->arch == bfd_arch_mips)
+ if (gdbarch_bfd_arch_info (target_gdbarch) != NULL
+ && gdbarch_bfd_arch_info (target_gdbarch)->arch == bfd_arch_mips)
{
- switch (gdbarch_bfd_arch_info (current_gdbarch)->mach)
+ switch (gdbarch_bfd_arch_info (target_gdbarch)->mach)
{
case bfd_mach_mips4100:
case bfd_mach_mips4300:
/* 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
#define REGNO_OFFSET 96
static int
-mips_map_regno (int regno)
+mips_map_regno (struct gdbarch *gdbarch, int regno)
{
if (regno < 32)
return regno;
- if (regno >= mips_regnum (current_gdbarch)->fp0
- && regno < mips_regnum (current_gdbarch)->fp0 + 32)
- return regno - mips_regnum (current_gdbarch)->fp0 + 32;
- else if (regno == mips_regnum (current_gdbarch)->pc)
+ if (regno >= mips_regnum (gdbarch)->fp0
+ && regno < mips_regnum (gdbarch)->fp0 + 32)
+ return regno - mips_regnum (gdbarch)->fp0 + 32;
+ else if (regno == mips_regnum (gdbarch)->pc)
return REGNO_OFFSET + 0;
- else if (regno == mips_regnum (current_gdbarch)->cause)
+ else if (regno == mips_regnum (gdbarch)->cause)
return REGNO_OFFSET + 1;
- else if (regno == mips_regnum (current_gdbarch)->hi)
+ else if (regno == mips_regnum (gdbarch)->hi)
return REGNO_OFFSET + 2;
- else if (regno == mips_regnum (current_gdbarch)->lo)
+ else if (regno == mips_regnum (gdbarch)->lo)
return REGNO_OFFSET + 3;
- else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
+ else if (regno == mips_regnum (gdbarch)->fp_control_status)
return REGNO_OFFSET + 4;
- else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision)
+ else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
return REGNO_OFFSET + 5;
else
/* FIXME: Is there a way to get the status register? */
/* 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;
}
{
/* If PMON doesn't support this register, don't waste serial
bandwidth trying to read it. */
- int pmon_reg = mips_map_regno (regno);
+ int pmon_reg = mips_map_regno (gdbarch, regno);
if (regno != 0 && pmon_reg == 0)
val = 0;
else
/* 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;
}
regcache_cooked_read_unsigned (regcache, regno, &val);
- mips_request ('R', mips_map_regno (regno), val,
+ mips_request ('R', mips_map_regno (gdbarch, regno), val,
&err, mips_receive_wait, NULL);
if (err)
mips_error ("Can't write register %d: %s", regno, safe_strerror (errno));
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);
int rpid, rerrflg, rresponse, rlen;
int nfields;
- addr = gdbarch_addr_bits_remove (current_gdbarch, addr);
+ addr = gdbarch_addr_bits_remove (target_gdbarch, addr);
if (mips_monitor == MON_LSI)
{
case 0x6: /* ACK */
return;
case 0x15: /* NACK */
- fprintf_unfiltered (gdb_stderr, "Download got a NACK at byte %s! Retrying.\n", paddr_u (addr));
+ fprintf_unfiltered (gdb_stderr, "Download got a NACK at byte 0x%s! Retrying.\n", paddr_nz (addr));
continue;
default:
error ("Download got unexpected ack char: 0x%x, retrying.\n", ch);
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: */
- regcache_set_valid_p (get_current_regcache (),
- gdbarch_pc_regnum (current_gdbarch), 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