/* Remote debugging interface for MIPS remote debugging protocol.
- Copyright (C) 1993-2013 Free Software Foundation, Inc.
+ Copyright (C) 1993-2014 Free Software Foundation, Inc.
Contributed by Cygnus Support. Written by Ian Lance Taylor
<ian@cygnus.com>.
#include "defs.h"
#include "inferior.h"
+#include "infrun.h"
#include "bfd.h"
#include "symfile.h"
#include "gdbcmd.h"
#include "serial.h"
#include "target.h"
#include "exceptions.h"
-#include "gdb_string.h"
-#include "gdb_stat.h"
+#include <string.h>
+#include <sys/stat.h>
#include "gdb_usleep.h"
#include "regcache.h"
#include <ctype.h>
static void lsi_open (char *name, int from_tty);
-static void mips_close (void);
-
-static void mips_detach (struct target_ops *ops, char *args, int from_tty);
+static void mips_close (struct target_ops *self);
static int mips_map_regno (struct gdbarch *, int);
static void mips_set_register (int regno, ULONGEST value);
-static void mips_prepare_to_store (struct regcache *regcache);
+static void mips_prepare_to_store (struct target_ops *self,
+ struct regcache *regcache);
static int mips_fetch_word (CORE_ADDR addr, unsigned int *valp);
static int mips_store_word (CORE_ADDR addr, unsigned int value,
int *old_contents);
-static int mips_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
- int write,
- struct mem_attrib *attrib,
- struct target_ops *target);
+static enum target_xfer_status mips_xfer_memory (gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST memaddr,
+ ULONGEST len,
+ ULONGEST *xfered_len);
static void mips_files_info (struct target_ops *ignore);
static void pmon_load_fast (char *file);
-static void mips_load (char *file, int from_tty);
+static void mips_load (struct target_ops *self, char *file, int from_tty);
static int mips_make_srec (char *buffer, int type, CORE_ADDR memaddr,
unsigned char *myaddr, int len);
mips_error (char *string,...)
{
va_list args;
-
- va_start (args, string);
+ char *fmt;
target_terminal_ours ();
wrap_here (""); /* Force out any buffered output. */
gdb_flush (gdb_stdout);
- if (error_pre_print)
- fputs_filtered (error_pre_print, gdb_stderr);
- vfprintf_filtered (gdb_stderr, string, args);
- fprintf_filtered (gdb_stderr, "\n");
- va_end (args);
gdb_flush (gdb_stderr);
/* Clean up in such a way that mips_close won't try to talk to the
it). */
close_ports ();
- printf_unfiltered ("Ending remote MIPS debugging.\n");
if (!ptid_equal (inferior_ptid, null_ptid))
target_mourn_inferior ();
- deprecated_throw_reason (RETURN_ERROR);
+ fmt = concat (_("Ending remote MIPS debugging: "),
+ string, (char *) NULL);
+ make_cleanup (xfree, fmt);
+
+ va_start (args, string);
+ throw_verror (TARGET_CLOSE_ERROR, fmt, args);
+ va_end (args);
}
/* putc_readable - print a character, displaying non-printable chars in
mips_request ('x', 0, 0, NULL, mips_receive_wait, NULL);
mips_need_reply = 0;
if (!mips_expect (" break!"))
- return -1;
+ {
+ do_cleanups (old_cleanups);
+ return -1;
+ }
}
else
mips_request ('x', 0, 0, &err, mips_receive_wait, NULL);
if (!mips_expect (mips_monitor_prompt))
- return -1;
+ {
+ do_cleanups (old_cleanups);
+ return -1;
+ }
do_cleanups (old_cleanups);
mips_initialize (void)
{
int err;
- struct cleanup *old_cleanups = make_cleanup (mips_initialize_cleanups, NULL);
+ struct cleanup *old_cleanups;
int j;
/* What is this code doing here? I don't see any way it can happen, and
return;
}
+ old_cleanups = make_cleanup (mips_initialize_cleanups, NULL);
+
mips_wait_flag = 0;
mips_initializing = 1;
char *remote_name = 0;
char *local_name = 0;
char **argv;
+ struct cleanup *cleanup;
if (name == 0)
error (_("\
/* Parse the serial port name, the optional TFTP name, and the
optional local TFTP name. */
argv = gdb_buildargv (name);
- make_cleanup_freeargv (argv);
+ cleanup = make_cleanup_freeargv (argv);
serial_port_name = xstrdup (argv[0]);
if (argv[1]) /* Remote TFTP name specified? */
reinit_frame_cache ();
registers_changed ();
stop_pc = regcache_read_pc (get_current_regcache ());
- print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC);
+ print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
xfree (serial_port_name);
+
+ do_cleanups (cleanup);
}
/* Open a connection to an IDT board. */
/* Close a connection to the remote board. */
static void
-mips_close (void)
+mips_close (struct target_ops *self)
{
if (mips_is_open)
{
/* Detach from the remote board. */
static void
-mips_detach (struct target_ops *ops, char *args, int from_tty)
+mips_detach (struct target_ops *ops, const char *args, int from_tty)
{
if (args)
error (_("Argument given to \"detach\" when remotely debugging."));
- pop_target ();
-
- mips_close ();
+ unpush_target (ops);
if (from_tty)
printf_unfiltered ("Ending remote MIPS debugging.\n");
registers, so this function doesn't have to do anything. */
static void
-mips_prepare_to_store (struct regcache *regcache)
+mips_prepare_to_store (struct target_ops *self, struct regcache *regcache)
{
}
return 0;
}
-/* Read or write LEN bytes from inferior memory at MEMADDR,
- transferring to or from debugger address MYADDR. Write to inferior
- if SHOULD_WRITE is nonzero. Returns length of data written or
- read; 0 for error. Note that protocol gives us the correct value
- for a longword, since it transfers values in ASCII. We want the
- byte values, so we have to swap the longword values. */
+/* Helper for mips_xfer_partial that handles memory transfers.
+ Arguments are like target_xfer_partial. Note that the protocol
+ gives us the correct value for a longword, since it transfers
+ values in ASCII. We want the byte values, so we have to swap the
+ longword values. */
static int mask_address_p = 1;
-static int
-mips_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
- struct mem_attrib *attrib, struct target_ops *target)
+static enum target_xfer_status
+mips_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
+ ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
int i;
/* Allocate buffer of that many longwords. */
buffer = alloca (count * 4);
- if (write)
+ if (writebuf != NULL)
{
/* Fill start and end extra bytes of buffer with existing data. */
if (addr != memaddr || len < 4)
unsigned int val;
if (mips_fetch_word (addr, &val))
- return 0;
+ return TARGET_XFER_E_IO;
/* Need part of initial word -- fetch it. */
store_unsigned_integer (&buffer[0], 4, byte_order, val);
/* Need part of last word -- fetch it. FIXME: we do this even
if we don't need it. */
if (mips_fetch_word (addr + (count - 1) * 4, &val))
- return 0;
+ return TARGET_XFER_E_IO;
store_unsigned_integer (&buffer[(count - 1) * 4],
4, byte_order, val);
/* Copy data to be written over corresponding part of buffer. */
- memcpy ((char *) buffer + (memaddr & 3), myaddr, len);
+ memcpy ((char *) buffer + (memaddr & 3), writebuf, len);
/* Write the entire buffer. */
gdb_flush (gdb_stdout);
}
if (status)
- {
- errno = status;
- return 0;
- }
+ return TARGET_XFER_E_IO;
/* FIXME: Do we want a QUIT here? */
}
if (count >= 256)
unsigned int val;
if (mips_fetch_word (addr, &val))
- return 0;
+ return TARGET_XFER_E_IO;
store_unsigned_integer (&buffer[i * 4], 4, byte_order, val);
QUIT;
}
/* Copy appropriate bytes out of the buffer. */
- memcpy (myaddr, buffer + (memaddr & 3), len);
+ memcpy (readbuf, buffer + (memaddr & 3), len);
}
return len;
}
+/* Target to_xfer_partial implementation. */
+
+static enum target_xfer_status
+mips_xfer_partial (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len)
+{
+ switch (object)
+ {
+ case TARGET_OBJECT_MEMORY:
+ return mips_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
+
+ default:
+ return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
+ readbuf, writebuf, offset, len,
+ xfered_len);
+ }
+}
+
/* Print info on this target. */
static void
printf_unfiltered ("Ending remote MIPS debugging.\n");
target_mourn_inferior ();
-
- deprecated_throw_reason (RETURN_QUIT);
+ quit ();
}
target_terminal_inferior ();
target contents. */
static int
-mips_insert_breakpoint (struct gdbarch *gdbarch,
+mips_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{
if (monitor_supports_breakpoints)
return mips_set_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
BREAK_FETCH);
else
- return memory_insert_breakpoint (gdbarch, bp_tgt);
+ return memory_insert_breakpoint (ops, gdbarch, bp_tgt);
}
/* Remove a breakpoint. */
static int
-mips_remove_breakpoint (struct gdbarch *gdbarch,
+mips_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{
if (monitor_supports_breakpoints)
return mips_clear_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
BREAK_FETCH);
else
- return memory_remove_breakpoint (gdbarch, bp_tgt);
+ return memory_remove_breakpoint (ops, gdbarch, bp_tgt);
}
/* Tell whether this target can support a hardware breakpoint. CNT
implements the target_can_use_hardware_watchpoint macro. */
static int
-mips_can_use_watchpoint (int type, int cnt, int othertype)
+mips_can_use_watchpoint (struct target_ops *self,
+ int type, int cnt, int othertype)
{
return cnt < MAX_LSI_BREAKPOINTS && strcmp (target_shortname, "lsi") == 0;
}
watchpoint. */
static int
-mips_insert_watchpoint (CORE_ADDR addr, int len, int type,
+mips_insert_watchpoint (struct target_ops *self,
+ CORE_ADDR addr, int len, int type,
struct expression *cond)
{
if (mips_set_breakpoint (addr, len, type))
/* Remove a watchpoint. */
static int
-mips_remove_watchpoint (CORE_ADDR addr, int len, int type,
+mips_remove_watchpoint (struct target_ops *self,
+ CORE_ADDR addr, int len, int type,
struct expression *cond)
{
if (mips_clear_breakpoint (addr, len, type))
if not. */
static int
-mips_stopped_by_watchpoint (void)
+mips_stopped_by_watchpoint (struct target_ops *ops)
{
return hit_watchpoint;
}
/* mips_load -- download a file. */
static void
-mips_load (char *file, int from_tty)
+mips_load (struct target_ops *self, char *file, int from_tty)
{
struct regcache *regcache;
mips_ops.to_fetch_registers = mips_fetch_registers;
mips_ops.to_store_registers = mips_store_registers;
mips_ops.to_prepare_to_store = mips_prepare_to_store;
- mips_ops.deprecated_xfer_memory = mips_xfer_memory;
+ mips_ops.to_xfer_partial = mips_xfer_partial;
mips_ops.to_files_info = mips_files_info;
mips_ops.to_insert_breakpoint = mips_insert_breakpoint;
mips_ops.to_remove_breakpoint = mips_remove_breakpoint;
projects / thirdparty / binutils-gdb.git / blobdiff