/* Remote debugging interface for MIPS remote debugging protocol.
- Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
- Free Software Foundation, Inc.
+
+ Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+ 2002 Free Software Foundation, Inc.
+
Contributed by Cygnus Support. Written by Ian Lance Taylor
<ian@cygnus.com>.
#include "gdb_stat.h"
#include "regcache.h"
#include <ctype.h>
+#include "mips-tdep.h"
\f
/* Breakpoint types. Values 0, 1, and 2 must agree with the watch
static void mips_detach (char *args, int from_tty);
-static void mips_resume (int pid, int step, enum target_signal siggnal);
+static void mips_resume (ptid_t ptid, int step,
+ enum target_signal siggnal);
-static int mips_wait (int pid, struct target_waitstatus *status);
+static ptid_t mips_wait (ptid_t ptid,
+ struct target_waitstatus *status);
static int mips_map_regno (int regno);
static int mips_need_reply = 0;
/* Handle used to access serial I/O stream. */
-static serial_t mips_desc;
+static struct serial *mips_desc;
/* UDP handle used to download files to target. */
-static serial_t udp_desc;
+static struct serial *udp_desc;
static int udp_in_use;
/* TFTP filename used to download files to DDB board, in the form
close_ports (void)
{
mips_is_open = 0;
- SERIAL_CLOSE (mips_desc);
+ serial_close (mips_desc);
if (udp_in_use)
{
- SERIAL_CLOSE (udp_desc);
+ serial_close (udp_desc);
udp_in_use = 0;
}
tftp_in_use = 0;
wrap_here (""); /* Force out any buffered output */
gdb_flush (gdb_stdout);
if (error_pre_print)
- fprintf_filtered (gdb_stderr, error_pre_print);
+ fputs_filtered (error_pre_print, gdb_stderr);
vfprintf_filtered (gdb_stderr, string, args);
fprintf_filtered (gdb_stderr, "\n");
va_end (args);
printf_unfiltered ("Ending remote MIPS debugging.\n");
target_mourn_inferior ();
- return_to_top_level (RETURN_ERROR);
+ throw_exception (RETURN_ERROR);
}
/* putc_readable - print a character, displaying non-printable chars in
timed out. TIMEOUT specifies timeout value in seconds.
*/
-int
+static int
mips_expect_timeout (const char *string, int timeout)
{
const char *p = string;
{
int c;
-/* Must use SERIAL_READCHAR here cuz mips_readchar would get confused if we
- were waiting for the mips_monitor_prompt... */
+ /* Must use serial_readchar() here cuz mips_readchar would get
+ confused if we were waiting for the mips_monitor_prompt... */
- c = SERIAL_READCHAR (mips_desc, timeout);
+ c = serial_readchar (mips_desc, timeout);
if (c == SERIAL_TIMEOUT)
{
mips_expect_timeout if a different timeout value is needed.
*/
-int
+static int
mips_expect (const char *string)
{
return mips_expect_timeout (string, remote_timeout);
}
-/* Read the required number of characters into the given buffer (which
- is assumed to be large enough). The only failure is a timeout. */
-int
-mips_getstring (char *string, int n)
-{
- char *p = string;
- int c;
-
- immediate_quit++;
- while (n > 0)
- {
- c = SERIAL_READCHAR (mips_desc, remote_timeout);
-
- if (c == SERIAL_TIMEOUT)
- {
- fprintf_unfiltered (gdb_stderr,
- "Failed to read %d characters from target (TIMEOUT)\n", n);
- immediate_quit--;
- return 0;
- }
-
- *p++ = c;
- n--;
- }
-
- immediate_quit--;
- return 1;
-}
-
/* Read a character from the remote, aborting on error. Returns
- SERIAL_TIMEOUT on timeout (since that's what SERIAL_READCHAR
- returns). FIXME: If we see the string mips_monitor_prompt from
- the board, then we are debugging on the main console port, and we
- have somehow dropped out of remote debugging mode. In this case,
- we automatically go back in to remote debugging mode. This is a
- hack, put in because I can't find any way for a program running on
- the remote board to terminate without also ending remote debugging
+ SERIAL_TIMEOUT on timeout (since that's what serial_readchar()
+ returns). FIXME: If we see the string mips_monitor_prompt from the
+ board, then we are debugging on the main console port, and we have
+ somehow dropped out of remote debugging mode. In this case, we
+ automatically go back in to remote debugging mode. This is a hack,
+ put in because I can't find any way for a program running on the
+ remote board to terminate without also ending remote debugging
mode. I assume users won't have any trouble with this; for one
thing, the IDT documentation generally assumes that the remote
debugging port is not the console port. This is, however, very
if (state == mips_monitor_prompt_len)
timeout = 1;
- ch = SERIAL_READCHAR (mips_desc, timeout);
+ ch = serial_readchar (mips_desc, timeout);
if (ch == SERIAL_TIMEOUT && timeout == -1) /* Watchdog went off */
{
static int
mips_cksum (const unsigned char *hdr, const unsigned char *data, int len)
{
- register const unsigned char *p;
- register int c;
- register int cksum;
+ const unsigned char *p;
+ int c;
+ int cksum;
cksum = 0;
{
/* unsigned */ int len;
unsigned char *packet;
- register int cksum;
+ int cksum;
int try;
len = strlen (s);
fprintf_unfiltered (gdb_stdlog, "Writing \"%s\"\n", packet + 1);
}
- if (SERIAL_WRITE (mips_desc, packet,
+ if (serial_write (mips_desc, packet,
HDR_LENGTH + len + TRLR_LENGTH) != 0)
mips_error ("write to target failed: %s", safe_strerror (errno));
ack + 1);
}
- if (SERIAL_WRITE (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
+ if (serial_write (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
{
if (throw_error)
mips_error ("write to target failed: %s", safe_strerror (errno));
ack + 1);
}
- if (SERIAL_WRITE (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
+ if (serial_write (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
{
if (throw_error)
mips_error ("write to target failed: %s", safe_strerror (errno));
}
static void
-mips_initialize_cleanups (PTR arg)
+mips_initialize_cleanups (void *arg)
{
mips_initializing = 0;
}
static void
-mips_exit_cleanups (PTR arg)
+mips_exit_cleanups (void *arg)
{
mips_exiting = 0;
}
static void
mips_send_command (const char *cmd, int prompt)
{
- SERIAL_WRITE (mips_desc, cmd, strlen (cmd));
+ serial_write (mips_desc, cmd, strlen (cmd));
mips_expect (cmd);
mips_expect ("\n");
if (prompt)
mips_send_command ("db tty0\r", 0);
sleep (1);
- SERIAL_WRITE (mips_desc, "\r", sizeof "\r" - 1);
+ serial_write (mips_desc, "\r", sizeof "\r" - 1);
/* We don't need to absorb any spurious characters here, since the
mips_receive_header will eat up a reasonable number of characters
switch (j)
{
case 0: /* First, try sending a CR */
- SERIAL_FLUSH_INPUT (mips_desc);
- SERIAL_WRITE (mips_desc, "\r", 1);
+ serial_flush_input (mips_desc);
+ serial_write (mips_desc, "\r", 1);
break;
case 1: /* First, try sending a break */
- SERIAL_SEND_BREAK (mips_desc);
+ serial_send_break (mips_desc);
break;
case 2: /* Then, try a ^C */
- SERIAL_WRITE (mips_desc, "\003", 1);
+ serial_write (mips_desc, "\003", 1);
break;
case 3: /* Then, try escaping from download */
{
packets. In-case we were downloading a large packet
we flush the output buffer before inserting a
termination sequence. */
- SERIAL_FLUSH_OUTPUT (mips_desc);
+ serial_flush_output (mips_desc);
sprintf (tbuff, "\r/E/E\r");
- SERIAL_WRITE (mips_desc, tbuff, 6);
+ serial_write (mips_desc, tbuff, 6);
}
else
{
for (i = 1; i <= 33; i++)
{
- SERIAL_WRITE (mips_desc, srec, 8);
+ serial_write (mips_desc, srec, 8);
- if (SERIAL_READCHAR (mips_desc, 0) >= 0)
+ if (serial_readchar (mips_desc, 0) >= 0)
break; /* Break immediatly if we get something from
the board. */
}
the request itself succeeds or fails. */
mips_request ('r', 0, 0, &err, mips_receive_wait, NULL);
- set_current_frame (create_new_frame (read_fp (), read_pc ()));
- select_frame (get_current_frame (), 0);
}
/* Open a connection to the remote board. */
unpush_target (current_ops);
/* Open and initialize the serial port. */
- mips_desc = SERIAL_OPEN (serial_port_name);
- if (mips_desc == (serial_t) NULL)
+ mips_desc = serial_open (serial_port_name);
+ if (mips_desc == NULL)
perror_with_name (serial_port_name);
if (baud_rate != -1)
{
- if (SERIAL_SETBAUDRATE (mips_desc, baud_rate))
+ if (serial_setbaudrate (mips_desc, baud_rate))
{
- SERIAL_CLOSE (mips_desc);
+ serial_close (mips_desc);
perror_with_name (serial_port_name);
}
}
- SERIAL_RAW (mips_desc);
+ serial_raw (mips_desc);
/* Open and initialize the optional download port. If it is in the form
hostname#portnumber, it's a UDP socket. If it is in the form
{
if (strchr (remote_name, '#'))
{
- udp_desc = SERIAL_OPEN (remote_name);
+ udp_desc = serial_open (remote_name);
if (!udp_desc)
perror_with_name ("Unable to open UDP port");
udp_in_use = 1;
/* FIXME: Should we call start_remote here? */
/* Try to figure out the processor model if possible. */
- ptype = mips_read_processor_type ();
- if (ptype)
- mips_set_processor_type_command (xstrdup (ptype), 0);
+ deprecated_mips_set_processor_regs_hack ();
-/* This is really the job of start_remote however, that makes an assumption
- that the target is about to print out a status message of some sort. That
- doesn't happen here (in fact, it may not be possible to get the monitor to
- send the appropriate packet). */
+ /* This is really the job of start_remote however, that makes an
+ assumption that the target is about to print out a status message
+ 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 ();
registers_changed ();
stop_pc = read_pc ();
- set_current_frame (create_new_frame (read_fp (), stop_pc));
- select_frame (get_current_frame (), 0);
- print_stack_frame (selected_frame, -1, 1);
+ print_stack_frame (get_selected_frame (), -1, 1);
xfree (serial_port_name);
}
where PMON does return a reply. */
static void
-mips_resume (int pid, int step, enum target_signal siggnal)
+mips_resume (ptid_t ptid, int step, enum target_signal siggnal)
{
int err;
/* Return the signal corresponding to SIG, where SIG is the number which
the MIPS protocol uses for the signal. */
-enum target_signal
+static enum target_signal
mips_signal_from_protocol (int sig)
{
/* We allow a few more signals than the IDT board actually returns, on
/* Wait until the remote stops, and return a wait status. */
-static int
-mips_wait (int pid, struct target_waitstatus *status)
+static ptid_t
+mips_wait (ptid_t ptid, struct target_waitstatus *status)
{
int rstatus;
int err;
{
status->kind = TARGET_WAITKIND_STOPPED;
status->value.sig = TARGET_SIGNAL_TRAP;
- return 0;
+ return inferior_ptid;
}
/* No timeout; we sit here as long as the program continues to execute. */
&rpc, &rfp, &rsp, flags);
if (nfields >= 3)
{
- char buf[MAX_REGISTER_RAW_SIZE];
+ char buf[MAX_REGISTER_SIZE];
- store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rpc);
+ store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM), rpc);
supply_register (PC_REGNUM, buf);
- store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rfp);
+ store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM), rfp);
supply_register (30, buf); /* This register they are avoiding and so it is unnamed */
- store_unsigned_integer (buf, REGISTER_RAW_SIZE (SP_REGNUM), rsp);
+ store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (SP_REGNUM), rsp);
supply_register (SP_REGNUM, buf);
- store_unsigned_integer (buf, REGISTER_RAW_SIZE (FP_REGNUM), 0);
- supply_register (FP_REGNUM, buf);
+ store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (DEPRECATED_FP_REGNUM), 0);
+ supply_register (DEPRECATED_FP_REGNUM, buf);
if (nfields == 9)
{
status->value.sig = mips_signal_from_protocol (rstatus & 0x7f);
}
- return 0;
+ return inferior_ptid;
}
/* We have to map between the register numbers used by gdb and the
{
if (regno < 32)
return regno;
- if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32)
- return regno - FP0_REGNUM + 32;
- switch (regno)
- {
- case PC_REGNUM:
- return REGNO_OFFSET + 0;
- case CAUSE_REGNUM:
- return REGNO_OFFSET + 1;
- case HI_REGNUM:
- return REGNO_OFFSET + 2;
- case LO_REGNUM:
- return REGNO_OFFSET + 3;
- case FCRCS_REGNUM:
- return REGNO_OFFSET + 4;
- case FCRIR_REGNUM:
- return REGNO_OFFSET + 5;
- default:
- /* FIXME: Is there a way to get the status register? */
- return 0;
- }
+ 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)
+ return REGNO_OFFSET + 0;
+ else if (regno == mips_regnum (current_gdbarch)->cause)
+ return REGNO_OFFSET + 1;
+ else if (regno == mips_regnum (current_gdbarch)->hi)
+ return REGNO_OFFSET + 2;
+ else if (regno == mips_regnum (current_gdbarch)->lo)
+ return REGNO_OFFSET + 3;
+ else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
+ return REGNO_OFFSET + 4;
+ else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision)
+ return REGNO_OFFSET + 5;
+ else
+ /* FIXME: Is there a way to get the status register? */
+ return 0;
}
/* Fetch the remote registers. */
return;
}
- if (regno == FP_REGNUM || regno == ZERO_REGNUM)
- /* FP_REGNUM on the mips is a hack which is just supposed to read
- zero (see also mips-nat.c). */
+ if (regno == DEPRECATED_FP_REGNUM || regno == ZERO_REGNUM)
+ /* DEPRECATED_FP_REGNUM on the mips is a hack which is just
+ supposed to read zero (see also mips-nat.c). */
val = 0;
else
{
}
{
- char buf[MAX_REGISTER_RAW_SIZE];
+ char buf[MAX_REGISTER_SIZE];
/* We got the number the register holds, but gdb expects to see a
value in the target byte ordering. */
- store_unsigned_integer (buf, REGISTER_RAW_SIZE (regno), val);
+ store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regno), val);
supply_register (regno, buf);
}
}
static int
mips_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
- struct mem_attrib *attrib ATTRIBUTE_UNUSED,
- struct target_ops *target ATTRIBUTE_UNUSED)
+ struct mem_attrib *attrib, struct target_ops *target)
{
int i;
CORE_ADDR addr;
printf_unfiltered ("Ending remote MIPS debugging.\n");
target_mourn_inferior ();
- return_to_top_level (RETURN_QUIT);
+ throw_exception (RETURN_QUIT);
}
target_terminal_inferior ();
if (remote_debug > 0)
printf_unfiltered ("Sending break\n");
- SERIAL_SEND_BREAK (mips_desc);
+ serial_send_break (mips_desc);
#if 0
if (mips_is_open)
/* Send a ^C. */
cc = '\003';
- SERIAL_WRITE (mips_desc, &cc, 1);
+ serial_write (mips_desc, &cc, 1);
sleep (1);
target_mourn_inferior ();
}
init_wait_for_inferior ();
- /* FIXME: Should we set inferior_pid here? */
+ /* FIXME: Should we set inferior_ptid here? */
proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
}
/* We can write a breakpoint and read the shadow contents in one
operation. */
-/* Insert a breakpoint. On targets that don't have built-in breakpoint
- support, we read the contents of the target location and stash it,
- then overwrite it with a breakpoint instruction. ADDR is the target
- location in the target machine. CONTENTS_CACHE is a pointer to
- memory allocated for saving the target contents. It is guaranteed
- by the caller to be long enough to save sizeof BREAKPOINT bytes (this
- is accomplished via BREAKPOINT_MAX). */
+/* Insert a breakpoint. On targets that don't have built-in
+ breakpoint support, we read the contents of the target location and
+ stash it, then overwrite it with a breakpoint instruction. ADDR is
+ the target location in the target machine. CONTENTS_CACHE is a
+ pointer to memory allocated for saving the target contents. It is
+ guaranteed by the caller to be long enough to save the breakpoint
+ length returned by BREAKPOINT_FROM_PC. */
static int
mips_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
return memory_remove_breakpoint (addr, contents_cache);
}
-#if 0 /* currently not used */
-/* PMON does not currently provide support for the debug mode 'b'
- commands to manipulate breakpoints. However, if we wanted to use
- the monitor breakpoints (rather than the GDB BREAK_INSN version)
- then this code performs the work needed to leave debug mode,
- set/clear the breakpoint, and then return to debug mode. */
-
-#define PMON_MAX_BP (33) /* 32 SW, 1 HW */
-static CORE_ADDR mips_pmon_bp_info[PMON_MAX_BP];
-/* NOTE: The code relies on this vector being zero-initialised by the system */
-
-static int
-pmon_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
-{
- int status;
-
- if (monitor_supports_breakpoints)
- {
- char tbuff[12]; /* space for breakpoint command */
- int bpnum;
- CORE_ADDR bpaddr;
-
- /* PMON does not support debug level breakpoint set/remove: */
- if (mips_exit_debug ())
- mips_error ("Failed to exit debug mode");
-
- sprintf (tbuff, "b %08x\r", addr);
- mips_send_command (tbuff, 0);
-
- mips_expect ("Bpt ");
-
- if (!mips_getstring (tbuff, remote_timeout))
- return 1;
- tbuff[2] = '\0'; /* terminate the string */
- if (sscanf (tbuff, "%d", &bpnum) != 1)
- {
- fprintf_unfiltered (gdb_stderr,
- "Invalid decimal breakpoint number from target: %s\n", tbuff);
- return 1;
- }
-
- mips_expect (" = ");
-
- /* Lead in the hex number we are expecting: */
- tbuff[0] = '0';
- tbuff[1] = 'x';
-
- /* FIXME!! only 8 bytes! need to expand for Bfd64;
- which targets return 64-bit addresses? PMON returns only 32! */
- if (!mips_getstring (&tbuff[2], 8))
- return 1;
- tbuff[10] = '\0'; /* terminate the string */
-
- if (sscanf (tbuff, "0x%08x", &bpaddr) != 1)
- {
- fprintf_unfiltered (gdb_stderr,
- "Invalid hex address from target: %s\n", tbuff);
- return 1;
- }
-
- if (bpnum >= PMON_MAX_BP)
- {
- fprintf_unfiltered (gdb_stderr,
- "Error: Returned breakpoint number %d outside acceptable range (0..%d)\n",
- bpnum, PMON_MAX_BP - 1);
- return 1;
- }
-
- if (bpaddr != addr)
- fprintf_unfiltered (gdb_stderr, "Warning: Breakpoint addresses do not match: 0x%x != 0x%x\n", addr, bpaddr);
-
- mips_pmon_bp_info[bpnum] = bpaddr;
-
- mips_expect ("\r\n");
- mips_expect (mips_monitor_prompt);
-
- mips_enter_debug ();
-
- return 0;
- }
-
- return mips_store_word (addr, BREAK_INSN, contents_cache);
-}
-
-static int
-pmon_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
-{
- if (monitor_supports_breakpoints)
- {
- int bpnum;
- char tbuff[7]; /* enough for delete breakpoint command */
-
- for (bpnum = 0; bpnum < PMON_MAX_BP; bpnum++)
- if (mips_pmon_bp_info[bpnum] == addr)
- break;
-
- if (bpnum >= PMON_MAX_BP)
- {
- fprintf_unfiltered (gdb_stderr,
- "pmon_remove_breakpoint: Failed to find breakpoint at address 0x%s\n",
- paddr_nz (addr));
- return 1;
- }
-
- if (mips_exit_debug ())
- mips_error ("Failed to exit debug mode");
-
- sprintf (tbuff, "db %02d\r", bpnum);
-
- mips_send_command (tbuff, -1);
- /* NOTE: If the breakpoint does not exist then a "Bpt <dd> not
- set" message will be returned. */
-
- mips_enter_debug ();
-
- return 0;
- }
-
- return target_write_memory (addr, contents_cache, BREAK_INSN_SIZE);
-}
-#endif
-
-
/* Tell whether this target can support a hardware breakpoint. CNT
is the number of hardware breakpoints already installed. This
implements the TARGET_CAN_USE_HARDWARE_WATCHPOINT macro. */
int
-remote_mips_can_use_hardware_watchpoint (int cnt)
+mips_can_use_watchpoint (int type, int cnt, int othertype)
{
return cnt < MAX_LSI_BREAKPOINTS && strcmp (target_shortname, "lsi") == 0;
}
}
-/* Insert a hardware breakpoint. This works only on LSI targets, which
- implement ordinary breakpoints using hardware facilities. */
-
-int
-remote_mips_insert_hw_breakpoint (CORE_ADDR addr, char *contents_cache)
-{
- if (strcmp (target_shortname, "lsi") == 0)
- return mips_insert_breakpoint (addr, contents_cache);
- else
- return -1;
-}
-
-
-/* Remove a hardware breakpoint. This works only on LSI targets, which
- implement ordinary breakpoints using hardware facilities. */
-
-int
-remote_mips_remove_hw_breakpoint (CORE_ADDR addr, char *contents_cache)
-{
- if (strcmp (target_shortname, "lsi") == 0)
- return mips_remove_breakpoint (addr, contents_cache);
- else
- return -1;
-}
-
/* Set a data watchpoint. ADDR and LEN should be obvious. TYPE is 0
for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
watchpoint. */
int
-remote_mips_set_watchpoint (CORE_ADDR addr, int len, int type)
+mips_insert_watchpoint (CORE_ADDR addr, int len, int type)
{
if (set_breakpoint (addr, len, type))
return -1;
}
int
-remote_mips_remove_watchpoint (CORE_ADDR addr, int len, int type)
+mips_remove_watchpoint (CORE_ADDR addr, int len, int type)
{
if (clear_breakpoint (addr, len, type))
return -1;
}
int
-remote_mips_stopped_by_watchpoint (void)
+mips_stopped_by_watchpoint (void)
{
return hit_watchpoint;
}
{
int ch;
- SERIAL_WRITE (mips_desc, srec, len);
+ serial_write (mips_desc, srec, len);
ch = mips_readchar (remote_timeout);
reclen = mips_make_srec (srec, '3', s->vma + i, buffer, numbytes);
send_srec (srec, reclen, s->vma + i);
+ if (ui_load_progress_hook)
+ ui_load_progress_hook (s->name, i);
+
if (hashmark)
{
putchar_unfiltered ('#');
send_srec (srec, reclen, abfd->start_address);
- SERIAL_FLUSH_INPUT (mips_desc);
+ serial_flush_input (mips_desc);
}
/*
if (!tftp_in_use)
{
- c = SERIAL_READCHAR (udp_in_use ? udp_desc : mips_desc,
+ c = serial_readchar (udp_in_use ? udp_desc : mips_desc,
remote_timeout);
if ((c == SERIAL_TIMEOUT) || (c != 0x06))
{
if (tftp_in_use)
fwrite (buffer, 1, length, tftp_file);
else
- SERIAL_WRITE (udp_in_use ? udp_desc : mips_desc, buffer, length);
+ serial_write (udp_in_use ? udp_desc : mips_desc, buffer, length);
}
static void
break;
}
+ if (ui_load_progress_hook)
+ ui_load_progress_hook (s->name, i);
+
if (hashmark)
{
putchar_unfiltered ('#');
if (finished)
{ /* Ignore the termination message: */
- SERIAL_FLUSH_INPUT (udp_in_use ? udp_desc : mips_desc);
+ serial_flush_input (udp_in_use ? udp_desc : mips_desc);
}
else
{ /* Deal with termination message: */
/* 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: */
- register_valid[PC_REGNUM] = 0;
+ deprecated_register_valid[PC_REGNUM] = 0;
}
if (exec_bfd)
write_pc (bfd_get_start_address (exec_bfd));
- inferior_pid = 0; /* No process now */
+ inferior_ptid = null_ptid; /* No process now */
/* This is necessary because many things were based on the PC at the time that
we attached to the monitor, which is no longer valid now that we have loaded
printf_filtered ("Received packet: %s\n", buf);
}
\f
+extern initialize_file_ftype _initialize_remote_mips; /* -Wmissing-prototypes */
+
void
_initialize_remote_mips (void)
{
mips_ops.to_files_info = mips_files_info;
mips_ops.to_insert_breakpoint = mips_insert_breakpoint;
mips_ops.to_remove_breakpoint = mips_remove_breakpoint;
+ mips_ops.to_insert_watchpoint = mips_insert_watchpoint;
+ mips_ops.to_remove_watchpoint = mips_remove_watchpoint;
+ mips_ops.to_stopped_by_watchpoint = mips_stopped_by_watchpoint;
+ mips_ops.to_can_use_hw_breakpoint = mips_can_use_watchpoint;
mips_ops.to_kill = mips_kill;
mips_ops.to_load = mips_load;
mips_ops.to_create_inferior = mips_create_inferior;
projects / deliverable / binutils-gdb.git / blobdiff