/* Remote debugging interface for boot monitors, for GDB.
- Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
- Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
+ Copyright 1990, 1991, 1992, 1993, 1995, 1996
+ Free Software Foundation, Inc.
+ Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
+ Resurrected from the ashes by Stu Grossman.
This file is part of GDB.
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* This file was derived from various remote-* modules. It is a collection
of generic support functions so GDB can talk directly to a ROM based
This module talks to a debug monitor called 'MONITOR', which
We communicate with MONITOR via either a direct serial line, or a TCP
(or possibly TELNET) stream to a terminal multiplexor,
- which in turn talks to the target board.
-*/
+ which in turn talks to the target board. */
+
+/* FIXME 32x64: This code assumes that registers and addresses are at
+ most 32 bits long. If they can be larger, you will need to declare
+ values as LONGEST and use %llx or some such to print values when
+ building commands to send to the monitor. Since we don't know of
+ any actual 64-bit targets with ROM monitors that use this code,
+ it's not an issue right now. -sts 4/18/96 */
#include "defs.h"
#include "gdbcore.h"
#include "target.h"
#include "wait.h"
+#ifdef ANSI_PROTOTYPES
+#include <stdarg.h>
+#else
#include <varargs.h>
+#endif
#include <signal.h>
-#include <string.h>
+#include <ctype.h>
+#include "gdb_string.h"
#include <sys/types.h>
#include "command.h"
#include "serial.h"
#include "monitor.h"
-#include "remote-utils.h"
+#include "gdbcmd.h"
+#include "inferior.h"
+#include "gnu-regex.h"
+#include "dcache.h"
+#include "srec.h"
-#ifdef HAVE_TERMIO
-# define TERMINAL struct termios
-#else
-# define TERMINAL struct sgttyb
-#endif
+static char *dev_name;
+static struct target_ops *targ_ops;
-struct monitor_ops *current_monitor;
-extern struct cmd_list_element *setlist;
-extern struct cmd_list_element *unsetlist;
-struct cmd_list_element *showlist;
+static int readchar PARAMS ((int timeout));
-static int hashmark; /* flag set by "set hash" */
+static void monitor_command PARAMS ((char *args, int fromtty));
-/* FIXME: Replace with sr_get_debug (). */
-#define LOG_FILE "monitor.log"
-#if defined (LOG_FILE)
-FILE *log_file;
-#endif
+static void monitor_fetch_register PARAMS ((int regno));
+static void monitor_store_register PARAMS ((int regno));
-static int timeout = 24;
+static void monitor_detach PARAMS ((char *args, int from_tty));
+static void monitor_resume PARAMS ((int pid, int step, enum target_signal sig));
+static void monitor_interrupt PARAMS ((int signo));
+static void monitor_interrupt_twice PARAMS ((int signo));
+static void monitor_interrupt_query PARAMS ((void));
+static void monitor_wait_cleanup PARAMS ((int old_timeout));
+
+static int monitor_wait PARAMS ((int pid, struct target_waitstatus *status));
+static void monitor_fetch_registers PARAMS ((int regno));
+static void monitor_store_registers PARAMS ((int regno));
+static void monitor_prepare_to_store PARAMS ((void));
+static int monitor_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len, int write, struct target_ops *target));
+static void monitor_files_info PARAMS ((struct target_ops *ops));
+static int monitor_insert_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
+static int monitor_remove_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
+static void monitor_kill PARAMS ((void));
+static void monitor_load PARAMS ((char *file, int from_tty));
+static void monitor_mourn_inferior PARAMS ((void));
+static void monitor_stop PARAMS ((void));
+static void monitor_debug PARAMS ((char *prefix, char *string, char *suffix));
+
+static int monitor_read_memory PARAMS ((CORE_ADDR addr, char *myaddr,int len));
+static int monitor_write_memory PARAMS ((CORE_ADDR addr, char *myaddr,int len));
+
+static int monitor_expect_regexp PARAMS ((struct re_pattern_buffer *pat,
+ char *buf, int buflen));
+static int from_hex PARAMS ((int a));
+static unsigned long get_hex_word PARAMS ((void));
+
+static struct monitor_ops *current_monitor;
+
+static int hashmark; /* flag set by "set hash" */
+
+static int timeout = 30;
+
+static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait() */
+
+static void (*ofunc)(); /* Old SIGINT signal handler */
+
+/* Descriptor for I/O to remote machine. Initialize it to NULL so
+ that monitor_open knows that we don't have a file open when the
+ program starts. */
-/* Descriptor for I/O to remote machine. Initialize it to NULL so that
- monitor_open knows that we don't have a file open when the program starts.
- */
static serial_t monitor_desc = NULL;
-/* sets the download protocol, choices are srec, generic, boot */
-char *loadtype;
-static char *loadtype_str;
-static void set_loadtype_command();
+/* Pointer to regexp pattern matching data */
+
+static struct re_pattern_buffer register_pattern;
+static char register_fastmap[256];
+
+static struct re_pattern_buffer getmem_resp_delim_pattern;
+static char getmem_resp_delim_fastmap[256];
+
+static int dump_reg_flag; /* Non-zero means do a dump_registers cmd when
+ monitor_wait wakes up. */
+
+static DCACHE *remote_dcache;
+static int first_time=0; /* is this the first time we're executing after
+ gaving created the child proccess? */
+
+/* monitor_debug is like fputs_unfiltered, except it prints special
+ characters in printable fashion. */
-/*
- * set_loadtype_command -- set the type for downloading. Check to make
- * sure you have a support protocol for this target.
- */
static void
-set_loadtype_command (ignore, from_tty, c)
- char *ignore;
- int from_tty;
- struct cmd_list_element *c;
+monitor_debug (prefix, string, suffix)
+ char *prefix;
+ char *string;
+ char *suffix;
{
-#if 0
- char *type;
- if (strcmp (LOADTYPES, "")) {
- error ("No loadtype set");
- return;
+ int ch;
+
+ /* print prefix and suffix after each line */
+ static int new_line=1;
+ static char *prev_prefix = "";
+ static char *prev_suffix = "";
+
+ /* if the prefix is changing, print the previous suffix, a new line,
+ and the new prefix */
+ if (strcmp(prev_prefix, prefix) != 0 && !new_line)
+ {
+ fputs_unfiltered (prev_suffix, gdb_stderr);
+ fputs_unfiltered ("\n", gdb_stderr);
+ fputs_unfiltered (prefix, gdb_stderr);
+ }
+ prev_prefix = prefix;
+ prev_suffix = suffix;
+
+ /* print prefix if last char was a newline*/
+
+ if (new_line == 1) {
+ fputs_unfiltered (prefix, gdb_stderr);
+ new_line=0;
}
-
- type = strtok(LOADTYPES, ",");
- if (STREQ (type, (*(char **) c->var))) {
- loadtype_str = savestring (*(char **) c->var, strlen (*(char **) c->var));
- return;
+ if (strchr(string,'\n')) /* save state for next call */
+ new_line=1;
+
+ while ((ch = *string++) != '\0')
+ {
+ switch (ch) {
+ default:
+ if (isprint (ch))
+ fputc_unfiltered (ch, gdb_stderr);
+
+ else
+ fprintf_unfiltered (gdb_stderr, "\\%03o", ch);
+
+ break;
+
+ case '\\': fputs_unfiltered ("\\\\", gdb_stderr); break;
+ case '\b': fputs_unfiltered ("\\b", gdb_stderr); break;
+ case '\f': fputs_unfiltered ("\\f", gdb_stderr); break;
+ case '\n': fputs_unfiltered ("\\n", gdb_stderr); break;
+ case '\r': fputs_unfiltered ("\\r", gdb_stderr); break;
+ case '\t': fputs_unfiltered ("\\t", gdb_stderr); break;
+ case '\v': fputs_unfiltered ("\\v", gdb_stderr); break;
+ }
}
-
- while (type = strtok (NULL, ",") != (char *)NULL)
- if (STREQ (type, (*(char **) c->var)))
- loadtype_str = savestring (*(char **) c->var, strlen (*(char **) c->var));
+
+ if (new_line==1) { /* print suffix if last char was a newline */
+ fputs_unfiltered (suffix, gdb_stderr);
+ fputs_unfiltered ("\n", gdb_stderr);
+ }
+}
+
+/* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
+ Works just like printf. */
+
+void
+#ifdef ANSI_PROTOTYPES
+monitor_printf_noecho (char *pattern, ...)
+#else
+monitor_printf_noecho (va_alist)
+ va_dcl
+#endif
+{
+ va_list args;
+ char sndbuf[2000];
+ int len;
+
+#if ANSI_PROTOTYPES
+ va_start (args, pattern);
+#else
+ char *pattern;
+ va_start (args);
+ pattern = va_arg (args, char *);
#endif
- loadtype_str = savestring (*(char **) c->var, strlen (*(char **) c->var));
+
+ vsprintf (sndbuf, pattern, args);
+
+ if (remote_debug > 0)
+ monitor_debug ("sent -->", sndbuf, "<--");
+
+ len = strlen (sndbuf);
+
+ if (len + 1 > sizeof sndbuf)
+ abort ();
+
+ if (SERIAL_WRITE(monitor_desc, sndbuf, len))
+ fprintf_unfiltered (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
}
-/*
- * printf_monitor -- send data to monitor. Works just like printf.
- */
-static void
-printf_monitor(va_alist)
+/* monitor_printf -- Send data to monitor and check the echo. Works just like
+ printf. */
+
+void
+#ifdef ANSI_PROTOTYPES
+monitor_printf (char *pattern, ...)
+#else
+monitor_printf (va_alist)
va_dcl
+#endif
{
va_list args;
+ char sndbuf[2000];
+ int len;
+
+#ifdef ANSI_PROTOTYPES
+ va_start (args, pattern);
+#else
char *pattern;
- char buf[200];
- int i;
+ va_start (args);
+ pattern = va_arg (args, char *);
+#endif
+
+ vsprintf (sndbuf, pattern, args);
- va_start(args);
+ if (remote_debug > 0)
+ monitor_debug ("sent -->", sndbuf, "<--");
- pattern = va_arg(args, char *);
+ len = strlen (sndbuf);
- vsprintf(buf, pattern, args);
+ if (len + 1 > sizeof sndbuf)
+ abort ();
- if (sr_get_debug() > 3)
- printf ("Sending to monitor,\r\n\t\"%s\".\r\n", buf);
+ if (SERIAL_WRITE(monitor_desc, sndbuf, len))
+ fprintf_unfiltered (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
- if (SERIAL_WRITE(monitor_desc, buf, strlen(buf)))
- fprintf(stderr, "SERIAL_WRITE failed: %s\n", safe_strerror(errno));
+ /* We used to expect that the next immediate output was the characters we
+ just output, but sometimes some extra junk appeared before the characters
+ we expected, like an extra prompt, or a portmaster sending telnet negotiations.
+ So, just start searching for what we sent, and skip anything unknown. */
+ monitor_expect (sndbuf, (char *)0, 0);
}
-/* readchar -- read a character from the remote system, doing all the fancy
- * timeout stuff.
- */
+/* Read a character from the remote system, doing all the fancy
+ timeout stuff. */
+
static int
-readchar(timeout)
+readchar (timeout)
int timeout;
{
int c;
+ static enum { last_random, last_nl, last_cr, last_crnl } state = last_random;
+ int looping;
- c = SERIAL_READCHAR(monitor_desc, timeout);
+ do
+ {
+ looping = 0;
+ c = SERIAL_READCHAR (monitor_desc, timeout);
- if (sr_get_debug() > 5)
- putchar(c & 0x7f);
+ if (c >= 0)
+ {
+ c &= 0x7f;
+ if (remote_debug > 0)
+ {
+ char buf[2];
+ buf[0] = c;
+ buf[1] = '\0';
+ monitor_debug ("read -->", buf, "<--");
+ }
+ }
-#ifdef LOG_FILE
- if (isascii (c))
- putc(c & 0x7f, log_file);
-#endif
+ /* Canonicialize \n\r combinations into one \r */
+ if ((current_monitor->flags & MO_HANDLE_NL) != 0)
+ {
+ if ((c == '\r' && state == last_nl)
+ || (c == '\n' && state == last_cr))
+ {
+ state = last_crnl;
+ looping = 1;
+ }
+ else if (c == '\r')
+ state = last_cr;
+ else if (c != '\n')
+ state = last_random;
+ else
+ {
+ state = last_nl;
+ c = '\r';
+ }
+ }
+ }
+ while (looping);
if (c >= 0)
- return c & 0x7f;
+ return c;
+
+ if (c == SERIAL_TIMEOUT)
+#ifdef MAINTENANCE_CMDS
+ if (in_monitor_wait) /* Watchdog went off */
+ {
+ target_mourn_inferior ();
+ error ("Watchdog has expired. Target detached.\n");
+ }
+ else
+#endif
+ error ("Timeout reading from remote system.");
- if (c == SERIAL_TIMEOUT) {
- if (timeout == 0)
- return c; /* Polls shouldn't generate timeout errors */
- error("Timeout reading from remote system.");
- }
- perror_with_name("remote-monitor");
+ perror_with_name ("remote-monitor");
}
-/*
- * expect -- scan input from the remote system, until STRING is found.
- * If DISCARD is non-zero, then discard non-matching input, else print
- * it out. Let the user break out immediately.
- */
-static void
-expect (string, discard)
+/* Scan input from the remote system, until STRING is found. If BUF is non-
+ zero, then collect input until we have collected either STRING or BUFLEN-1
+ chars. In either case we terminate BUF with a 0. If input overflows BUF
+ because STRING can't be found, return -1, else return number of chars in BUF
+ (minus the terminating NUL). Note that in the non-overflow case, STRING
+ will be at the end of BUF. */
+
+int
+monitor_expect (string, buf, buflen)
char *string;
- int discard;
+ char *buf;
+ int buflen;
{
char *p = string;
+ int obuflen = buflen;
int c;
+ extern struct target_ops *targ_ops;
+
+ immediate_quit = 1;
+ while (1)
+ {
+ if (buf)
+ {
+ if (buflen < 2)
+ {
+ *buf = '\000';
+ immediate_quit = 0;
+ return -1;
+ }
+
+ c = readchar (timeout);
+ if (c == '\000')
+ continue;
+ *buf++ = c;
+ buflen--;
+ }
+ else
+ c = readchar (timeout);
+
+ /* Don't expect any ^C sent to be echoed */
+
+ if (*p == '\003' || c == *p)
+ {
+ p++;
+ if (*p == '\0')
+ {
+ immediate_quit = 0;
+
+ if (buf)
+ {
+ *buf++ = '\000';
+ return obuflen - buflen;
+ }
+ else
+ return 0;
+ }
+ }
+ else if ((c == '\021' || c == '\023') &&
+ (strcmp(targ_ops->to_shortname, "m32r") == 0))
+ { /* m32r monitor emits random DC1/DC3 chars */
+ continue;
+ }
+ else
+ {
+ p = string;
+ if (c == *p)
+ p++;
+ }
+ }
+}
+/* Search for a regexp. */
- if (sr_get_debug())
- printf ("Expecting \"%s\".\n", string);
+static int
+monitor_expect_regexp (pat, buf, buflen)
+ struct re_pattern_buffer *pat;
+ char *buf;
+ int buflen;
+{
+ char *mybuf;
+ char *p;
- immediate_quit = 1;
- while (1) {
- c = readchar(timeout);
- if (!isascii (c))
- continue;
- if (c == *p++) {
- if (*p == '\0') {
- immediate_quit = 0;
- if (sr_get_debug())
- printf ("\nMatched\n");
- return;
- }
- } else {
- if (!discard) {
- fwrite(string, 1, (p - 1) - string, stdout);
- putchar((char)c);
- fflush(stdout);
- }
- p = string;
+ if (buf)
+ mybuf = buf;
+ else
+ {
+ mybuf = alloca (1024);
+ buflen = 1024;
+ }
+
+ p = mybuf;
+ while (1)
+ {
+ int retval;
+
+ if (p - mybuf >= buflen)
+ { /* Buffer about to overflow */
+
+/* On overflow, we copy the upper half of the buffer to the lower half. Not
+ great, but it usually works... */
+
+ memcpy (mybuf, mybuf + buflen / 2, buflen / 2);
+ p = mybuf + buflen / 2;
+ }
+
+ *p++ = readchar (timeout);
+
+ retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL);
+ if (retval >= 0)
+ return 1;
}
- }
}
/* Keep discarding input until we see the MONITOR prompt.
o *then* wait for the prompt.
Thus the last thing that a procedure does with the serial line
- will be an expect_prompt(). Exception: monitor_resume does not
+ will be an monitor_expect_prompt(). Exception: monitor_resume does not
wait for the prompt, because the terminal is being handed over
to the inferior. However, the next thing which happens after that
is a monitor_wait which does wait for the prompt.
Note that this includes abnormal exit, e.g. error(). This is
necessary to prevent getting into states from which we can't
recover. */
-static void
-expect_prompt(discard)
- int discard;
-{
-#if defined (LOG_FILE)
- /* This is a convenient place to do this. The idea is to do it often
- enough that we never lose much data if we terminate abnormally. */
- fflush(log_file);
-#endif
- expect (PROMPT, discard);
-}
-
-/*
- * junk -- ignore junk characters. Returns a 1 if junk, 0 otherwise
- */
-static int
-junk(ch)
- char ch;
-{
- switch (ch) {
- case ' ':
- case '-':
- case '\t':
- case '\r':
- case '\n':
- if (sr_get_debug() > 5)
- printf ("Ignoring \'%c\'.\n", ch);
- return 1;
- default:
- if (sr_get_debug() > 5)
- printf ("Accepting \'%c\'.\n", ch);
- return 0;
- }
-}
-/*
- * get_hex_digit -- Get a hex digit from the remote system & return its value.
- * If ignore is nonzero, ignore spaces, newline & tabs.
- */
-static int
-get_hex_digit(ignore)
- int ignore;
+int
+monitor_expect_prompt (buf, buflen)
+ char *buf;
+ int buflen;
{
- static int ch;
- while (1) {
- ch = readchar(timeout);
- if (junk(ch))
- continue;
- if (sr_get_debug() > 4)
- printf ("get_hex_digit() got a 0x%x(%c)\n", ch, ch);
-
- if (ch >= '0' && ch <= '9')
- return ch - '0';
- else if (ch >= 'A' && ch <= 'F')
- return ch - 'A' + 10;
- else if (ch >= 'a' && ch <= 'f')
- return ch - 'a' + 10;
- else if (ch == ' ' && ignore)
- ;
- else {
- expect_prompt(1);
- error("Invalid hex digit from remote system.");
- }
- }
+ return monitor_expect (current_monitor->prompt, buf, buflen);
}
-/* get_hex_byte -- Get a byte from monitor and put it in *BYT.
- * Accept any number leading spaces.
- */
-static void
-get_hex_byte (byt)
- char *byt;
-{
- int val;
-
- val = get_hex_digit (1) << 4;
- if (sr_get_debug() > 3)
- printf ("\nget_hex_digit() -- Read first nibble 0x%x\n", val);
-
- val |= get_hex_digit (0);
- if (sr_get_debug() > 3)
- printf ("\nget_hex_digit() -- Read second nibble 0x%x\n", val);
- *byt = val;
-
- if (sr_get_debug() > 3)
- printf ("\nget_hex_digit() -- Read a 0x%x\n", val);
-}
+/* Get N 32-bit words from remote, each preceded by a space, and put
+ them in registers starting at REGNO. */
-/*
- * get_hex_word -- Get N 32-bit words from remote, each preceded by a space,
- * and put them in registers starting at REGNO.
- */
-static int
+static unsigned long
get_hex_word ()
{
- long val;
+ unsigned long val;
int i;
+ int ch;
- val = 0;
- for (i = 0; i < 8; i++)
- val = (val << 4) + get_hex_digit (i == 0);
-
- if (sr_get_debug() > 3)
- printf ("\nget_hex_word() got a 0x%x.\n", val);
+ do
+ ch = readchar (timeout);
+ while (isspace(ch));
+
+ val = from_hex (ch);
+
+ for (i = 7; i >= 1; i--)
+ {
+ ch = readchar (timeout);
+ if (!isxdigit (ch))
+ break;
+ val = (val << 4) | from_hex (ch);
+ }
return val;
}
-/* This is called not only when we first attach, but also when the
- user types "run" after having attached. */
-void
-monitor_create_inferior (execfile, args, env)
- char *execfile;
- char *args;
- char **env;
+static void
+compile_pattern (pattern, compiled_pattern, fastmap)
+ char *pattern;
+ struct re_pattern_buffer *compiled_pattern;
+ char *fastmap;
{
- int entry_pt;
-
- if (args && *args)
- error("Can't pass arguments to remote MONITOR process");
-
- if (execfile == 0 || exec_bfd == 0)
- error("No exec file specified");
-
- entry_pt = (int) bfd_get_start_address (exec_bfd);
-
-#ifdef LOG_FILE
- fputs ("\nIn Create_inferior()", log_file);
-#endif
-
-/* The "process" (board) is already stopped awaiting our commands, and
- the program is already downloaded. We just set its PC and go. */
+ int tmp;
+ char *val;
- clear_proceed_status ();
-
- /* Tell wait_for_inferior that we've started a new process. */
- init_wait_for_inferior ();
+ compiled_pattern->fastmap = fastmap;
- /* Set up the "saved terminal modes" of the inferior
- based on what modes we are starting it with. */
- target_terminal_init ();
-
- /* Install inferior's terminal modes. */
- target_terminal_inferior ();
+ tmp = re_set_syntax (RE_SYNTAX_EMACS);
+ val = re_compile_pattern (pattern,
+ strlen (pattern),
+ compiled_pattern);
+ re_set_syntax (tmp);
- /* insert_step_breakpoint (); FIXME, do we need this? */
+ if (val)
+ error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern, val);
- /* Let 'er rip... */
- proceed ((CORE_ADDR)entry_pt, TARGET_SIGNAL_DEFAULT, 0);
+ if (fastmap)
+ re_compile_fastmap (compiled_pattern);
}
-/*
- * monitor_open -- open a connection to a remote debugger.
- * NAME is the filename used for communication.
- */
-static int baudrate = 9600;
-static char dev_name[100];
+/* Open a connection to a remote debugger. NAME is the filename used
+ for communication. */
void
-monitor_open(args, name, from_tty)
+monitor_open (args, mon_ops, from_tty)
char *args;
- char *name;
+ struct monitor_ops *mon_ops;
int from_tty;
{
+ char *name;
+ int i;
+ char **p;
+
+ if (mon_ops->magic != MONITOR_OPS_MAGIC)
+ error ("Magic number of monitor_ops struct wrong.");
+
+ targ_ops = mon_ops->target;
+ name = targ_ops->to_shortname;
- if (args == NULL)
+ if (!args)
error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
`target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name, name);
-/* if (is_open) */
- monitor_close(0);
+ target_preopen (from_tty);
- strcpy(dev_name, args);
- monitor_desc = SERIAL_OPEN(dev_name);
+ /* Setup pattern for register dump */
- if (monitor_desc == NULL)
- perror_with_name(dev_name);
+ if (mon_ops->register_pattern)
+ compile_pattern (mon_ops->register_pattern, ®ister_pattern,
+ register_fastmap);
+
+ if (mon_ops->getmem.resp_delim)
+ compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
+ getmem_resp_delim_fastmap);
+
+ unpush_target (targ_ops);
+
+ if (dev_name)
+ free (dev_name);
+ dev_name = strsave (args);
+
+ monitor_desc = SERIAL_OPEN (dev_name);
+
+ if (!monitor_desc)
+ perror_with_name (dev_name);
if (baud_rate != -1)
{
if (SERIAL_SETBAUDRATE (monitor_desc, baud_rate))
{
SERIAL_CLOSE (monitor_desc);
- perror_with_name (name);
+ perror_with_name (dev_name);
}
}
+
+ SERIAL_RAW (monitor_desc);
- SERIAL_RAW(monitor_desc);
+ SERIAL_FLUSH_INPUT (monitor_desc);
-#if defined (LOG_FILE)
- log_file = fopen (LOG_FILE, "w");
- if (log_file == NULL)
- perror_with_name (LOG_FILE);
-#endif
+ /* some systems only work with 2 stop bits */
+
+ SERIAL_SETSTOPBITS (monitor_desc, mon_ops->stopbits);
+
+ current_monitor = mon_ops;
+
+ /* See if we can wake up the monitor. First, try sending a stop sequence,
+ then send the init strings. Last, remove all breakpoints. */
+
+ if (current_monitor->stop)
+ {
+ monitor_stop ();
+ if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
+ {
+ monitor_expect_prompt (NULL, 0);
+ }
+ }
/* wake up the monitor and see if it's alive */
- printf_monitor(INIT_CMD);
- expect_prompt(1); /* See if we get a prompt */
+ for (p = mon_ops->init; *p != NULL; p++)
+ {
+ /* Some of the characters we send may not be echoed,
+ but we hope to get a prompt at the end of it all. */
+
+ if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
+ monitor_printf(*p);
+ else
+ monitor_printf_noecho (*p);
+ monitor_expect_prompt (NULL, 0);
+ }
+
+ SERIAL_FLUSH_INPUT (monitor_desc);
- /* try again to be sure */
- printf_monitor(INIT_CMD);
- expect_prompt(1); /* See if we get a prompt */
+ /* Remove all breakpoints */
+
+ if (mon_ops->clr_all_break)
+ {
+ monitor_printf (mon_ops->clr_all_break);
+ monitor_expect_prompt (NULL, 0);
+ }
if (from_tty)
- printf("Remote target %s connected to %s\n", TARGET_NAME, dev_name);
+ printf_unfiltered ("Remote target %s connected to %s\n", name, dev_name);
-
+ push_target (targ_ops);
+
+ inferior_pid = 42000; /* Make run command think we are busy... */
+
+ /* Give monitor_wait something to read */
+
+ monitor_printf (current_monitor->line_term);
+
+ remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory);
+
+ start_remote ();
}
-/*
- * monitor_close -- Close out all files and local state before this
- * target loses control.
- */
+/* Close out all files and local state before this target loses
+ control. */
void
monitor_close (quitting)
int quitting;
{
- SERIAL_CLOSE(monitor_desc);
+ if (monitor_desc)
+ SERIAL_CLOSE (monitor_desc);
monitor_desc = NULL;
-
- if (sr_get_debug() > 4)
- puts ("\nmonitor_close ()");
-
-#if defined (LOG_FILE)
- if (log_file) {
- if (ferror(log_file))
- fprintf(stderr, "Error writing log file.\n");
- if (fclose(log_file) != 0)
- fprintf(stderr, "Error closing log file.\n");
- }
-#endif
}
-/*
- * monitor_detach -- terminate the open connection to the remote
- * debugger. Use this when you want to detach and do something
- * else with your gdb.
- */
-void
-monitor_detach (from_tty)
- int from_tty;
-{
-#ifdef LOG_FILE
- fprintf (log_file, "\nmonitor_detach ()\n");
-#endif
-
- pop_target(); /* calls monitor_close to do the real work */
- if (from_tty)
- printf ("Ending remote %s debugging\n", target_shortname);
-}
+/* Terminate the open connection to the remote debugger. Use this
+ when you want to detach and do something else with your gdb. */
-/*
- * monitor_attach -- attach GDB to the target.
- */
-void
-monitor_attach (args, from_tty)
+static void
+monitor_detach (args, from_tty)
char *args;
int from_tty;
{
+ pop_target (); /* calls monitor_close to do the real work */
if (from_tty)
- printf ("Starting remote %s debugging\n", target_shortname);
-
-#ifdef LOG_FILE
- fprintf (log_file, "\nmonitor_attach (args=%s)\n", args);
-#endif
-
- if (sr_get_debug() > 4)
- printf ("\nmonitor_attach (args=%s)\n", args);
-
- printf_monitor (GO_CMD);
- /* swallow the echo. */
- expect (GO_CMD, 1);
-}
-
-/*
- * monitor_resume -- Tell the remote machine to resume.
- */
-void
-monitor_resume (pid, step, sig)
- int pid, step;
- enum target_signal sig;
-{
-#ifdef LOG_FILE
- fprintf (log_file, "\nmonitor_resume (step=%d, sig=%d)\n", step, sig);
-#endif
-
- if (sr_get_debug() > 4)
- printf ("\nmonitor_resume (step=%d, sig=%d)\n", step, sig);
-
- if (step) {
- printf_monitor (STEP_CMD);
- /* wait for the echo. */
- expect (STEP_CMD, 1);
- } else {
- printf_monitor (CONT_CMD);
- /* swallow the echo. */
- expect (CONT_CMD, 1);
- }
+ printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
}
-/*
- * _wait -- Wait until the remote machine stops, then return,
- * storing status in status just as `wait' would.
- */
+/* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
-int
-monitor_wait (pid, status)
- int pid;
- struct target_waitstatus *status;
+char *
+monitor_supply_register (regno, valstr)
+ int regno;
+ char *valstr;
{
- int old_timeout = timeout;
-#ifdef LOG_FILE
- fputs ("\nIn wait ()", log_file);
-#endif
+ unsigned int val;
+ unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
+ char *p;
- status->kind = TARGET_WAITKIND_EXITED;
- status->value.integer = 0;
+ val = strtoul (valstr, &p, 16);
- timeout = 0; /* Don't time out -- user program is running. */
+ if (val == 0 && valstr == p)
+ error ("monitor_supply_register (%d): bad value from monitor: %s.",
+ regno, valstr);
- expect_prompt(0); /* Wait for prompt, outputting extraneous text */
+ /* supply register stores in target byte order, so swap here */
- status->kind = TARGET_WAITKIND_STOPPED;
- status->value.sig = TARGET_SIGNAL_TRAP;
+ store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
- timeout = old_timeout;
+ supply_register (regno, regbuf);
- return 0;
+ return p;
}
-/* Return the name of register number regno in the form input and output by
- monitor. Currently, register_names just happens to contain exactly what
- monitor wants. Lets take advantage of that just as long as possible! */
+/* Tell the remote machine to resume. */
-static char *
-get_reg_name (regno)
- int regno;
+static void
+monitor_resume (pid, step, sig)
+ int pid, step;
+ enum target_signal sig;
{
- static char buf[50];
- const char *p;
- char *b;
-
- b = buf;
-
- if (regno < 0)
- return ("");
+ /* Some monitors require a different command when starting a program */
+ if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
+ {
+ first_time = 0;
+ monitor_printf ("run\r");
+ if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
+ dump_reg_flag = 1;
+ return;
+ }
+ dcache_flush (remote_dcache);
+ if (step)
+ monitor_printf (current_monitor->step);
+ else
+ {
+ monitor_printf (current_monitor->cont);
+ if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
+ dump_reg_flag = 1;
+ }
+}
- for (p = REGNAMES(regno); *p; p++)
- *b++ = tolower(*p);
+/* Parse the output of a register dump command. A monitor specific
+ regexp is used to extract individual register descriptions of the
+ form REG=VAL. Each description is split up into a name and a value
+ string which are passed down to monitor specific code. */
- *b = '\000';
+static char *
+parse_register_dump (buf, len)
+ char *buf;
+ int len;
+{
+ while (1)
+ {
+ int regnamelen, vallen;
+ char *regname, *val;
+ /* Element 0 points to start of register name, and element 1
+ points to the start of the register value. */
+ struct re_registers register_strings;
+
+ if (re_search (®ister_pattern, buf, len, 0, len,
+ ®ister_strings) == -1)
+ break;
- if (sr_get_debug() > 5)
- printf ("Got name \"%s\" from regno #%d.\n", buf, regno);
+ regnamelen = register_strings.end[1] - register_strings.start[1];
+ regname = buf + register_strings.start[1];
+ vallen = register_strings.end[2] - register_strings.start[2];
+ val = buf + register_strings.start[2];
-#ifdef LOG_FILE
- fprintf (log_file, "Got name \"%s\" from regno #%d.\n", buf, regno);
- fflush (log_file);
-#endif
+ current_monitor->supply_register (regname, regnamelen, val, vallen);
- return buf;
+ buf += register_strings.end[0];
+ len -= register_strings.end[0];
+ }
}
-/* read the remote registers into the block regs. */
+/* Send ^C to target to halt it. Target will respond, and send us a
+ packet. */
-void
-monitor_fetch_registers ()
+static void
+monitor_interrupt (signo)
+ int signo;
{
- int regno;
-
- /* yeah yeah, i know this is horribly inefficient. but it isn't done
- very often... i'll clean it up later. */
+ /* If this doesn't work, try more severe steps. */
+ signal (signo, monitor_interrupt_twice);
+
+ if (remote_debug)
+ printf_unfiltered ("monitor_interrupt called\n");
- for (regno = 0; regno <= PC_REGNUM; regno++)
- monitor_fetch_register(regno);
+ target_stop ();
}
-/*
- * monitor_fetch_register -- fetch register REGNO, or all registers if REGNO
- * is -1. Returns errno value.
- */
-void
-monitor_fetch_register (regno)
- int regno;
+/* The user typed ^C twice. */
+
+static void
+monitor_interrupt_twice (signo)
+ int signo;
+{
+ signal (signo, ofunc);
+
+ monitor_interrupt_query ();
+
+ signal (signo, monitor_interrupt);
+}
+
+/* Ask the user what to do when an interrupt is received. */
+
+static void
+monitor_interrupt_query ()
+{
+ target_terminal_ours ();
+
+ if (query ("Interrupted while waiting for the program.\n\
+Give up (and stop debugging it)? "))
+ {
+ target_mourn_inferior ();
+ return_to_top_level (RETURN_QUIT);
+ }
+
+ target_terminal_inferior ();
+}
+
+static void
+monitor_wait_cleanup (old_timeout)
+ int old_timeout;
{
- int val, j;
+ timeout = old_timeout;
+ signal (SIGINT, ofunc);
+ in_monitor_wait = 0;
+}
+
+/* Wait until the remote machine stops, then return, storing status in
+ status just as `wait' would. */
-#ifdef LOG_FILE
- fprintf (log_file, "\nIn Fetch Register (reg=%s)\n", get_reg_name (regno));
- fflush (log_file);
+static int
+monitor_wait (pid, status)
+ int pid;
+ struct target_waitstatus *status;
+{
+ int old_timeout = timeout;
+ char buf[1024];
+ int resp_len;
+ struct cleanup *old_chain;
+
+ status->kind = TARGET_WAITKIND_EXITED;
+ status->value.integer = 0;
+
+ old_chain = make_cleanup (monitor_wait_cleanup, old_timeout);
+
+#ifdef MAINTENANCE_CMDS
+ in_monitor_wait = 1;
+ timeout = watchdog > 0 ? watchdog : -1;
+#else
+ timeout = -1; /* Don't time out -- user program is running. */
#endif
- if (regno < 0) {
- monitor_fetch_registers ();
- } else {
- char *name = get_reg_name (regno);
- if (STREQ(name, ""))
+ ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
+
+ do
+ {
+ resp_len = monitor_expect_prompt (buf, sizeof (buf));
+
+ if (resp_len <= 0)
+ fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
+ }
+ while (resp_len < 0);
+
+ signal (SIGINT, ofunc);
+
+ timeout = old_timeout;
+
+ if (dump_reg_flag && current_monitor->dump_registers)
+ {
+ dump_reg_flag = 0;
+
+ monitor_printf (current_monitor->dump_registers);
+ resp_len = monitor_expect_prompt (buf, sizeof (buf));
+ }
+
+ if (current_monitor->register_pattern)
+ parse_register_dump (buf, resp_len);
+
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TRAP;
+
+ discard_cleanups (old_chain);
+
+ in_monitor_wait = 0;
+
+ return inferior_pid;
+}
+
+/* Fetch register REGNO, or all registers if REGNO is -1. Returns
+ errno value. */
+
+static void
+monitor_fetch_register (regno)
+ int regno;
+{
+ char *name;
+ static char zerobuf[MAX_REGISTER_RAW_SIZE] = {0};
+ char regbuf[MAX_REGISTER_RAW_SIZE * 2 + 1];
+ int i;
+
+ name = current_monitor->regnames[regno];
+
+ if (!name)
+ {
+ supply_register (regno, zerobuf);
return;
- printf_monitor (ROMCMD(GET_REG), name); /* send the command */
- expect (name, 1); /* then strip the leading garbage */
- if (*ROMDELIM(GET_REG) != 0) { /* if there's a delimiter */
- expect (ROMDELIM(GET_REG), 1);
}
-
- val = get_hex_word(); /* get the value, ignore junk */
- supply_register (regno, (char *) &val);
-
- if (*ROMDELIM(GET_REG) != 0) {
-/*** expect (ROMRES(GET_REG)); ***/
- printf_monitor (CMD_END);
+
+ /* send the register examine command */
+
+ monitor_printf (current_monitor->getreg.cmd, name);
+
+ /* If RESP_DELIM is specified, we search for that as a leading
+ delimiter for the register value. Otherwise, we just start
+ searching from the start of the buf. */
+
+ if (current_monitor->getreg.resp_delim)
+ monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
+
+ /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
+ if (current_monitor->flags & MO_HEX_PREFIX)
+ {
+ int c;
+ c = readchar (timeout);
+ while (c == ' ')
+ c = readchar (timeout);
+ if ((c == '0') && ((c = readchar (timeout)) == 'x'))
+ ;
+ else
+ error ("Bad value returned from monitor while fetching register %x.",
+ regno);
}
- expect_prompt (1);
- }
- return;
+
+ /* Read upto the maximum number of hex digits for this register, skipping
+ spaces, but stop reading if something else is seen. Some monitors
+ like to drop leading zeros. */
+
+ for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
+ {
+ int c;
+ c = readchar (timeout);
+ while (c == ' ')
+ c = readchar (timeout);
+
+ if (!isxdigit (c))
+ break;
+
+ regbuf[i] = c;
+ }
+
+ regbuf[i] = '\000'; /* terminate the number */
+
+ /* If TERM is present, we wait for that to show up. Also, (if TERM
+ is present), we will send TERM_CMD if that is present. In any
+ case, we collect all of the output into buf, and then wait for
+ the normal prompt. */
+
+ if (current_monitor->getreg.term)
+ {
+ monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */
+
+ if (current_monitor->getreg.term_cmd)
+ {
+ monitor_printf (current_monitor->getreg.term_cmd);
+ monitor_expect_prompt (NULL, 0);
+ }
+ }
+ else
+ monitor_expect_prompt (NULL, 0); /* get response */
+
+ monitor_supply_register (regno, regbuf);
}
-/* Store the remote registers from the contents of the block REGS. */
+/* Read the remote registers into the block regs. */
-void
-monitor_store_registers ()
+static void monitor_dump_regs ()
{
- int regno;
+ char buf[1024];
+ int resp_len;
-#ifdef LOG_FILE
- fprintf (log_file, "\nIn Fetch Registers\n");
- fflush (log_file);
-#endif
- for (regno = 0; regno <= PC_REGNUM; regno++)
- monitor_store_register(regno);
+ if (current_monitor->dump_registers)
+ {
+ monitor_printf (current_monitor->dump_registers);
+ resp_len = monitor_expect_prompt (buf, sizeof (buf));
+ parse_register_dump (buf, resp_len);
+ }
+ else
+ abort(); /* Need some way to read registers */
+}
+
+static void
+monitor_fetch_registers (regno)
+ int regno;
+{
+ if (current_monitor->getreg.cmd)
+ {
+ if (regno >= 0)
+ {
+ monitor_fetch_register (regno);
+ return;
+ }
- registers_changed ();
+ for (regno = 0; regno < NUM_REGS; regno++)
+ monitor_fetch_register (regno);
+ }
+ else {
+ monitor_dump_regs ();
+ }
}
-/*
- * monitor_store_register -- store register REGNO, or all if REGNO == 0.
- * return errno value.
- */
-void
+/* Store register REGNO, or all if REGNO == 0. Return errno value. */
+
+static void
monitor_store_register (regno)
int regno;
{
char *name;
- int i;
+ unsigned int val;
+
+ name = current_monitor->regnames[regno];
+ if (!name)
+ return;
- i = read_register(regno);
+ val = read_register (regno);
-#ifdef LOG_FILE
- fprintf (log_file, "\nIn Store_register (regno=%d)\n", regno);
-#endif
+ /* send the register deposit command */
- if (regno < 0)
- monitor_store_registers ();
- else {
- if (sr_get_debug() > 3)
- printf ("Setting register %s to 0x%x\n", get_reg_name (regno), read_register (regno));
-
- name = get_reg_name (regno);
- if (STREQ(name, ""))
+ if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
+ monitor_printf (current_monitor->setreg.cmd, val, name);
+ else
+ monitor_printf (current_monitor->setreg.cmd, name, val);
+
+/* It's possible that there are actually some monitors out there that
+ will prompt you when you set a register. In that case, you may
+ need to add some code here to deal with TERM and TERM_CMD (see
+ monitor_fetch_register to get an idea of what's needed...) */
+
+ monitor_expect_prompt (NULL, 0);
+}
+
+/* Store the remote registers. */
+
+static void
+monitor_store_registers (regno)
+ int regno;
+{
+ if (regno >= 0)
+ {
+ monitor_store_register (regno);
return;
- printf_monitor (ROMCMD(SET_REG), name, read_register(regno));
- expect (name, 1); /* strip the leading garbage */
- if (*ROMDELIM(SET_REG) != 0) { /* if there's a delimiter */
- expect (ROMDELIM(SET_REG), 1);
- get_hex_word(1);
- printf_monitor ("%d%s\n", i, CMD_END);
}
- expect_prompt (1);
- }
- return;
-
-#if 0
- printf_monitor (SET_REG, get_reg_name (regno),
- read_register (regno));
- expect_prompt (1);
- }
-#endif
+
+ for (regno = 0; regno < NUM_REGS; regno++)
+ monitor_store_register (regno);
}
/* Get ready to modify the registers array. On machines which store
that registers contains all the registers from the program being
debugged. */
-void
+static void
monitor_prepare_to_store ()
{
/* Do nothing, since we can store individual regs */
}
-void
-monitor_files_info ()
+static void
+monitor_files_info (ops)
+ struct target_ops *ops;
{
- printf ("\tAttached to %s at %d baud.\n",
- dev_name, baudrate);
+ printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
}
-/*
- * monitor_write_inferior_memory -- Copy LEN bytes of data from debugger
- * memory at MYADDR to inferior's memory at MEMADDR. Returns length moved.
- */
-int
-monitor_write_inferior_memory (memaddr, myaddr, len)
+static int
+monitor_write_memory (memaddr, myaddr, len)
CORE_ADDR memaddr;
- unsigned char *myaddr;
+ char *myaddr;
int len;
{
+ unsigned int val;
+ char *cmd;
int i;
- char buf[10];
-#ifdef LOG_FILE
- fprintf (log_file, "\nIn Write_inferior_memory (memaddr=%x, len=%d)\n", memaddr, len);
+ /* Use memory fill command for leading 0 bytes. */
+
+ if (current_monitor->fill)
+ {
+ for (i = 0; i < len; i++)
+ if (myaddr[i] != 0)
+ break;
+
+ if (i > 4) /* More than 4 zeros is worth doing */
+ {
+ if (current_monitor->flags & MO_FILL_USES_ADDR)
+ monitor_printf (current_monitor->fill, memaddr, memaddr + i, 0);
+ else
+ monitor_printf (current_monitor->fill, memaddr, i, 0);
+
+ monitor_expect_prompt (NULL, 0);
+
+ return i;
+ }
+ }
+
+#if 0
+ /* Can't actually use long longs if VAL is an int (nice idea, though). */
+ if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
+ {
+ len = 8;
+ cmd = current_monitor->setmem.cmdll;
+ }
+ else
#endif
+ if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
+ {
+ len = 4;
+ cmd = current_monitor->setmem.cmdl;
+ }
+ else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw)
+ {
+ len = 2;
+ cmd = current_monitor->setmem.cmdw;
+ }
+ else
+ {
+ len = 1;
+ cmd = current_monitor->setmem.cmdb;
+ }
+
+ val = extract_unsigned_integer (myaddr, len);
+
+ if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
+ monitor_printf_noecho (cmd, memaddr, val);
+ else
+ monitor_printf (cmd, memaddr, val);
- if (sr_get_debug() > 0)
- printf ("\nTrying to set 0x%x to 0x%x\n", memaddr, myaddr);
+ monitor_expect_prompt (NULL, 0);
- for (i = 0; i < len; i++) {
- printf_monitor (ROMCMD(SET_MEM), memaddr + i, myaddr[i] );
- if (*ROMDELIM(SET_MEM) != 0) { /* if there's a delimiter */
- expect (ROMDELIM(SET_MEM), 1);
- expect (CMD_DELIM);
- printf_monitor ("%x", myaddr[i]);
+ return len;
+}
+
+/* This is an alternate form of monitor_read_memory which is used for monitors
+ which can only read a single byte/word/etc. at a time. */
+
+static int
+monitor_read_memory_single (memaddr, myaddr, len)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+{
+ unsigned int val;
+ char membuf[sizeof(int) * 2 + 1];
+ char *p;
+ char *cmd;
+ int i;
+
+#if 0
+ /* Can't actually use long longs (nice idea, though). In fact, the
+ call to strtoul below will fail if it tries to convert a value
+ that's too big to fit in a long. */
+ if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
+ {
+ len = 8;
+ cmd = current_monitor->getmem.cmdll;
}
-/*** printf_monitor ("%x", myaddr[i]); ***/
- if (sr_get_debug() > 1)
- printf ("\nSet 0x%x to 0x%x\n", memaddr + i, myaddr[i]);
- if (*ROMDELIM(SET_MEM) != 0) {
- expect (CMD_DELIM);
- printf_monitor (CMD_END);
+ else
+#endif
+ if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
+ {
+ len = 4;
+ cmd = current_monitor->getmem.cmdl;
}
- expect_prompt (1);
- }
+ else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->getmem.cmdw)
+ {
+ len = 2;
+ cmd = current_monitor->getmem.cmdw;
+ }
+ else
+ {
+ len = 1;
+ cmd = current_monitor->getmem.cmdb;
+ }
+
+/* Send the examine command. */
+
+ monitor_printf (cmd, memaddr);
+
+/* If RESP_DELIM is specified, we search for that as a leading delimiter for
+ the register value. Otherwise, we just start searching from the start of
+ the buf. */
+
+ if (current_monitor->getmem.resp_delim)
+ monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
+
+/* Now, read the appropriate number of hex digits for this loc, skipping
+ spaces. */
+
+ /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
+ if (current_monitor->flags & MO_HEX_PREFIX)
+ {
+ int c;
+ c = readchar (timeout);
+ while (c == ' ')
+ c = readchar (timeout);
+ if ((c == '0') && ((c = readchar (timeout)) == 'x'))
+ ;
+ else
+ error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
+ memaddr, i, membuf, c);
+ }
+ for (i = 0; i < len * 2; i++)
+ {
+ int c;
+
+ while (1)
+ {
+ c = readchar (timeout);
+ if (isxdigit (c))
+ break;
+ if (c == ' ')
+ continue;
+
+ error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
+ memaddr, i, membuf, c);
+ }
+
+ membuf[i] = c;
+ }
+
+ membuf[i] = '\000'; /* terminate the number */
+
+/* If TERM is present, we wait for that to show up. Also, (if TERM is
+ present), we will send TERM_CMD if that is present. In any case, we collect
+ all of the output into buf, and then wait for the normal prompt. */
+
+ if (current_monitor->getmem.term)
+ {
+ monitor_expect (current_monitor->getmem.term, NULL, 0); /* get response */
+
+ if (current_monitor->getmem.term_cmd)
+ {
+ monitor_printf (current_monitor->getmem.term_cmd);
+ monitor_expect_prompt (NULL, 0);
+ }
+ }
+ else
+ monitor_expect_prompt (NULL, 0); /* get response */
+
+ p = membuf;
+ val = strtoul (membuf, &p, 16);
+
+ if (val == 0 && membuf == p)
+ error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
+ memaddr, membuf);
+
+ /* supply register stores in target byte order, so swap here */
+
+ store_unsigned_integer (myaddr, len, val);
+
return len;
}
-/*
- * monitor_read_inferior_memory -- read LEN bytes from inferior memory
- * at MEMADDR. Put the result at debugger address MYADDR. Returns
- * length moved.
- */
-int
-monitor_read_inferior_memory(memaddr, myaddr, len)
+/* Copy LEN bytes of data from debugger memory at MYADDR to inferior's memory
+ at MEMADDR. Returns length moved. Currently, we only do one byte at a
+ time. */
+
+static int
+monitor_read_memory (memaddr, myaddr, len)
CORE_ADDR memaddr;
char *myaddr;
int len;
{
- int i, j;
- char buf[20];
+ unsigned int val;
+ unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
+ char buf[512];
+ char *p, *p1;
+ char *name;
+ int resp_len;
+ int i;
- /* Number of bytes read so far. */
- int count;
+ if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
+ return monitor_read_memory_single (memaddr, myaddr, len);
- /* Starting address of this pass. */
- unsigned long startaddr;
+ len = min (len, 16);
- /* Number of bytes to read in this pass. */
- int len_this_pass;
+/* See if xfer would cross a 16 byte boundary. If so, clip it. */
+ if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
+ len = ((memaddr + len) & ~0xf) - memaddr;
-#ifdef LOG_FILE
- fprintf (log_file, "\nIn Read_inferior_memory (memaddr=%x, len=%d)\n", memaddr, len);
-#endif
+ /* send the memory examine command */
- /* Note that this code works correctly if startaddr is just less
- than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
- thing). That is, something like
- monitor_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
- works--it never adds len To memaddr and gets 0. */
- /* However, something like
- monitor_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
- doesn't need to work. Detect it and give up if there's an attempt
- to do that. */
- if (((memaddr - 1) + len) < memaddr) {
- errno = EIO;
- return 0;
- }
-
- startaddr = memaddr;
- count = 0;
- while (count < len) {
- len_this_pass = 16;
- if ((startaddr % 16) != 0)
- len_this_pass -= startaddr % 16;
- if (len_this_pass > (len - count))
- len_this_pass = (len - count);
- if (sr_get_debug())
- printf ("\nDisplay %d bytes at %x\n", len_this_pass, startaddr);
-
- for (i = 0; i < len_this_pass; i++) {
- printf_monitor (ROMCMD(GET_MEM), startaddr, startaddr);
- sprintf (buf, ROMCMD(GET_MEM), startaddr, startaddr);
+ if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
+ monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len - 1);
+ else
+ monitor_printf (current_monitor->getmem.cmdb, memaddr, len);
+
+/* If TERM is present, we wait for that to show up. Also, (if TERM is
+ present), we will send TERM_CMD if that is present. In any case, we collect
+ all of the output into buf, and then wait for the normal prompt. */
+
+ if (current_monitor->getmem.term)
+ {
+ resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf); /* get response */
+
+ if (resp_len <= 0)
+ error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
+ memaddr, resp_len, buf);
+
+ if (current_monitor->getmem.term_cmd)
+ {
+ SERIAL_WRITE (monitor_desc, current_monitor->getmem.term_cmd,
+ strlen (current_monitor->getmem.term_cmd));
+ monitor_expect_prompt (NULL, 0);
+ }
+ }
+ else
+ resp_len = monitor_expect_prompt (buf, sizeof buf); /* get response */
+
+ p = buf;
+
+ /* If RESP_DELIM is specified, we search for that as a leading delimiter for
+ the values. Otherwise, we just start searching from the start of the buf.
+ */
+
+ if (current_monitor->getmem.resp_delim)
+ {
+ int retval, tmp;
+ struct re_registers resp_strings;
+
+ tmp = strlen (p);
+ retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
+ &resp_strings);
+
+ if (retval < 0)
+ error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
+ memaddr, resp_len, buf);
+
+ p += resp_strings.end[0];
#if 0
- expect (buf,1); /* get the command echo */
- get_hex_word(1); /* strip away the address */
+ p = strstr (p, current_monitor->getmem.resp_delim);
+ if (!p)
+ error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
+ memaddr, resp_len, buf);
+ p += strlen (current_monitor->getmem.resp_delim);
#endif
- if (*ROMDELIM(GET_MEM) != 0) { /* if there's a delimiter */
- expect (ROMDELIM(GET_MEM), 1);
- } else {
- sprintf (buf, ROMCMD(GET_MEM), startaddr, startaddr);
- expect (buf,1); /* get the command echo */
- get_hex_word(1); /* strip away the address */
- }
- get_hex_byte (&myaddr[count++]); /* get the value at this address */
+ }
- if (*ROMDELIM(GET_MEM) != 0) {
- printf_monitor (CMD_END);
- }
- expect_prompt (1);
- startaddr += 1;
+ for (i = len; i > 0; i--)
+ {
+ /* Skip non-hex chars, but bomb on end of string and newlines */
+
+ while (1)
+ {
+ if (isxdigit (*p))
+ break;
+ if (*p == '\000' || *p == '\n' || *p == '\r')
+ error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s", memaddr, resp_len, buf);
+ p++;
+ }
+
+ val = strtoul (p, &p1, 16);
+
+ if (val == 0 && p == p1)
+ error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.", memaddr,
+ resp_len, buf);
+
+ *myaddr++ = val;
+
+ if (i == 1)
+ break;
+
+ p = p1;
}
- }
+
return len;
}
-/* FIXME-someday! merge these two. */
-int
-monitor_xfer_inferior_memory (memaddr, myaddr, len, write, target)
+static int
+monitor_xfer_memory (memaddr, myaddr, len, write, target)
CORE_ADDR memaddr;
char *myaddr;
int len;
int write;
struct target_ops *target; /* ignored */
{
- if (write)
- return monitor_write_inferior_memory (memaddr, myaddr, len);
- else
- return monitor_read_inferior_memory (memaddr, myaddr, len);
+ return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, write);
}
-void
-monitor_kill (args, from_tty)
- char *args;
- int from_tty;
+static void
+monitor_kill ()
{
return; /* ignore attempts to kill target system */
}
+/* All we actually do is set the PC to the start address of exec_bfd, and start
+ the program at that point. */
+
+static void
+monitor_create_inferior (exec_file, args, env)
+ char *exec_file;
+ char *args;
+ char **env;
+{
+ if (args && (*args != '\000'))
+ error ("Args are not supported by the monitor.");
+
+ first_time = 1;
+ clear_proceed_status ();
+ proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0);
+}
+
/* Clean up when a program exits.
The program actually lives on in the remote processor's RAM, and may be
run again without a download. Don't leave it full of breakpoint
instructions. */
-void
+static void
monitor_mourn_inferior ()
{
- remove_breakpoints ();
+ unpush_target (targ_ops);
generic_mourn_inferior (); /* Do all the proper things now */
}
-#define MAX_MONITOR_BREAKPOINTS 16
+#define NUM_MONITOR_BREAKPOINTS 8
-extern int memory_breakpoint_size;
-static CORE_ADDR breakaddr[MAX_MONITOR_BREAKPOINTS] = {0};
+static CORE_ADDR breakaddr[NUM_MONITOR_BREAKPOINTS] = {0};
-/*
- * monitor_insert_breakpoint -- add a breakpoint
- */
-int
+/* Tell the monitor to add a breakpoint. */
+
+static int
monitor_insert_breakpoint (addr, shadow)
CORE_ADDR addr;
char *shadow;
{
int i;
+ static unsigned char break_insn[] = BREAKPOINT;
-#ifdef LOG_FILE
- fprintf (log_file, "\nIn Insert_breakpoint (addr=%x)\n", addr);
-#endif
-
- if (sr_get_debug() > 4)
- printf ("insert_breakpoint() addr = 0x%x\n", addr);
-
- for (i = 0; i <= MAX_MONITOR_BREAKPOINTS; i++) {
- if (breakaddr[i] == 0) {
- breakaddr[i] = addr;
- if (sr_get_debug() > 4)
- printf ("Breakpoint at %x\n", addr);
- monitor_read_inferior_memory(addr, shadow, memory_breakpoint_size);
- printf_monitor(SET_BREAK_CMD, addr);
- expect_prompt(1);
- return 0;
+ for (i = 0; i < NUM_MONITOR_BREAKPOINTS; i++)
+ {
+ if (breakaddr[i] == 0)
+ {
+ breakaddr[i] = addr;
+ monitor_read_memory (addr, shadow, sizeof (break_insn));
+ monitor_printf (current_monitor->set_break, addr);
+ monitor_expect_prompt (NULL, 0);
+ return 0;
+ }
}
- }
- fprintf(stderr, "Too many breakpoints (> 16) for monitor\n");
- return 1;
+ error ("Too many breakpoints (> %d) for monitor.", NUM_MONITOR_BREAKPOINTS);
}
-/*
- * _remove_breakpoint -- Tell the monitor to remove a breakpoint
- */
-int
+/* Tell the monitor to remove a breakpoint. */
+
+static int
monitor_remove_breakpoint (addr, shadow)
CORE_ADDR addr;
char *shadow;
{
int i;
-#ifdef LOG_FILE
- fprintf (log_file, "\nIn Remove_breakpoint (addr=%x)\n", addr);
-#endif
-
- if (sr_get_debug() > 4)
- printf ("remove_breakpoint (addr=%x)\n", addr);
-
- for (i = 0; i < MAX_MONITOR_BREAKPOINTS; i++) {
- if (breakaddr[i] == addr) {
- breakaddr[i] = 0;
- /* some monitors remove breakpoints based on the address */
- if (CLR_BREAK_ADDR)
- printf_monitor(CLR_BREAK_CMD, addr);
- else
- printf_monitor(CLR_BREAK_CMD, i);
- expect_prompt(1);
- return 0;
+ for (i = 0; i < NUM_MONITOR_BREAKPOINTS; i++)
+ {
+ if (breakaddr[i] == addr)
+ {
+ breakaddr[i] = 0;
+ /* some monitors remove breakpoints based on the address */
+ if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
+ monitor_printf (current_monitor->clr_break, addr);
+ else
+ monitor_printf (current_monitor->clr_break, i);
+ monitor_expect_prompt (NULL, 0);
+ return 0;
+ }
}
- }
- fprintf(stderr, "Can't find breakpoint associated with 0x%x\n", addr);
+ fprintf_unfiltered (stderr, "Can't find breakpoint associated with 0x%x\n", addr);
return 1;
}
-/* Load a file. This is usually an srecord, which is ascii. No
- protocol, just sent line by line. */
+/* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
+ an S-record. Return non-zero if the ACK is received properly. */
-#define DOWNLOAD_LINE_SIZE 100
-void
-monitor_load (arg)
- char *arg;
+static int
+monitor_wait_srec_ack ()
{
- FILE *download;
- char buf[DOWNLOAD_LINE_SIZE];
- int i, bytes_read;
+ /* FIXME: eventually we'll want to be able to handle acknowledgements
+ of something other than a '+' character. Right now this is only
+ going to work for EST visionICE. */
+ return readchar (timeout) == '+';
+}
- if (sr_get_debug())
- printf ("Loading %s to monitor\n", arg);
+/* monitor_load -- download a file. */
- download = fopen (arg, "r");
- if (download == NULL)
- {
- error (sprintf (buf, "%s Does not exist", arg));
- return;
- }
+static void
+monitor_load (file, from_tty)
+ char *file;
+ int from_tty;
+{
+ dcache_flush (remote_dcache);
- printf_monitor (LOAD_CMD);
-/* expect ("Waiting for S-records from host... ", 1); */
+ if (current_monitor->load_routine)
+ current_monitor->load_routine (monitor_desc, file, hashmark);
+ else
+ { /* The default is ascii S-records */
+ monitor_printf (current_monitor->load);
+ if (current_monitor->loadresp)
+ monitor_expect (current_monitor->loadresp, NULL, 0);
- while (!feof (download))
- {
- bytes_read = fread (buf, sizeof (char), DOWNLOAD_LINE_SIZE, download);
- if (hashmark)
- {
- putchar ('.');
- fflush (stdout);
- }
+/* FIXME Should add arg here for load_offset (already done for generic_load) */
+ load_srec (monitor_desc, file, 32, SREC_ALL, hashmark,
+ current_monitor->flags & MO_SREC_ACK ?
+ monitor_wait_srec_ack : NULL);
- if (SERIAL_WRITE(monitor_desc, buf, bytes_read)) {
- fprintf(stderr, "SERIAL_WRITE failed: (while downloading) %s\n", safe_strerror(errno));
- break;
- }
- i = 0;
- while (i++ <=200000) {} ; /* Ugly HACK, probably needs flow control */
- if (bytes_read < DOWNLOAD_LINE_SIZE)
- {
- if (!feof (download))
- error ("Only read %d bytes\n", bytes_read);
- break;
- }
+ monitor_expect_prompt (NULL, 0);
}
- if (hashmark)
- {
- putchar ('\n');
- }
- if (!feof (download))
- error ("Never got EOF while downloading");
- fclose (download);
+/* Finally, make the PC point at the start address */
+
+ if (exec_bfd)
+ write_pc (bfd_get_start_address (exec_bfd));
+
+ inferior_pid = 0; /* 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
+ new code (and just changed the PC). Another way to do this might be to call
+ normal_stop, except that the stack may not be valid, and things would get
+ horribly confused... */
+
+ clear_symtab_users ();
}
-/*
- * monitor_command -- put a command string, in args, out to MONITOR.
- * Output from MONITOR is placed on the users terminal until the
- * prompt is seen. FIXME: We read the charcters ourseleves here
- * cause of a nasty echo.
- */
-void
-monitor_command (args, fromtty)
- char *args;
- int fromtty;
+static void
+monitor_stop ()
{
+ if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
+ SERIAL_SEND_BREAK (monitor_desc);
+ if (current_monitor->stop)
+ monitor_printf_noecho (current_monitor->stop);
+}
+/* Put a command string, in args, out to MONITOR. Output from MONITOR
+ is placed on the users terminal until the prompt is seen. FIXME: We
+ read the characters ourseleves here cause of a nasty echo. */
+
+static void
+monitor_command (args, from_tty)
+ char *args;
+ int from_tty;
+{
char *p;
- char c, cp;
- p = PROMPT;
+ int resp_len;
+ char buf[1000];
-#ifdef LOG_FILE
- fprintf (log_file, "\nmonitor_command (args=%s)\n", args);
-#endif
if (monitor_desc == NULL)
- error("monitor target not open.");
+ error ("monitor target not open.");
- if (!args)
- error("Missing command.");
-
- if (sr_get_debug() > 4)
- printf ("monitor_command (args=%s)\n", args);
+ p = current_monitor->prompt;
+
+ /* Send the command. Note that if no args were supplied, then we're
+ just sending the monitor a newline, which is sometimes useful. */
- printf_monitor ("%s\n", args);
+ monitor_printf ("%s\r", (args ? args : ""));
- expect_prompt(0);
+ resp_len = monitor_expect_prompt (buf, sizeof buf);
+
+ fputs_unfiltered (buf, gdb_stdout); /* Output the response */
}
-/*
- * _initialize_remote_monitors -- setup a few addtitional commands that
- * are usually only used by monitors.
- */
+/* Convert hex digit A to a number. */
+
+static int
+from_hex (a)
+ int a;
+{
+ if (a >= '0' && a <= '9')
+ return a - '0';
+ if (a >= 'a' && a <= 'f')
+ return a - 'a' + 10;
+ if (a >= 'A' && a <= 'F')
+ return a - 'A' + 10;
+
+ error ("Reply contains invalid hex digit 0x%x", a);
+}
+
+static struct target_ops monitor_ops =
+{
+ NULL, /* to_shortname */
+ NULL, /* to_longname */
+ NULL, /* to_doc */
+ NULL, /* to_open */
+ monitor_close, /* to_close */
+ NULL, /* to_attach */
+ monitor_detach, /* to_detach */
+ monitor_resume, /* to_resume */
+ monitor_wait, /* to_wait */
+ monitor_fetch_registers, /* to_fetch_registers */
+ monitor_store_registers, /* to_store_registers */
+ monitor_prepare_to_store, /* to_prepare_to_store */
+ monitor_xfer_memory, /* to_xfer_memory */
+ monitor_files_info, /* to_files_info */
+ monitor_insert_breakpoint, /* to_insert_breakpoint */
+ monitor_remove_breakpoint, /* to_remove_breakpoint */
+ 0, /* to_terminal_init */
+ 0, /* to_terminal_inferior */
+ 0, /* to_terminal_ours_for_output */
+ 0, /* to_terminal_ours */
+ 0, /* to_terminal_info */
+ monitor_kill, /* to_kill */
+ monitor_load, /* to_load */
+ 0, /* to_lookup_symbol */
+ monitor_create_inferior, /* to_create_inferior */
+ monitor_mourn_inferior, /* to_mourn_inferior */
+ 0, /* to_can_run */
+ 0, /* to_notice_signals */
+ 0, /* to_thread_alive */
+ monitor_stop, /* to_stop */
+ process_stratum, /* to_stratum */
+ 0, /* to_next */
+ 1, /* to_has_all_memory */
+ 1, /* to_has_memory */
+ 1, /* to_has_stack */
+ 1, /* to_has_registers */
+ 1, /* to_has_execution */
+ 0, /* sections */
+ 0, /* sections_end */
+ OPS_MAGIC /* to_magic */
+};
+
+/* Init the target_ops structure pointed at by OPS */
+
void
-_initialize_remote_monitors ()
+init_monitor_ops (ops)
+ struct target_ops *ops;
{
- struct cmd_list_element *c;
+ memcpy (ops, &monitor_ops, sizeof monitor_ops);
+}
- /* this sets the type of download protocol */
- c = add_set_cmd ("loadtype", no_class, var_string, (char *)&loadtype_str,
- "Set the type of the remote load protocol.\n", &setlist);
- c->function.sfunc = set_loadtype_command;
- add_show_from_set (c, &showlist);
- loadtype_str = savestring ("generic", 8);
+/* Define additional commands that are usually only used by monitors. */
+void
+_initialize_remote_monitors ()
+{
add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
(char *)&hashmark,
"Set display of activity while downloading a file.\n\
-When enabled, a period \'.\' is displayed.",
+When enabled, a hashmark \'#\' is displayed.",
&setlist),
&showlist);
- /* generic monitor command */
add_com ("monitor", class_obscure, monitor_command,
"Send a command to the debug monitor.");
}
projects / binutils.git / blobdiff