#include <sys/types.h>
#include <sys/stat.h>
+#include <ctype.h>
+
/* Microsoft C's stat.h doesn't define all the POSIX file modes. */
#ifndef S_IROTH
#define S_IROTH S_IREAD
static int mips_receive_packet (char *buff, int throw_error, int timeout);
-static CORE_ADDR mips_request (int cmd, CORE_ADDR addr,
- CORE_ADDR data, int *perr, int timeout,
- char *buff);
+static ULONGEST mips_request (int cmd, ULONGEST addr, ULONGEST data,
+ int *perr, int timeout, char *buff);
static void mips_initialize (void);
/* The number of garbage characters to accept when looking for an
SYN for the next packet. */
-static int mips_syn_garbage = 1050;
+static int mips_syn_garbage = 10;
/* The time to wait for a packet, in seconds. */
static int mips_receive_wait = 5;
static void
-close_ports ()
+close_ports (void)
{
mips_is_open = 0;
SERIAL_CLOSE (mips_desc);
^x notation or in hex. */
static void
-fputc_readable (ch, file)
- int ch;
- struct ui_file *file;
+fputc_readable (int ch, struct ui_file *file)
{
if (ch == '\n')
fputc_unfiltered ('\n', file);
^x notation or in hex. */
static void
-fputs_readable (string, file)
- char *string;
- struct ui_file *file;
+fputs_readable (const char *string, struct ui_file *file)
{
int c;
*/
int
-mips_expect_timeout (string, timeout)
- char *string;
- int timeout;
+mips_expect_timeout (const char *string, int timeout)
{
- char *p = string;
+ const char *p = string;
if (remote_debug)
{
fprintf_unfiltered (gdb_stdlog, "\", got \"");
}
- immediate_quit = 1;
+ immediate_quit++;
while (1)
{
int c;
{
if (*p == '\0')
{
- immediate_quit = 0;
+ immediate_quit--;
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "\": OK\n");
return 1;
*/
int
-mips_expect (string)
- char *string;
+mips_expect (const char *string)
{
- return mips_expect_timeout (string, 2);
+ 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 (string, n)
- char *string;
- int n;
+mips_getstring (char *string, int n)
{
char *p = string;
int c;
- immediate_quit = 1;
+ immediate_quit++;
while (n > 0)
{
- c = SERIAL_READCHAR (mips_desc, 2);
+ 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;
}
n--;
}
+ immediate_quit--;
return 1;
}
port. */
static int
-mips_readchar (timeout)
- int timeout;
+mips_readchar (int timeout)
{
int ch;
static int state = 0;
or -1 for timeout. */
static int
-mips_receive_header (hdr, pgarbage, ch, timeout)
- unsigned char *hdr;
- int *pgarbage;
- int ch;
- int timeout;
+mips_receive_header (unsigned char *hdr, int *pgarbage, int ch, int timeout)
{
int i;
{
/* Printing the character here lets the user of gdb see
what the program is outputting, if the debugging is
- being done on the console port. Don't use _filtered;
- we can't deal with a QUIT out of target_wait. */
- if (!mips_initializing || remote_debug > 0)
- {
- fputc_readable (ch, gdb_stdlog);
- gdb_flush (gdb_stdlog);
- }
+ being done on the console port. Don't use _filtered:
+ we can't deal with a QUIT out of target_wait and
+ buffered target output confuses the user. */
+ if (!mips_initializing || remote_debug > 0)
+ {
+ if (isprint (ch) || isspace (ch))
+ {
+ fputc_unfiltered (ch, gdb_stdtarg);
+ }
+ else
+ {
+ fputc_readable (ch, gdb_stdtarg);
+ }
+ gdb_flush (gdb_stdtarg);
+ }
+
+ /* Only count unprintable characters. */
+ if (! (isprint (ch) || isspace (ch)))
+ (*pgarbage) += 1;
- ++*pgarbage;
if (mips_syn_garbage > 0
&& *pgarbage > mips_syn_garbage)
mips_error ("Debug protocol failure: more than %d characters before a sync.",
for success, -1 for timeout, -2 for error. */
static int
-mips_receive_trailer (trlr, pgarbage, pch, timeout)
- unsigned char *trlr;
- int *pgarbage;
- int *pch;
- int timeout;
+mips_receive_trailer (unsigned char *trlr, int *pgarbage, int *pch, int timeout)
{
int i;
int ch;
DATA points to the packet data. LEN is the length of DATA. */
static int
-mips_cksum (hdr, data, len)
- const unsigned char *hdr;
- const unsigned char *data;
- int len;
+mips_cksum (const unsigned char *hdr, const unsigned char *data, int len)
{
register const unsigned char *p;
register int c;
/* Send a packet containing the given ASCII string. */
static void
-mips_send_packet (s, get_ack)
- const char *s;
- int get_ack;
+mips_send_packet (const char *s, int get_ack)
{
/* unsigned */ int len;
unsigned char *packet;
{
int rch;
- rch = mips_readchar (2);
+ rch = mips_readchar (remote_timeout);
if (rch == SYN)
{
ch = SYN;
}
if (i == len)
- (void) mips_receive_trailer (trlr, &garbage, &ch, 2);
+ (void) mips_receive_trailer (trlr, &garbage, &ch,
+ remote_timeout);
/* We don't bother checking the checksum, or providing an
ACK to the packet. */
don't print an error message and return -1. */
static int
-mips_receive_packet (buff, throw_error, timeout)
- char *buff;
- int throw_error;
- int timeout;
+mips_receive_packet (char *buff, int throw_error, int timeout)
{
int ch;
int garbage;
occurs, it sets *PERR to 1 and sets errno according to what the
target board reports. */
-static CORE_ADDR
-mips_request (cmd, addr, data, perr, timeout, buff)
- int cmd;
- CORE_ADDR addr;
- CORE_ADDR data;
- int *perr;
- int timeout;
- char *buff;
+static ULONGEST
+mips_request (int cmd,
+ ULONGEST addr,
+ ULONGEST data,
+ int *perr,
+ int timeout,
+ char *buff)
{
char myBuff[DATA_MAXLEN + 1];
int len;
}
static void
-mips_initialize_cleanups (arg)
- PTR arg;
+mips_initialize_cleanups (PTR arg)
{
mips_initializing = 0;
}
static void
-mips_exit_cleanups (arg)
- PTR arg;
+mips_exit_cleanups (PTR arg)
{
mips_exiting = 0;
}
static void
-mips_send_command (cmd, prompt)
- const char *cmd;
- int prompt;
+mips_send_command (const char *cmd, int prompt)
{
SERIAL_WRITE (mips_desc, cmd, strlen (cmd));
mips_expect (cmd);
/* Enter remote (dbx) debug mode: */
static void
-mips_enter_debug ()
+mips_enter_debug (void)
{
/* Reset the sequence numbers, ready for the new debug sequence: */
mips_send_seq = 0;
/* Exit remote (dbx) debug mode, returning to the monitor prompt: */
static int
-mips_exit_debug ()
+mips_exit_debug (void)
{
int err;
struct cleanup *old_cleanups = make_cleanup (mips_exit_cleanups, NULL);
{
/* The DDB (NEC) and MiniRISC (LSI) versions of PMON exit immediately,
so we do not get a reply to this command: */
- mips_request ('x', (unsigned int) 0, (unsigned int) 0, NULL,
- mips_receive_wait, NULL);
+ mips_request ('x', 0, 0, NULL, mips_receive_wait, NULL);
mips_need_reply = 0;
if (!mips_expect (" break!"))
return -1;
}
else
- mips_request ('x', (unsigned int) 0, (unsigned int) 0, &err,
- mips_receive_wait, NULL);
+ mips_request ('x', 0, 0, &err, mips_receive_wait, NULL);
if (!mips_expect (mips_monitor_prompt))
return -1;
really connected. */
static void
-mips_initialize ()
+mips_initialize (void)
{
int err;
struct cleanup *old_cleanups = make_cleanup (mips_initialize_cleanups, NULL);
/* If this doesn't call error, we have connected; we don't care if
the request itself succeeds or fails. */
- mips_request ('r', (unsigned int) 0, (unsigned int) 0, &err,
- mips_receive_wait, NULL);
+ 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. */
static void
-common_open (ops, name, from_tty, new_monitor, new_monitor_prompt)
- struct target_ops *ops;
- char *name;
- int from_tty;
- enum mips_monitor_type new_monitor;
- char *new_monitor_prompt;
+common_open (struct target_ops *ops, char *name, int from_tty,
+ enum mips_monitor_type new_monitor,
+ const char *new_monitor_prompt)
{
char *ptype;
char *serial_port_name;
the user didn't specify a local name, assume it's the same
as the part of the remote name after the "host:". */
if (tftp_name)
- free (tftp_name);
+ xfree (tftp_name);
if (tftp_localname)
- free (tftp_localname);
+ xfree (tftp_localname);
if (local_name == NULL)
if ((local_name = strchr (remote_name, ':')) != NULL)
local_name++; /* skip over the colon */
set_current_frame (create_new_frame (read_fp (), stop_pc));
select_frame (get_current_frame (), 0);
print_stack_frame (selected_frame, -1, 1);
- free (serial_port_name);
+ xfree (serial_port_name);
}
static void
-mips_open (name, from_tty)
- char *name;
- int from_tty;
+mips_open (char *name, int from_tty)
{
const char *monitor_prompt = NULL;
if (TARGET_ARCHITECTURE != NULL
}
static void
-pmon_open (name, from_tty)
- char *name;
- int from_tty;
+pmon_open (char *name, int from_tty)
{
common_open (&pmon_ops, name, from_tty, MON_PMON, "PMON> ");
}
static void
-ddb_open (name, from_tty)
- char *name;
- int from_tty;
+ddb_open (char *name, int from_tty)
{
common_open (&ddb_ops, name, from_tty, MON_DDB, "NEC010>");
}
static void
-lsi_open (name, from_tty)
- char *name;
- int from_tty;
+lsi_open (char *name, int from_tty)
{
int i;
/* Close a connection to the remote board. */
static void
-mips_close (quitting)
- int quitting;
+mips_close (int quitting)
{
if (mips_is_open)
{
/* Detach from the remote board. */
static void
-mips_detach (args, from_tty)
- char *args;
- int from_tty;
+mips_detach (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 (pid, step, siggnal)
- int pid, step;
- enum target_signal siggnal;
+mips_resume (int pid, int step, enum target_signal siggnal)
{
int err;
/* LSI PMON requires returns a reply packet "0x1 s 0x0 0x57f" after
a single step, so we wait for that. */
- mips_request (step ? 's' : 'c',
- (unsigned int) 1,
- (unsigned int) siggnal,
+ mips_request (step ? 's' : 'c', 1, siggnal,
mips_monitor == MON_LSI && step ? &err : (int *) NULL,
mips_receive_wait, NULL);
}
/* Return the signal corresponding to SIG, where SIG is the number which
the MIPS protocol uses for the signal. */
enum target_signal
-mips_signal_from_protocol (sig)
- int sig;
+mips_signal_from_protocol (int sig)
{
/* We allow a few more signals than the IDT board actually returns, on
the theory that there is at least *some* hope that perhaps the numbering
/* Wait until the remote stops, and return a wait status. */
static int
-mips_wait (pid, status)
- int pid;
- struct target_waitstatus *status;
+mips_wait (int pid, struct target_waitstatus *status)
{
int rstatus;
int err;
/* No timeout; we sit here as long as the program continues to execute. */
mips_wait_flag = 1;
- rstatus = mips_request ('\000', (unsigned int) 0, (unsigned int) 0, &err, -1,
- buff);
+ rstatus = mips_request ('\000', 0, 0, &err, -1, buff);
mips_wait_flag = 0;
if (err)
mips_error ("Remote failure: %s", safe_strerror (errno));
#define REGNO_OFFSET 96
static int
-mips_map_regno (regno)
- int regno;
+mips_map_regno (int regno)
{
if (regno < 32)
return regno;
/* Fetch the remote registers. */
static void
-mips_fetch_registers (regno)
- int regno;
+mips_fetch_registers (int regno)
{
unsigned LONGEST val;
int err;
compiled without the 64bit register access commands. This
means we cannot get hold of the full register width. */
if (mips_monitor == MON_DDB)
- val = (unsigned) mips_request ('t', (unsigned int) pmon_reg,
- (unsigned int) 0, &err, mips_receive_wait, NULL);
+ val = (unsigned) mips_request ('t', pmon_reg, 0,
+ &err, mips_receive_wait, NULL);
else
- val = mips_request ('r', (unsigned int) pmon_reg,
- (unsigned int) 0, &err, mips_receive_wait, NULL);
+ val = mips_request ('r', pmon_reg, 0,
+ &err, mips_receive_wait, NULL);
if (err)
mips_error ("Can't read register %d: %s", regno,
safe_strerror (errno));
registers, so this function doesn't have to do anything. */
static void
-mips_prepare_to_store ()
+mips_prepare_to_store (void)
{
}
/* Store remote register(s). */
static void
-mips_store_registers (regno)
- int regno;
+mips_store_registers (int regno)
{
int err;
return;
}
- mips_request ('R', (unsigned int) mips_map_regno (regno),
+ mips_request ('R', mips_map_regno (regno),
read_register (regno),
&err, mips_receive_wait, NULL);
if (err)
/* Fetch a word from the target board. */
static unsigned int
-mips_fetch_word (addr)
- CORE_ADDR addr;
+mips_fetch_word (CORE_ADDR addr)
{
unsigned int val;
int err;
- /* FIXME! addr was cast to uint! */
- val = mips_request ('d', addr, (unsigned int) 0, &err,
- mips_receive_wait, NULL);
+ val = mips_request ('d', addr, 0, &err, mips_receive_wait, NULL);
if (err)
{
/* Data space failed; try instruction space. */
- /* FIXME! addr was cast to uint! */
- val = mips_request ('i', addr, (unsigned int) 0, &err,
+ val = mips_request ('i', addr, 0, &err,
mips_receive_wait, NULL);
if (err)
mips_error ("Can't read address 0x%s: %s",
/* FIXME! make sure only 32-bit quantities get stored! */
static int
-mips_store_word (addr, val, old_contents)
- CORE_ADDR addr;
- unsigned int val;
- char *old_contents;
+mips_store_word (CORE_ADDR addr, unsigned int val, char *old_contents)
{
int err;
unsigned int oldcontents;
- oldcontents = mips_request ('D', addr, (unsigned int) val,
- &err,
+ oldcontents = mips_request ('D', addr, val, &err,
mips_receive_wait, NULL);
if (err)
{
/* Data space failed; try instruction space. */
- oldcontents = mips_request ('I', addr,
- (unsigned int) val, &err,
+ oldcontents = mips_request ('I', addr, val, &err,
mips_receive_wait, NULL);
if (err)
return errno;
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 (memaddr, myaddr, len, write, ignore)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int write;
- struct target_ops *ignore;
-{
- register int i;
+mips_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+ struct target_ops *ignore)
+{
+ int i;
+ CORE_ADDR addr;
+ int count;
+ char *buffer;
+ int status;
+
+ /* PMON targets do not cope well with 64 bit addresses. Mask the
+ value down to 32 bits. */
+ if (mask_address_p)
+ memaddr &= (CORE_ADDR) 0xffffffff;
+
/* Round starting address down to longword boundary. */
- register CORE_ADDR addr = memaddr & ~3;
+ addr = memaddr & ~3;
/* Round ending address up; get number of longwords that makes. */
- register int count = (((memaddr + len) - addr) + 3) / 4;
+ count = (((memaddr + len) - addr) + 3) / 4;
/* Allocate buffer of that many longwords. */
- register char *buffer = alloca (count * 4);
-
- int status;
+ buffer = alloca (count * 4);
if (write)
{
/* Print info on this target. */
static void
-mips_files_info (ignore)
- struct target_ops *ignore;
+mips_files_info (struct target_ops *ignore)
{
printf_unfiltered ("Debugging a MIPS board over a serial line.\n");
}
right port, we could interrupt the process with a break signal. */
static void
-mips_kill ()
+mips_kill (void)
{
if (!mips_wait_flag)
return;
/* Start running on the target board. */
static void
-mips_create_inferior (execfile, args, env)
- char *execfile;
- char *args;
- char **env;
+mips_create_inferior (char *execfile, char *args, char **env)
{
CORE_ADDR entry_pt;
/* Clean up after a process. Actually nothing to do. */
static void
-mips_mourn_inferior ()
+mips_mourn_inferior (void)
{
if (current_ops != NULL)
unpush_target (current_ops);
is accomplished via BREAKPOINT_MAX). */
static int
-mips_insert_breakpoint (addr, contents_cache)
- CORE_ADDR addr;
- char *contents_cache;
+mips_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
{
if (monitor_supports_breakpoints)
return set_breakpoint (addr, MIPS_INSTLEN, BREAK_FETCH);
}
static int
-mips_remove_breakpoint (addr, contents_cache)
- CORE_ADDR addr;
- char *contents_cache;
+mips_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
{
if (monitor_supports_breakpoints)
return clear_breakpoint (addr, MIPS_INSTLEN, BREAK_FETCH);
/* NOTE: The code relies on this vector being zero-initialised by the system */
static int
-pmon_insert_breakpoint (addr, contents_cache)
- CORE_ADDR addr;
- char *contents_cache;
+pmon_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
{
int status;
mips_expect ("Bpt ");
- if (!mips_getstring (tbuff, 2))
+ if (!mips_getstring (tbuff, remote_timeout))
return 1;
tbuff[2] = '\0'; /* terminate the string */
if (sscanf (tbuff, "%d", &bpnum) != 1)
}
static int
-pmon_remove_breakpoint (addr, contents_cache)
- CORE_ADDR addr;
- char *contents_cache;
+pmon_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
{
if (monitor_supports_breakpoints)
{
implements the TARGET_CAN_USE_HARDWARE_WATCHPOINT macro. */
int
-remote_mips_can_use_hardware_watchpoint (cnt)
- int cnt;
+remote_mips_can_use_hardware_watchpoint (int cnt)
{
return cnt < MAX_LSI_BREAKPOINTS && strcmp (target_shortname, "lsi") == 0;
}
This is used for memory ref breakpoints. */
static unsigned long
-calculate_mask (addr, len)
- CORE_ADDR addr;
- int len;
+calculate_mask (CORE_ADDR addr, int len)
{
unsigned long mask;
int i;
implement ordinary breakpoints using hardware facilities. */
int
-remote_mips_insert_hw_breakpoint (addr, contents_cache)
- CORE_ADDR addr;
- char *contents_cache;
+remote_mips_insert_hw_breakpoint (CORE_ADDR addr, char *contents_cache)
{
if (strcmp (target_shortname, "lsi") == 0)
return mips_insert_breakpoint (addr, contents_cache);
implement ordinary breakpoints using hardware facilities. */
int
-remote_mips_remove_hw_breakpoint (addr, contents_cache)
- CORE_ADDR addr;
- char *contents_cache;
+remote_mips_remove_hw_breakpoint (CORE_ADDR addr, char *contents_cache)
{
if (strcmp (target_shortname, "lsi") == 0)
return mips_remove_breakpoint (addr, contents_cache);
watchpoint. */
int
-remote_mips_set_watchpoint (addr, len, type)
- CORE_ADDR addr;
- int len;
- int type;
+remote_mips_set_watchpoint (CORE_ADDR addr, int len, int type)
{
if (set_breakpoint (addr, len, type))
return -1;
}
int
-remote_mips_remove_watchpoint (addr, len, type)
- CORE_ADDR addr;
- int len;
- int type;
+remote_mips_remove_watchpoint (CORE_ADDR addr, int len, int type)
{
if (clear_breakpoint (addr, len, type))
return -1;
/* Insert a breakpoint. */
static int
-set_breakpoint (addr, len, type)
- CORE_ADDR addr;
- int len;
- enum break_type type;
+set_breakpoint (CORE_ADDR addr, int len, enum break_type type)
{
return common_breakpoint (1, addr, len, type);
}
/* Clear a breakpoint. */
static int
-clear_breakpoint (addr, len, type)
- CORE_ADDR addr;
- int len;
- enum break_type type;
+clear_breakpoint (CORE_ADDR addr, int len, enum break_type type)
{
return common_breakpoint (0, addr, len, type);
}
This is a helper function for common_breakpoint. */
static int
-check_lsi_error (addr, rerrflg)
- CORE_ADDR addr;
- int rerrflg;
+check_lsi_error (CORE_ADDR addr, int rerrflg)
{
struct lsi_error *err;
char *saddr = paddr_nz (addr); /* printable address string */
Return 0 if successful; otherwise 1. */
static int
-common_breakpoint (set, addr, len, type)
- int set;
- CORE_ADDR addr;
- int len;
- enum break_type type;
+common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
{
char buf[DATA_MAXLEN + 1];
char cmd, rcmd;
}
\f
static void
-send_srec (srec, len, addr)
- char *srec;
- int len;
- CORE_ADDR addr;
+send_srec (char *srec, int len, CORE_ADDR addr)
{
while (1)
{
SERIAL_WRITE (mips_desc, srec, len);
- ch = mips_readchar (2);
+ ch = mips_readchar (remote_timeout);
switch (ch)
{
/* Download a binary file by converting it to S records. */
static void
-mips_load_srec (args)
- char *args;
+mips_load_srec (char *args)
{
bfd *abfd;
asection *s;
*/
static int
-mips_make_srec (buf, type, memaddr, myaddr, len)
- char *buf;
- int type;
- CORE_ADDR memaddr;
- unsigned char *myaddr;
- int len;
+mips_make_srec (char *buf, int type, CORE_ADDR memaddr, unsigned char *myaddr,
+ int len)
{
unsigned char checksum;
int i;
pointer non-NULL). The function returns the number of encoded
characters written into the buffer. */
static int
-pmon_makeb64 (v, p, n, chksum)
- unsigned long v;
- char *p;
- int n;
- int *chksum;
+pmon_makeb64 (unsigned long v, char *p, int n, int *chksum)
{
int count = (n / 6);
/* Shorthand function (that could be in-lined) to output the zero-fill
escape sequence into the data stream. */
static int
-pmon_zeroset (recsize, buff, amount, chksum)
- int recsize;
- char **buff;
- int *amount;
- unsigned int *chksum;
+pmon_zeroset (int recsize, char **buff, int *amount, unsigned int *chksum)
{
int count;
}
static int
-pmon_checkset (recsize, buff, value)
- int recsize;
- char **buff;
- int *value;
+pmon_checkset (int recsize, char **buff, int *value)
{
int count;
is for PMON 5.x on the Cogent Vr4300 board. */
static void
-pmon_make_fastrec (outbuf, inbuf, inptr, inamount, recsize, csum, zerofill)
- char **outbuf;
- unsigned char *inbuf;
- int *inptr;
- int inamount;
- int *recsize;
- unsigned int *csum;
- unsigned int *zerofill;
+pmon_make_fastrec (char **outbuf, unsigned char *inbuf, int *inptr,
+ int inamount, int *recsize, unsigned int *csum,
+ unsigned int *zerofill)
{
int count = 0;
char *p = *outbuf;
}
static int
-pmon_check_ack (mesg)
- char *mesg;
+pmon_check_ack (char *mesg)
{
#if defined(DOETXACK)
int c;
if (!tftp_in_use)
{
- c = SERIAL_READCHAR (udp_in_use ? udp_desc : mips_desc, 2);
+ c = SERIAL_READCHAR (udp_in_use ? udp_desc : mips_desc,
+ remote_timeout);
if ((c == SERIAL_TIMEOUT) || (c != 0x06))
{
fprintf_unfiltered (gdb_stderr,
which is either a serial port or a UDP socket. */
static void
-pmon_start_download ()
+pmon_start_download (void)
{
if (tftp_in_use)
{
}
static void
-pmon_end_download (final, bintotal)
- int final;
- int bintotal;
+pmon_check_entry_address (char *entry_address, int final)
+{
+ char hexnumber[9]; /* includes '\0' space */
+ mips_expect_timeout (entry_address, tftp_in_use ? 15 : remote_timeout);
+ sprintf (hexnumber, "%x", final);
+ mips_expect (hexnumber);
+ mips_expect ("\r\n");
+}
+
+static int
+pmon_check_total (int bintotal)
+{
+ char hexnumber[9]; /* includes '\0' space */
+ mips_expect ("\r\ntotal = 0x");
+ sprintf (hexnumber, "%x", bintotal);
+ mips_expect (hexnumber);
+ return mips_expect_download (" bytes\r\n");
+}
+
+static void
+pmon_end_download (int final, int bintotal)
{
char hexnumber[9]; /* includes '\0' space */
strcat (cmd, tftp_name);
strcat (cmd, "\r");
mips_send_command (cmd, 0);
- free (cmd);
+ xfree (cmd);
if (!mips_expect_download ("Downloading from "))
return;
if (!mips_expect_download (tftp_name))
/* Wait for the stuff that PMON prints after the load has completed.
The timeout value for use in the tftp case (15 seconds) was picked
arbitrarily but might be too small for really large downloads. FIXME. */
- if (mips_monitor == MON_LSI)
+ switch (mips_monitor)
{
+ case MON_LSI:
+ pmon_check_ack ("termination");
+ pmon_check_entry_address ("Entry address is ", final);
+ if (!pmon_check_total (bintotal))
+ return;
+ break;
+ default:
+ pmon_check_entry_address ("Entry Address = ", final);
pmon_check_ack ("termination");
- mips_expect_timeout ("Entry address is ", tftp_in_use ? 15 : 2);
+ if (!pmon_check_total (bintotal))
+ return;
+ break;
}
- else
- mips_expect_timeout ("Entry Address = ", tftp_in_use ? 15 : 2);
-
- sprintf (hexnumber, "%x", final);
- mips_expect (hexnumber);
- mips_expect ("\r\n");
- if (mips_monitor != MON_LSI)
- pmon_check_ack ("termination");
- mips_expect ("\r\ntotal = 0x");
- sprintf (hexnumber, "%x", bintotal);
- mips_expect (hexnumber);
- if (!mips_expect_download (" bytes\r\n"))
- return;
if (tftp_in_use)
remove (tftp_localname); /* Remove temporary file */
}
static void
-pmon_download (buffer, length)
- char *buffer;
- int length;
+pmon_download (char *buffer, int length)
{
if (tftp_in_use)
fwrite (buffer, 1, length, tftp_file);
}
static void
-pmon_load_fast (file)
- char *file;
+pmon_load_fast (char *file)
{
bfd *abfd;
asection *s;
/* mips_load -- download a file. */
static void
-mips_load (file, from_tty)
- char *file;
- int from_tty;
+mips_load (char *file, int from_tty)
{
/* Get the board out of remote debugging mode. */
if (mips_exit_debug ())
/* Pass the command argument as a packet to PMON verbatim. */
static void
-pmon_command (args, from_tty)
- char *args;
- int from_tty;
+pmon_command (char *args, int from_tty)
{
char buf[DATA_MAXLEN + 1];
int rlen;
}
\f
void
-_initialize_remote_mips ()
+_initialize_remote_mips (void)
{
/* Initialize the fields in mips_ops that are common to all four targets. */
mips_ops.to_longname = "Remote MIPS debugging over serial line";
add_com ("pmon <command>", class_obscure, pmon_command,
"Send a packet to PMON (must be in debug mode).");
+
+ add_show_from_set (add_set_cmd ("mask-address", no_class,
+ var_boolean, &mask_address_p,
+ "Set zeroing of upper 32 bits of 64-bit addresses when talking to PMON targets.\n\
+Use \"on\" to enable the masking and \"off\" to disable it.\n",
+ &setlist),
+ &showlist);
}