/* Remote debugging interface for MIPS remote debugging protocol.
- Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
- 2002, 2003, 2004, 2006 Free Software Foundation, Inc.
+ Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+ 2003, 2004, 2006, 2007, 2008 Free Software Foundation, Inc.
Contributed by Cygnus Support. Written by Ian Lance Taylor
<ian@cygnus.com>.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "inferior.h"
#include "serial.h"
#include "target.h"
#include "exceptions.h"
-#include "remote-utils.h"
#include "gdb_string.h"
#include "gdb_stat.h"
#include "regcache.h"
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 int mips_map_regno (struct gdbarch *, int);
-static void mips_fetch_registers (int regno);
+static void mips_fetch_registers (struct regcache *regcache, int regno);
-static void mips_prepare_to_store (void);
+static void mips_prepare_to_store (struct regcache *regcache);
-static void mips_store_registers (int regno);
+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,
char *old_contents);
-static int mips_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
+static int mips_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
int write,
struct mem_attrib *attrib,
struct target_ops *target);
static int mips_make_srec (char *buffer, int type, CORE_ADDR memaddr,
unsigned char *myaddr, int len);
-static int set_breakpoint (CORE_ADDR addr, int len, enum break_type type);
+static int mips_set_breakpoint (CORE_ADDR addr, int len, enum break_type type);
-static int clear_breakpoint (CORE_ADDR addr, int len, enum break_type type);
+static int mips_clear_breakpoint (CORE_ADDR addr, int len,
+ enum break_type type);
-static int common_breakpoint (int set, CORE_ADDR addr, int len,
- enum break_type type);
+static int mips_common_breakpoint (int set, CORE_ADDR addr, int len,
+ enum break_type type);
/* Forward declarations. */
extern struct target_ops mips_ops;
/* Clear all breakpoints: */
if ((mips_monitor == MON_IDT
- && clear_breakpoint (-1, 0, BREAK_UNUSED) == 0)
+ && mips_clear_breakpoint (-1, 0, BREAK_UNUSED) == 0)
|| mips_monitor == MON_LSI)
monitor_supports_breakpoints = 1;
else
/* 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]);
of some sort. That doesn't happen here (in fact, it may not be
possible to get the monitor to send the appropriate packet). */
- flush_cached_frames ();
+ reinit_frame_cache ();
registers_changed ();
stop_pc = read_pc ();
print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC);
mips_open (char *name, int from_tty)
{
const char *monitor_prompt = NULL;
- if (TARGET_ARCHITECTURE != NULL
- && TARGET_ARCHITECTURE->arch == bfd_arch_mips)
+ if (gdbarch_bfd_arch_info (target_gdbarch) != NULL
+ && gdbarch_bfd_arch_info (target_gdbarch)->arch == bfd_arch_mips)
{
- switch (TARGET_ARCHITECTURE->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.");
&rpc, &rfp, &rsp, flags);
if (nfields >= 3)
{
+ struct regcache *regcache = get_current_regcache ();
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
char buf[MAX_REGISTER_SIZE];
- store_unsigned_integer (buf, register_size (current_gdbarch, PC_REGNUM), rpc);
- regcache_raw_supply (current_regcache, PC_REGNUM, buf);
+ store_unsigned_integer (buf,
+ register_size
+ (gdbarch, gdbarch_pc_regnum (gdbarch)), rpc);
+ regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch), buf);
- store_unsigned_integer (buf, register_size (current_gdbarch, PC_REGNUM), rfp);
- regcache_raw_supply (current_regcache, 30, buf); /* This register they are avoiding and so it is unnamed */
+ store_unsigned_integer
+ (buf, register_size (gdbarch, gdbarch_pc_regnum (gdbarch)), rfp);
+ regcache_raw_supply (regcache, 30, buf); /* This register they are avoiding and so it is unnamed */
- store_unsigned_integer (buf, register_size (current_gdbarch, SP_REGNUM), rsp);
- regcache_raw_supply (current_regcache, SP_REGNUM, buf);
+ store_unsigned_integer (buf, register_size (gdbarch,
+ gdbarch_sp_regnum (gdbarch)), rsp);
+ regcache_raw_supply (regcache, gdbarch_sp_regnum (gdbarch), buf);
- store_unsigned_integer (buf, register_size (current_gdbarch, DEPRECATED_FP_REGNUM), 0);
- regcache_raw_supply (current_regcache, DEPRECATED_FP_REGNUM, buf);
+ store_unsigned_integer (buf,
+ register_size (gdbarch,
+ gdbarch_deprecated_fp_regnum
+ (gdbarch)),
+ 0);
+ regcache_raw_supply (regcache,
+ gdbarch_deprecated_fp_regnum (gdbarch), buf);
if (nfields == 9)
{
#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 (int regno)
+mips_fetch_registers (struct regcache *regcache, int regno)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
unsigned LONGEST val;
int err;
if (regno == -1)
{
- for (regno = 0; regno < NUM_REGS; regno++)
- mips_fetch_registers (regno);
+ for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
+ mips_fetch_registers (regcache, regno);
return;
}
- if (regno == DEPRECATED_FP_REGNUM || regno == MIPS_ZERO_REGNUM)
- /* DEPRECATED_FP_REGNUM on the mips is a hack which is just
+ if (regno == gdbarch_deprecated_fp_regnum (gdbarch)
+ || regno == MIPS_ZERO_REGNUM)
+ /* gdbarch_deprecated_fp_regnum on the mips is a hack which is just
supposed to read zero (see also mips-nat.c). */
val = 0;
else
{
/* 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
/* We got the number the register holds, but gdb expects to see a
value in the target byte ordering. */
- store_unsigned_integer (buf, register_size (current_gdbarch, regno), val);
- regcache_raw_supply (current_regcache, regno, buf);
+ store_unsigned_integer (buf, register_size (gdbarch, regno), val);
+ regcache_raw_supply (regcache, regno, buf);
}
}
registers, so this function doesn't have to do anything. */
static void
-mips_prepare_to_store (void)
+mips_prepare_to_store (struct regcache *regcache)
{
}
/* Store remote register(s). */
static void
-mips_store_registers (int regno)
+mips_store_registers (struct regcache *regcache, int regno)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ ULONGEST val;
int err;
if (regno == -1)
{
- for (regno = 0; regno < NUM_REGS; regno++)
- mips_store_registers (regno);
+ for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
+ mips_store_registers (regcache, regno);
return;
}
- mips_request ('R', mips_map_regno (regno),
- read_register (regno),
+ regcache_cooked_read_unsigned (regcache, 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));
static int mask_address_p = 1;
static int
-mips_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+mips_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
struct mem_attrib *attrib, struct target_ops *target)
{
int i;
mips_insert_breakpoint (struct bp_target_info *bp_tgt)
{
if (monitor_supports_breakpoints)
- return set_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
- BREAK_FETCH);
+ return mips_set_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
+ BREAK_FETCH);
else
return memory_insert_breakpoint (bp_tgt);
}
mips_remove_breakpoint (struct bp_target_info *bp_tgt)
{
if (monitor_supports_breakpoints)
- return clear_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
- BREAK_FETCH);
+ return mips_clear_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
+ BREAK_FETCH);
else
return memory_remove_breakpoint (bp_tgt);
}
int
mips_insert_watchpoint (CORE_ADDR addr, int len, int type)
{
- if (set_breakpoint (addr, len, type))
+ if (mips_set_breakpoint (addr, len, type))
return -1;
return 0;
int
mips_remove_watchpoint (CORE_ADDR addr, int len, int type)
{
- if (clear_breakpoint (addr, len, type))
+ if (mips_clear_breakpoint (addr, len, type))
return -1;
return 0;
/* Insert a breakpoint. */
static int
-set_breakpoint (CORE_ADDR addr, int len, enum break_type type)
+mips_set_breakpoint (CORE_ADDR addr, int len, enum break_type type)
{
- return common_breakpoint (1, addr, len, type);
+ return mips_common_breakpoint (1, addr, len, type);
}
/* Clear a breakpoint. */
static int
-clear_breakpoint (CORE_ADDR addr, int len, enum break_type type)
+mips_clear_breakpoint (CORE_ADDR addr, int len, enum break_type type)
{
- return common_breakpoint (0, addr, len, type);
+ return mips_common_breakpoint (0, addr, len, type);
}
print the warning text and return 0. If it's an error, print
the error text and return 1. <ADDR> is the address of the breakpoint
that was being set. <RERRFLG> is the error code returned by PMON.
- This is a helper function for common_breakpoint. */
+ This is a helper function for mips_common_breakpoint. */
static int
-check_lsi_error (CORE_ADDR addr, int rerrflg)
+mips_check_lsi_error (CORE_ADDR addr, int rerrflg)
{
struct lsi_error *err;
char *saddr = paddr_nz (addr); /* printable address string */
if ((err->code & rerrflg) == err->code)
{
found = 1;
- fprintf_unfiltered (gdb_stderr,
- "common_breakpoint (0x%s): Warning: %s\n",
+ fprintf_unfiltered (gdb_stderr, "\
+mips_common_breakpoint (0x%s): Warning: %s\n",
saddr,
err->string);
}
}
if (!found)
- fprintf_unfiltered (gdb_stderr,
- "common_breakpoint (0x%s): Unknown warning: 0x%x\n",
+ fprintf_unfiltered (gdb_stderr, "\
+mips_common_breakpoint (0x%s): Unknown warning: 0x%x\n",
saddr,
rerrflg);
}
{
if ((err->code & rerrflg) == err->code)
{
- fprintf_unfiltered (gdb_stderr,
- "common_breakpoint (0x%s): Error: %s\n",
+ fprintf_unfiltered (gdb_stderr, "\
+mips_common_breakpoint (0x%s): Error: %s\n",
saddr,
err->string);
return 1;
}
}
- fprintf_unfiltered (gdb_stderr,
- "common_breakpoint (0x%s): Unknown error: 0x%x\n",
+ fprintf_unfiltered (gdb_stderr, "\
+mips_common_breakpoint (0x%s): Unknown error: 0x%x\n",
saddr,
rerrflg);
return 1;
Return 0 if successful; otherwise 1. */
static int
-common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
+mips_common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
{
char buf[DATA_MAXLEN + 1];
char cmd, rcmd;
int rpid, rerrflg, rresponse, rlen;
int nfields;
- addr = ADDR_BITS_REMOVE (addr);
+ addr = gdbarch_addr_bits_remove (target_gdbarch, addr);
if (mips_monitor == MON_LSI)
{
/* Clear the table entry and tell PMON to clear the breakpoint. */
if (i == MAX_LSI_BREAKPOINTS)
{
- warning ("common_breakpoint: Attempt to clear bogus breakpoint at %s\n",
+ warning ("\
+mips_common_breakpoint: Attempt to clear bogus breakpoint at %s\n",
paddr_nz (addr));
return 1;
}
nfields = sscanf (buf, "0x%x b 0x0 0x%x", &rpid, &rerrflg);
if (nfields != 2)
- mips_error ("common_breakpoint: Bad response from remote board: %s", buf);
+ mips_error ("\
+mips_common_breakpoint: Bad response from remote board: %s",
+ buf);
- return (check_lsi_error (addr, rerrflg));
+ return (mips_check_lsi_error (addr, rerrflg));
}
else
/* set a breakpoint */
nfields = sscanf (buf, "0x%x %c 0x%x 0x%x",
&rpid, &rcmd, &rresponse, &rerrflg);
if (nfields != 4 || rcmd != cmd || rresponse > 255)
- mips_error ("common_breakpoint: Bad response from remote board: %s", buf);
+ mips_error ("\
+mips_common_breakpoint: Bad response from remote board: %s",
+ buf);
if (rerrflg != 0)
- if (check_lsi_error (addr, rerrflg))
+ if (mips_check_lsi_error (addr, rerrflg))
return 1;
/* rresponse contains PMON's breakpoint number. Record the
&rpid, &rcmd, &rerrflg, &rresponse);
if (nfields != 4 || rcmd != cmd)
- mips_error ("common_breakpoint: Bad response from remote board: %s",
+ mips_error ("\
+mips_common_breakpoint: Bad response from remote board: %s",
buf);
if (rerrflg != 0)
if (mips_monitor == MON_DDB)
rresponse = rerrflg;
if (rresponse != 22) /* invalid argument */
- fprintf_unfiltered (gdb_stderr,
- "common_breakpoint (0x%s): Got error: 0x%x\n",
+ fprintf_unfiltered (gdb_stderr, "\
+mips_common_breakpoint (0x%s): Got error: 0x%x\n",
paddr_nz (addr), rresponse);
return 1;
}
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);
/* 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: */
- deprecated_register_valid[PC_REGNUM] = 0;
+ struct regcache *regcache = get_current_regcache ();
+ regcache_set_valid_p (regcache,
+ gdbarch_pc_regnum (get_regcache_arch (regcache)),
+ 0);
}
if (exec_bfd)
write_pc (bfd_get_start_address (exec_bfd));
mips_ops.to_load = mips_load;
mips_ops.to_create_inferior = mips_create_inferior;
mips_ops.to_mourn_inferior = mips_mourn_inferior;
+ mips_ops.to_log_command = serial_log_command;
mips_ops.to_stratum = process_stratum;
mips_ops.to_has_all_memory = 1;
mips_ops.to_has_memory = 1;