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;
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;
}
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);
really connected. */
static void
-mips_initialize ()
+mips_initialize (void)
{
int err;
struct cleanup *old_cleanups = make_cleanup (mips_initialize_cleanups, NULL);
/* 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;
/* 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;
#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;
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;
/* 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! 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;
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;
+mips_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+ struct target_ops *ignore)
{
int i;
CORE_ADDR addr;
/* 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";
projects / deliverable / binutils-gdb.git / blobdiff