/* Remote debugging interface for boot monitors, for GDB.
- Copyright 1990, 1991, 1992, 1993, 1995 Free Software Foundation, Inc.
- Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
+ Copyright 1990-1993, 1995-1997, 1999-2000 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.
+ This file is part of GDB.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-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. */
+ 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., 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
monitor. This saves use from having to hack an exception based handler
- into existance, and makes for quick porting.
+ into existence, and makes for quick porting.
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. */
+/* 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"
-#include <varargs.h>
+#include "gdb_wait.h"
#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"
-
-#if !defined (HAVE_TERMIOS) && !defined (HAVE_TERMIO) && !defined (HAVE_SGTTY)
-#define HAVE_SGTTY
+#include "gdbcmd.h"
+#include "inferior.h"
+#include "gdb_regex.h"
+#include "srec.h"
+
+static char *dev_name;
+static struct target_ops *targ_ops;
+
+static void monitor_vsprintf (char *sndbuf, char *pattern, va_list args);
+
+static int readchar (int timeout);
+
+static void monitor_fetch_register (int regno);
+static void monitor_store_register (int regno);
+
+static void monitor_printable_string (char *newstr, char *oldstr, int len);
+static void monitor_error (char *function, char *message, CORE_ADDR memaddr, int len, char *string, int final_char);
+static void monitor_detach (char *args, int from_tty);
+static void monitor_resume (int pid, int step, enum target_signal sig);
+static void monitor_interrupt (int signo);
+static void monitor_interrupt_twice (int signo);
+static void monitor_interrupt_query (void);
+static void monitor_wait_cleanup (void *old_timeout);
+
+static int monitor_wait (int pid, struct target_waitstatus *status);
+static void monitor_fetch_registers (int regno);
+static void monitor_store_registers (int regno);
+static void monitor_prepare_to_store (void);
+static int monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
+ int write, struct target_ops *target);
+static void monitor_files_info (struct target_ops *ops);
+static int monitor_insert_breakpoint (CORE_ADDR addr, char *shadow);
+static int monitor_remove_breakpoint (CORE_ADDR addr, char *shadow);
+static void monitor_kill (void);
+static void monitor_load (char *file, int from_tty);
+static void monitor_mourn_inferior (void);
+static void monitor_stop (void);
+
+static int monitor_read_memory (CORE_ADDR addr, char *myaddr, int len);
+static int monitor_write_memory (CORE_ADDR addr, char *myaddr, int len);
+static int monitor_write_memory_bytes (CORE_ADDR addr, char *myaddr, int len);
+static int monitor_write_memory_block (CORE_ADDR memaddr,
+ char *myaddr, int len);
+static int monitor_expect_regexp (struct re_pattern_buffer *pat,
+ char *buf, int buflen);
+static void monitor_dump_regs (void);
+#if 0
+static int from_hex (int a);
+static unsigned long get_hex_word (void);
#endif
+static void parse_register_dump (char *, int);
-#ifdef HAVE_TERMIOS
-#include <termio.h>
-#include <termios.h>
-# define TERMINAL struct termios
-#else
-#include <fcntl.h>
-# define TERMINAL struct sgttyb
-#endif
-#include "terminal.h"
-#ifndef CSTOPB
-#define CSTOPB 0x00000040
-#endif
+static struct monitor_ops *current_monitor;
-static const char hexchars[] = "0123456789abcdef";
-static char *hex2mem ();
-
-#define SWAP_TARGET_AND_HOST(buffer,len) \
- do \
- { \
- if (TARGET_BYTE_ORDER != HOST_BYTE_ORDER) \
- { \
- char tmp; \
- char *p = (char *)(buffer); \
- char *q = ((char *)(buffer)) + len - 1; \
- for (; p < q; p++, q--) \
- { \
- tmp = *q; \
- *q = *p; \
- *p = tmp; \
- } \
- } \
- } \
- while (0)
-
-static void make_xmodem_packet ();
-static void print_xmodem_packet ();
-static void make_gdb_packet ();
-
-static void monitor_load_ascii_srec PARAMS ((char *file, int fromtty));
-
-static int monitor_make_srec PARAMS ((char *buffer, int type,
- CORE_ADDR memaddr,
- unsigned char *myaddr, int len));
-
-static unsigned long ascii2hexword ();
-static char *hexword2ascii ();
-static int tohex ();
-static int to_hex ();
-static int from_hex ();
-
-struct monitor_ops *current_monitor;
-
-extern struct cmd_list_element *setlist;
-extern struct cmd_list_element *unsetlist;
-
-struct cmd_list_element *showlist;
-
-extern char *version;
-extern char *host_name;
-extern char *target_name;
-
-static int hashmark; /* flag set by "set hash" */
-
-#define LOG_FILE "monitor.log"
-#if defined (LOG_FILE)
-FILE *log_file;
-#endif
+static int hashmark; /* flag set by "set hash" */
static int timeout = 30;
-/* Having this larger than 400 causes us to be incompatible with m68k-stub.c
- and i386-stub.c. Normally, no one would notice because it only matters
- for writing large chunks of memory (e.g. in downloads). Also, this needs
- to be more than 400 if required to hold the registers (see below, where
- we round it up based on REGISTER_BYTES). */
+static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait() */
+
+static void (*ofunc) (); /* Old SIGINT signal handler */
-#define PBUFSIZ 400
+static CORE_ADDR *breakaddr;
/* 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. */
-serial_t monitor_desc = NULL;
-
-/* sets the download protocol, choices are srec, generic, boot */
-char *loadtype;
-
-static char *loadtype_str;
-static char *loadproto_str;
-static void set_loadtype_command();
-static void set_loadproto_command();
-static void monitor_load_srec();
-
-/* These definitions are for xmodem protocol. */
-
-#define SOH 0x01
-#define ACK 0x06
-#define NAK 0x15
-#define EOT 0x04
-#define CANCEL 0x18
-#define GETACK getacknak(ACK)
-#define GETNAK getacknak(NAK)
-#define XMODEM_DATASIZE 128 /* the data size is ALWAYS 128 */
-#define XMODEM_PACKETSIZE 131 /* the packet size is ALWAYS 132 (zero based) */
-#define XMODEM 1
-
-/*
- * set_loadtype_command -- set the type for downloading. Check to make
- * sure you have a support protocol for this target.
- */
+static serial_t monitor_desc = NULL;
+
+/* 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 int first_time = 0; /* is this the first time we're executing after
+ gaving created the child proccess? */
+
+#define TARGET_BUF_SIZE 2048
+
+/* Monitor specific debugging information. Typically only useful to
+ the developer of a new monitor interface. */
+
+static void monitor_debug (const char *fmt, ...) ATTR_FORMAT(printf, 1, 2);
+
+static int monitor_debug_p = 0;
+
+/* NOTE: This file alternates between monitor_debug_p and remote_debug
+ when determining if debug information is printed. Perhaphs this
+ could be simplified. */
+
static void
-set_loadtype_command (ignore, from_tty, c)
- char *ignore;
- int from_tty;
- struct cmd_list_element *c;
+monitor_debug (const char *fmt, ...)
{
- char *tmp;
- char *type;
-
- if (current_monitor == 0x0)
- return;
-
- if (STREQ (LOADTYPES, "")) {
- error ("No loadtype set");
- return;
- }
-
- tmp = savestring (LOADTYPES, strlen(LOADTYPES));
- type = strtok(tmp, ",");
- if (STREQ (type, (*(char **) c->var))) {
- loadtype_str = savestring (*(char **) c->var, strlen (*(char **) c->var));
- return;
+ if (monitor_debug_p)
+ {
+ va_list args;
+ va_start (args, fmt);
+ vfprintf_filtered (gdb_stdlog, fmt, args);
+ va_end (args);
}
-
- while ((type = strtok (NULL, ",")) != (char *)NULL) {
- if (STREQ (type, (*(char **) c->var)))
- loadtype_str = savestring (*(char **) c->var, strlen (*(char **) c->var));
- return;
- }
- free (tmp);
- error ("Loadtype \"%s\" does not exist.", (*(char **) c->var));
}
-/*
- * set_loadproto_command -- set the protocol for downloading. Check to make
- * sure you have a supported protocol for this target.
- */
+
+
+/* Convert a string into a printable representation, Return # byte in
+ the new string. When LEN is >0 it specifies the size of the
+ string. Otherwize strlen(oldstr) is used. */
+
static void
-set_loadproto_command (ignore, from_tty, c)
- char *ignore;
- int from_tty;
- struct cmd_list_element *c;
+monitor_printable_string (char *newstr, char *oldstr, int len)
{
- char *tmp;
- char *type;
-
- if (current_monitor == 0x0)
- return;
-
- if (STREQ (LOADPROTOS, "")) {
- error ("No load protocols set");
- return;
- }
-
- tmp = savestring (LOADPROTOS, strlen(LOADPROTOS));
- type = strtok(tmp, ",");
- if (STREQ (type, (*(char **) c->var))) {
- loadproto_str = savestring (*(char **) c->var, strlen (*(char **) c->var));
- return;
+ int ch;
+ int i;
+
+ if (len <= 0)
+ len = strlen (oldstr);
+
+ for (i = 0; i < len; i++)
+ {
+ ch = oldstr[i];
+ switch (ch)
+ {
+ default:
+ if (isprint (ch))
+ *newstr++ = ch;
+
+ else
+ {
+ sprintf (newstr, "\\x%02x", ch & 0xff);
+ newstr += 4;
+ }
+ break;
+
+ case '\\':
+ *newstr++ = '\\';
+ *newstr++ = '\\';
+ break;
+ case '\b':
+ *newstr++ = '\\';
+ *newstr++ = 'b';
+ break;
+ case '\f':
+ *newstr++ = '\\';
+ *newstr++ = 't';
+ break;
+ case '\n':
+ *newstr++ = '\\';
+ *newstr++ = 'n';
+ break;
+ case '\r':
+ *newstr++ = '\\';
+ *newstr++ = 'r';
+ break;
+ case '\t':
+ *newstr++ = '\\';
+ *newstr++ = 't';
+ break;
+ case '\v':
+ *newstr++ = '\\';
+ *newstr++ = 'v';
+ break;
+ }
}
-
- while ((type = strtok (NULL, ",")) != (char *)NULL) {
- if (STREQ (type, (*(char **) c->var)))
- loadproto_str = savestring (*(char **) c->var, strlen (*(char **) c->var));
- return;
- }
- free (tmp);
- error ("Load protocol \"%s\" does not exist.", (*(char **) c->var));
+
+ *newstr++ = '\0';
}
-/* printf_monitor -- send data to monitor. Works just like printf. */
+/* Print monitor errors with a string, converting the string to printable
+ representation. */
static void
-printf_monitor (va_alist)
- va_dcl
+monitor_error (char *function, char *message,
+ CORE_ADDR memaddr, int len, char *string, int final_char)
{
- va_list args;
- char *pattern;
- char buf[PBUFSIZ];
+ int real_len = (len == 0 && string != (char *) 0) ? strlen (string) : len;
+ char *safe_string = alloca ((real_len * 4) + 1);
+ monitor_printable_string (safe_string, string, real_len);
+
+ if (final_char)
+ error ("%s (0x%s): %s: %s%c", function, paddr_nz (memaddr), message, safe_string, final_char);
+ else
+ error ("%s (0x%s): %s: %s", function, paddr_nz (memaddr), message, safe_string);
+}
- va_start (args);
+/* Convert hex digit A to a number. */
- pattern = va_arg (args, char *);
+static int
+fromhex (int a)
+{
+ if (a >= '0' && a <= '9')
+ return a - '0';
+ else if (a >= 'a' && a <= 'f')
+ return a - 'a' + 10;
+ else if (a >= 'A' && a <= 'F')
+ return a - 'A' + 10;
+ else
+ error ("Invalid hex digit %d", a);
+}
- vsprintf (buf, pattern, args);
+/* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
- debuglogs (1, "printf_monitor(), Sending: \"%s\".", buf);
+ This function exists to get around the problem that many host platforms
+ don't have a printf that can print 64-bit addresses. The %A format
+ specification is recognized as a special case, and causes the argument
+ to be printed as a 64-bit hexadecimal address.
- if (strlen (buf) > PBUFSIZ)
- error ("printf_monitor(): string too long");
- if (SERIAL_WRITE(monitor_desc, buf, strlen (buf)))
- fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
-}
+ Only format specifiers of the form "[0-9]*[a-z]" are recognized.
+ If it is a '%s' format, the argument is a string; otherwise the
+ argument is assumed to be a long integer.
-/* Send raw data to monitor. */
+ %% is also turned into a single %.
+ */
static void
-write_monitor (data, len)
- char *data;
- int len;
+monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
{
- if (SERIAL_WRITE (monitor_desc, data, len))
- fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror(errno));
-
- *(data + len + 1) = '\0';
- debuglogs (1, "write_monitor(), Sending: \"%s\".", data);
+ char format[10];
+ char fmt;
+ char *p;
+ int i;
+ long arg_int;
+ CORE_ADDR arg_addr;
+ char *arg_string;
+
+ for (p = pattern; *p; p++)
+ {
+ if (*p == '%')
+ {
+ /* Copy the format specifier to a separate buffer. */
+ format[0] = *p++;
+ for (i = 1; *p >= '0' && *p <= '9' && i < (int) sizeof (format) - 2;
+ i++, p++)
+ format[i] = *p;
+ format[i] = fmt = *p;
+ format[i + 1] = '\0';
+
+ /* Fetch the next argument and print it. */
+ switch (fmt)
+ {
+ case '%':
+ strcpy (sndbuf, "%");
+ break;
+ case 'A':
+ arg_addr = va_arg (args, CORE_ADDR);
+ strcpy (sndbuf, paddr_nz (arg_addr));
+ break;
+ case 's':
+ arg_string = va_arg (args, char *);
+ sprintf (sndbuf, format, arg_string);
+ break;
+ default:
+ arg_int = va_arg (args, long);
+ sprintf (sndbuf, format, arg_int);
+ break;
+ }
+ sndbuf += strlen (sndbuf);
+ }
+ else
+ *sndbuf++ = *p;
+ }
+ *sndbuf = '\0';
}
-/* Deal with debugging info to multiple sources. This takes two real
- args, the first one is the level to be compared against the
- sr_get_debug() value, the second arg is a printf buffer and args to
- be formatted and printed. A CR is added after each string is
- printed. */
+
+/* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
+ Works just like printf. */
void
-debuglogs (va_alist)
- va_dcl
+monitor_printf_noecho (char *pattern,...)
{
va_list args;
- char *pattern, *p;
- unsigned char buf[PBUFSIZ];
- char newbuf[PBUFSIZ];
- int level, i;
+ char sndbuf[2000];
+ int len;
+
+ va_start (args, pattern);
- va_start(args);
+ monitor_vsprintf (sndbuf, pattern, args);
- level = va_arg(args, int); /* get the debug level */
- if ((level < 0) || (level > 100))
+ len = strlen (sndbuf);
+ if (len + 1 > sizeof sndbuf)
+ abort ();
+
+ if (monitor_debug_p)
{
- error ("Bad argument passed to debuglogs(), needs debug level");
- return;
+ char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);
+ monitor_printable_string (safe_string, sndbuf, 0);
+ fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
}
-
- pattern = va_arg(args, char *); /* get the printf style pattern */
- vsprintf(buf, pattern, args); /* format the string */
-
- /* convert some characters so it'll look right in the log */
- p = newbuf;
- for (i = 0 ; buf[i] != '\0'; i++)
- {
- if (i > PBUFSIZ)
- error ("Debug message too long");
- switch (buf[i])
- {
- case '\n': /* newlines */
- *p++ = '\\';
- *p++ = 'n';
- continue;
- case '\r': /* carriage returns */
- *p++ = '\\';
- *p++ = 'r';
- continue;
- case '\033': /* escape */
- *p++ = '\\';
- *p++ = 'e';
- continue;
- case '\t': /* tab */
- *p++ = '\\';
- *p++ = 't';
- continue;
- case '\b': /* backspace */
- *p++ = '\\';
- *p++ = 'b';
- continue;
- default: /* no change */
- *p++ = buf[i];
- }
+ monitor_write (sndbuf, len);
+}
- /* modify control characters */
- if (buf[i] < 26)
- {
- *p++ = '^';
- *p++ = buf[i] + 'A';
- continue;
- }
+/* monitor_printf -- Send data to monitor and check the echo. Works just like
+ printf. */
- /* modify control characters */
- if (buf[i] >= 128)
- {
- *p++ = '!';
- *p++ = buf[i] + 'A';
- continue;
- }
- }
- *p = '\0'; /* terminate the string */
+void
+monitor_printf (char *pattern,...)
+{
+ va_list args;
+ char sndbuf[2000];
+ int len;
+
+ va_start (args, pattern);
+
+ monitor_vsprintf (sndbuf, pattern, args);
- if (sr_get_debug () > level)
- printf_unfiltered ("%s\n", newbuf);
+ len = strlen (sndbuf);
+ if (len + 1 > sizeof sndbuf)
+ abort ();
-#ifdef LOG_FILE /* write to the monitor log */
- if (log_file != 0x0)
+ if (monitor_debug_p)
{
- fputs (newbuf, log_file);
- fputc ('\n', log_file);
- fflush (log_file);
+ char *safe_string = (char *) alloca ((len * 4) + 1);
+ monitor_printable_string (safe_string, sndbuf, 0);
+ fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
}
-#endif
+
+ monitor_write (sndbuf, len);
+
+ /* 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_debug ("ExpectEcho\n");
+ monitor_expect (sndbuf, (char *) 0, 0);
}
-/* Read a character from the remote system, doing all the fancy
- timeout stuff. */
-static int
-readchar (timeout)
- int timeout;
+/* Write characters to the remote system. */
+
+void
+monitor_write (char *buf, int buflen)
{
- int c;
+ if (SERIAL_WRITE (monitor_desc, buf, buflen))
+ fprintf_unfiltered (gdb_stderr, "SERIAL_WRITE failed: %s\n",
+ safe_strerror (errno));
+}
+
+
+/* Read a binary character from the remote system, doing all the fancy
+ timeout stuff, but without interpreting the character in any way,
+ and without printing remote debug information. */
- c = SERIAL_READCHAR (monitor_desc, timeout);
+int
+monitor_readchar (void)
+{
+ int c;
+ int looping;
- if (sr_get_debug () > 5)
+ do
{
- putchar (c & 0x7f);
- debuglogs (5, "readchar: timeout = %d\n", timeout);
- }
+ looping = 0;
+ c = SERIAL_READCHAR (monitor_desc, timeout);
-#ifdef LOG_FILE
- if (isascii (c))
- putc(c & 0x7f, log_file);
-#endif
+ if (c >= 0)
+ c &= 0xff; /* don't lose bit 7 */
+ }
+ while (looping);
if (c >= 0)
- return c & 0x7f;
+ return c;
if (c == SERIAL_TIMEOUT)
- {
- if (timeout == 0)
- return c; /* Polls shouldn't generate timeout errors */
- error ("Timeout reading from remote system.");
-#ifdef LOG_FILE
- fputs ("ERROR: Timeout reading from remote system", log_file);
-#endif
- }
+ error ("Timeout reading from remote system.");
+
perror_with_name ("remote-monitor");
}
-/* 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)
- char *string;
- int discard;
+/* Read a character from the remote system, doing all the fancy
+ timeout stuff. */
+
+static int
+readchar (int timeout)
{
- char *p = string;
int c;
+ static enum
+ {
+ last_random, last_nl, last_cr, last_crnl
+ }
+ state = last_random;
+ int looping;
- debuglogs (1, "Expecting \"%s\".", string);
-
- immediate_quit = 1;
- while (1)
+ do
{
- c = readchar (timeout);
- if (!isascii (c))
- continue;
- if (c == *p++)
+ looping = 0;
+ c = SERIAL_READCHAR (monitor_desc, timeout);
+
+ if (c >= 0)
{
- if (*p == '\0')
+ c &= 0x7f;
+ /* This seems to interfere with proper function of the
+ input stream */
+ if (monitor_debug_p || remote_debug)
{
- immediate_quit = 0;
- debuglogs (4, "Matched");
- return;
+ char buf[2];
+ buf[0] = c;
+ buf[1] = '\0';
+ puts_debug ("read -->", buf, "<--");
}
+
}
- else
+
+ /* Canonicialize \n\r combinations into one \r */
+ if ((current_monitor->flags & MO_HANDLE_NL) != 0)
{
- if (!discard)
+ if ((c == '\r' && state == last_nl)
+ || (c == '\n' && state == last_cr))
{
- putc_unfiltered (c);
-#if 0
- fwrite(string, 1, (p - 1) - string, stdout);
- putchar ((char)c);
- fflush (stdout);
-#endif
+ 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';
}
- p = string;
}
}
-}
-
-/* Keep discarding input until we see the MONITOR prompt.
+ while (looping);
- The convention for dealing with the prompt is that you
- o give your command
- o *then* wait for the prompt.
+ if (c >= 0)
+ return c;
- Thus the last thing that a procedure does with the serial line
- will be an 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. */
+ if (c == SERIAL_TIMEOUT)
+#if 0
+ /* I fail to see how detaching here can be useful */
+ if (in_monitor_wait) /* Watchdog went off */
+ {
+ target_mourn_inferior ();
+ error ("GDB serial timeout has expired. Target detached.\n");
+ }
+ else
+#endif
+ error ("Timeout reading from remote system.");
-static void
-expect_prompt (discard)
- int discard;
-{
- expect (PROMPT, discard);
+ perror_with_name ("remote-monitor");
}
-/* Ignore junk characters. Returns a 1 if junk, 0 otherwise. */
+/* 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. */
-static int
-junk (ch)
- char ch;
+int
+monitor_expect (char *string, char *buf, int buflen)
{
- switch (ch)
- {
- case '\0':
- case ' ':
- case '-':
- case '\t':
- case '\r':
- case '\n':
- if (sr_get_debug () > 5)
- debuglogs (5, "Ignoring \'%c\'.", ch);
- return 1;
- default:
- if (sr_get_debug () > 5)
- debuglogs (5, "Accepting \'%c\'.", ch);
- return 0;
- }
-}
-
-/* Get a hex digit from the remote system & return its value. If
- ignore is nonzero, ignore spaces, newline & tabs. */
+ char *p = string;
+ int obuflen = buflen;
+ int c;
+ extern struct target_ops *targ_ops;
-static int
-get_hex_digit (ignore)
- int ignore;
-{
- static int ch;
+ if (monitor_debug_p)
+ {
+ char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
+ monitor_printable_string (safe_string, string, 0);
+ fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
+ }
+ immediate_quit++;
while (1)
{
- ch = readchar (timeout);
- if (junk (ch))
- continue;
- if (sr_get_debug () > 4)
+ if (buf)
{
- debuglogs (4, "get_hex_digit() got a 0x%x(%c)", ch, ch);
+ if (buflen < 2)
+ {
+ *buf = '\000';
+ immediate_quit--;
+ 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)
{
-#ifdef LOG_FILE /* write to the monitor log */
- if (log_file != 0x0)
+ p++;
+ if (*p == '\0')
{
- fputs ("get_hex_digit() got a 0x", log_file);
- fputc (ch, log_file);
- fputc ('\n', log_file);
- fflush (log_file);
+ immediate_quit--;
+
+ if (buf)
+ {
+ *buf++ = '\000';
+ return obuflen - buflen;
+ }
+ else
+ return 0;
}
-#endif
}
-
- 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 if ((c == '\021' || c == '\023') &&
+ (STREQ (targ_ops->to_shortname, "m32r")
+ || STREQ (targ_ops->to_shortname, "mon2000")))
+ { /* m32r monitor emits random DC1/DC3 chars */
+ continue;
+ }
else
{
- expect_prompt (1);
- debuglogs (4, "Invalid hex digit from remote system. (0x%x)", ch);
- error ("Invalid hex digit from remote system. (0x%x)", ch);
+ /* We got a character that doesn't match the string. We need to
+ back up p, but how far? If we're looking for "..howdy" and the
+ monitor sends "...howdy"? There's certainly a match in there,
+ but when we receive the third ".", we won't find it if we just
+ restart the matching at the beginning of the string.
+
+ This is a Boyer-Moore kind of situation. We want to reset P to
+ the end of the longest prefix of STRING that is a suffix of
+ what we've read so far. In the example above, that would be
+ ".." --- the longest prefix of "..howdy" that is a suffix of
+ "...". This longest prefix could be the empty string, if C
+ is nowhere to be found in STRING.
+
+ If this longest prefix is not the empty string, it must contain
+ C, so let's search from the end of STRING for instances of C,
+ and see if the portion of STRING before that is a suffix of
+ what we read before C. Actually, we can search backwards from
+ p, since we know no prefix can be longer than that.
+
+ Note that we can use STRING itself, along with C, as a record
+ of what we've received so far. :) */
+ int i;
+
+ for (i = (p - string) - 1; i >= 0; i--)
+ if (string[i] == c)
+ {
+ /* Is this prefix a suffix of what we've read so far?
+ In other words, does
+ string[0 .. i-1] == string[p - i, p - 1]? */
+ if (! memcmp (string, p - i, i))
+ {
+ p = string + i + 1;
+ break;
+ }
+ }
+ if (i < 0)
+ p = string;
}
}
}
-/* Get a byte from monitor and put it in *BYT. Accept any number of
- leading spaces. */
-
-static void
-get_hex_byte (byt)
- char *byt;
-{
- int val;
-
- val = get_hex_digit (1) << 4;
- debuglogs (4, "get_hex_byte() -- Read first nibble 0x%x", val);
-
- val |= get_hex_digit (0);
- debuglogs (4, "get_hex_byte() -- Read second nibble 0x%x", val);
- *byt = val;
-
- debuglogs (4, "get_hex_byte() -- Read a 0x%x", val);
-}
-
-/* Get N 32-bit words from remote, each preceded by a space, and put
- them in registers starting at REGNO. */
+/* Search for a regexp. */
static int
-get_hex_word ()
+monitor_expect_regexp (struct re_pattern_buffer *pat, char *buf, int buflen)
{
- long val;
- int i;
-
- val = 0;
-
-#if 0
- if (HOST_BYTE_ORDER == BIG_ENDIAN)
- {
-#endif
- for (i = 0; i < 8; i++)
- val = (val << 4) + get_hex_digit (i == 0);
-#if 0
- }
+ char *mybuf;
+ char *p;
+ monitor_debug ("MON Expecting regexp\n");
+ if (buf)
+ mybuf = buf;
else
{
- for (i = 7; i >= 0; i--)
- val = (val << 4) + get_hex_digit (i == 0);
+ mybuf = alloca (TARGET_BUF_SIZE);
+ buflen = TARGET_BUF_SIZE;
}
-#endif
- debuglogs (4, "get_hex_word() got a 0x%x for a %s host.",
- val,
- (HOST_BYTE_ORDER == BIG_ENDIAN) ? "big endian" : "little endian");
+ p = mybuf;
+ while (1)
+ {
+ int retval;
+
+ if (p - mybuf >= buflen)
+ { /* Buffer about to overflow */
- return val;
+/* 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;
+ }
}
-/* This is called not only when we first attach, but also when the
- user types "run" after having attached. */
+/* Keep discarding input until we see the MONITOR prompt.
-void
-monitor_create_inferior (execfile, args, env)
- char *execfile;
- char *args;
- char **env;
+ The convention for dealing with the prompt is that you
+ o give your command
+ o *then* wait for the prompt.
+
+ Thus the last thing that a procedure does with the serial line 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. */
+
+int
+monitor_expect_prompt (char *buf, int buflen)
{
- int entry_pt;
+ monitor_debug ("MON Expecting prompt\n");
+ return monitor_expect (current_monitor->prompt, buf, buflen);
+}
+
+/* Get N 32-bit words from remote, each preceded by a space, and put
+ them in registers starting at REGNO. */
- if (args && *args)
- error ("Can't pass arguments to remote MONITOR process");
+#if 0
+static unsigned long
+get_hex_word (void)
+{
+ unsigned long val;
+ int i;
+ int ch;
- if (execfile == 0 || exec_bfd == 0)
- error ("No exec file specified");
+ do
+ ch = readchar (timeout);
+ while (isspace (ch));
- entry_pt = (int) bfd_get_start_address (exec_bfd);
+ val = from_hex (ch);
- /* The "process" (board) is already stopped awaiting our commands, and
- the program is already downloaded. We just set its PC and go. */
+ for (i = 7; i >= 1; i--)
+ {
+ ch = readchar (timeout);
+ if (!isxdigit (ch))
+ break;
+ val = (val << 4) | from_hex (ch);
+ }
- clear_proceed_status ();
+ return val;
+}
+#endif
- /* Tell wait_for_inferior that we've started a new process. */
- init_wait_for_inferior ();
+static void
+compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern,
+ char *fastmap)
+{
+ int tmp;
+ const char *val;
- /* Set up the "saved terminal modes" of the inferior
- based on what modes we are starting it with. */
- target_terminal_init ();
+ compiled_pattern->fastmap = fastmap;
- /* 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);
}
/* Open a connection to a remote debugger. NAME is the filename used
for communication. */
-static int baudrate = 9600;
-static char dev_name[100];
-
void
-monitor_open (args, name, from_tty)
- char *args;
- char *name;
- int from_tty;
+monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
{
- TERMINAL *temptempio;
+ char *name;
+ 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);
+
+ /* Setup pattern for register dump */
+
+ 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)
+ xfree (dev_name);
+ dev_name = strsave (args);
- strcpy (dev_name, args);
monitor_desc = SERIAL_OPEN (dev_name);
- if (monitor_desc == NULL)
+ 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_FLUSH_INPUT (monitor_desc);
+
/* some systems only work with 2 stop bits */
-#if !defined(__GO32__) && !defined(GDB_TARGET_IS_PA_ELF)
- if (STOPBITS == 2) {
- if (!strchr (dev_name, ':')) { /* don't set for a tcp connection */
- temptempio = (TERMINAL *) SERIAL_GET_TTY_STATE (monitor_desc);
-#ifdef HAVE_SGTTY
- temptempio->sg_cflag |= baud_rate | CSTOPB;
-#else
- temptempio->c_cflag |= baud_rate | CSTOPB;
-#endif
- SERIAL_SET_TTY_STATE (monitor_desc, temptempio);
- debuglogs (4, "Set serial port to 2 stop bits");
- }
- }
-#endif /* __GO32__ */
-
-#if defined (LOG_FILE)
- log_file = fopen (LOG_FILE, "w");
- if (log_file == NULL)
- perror_with_name (LOG_FILE);
- fprintf_filtered (log_file, "GDB %s (%s", version, host_name);
- fprintf_filtered (log_file, " --target %s)\n", target_name);
- fprintf_filtered (log_file, "Remote target %s connected to %s\n\n",
- TARGET_NAME, dev_name);
-#endif
- /* see if the target is alive. For a ROM monitor, we can just try to
- force the prompt to print a few times. FOr the GDB remote
- protocol, the application being debugged is sitting at a
- breakpoint and waiting for GDB to initialize the connection. We
- force it to give us an empty packet to see if it's alive. */
+ SERIAL_SETSTOPBITS (monitor_desc, mon_ops->stopbits);
- if (GDBPROTO)
- {
- debuglogs (3, "Trying to ACK the target's debug stub");
- printf_monitor (INIT_CMD); /* ask for the last signal */
- expect ("$S05#b8",0); /* look for a response */
- printf_monitor ("+"); /* ask for the last signal */
- expect_prompt (1); /* See if we get a prompt */
+ 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_debug ("EXP Open echo\n");
+ monitor_expect_prompt (NULL, 0);
+ }
}
- else
+
+ /* wake up the monitor and see if it's alive */
+ 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);
+
+ /* Alloc breakpoints */
+ if (mon_ops->set_break != NULL)
{
- /* wake up the monitor and see if it's alive */
- printf_monitor (INIT_CMD);
- expect_prompt (1); /* See if we get a prompt */
+ if (mon_ops->num_breakpoints == 0)
+ mon_ops->num_breakpoints = 8;
+
+ breakaddr = (CORE_ADDR *) xmalloc (mon_ops->num_breakpoints * sizeof (CORE_ADDR));
+ memset (breakaddr, 0, mon_ops->num_breakpoints * sizeof (CORE_ADDR));
+ }
+
+ /* Remove all breakpoints */
- /* try again to be sure */
- printf_monitor (INIT_CMD);
- expect_prompt (1); /* See if we get a prompt */
+ 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);
+
+ start_remote ();
}
/* Close out all files and local state before this target loses
control. */
void
-monitor_close (quitting)
- int quitting;
+monitor_close (int quitting)
{
- SERIAL_CLOSE (monitor_desc);
- monitor_desc = NULL;
-
- debuglogs (1, "monitor_close (quitting=%d)", quitting);
+ if (monitor_desc)
+ SERIAL_CLOSE (monitor_desc);
-#if defined (LOG_FILE)
- if (log_file)
+ /* Free breakpoint memory */
+ if (breakaddr != NULL)
{
- if (ferror (log_file))
- printf_filtered ("Error writing log file.\n");
- if (fclose (log_file) != 0)
- printf_filtered ("Error closing log file.\n");
+ xfree (breakaddr);
+ breakaddr = NULL;
}
-#endif
+
+ monitor_desc = NULL;
}
/* 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;
+static void
+monitor_detach (char *args, int from_tty)
{
- debuglogs (1, "monitor_detach ()");
-
pop_target (); /* calls monitor_close to do the real work */
if (from_tty)
- printf ("Ending remote %s debugging\n", target_shortname);
+ printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
}
-/* Attach GDB to the target. */
+/* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
-void
-monitor_attach (args, from_tty)
- char *args;
- int from_tty;
+char *
+monitor_supply_register (int regno, char *valstr)
{
- if (from_tty)
- printf ("Starting remote %s debugging\n", target_shortname);
-
- debuglogs (1, "monitor_attach (args=%s)", args);
-
- printf_monitor (GO_CMD);
- /* swallow the echo. */
- expect (GO_CMD, 1);
+ ULONGEST val;
+ unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
+ char *p;
+
+ val = 0;
+ p = valstr;
+ while (p && *p != '\0')
+ {
+ if (*p == '\r' || *p == '\n')
+ {
+ while (*p != '\0')
+ p++;
+ break;
+ }
+ if (isspace (*p))
+ {
+ p++;
+ continue;
+ }
+ if (!isxdigit (*p) && *p != 'x')
+ {
+ break;
+ }
+
+ val <<= 4;
+ val += fromhex (*p++);
+ }
+ monitor_debug ("Supplying Register %d %s\n", regno, valstr);
+
+ if (*p != '\0')
+ error ("monitor_supply_register (%d): bad value from monitor: %s.",
+ regno, valstr);
+
+ /* supply register stores in target byte order, so swap here */
+
+ store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
+
+ supply_register (regno, regbuf);
+
+ return p;
}
-
+
/* Tell the remote machine to resume. */
-void
-monitor_resume (pid, step, sig)
- int pid, step;
- enum target_signal sig;
+static void
+monitor_resume (int pid, int step, enum target_signal sig)
{
- debuglogs (1, "monitor_resume (step=%d, sig=%d)", step, sig);
-
+ /* Some monitors require a different command when starting a program */
+ monitor_debug ("MON resume\n");
+ 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;
+ }
if (step)
- printf_monitor (STEP_CMD);
+ monitor_printf (current_monitor->step);
else
- printf_monitor (CONT_CMD);
+ {
+ if (current_monitor->continue_hook)
+ (*current_monitor->continue_hook) ();
+ else
+ monitor_printf (current_monitor->cont);
+ if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
+ dump_reg_flag = 1;
+ }
}
-/* Wait until the remote machine stops, then return, storing status in
- status just as `wait' would. */
+/* 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. */
-int
-monitor_wait (pid, status)
- int pid;
- struct target_waitstatus *status;
+static void
+parse_register_dump (char *buf, int len)
{
- int old_timeout = timeout;
-
- debuglogs(1, "monitor_wait (), printing extraneous text.");
-
- status->kind = TARGET_WAITKIND_EXITED;
- status->value.integer = 0;
+ monitor_debug ("MON Parsing register dump\n");
+ 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;
- timeout = 0; /* Don't time out -- user program is running. */
+ memset (®ister_strings, 0, sizeof (struct re_registers));
- expect_prompt (0); /* Wait for prompt, outputting extraneous text */
- debuglogs (4, "monitor_wait(), got the prompt.");
+ if (re_search (®ister_pattern, buf, len, 0, len,
+ ®ister_strings) == -1)
+ break;
- status->kind = TARGET_WAITKIND_STOPPED;
- status->value.sig = TARGET_SIGNAL_TRAP;
+ 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];
- timeout = old_timeout;
+ current_monitor->supply_register (regname, regnamelen, val, vallen);
- return 0;
+ buf += register_strings.end[0];
+ len -= register_strings.end[0];
+ }
}
-/* 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! */
+/* Send ^C to target to halt it. Target will respond, and send us a
+ packet. */
-static char *
-get_reg_name (regno)
- int regno;
+static void
+monitor_interrupt (int signo)
{
- static char buf[50];
- const char *p;
- char *b;
-
- b = buf;
+ /* If this doesn't work, try more severe steps. */
+ signal (signo, monitor_interrupt_twice);
- if (regno < 0)
- return ("");
+ if (monitor_debug_p || remote_debug)
+ fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
+
+ target_stop ();
+}
- for (p = REGNAMES (regno); *p; p++)
- *b++ = tolower (*p);
+/* The user typed ^C twice. */
- *b = '\000';
+static void
+monitor_interrupt_twice (int signo)
+{
+ signal (signo, ofunc);
- debuglogs (5, "Got name \"%s\" from regno #%d.", buf, regno);
+ monitor_interrupt_query ();
- return buf;
+ signal (signo, monitor_interrupt);
}
-/* Read the remote registers into the block regs. */
+/* Ask the user what to do when an interrupt is received. */
-void
-monitor_fetch_registers (ignored)
- int ignored;
+static void
+monitor_interrupt_query (void)
{
- int regno, i;
- unsigned char packet[PBUFSIZ];
- char regs[REGISTER_BYTES];
-
- debuglogs (1, "monitor_fetch_registers (ignored=%d)\n", ignored);
-
- memset (packet, 0, PBUFSIZ);
- if (GDBPROTO)
- {
- /* Unimplemented registers read as all bits zero. */
- memset (regs, 0, REGISTER_BYTES);
- make_gdb_packet (packet, "g");
- if (monitor_send_packet (packet) == 0)
- error ("Couldn't transmit packet\n");
- if (monitor_get_packet (packet) == 0)
- error ("Couldn't receive packet\n");
- /* FIXME: read bytes from packet */
- debuglogs (4, "monitor_fetch_registers: Got a \"%s\" back\n", packet);
- for (regno = 0; regno <= PC_REGNUM+4; regno++)
- {
- /* supply register stores in target byte order, so swap here */
- /* FIXME: convert from ASCII hex to raw bytes */
- i = ascii2hexword (packet + (regno * 8));
- debuglogs (5, "Adding register %d = %x\n", regno, i);
- SWAP_TARGET_AND_HOST (&i, 4);
- supply_register (regno, (char *)&i);
- }
- }
- else
+ target_terminal_ours ();
+
+ if (query ("Interrupted while waiting for the program.\n\
+Give up (and stop debugging it)? "))
{
- for (regno = 0; regno <= PC_REGNUM; regno++)
- monitor_fetch_register (regno);
+ target_mourn_inferior ();
+ return_to_top_level (RETURN_QUIT);
}
-}
-/* Fetch register REGNO, or all registers if REGNO is -1. Returns
- errno value. */
+ target_terminal_inferior ();
+}
-void
-monitor_fetch_register (regno)
- int regno;
+static void
+monitor_wait_cleanup (void *old_timeout)
{
- int val;
- char *name;
+ timeout = *(int *) old_timeout;
+ signal (SIGINT, ofunc);
+ in_monitor_wait = 0;
+}
- debuglogs (1, "monitor_fetch_register (reg=%s)", get_reg_name (regno));
- if (regno < 0)
- monitor_fetch_registers ();
- else
+
+void
+monitor_wait_filter (char *buf,
+ int bufmax,
+ int *ext_resp_len,
+ struct target_waitstatus *status
+)
+{
+ int resp_len;
+ do
{
- name = get_reg_name (regno);
+ resp_len = monitor_expect_prompt (buf, bufmax);
+ *ext_resp_len = resp_len;
- if (STREQ (name, ""))
- return;
+ if (resp_len <= 0)
+ fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
+ }
+ while (resp_len < 0);
- printf_monitor (ROMCMD (GET_REG), name); /* send the command */
- expect (name, 1); /* then strip the leading garbage */
- if (*ROMDELIM (GET_REG) != 0)
- expect (ROMDELIM (GET_REG), 1);
-
- val = get_hex_word (); /* get the value, ignore junk */
+ /* Print any output characters that were preceded by ^O. */
+ /* FIXME - This would be great as a user settabgle flag */
+ if (monitor_debug_p || remote_debug
+ || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
+ {
+ int i;
- /* supply register stores in target byte order, so swap here */
- SWAP_TARGET_AND_HOST (&val, 4);
- supply_register (regno, (char *) &val);
-
- if (*ROMDELIM(GET_REG) != 0)
- {
- /*** expect (ROMRES(GET_REG)); ***/
- printf_monitor (CMD_END);
- }
- expect_prompt (1);
+ for (i = 0; i < resp_len - 1; i++)
+ if (buf[i] == 0x0f)
+ putchar_unfiltered (buf[++i]);
}
}
-/* Store the remote registers. */
-void
-monitor_store_registers (ignored)
- int ignored;
+
+/* Wait until the remote machine stops, then return, storing status in
+ status just as `wait' would. */
+
+static int
+monitor_wait (int pid, struct target_waitstatus *status)
{
- int regno;
- unsigned long i;
- char packet[PBUFSIZ];
- char buf[PBUFSIZ];
- char num[9];
-
- debuglogs (1, "monitor_store_registers()");
-
- if (GDBPROTO)
- {
- memset (packet, 0, PBUFSIZ);
- memset (buf, 0, PBUFSIZ);
- buf[0] = 'G';
-
- /* Unimplemented registers read as all bits zero. */
- /* FIXME: read bytes from packet */
- for (regno = 0; regno < 41; regno++) /* FIXME */
- {
- /* supply register stores in target byte order, so swap here */
- /* FIXME: convert from ASCII hex to raw bytes */
- i = (unsigned long)read_register (regno);
+ int old_timeout = timeout;
+ char buf[TARGET_BUF_SIZE];
+ 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);
+ monitor_debug ("MON wait\n");
+
#if 0
- SWAP_TARGET_AND_HOST (&i, 4);
+ /* This is somthing other than a maintenance command */
+ in_monitor_wait = 1;
+ timeout = watchdog > 0 ? watchdog : -1;
+#else
+ timeout = -1; /* Don't time out -- user program is running. */
#endif
- hexword2ascii (num, i);
- strcpy (buf + (regno * 8) + 1, num);
- }
- *(buf + (regno * 8) + 2) = 0;
- make_gdb_packet (packet, buf);
- if (monitor_send_packet (packet) == 0)
- error ("Couldn't transmit packet\n");
- if (monitor_get_packet (packet) == 0)
- error ("Couldn't receive packet\n");
- }
+ ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
+
+ if (current_monitor->wait_filter)
+ (*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status);
else
- {
- for (regno = 0; regno <= PC_REGNUM; regno++)
- monitor_store_register(regno);
- }
+ monitor_wait_filter (buf, sizeof (buf), &resp_len, status);
- registers_changed ();
-}
+#if 0 /* Transferred to monitor wait filter */
+ do
+ {
+ resp_len = monitor_expect_prompt (buf, sizeof (buf));
-/* Store register REGNO, or all if REGNO == 0. Return errno value. */
+ if (resp_len <= 0)
+ fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
+ }
+ while (resp_len < 0);
-void
-monitor_store_register (regno)
- int regno;
-{
- char *name;
- int i;
+ /* Print any output characters that were preceded by ^O. */
+ /* FIXME - This would be great as a user settabgle flag */
+ if (monitor_debug_p || remote_debug
+ || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
+ {
+ int i;
- i = read_register (regno);
+ for (i = 0; i < resp_len - 1; i++)
+ if (buf[i] == 0x0f)
+ putchar_unfiltered (buf[++i]);
+ }
+#endif
- debuglogs (1, "monitor_store_register (regno=%d)", regno);
+ signal (SIGINT, ofunc);
- if (regno < 0)
- monitor_store_registers ();
- else
+ timeout = old_timeout;
+#if 0
+ if (dump_reg_flag && current_monitor->dump_registers)
{
- debuglogs (3, "Setting register %s to 0x%x",
- get_reg_name (regno), read_register (regno));
-
- name = get_reg_name (regno);
- if (STREQ (name, ""))
- return;
- printf_monitor (ROMCMD (SET_REG), name, read_register (regno));
- expect (name, 1); /* strip the leading garbage */
- if (*ROMDELIM (SET_REG) != 0)
- {
- expect (ROMDELIM (SET_REG), 1);
- get_hex_word (1);
- printf_monitor ("%d%s\n", i, CMD_END);
- }
- expect_prompt (1);
+ dump_reg_flag = 0;
+ monitor_printf (current_monitor->dump_registers);
+ resp_len = monitor_expect_prompt (buf, sizeof (buf));
}
- return;
-#if 0
- printf_monitor (SET_REG, get_reg_name (regno),
- read_register (regno));
- expect_prompt (1);
+ if (current_monitor->register_pattern)
+ parse_register_dump (buf, resp_len);
+#else
+ monitor_debug ("Wait fetching registers after stop\n");
+ monitor_dump_regs ();
#endif
-}
-/* Get ready to modify the registers array. On machines which store
- individual registers, this doesn't need to do anything. On machines
- which store all the registers in one fell swoop, this makes sure
- that registers contains all the registers from the program being
- debugged. */
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TRAP;
-void
-monitor_prepare_to_store ()
-{
- /* Do nothing, since we can store individual regs */
-}
+ discard_cleanups (old_chain);
-void
-monitor_files_info ()
-{
- printf ("\tAttached to %s at %d baud.\n", dev_name, baudrate);
+ in_monitor_wait = 0;
+
+ return inferior_pid;
}
-/* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
- memory at MEMADDR. Returns length moved. */
+/* Fetch register REGNO, or all registers if REGNO is -1. Returns
+ errno value. */
-int
-monitor_write_inferior_memory (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- unsigned char *myaddr;
- int len;
+static void
+monitor_fetch_register (int regno)
{
- unsigned long i;
- int j;
- char packet[PBUFSIZ];
- char buf[PBUFSIZ];
- char num[9];
- char *p;
-
- debuglogs (1, "monitor_write_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)",
- memaddr, myaddr, len);
- memset (buf, '\0', PBUFSIZ); /* this also sets the string terminator */
- p = buf;
+ char *name;
+ char *zerobuf;
+ char *regbuf;
+ int i;
- if (GDBPROTO)
- {
- *p++ = 'M'; /* The command to write memory */
- hexword2ascii (num, memaddr); /* convert the address */
- strcpy (p, num); /* copy the address */
- p += 8;
- *p++ = ','; /* add comma delimeter */
- hexword2ascii (num, len); /* Get the length as a 4 digit number */
- *p++ = num[4];
- *p++ = num[5];
- *p++ = num[6];
- *p++ = num[7];
- *p++ = ':'; /* add the colon delimeter */
- for (j = 0; j < len; j++)
- { /* copy the data in after converting it */
- *p++ = tohex ((myaddr[j] >> 4) & 0xf);
- *p++ = tohex (myaddr[j] & 0xf);
- }
+ regbuf = alloca (MAX_REGISTER_RAW_SIZE * 2 + 1);
+ zerobuf = alloca (MAX_REGISTER_RAW_SIZE);
+ memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE);
- make_gdb_packet (packet, buf);
- if (monitor_send_packet (packet) == 0)
- error ("Couldn't transmit packet\n");
- if (monitor_get_packet (packet) == 0)
- error ("Couldn't receive packet\n");
+ name = current_monitor->regnames[regno];
+ monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
+
+ if (!name || (*name == '\0'))
+ {
+ monitor_debug ("No register known for %d\n", regno);
+ supply_register (regno, zerobuf);
+ return;
}
- else
+
+ /* 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)
{
- for (i = 0; i < len; i++)
+ monitor_debug ("EXP getreg.resp_delim\n");
+ monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
+ /* Handle case of first 32 registers listed in pairs. */
+ if (current_monitor->flags & MO_32_REGS_PAIRED
+ && (regno & 1) != 0 && regno < 32)
{
- printf_monitor (ROMCMD (SET_MEM), memaddr + i, myaddr[i]);
- if (*ROMDELIM (SET_MEM) != 0)
- {
- expect (ROMDELIM (SET_MEM), 1);
- expect (CMD_DELIM);
- printf_monitor ("%x", myaddr[i]);
- }
- /*** 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);
- }
- expect_prompt (1);
+ monitor_debug ("EXP getreg.resp_delim\n");
+ monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
}
}
- return len;
-}
-/* Read LEN bytes from inferior memory at MEMADDR. Put the result at
- debugger address MYADDR. Returns length moved. */
+ /* 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);
+ }
-int
-monitor_read_inferior_memory(memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
-{
- int i, j;
- char buf[20];
- char packet[PBUFSIZ];
+ /* 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. */
- /* Number of bytes read so far. */
- int count;
+ for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
+ {
+ int c;
+ c = readchar (timeout);
+ while (c == ' ')
+ c = readchar (timeout);
- /* Starting address of this pass. */
- unsigned long startaddr;
+ if (!isxdigit (c))
+ break;
- /* Starting address of this pass. */
- unsigned long endaddr;
+ regbuf[i] = c;
+ }
- /* Number of bytes to read in this pass. */
- int len_this_pass;
+ regbuf[i] = '\000'; /* terminate the number */
+ monitor_debug ("REGVAL '%s'\n", regbuf);
- debuglogs (1, "monitor_read_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr, myaddr, 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. */
- /* 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)
+ if (current_monitor->getreg.term)
{
- errno = EIO;
- return 0;
+ monitor_debug ("EXP getreg.term\n");
+ monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */
}
-
- 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);
-
- debuglogs (3, "Display %d bytes at %x for Big Endian host",
- len_this_pass, startaddr);
-
- if (GDBPROTO)
- {
- for (i = 0; i < len_this_pass; i++)
- {
- sprintf (buf, "m%08x,%04x", startaddr, len_this_pass);
- make_gdb_packet (packet, buf);
- if (monitor_send_packet (packet) == 0)
- error ("Couldn't transmit packet\n");
- if (monitor_get_packet (packet) == 0)
- error ("Couldn't receive packet\n");
- debuglogs (4, "monitor_read_inferior: Got a \"%s\" back\n",
- packet);
- for (j = 0; j < len_this_pass ; j++)
- {
- myaddr[count++] =
- from_hex (*(packet+(j*2))) * 16
- + from_hex (*(packet+(j*2)+1));
- debuglogs (5, "myaddr set to %x\n", myaddr[count-1]);
- }
- startaddr += 1;
- }
- }
- else
- {
- for (i = 0; i < len_this_pass; i++)
- {
- printf_monitor (ROMCMD (GET_MEM), startaddr, startaddr);
- sprintf (buf, ROMCMD (GET_MEM), startaddr, startaddr);
- if (*ROMDELIM(GET_MEM) != 0)
- {
- 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;
- }
- }
+
+ if (current_monitor->getreg.term_cmd)
+ {
+ monitor_debug ("EMIT getreg.term.cmd\n");
+ monitor_printf (current_monitor->getreg.term_cmd);
}
- return len;
-}
+ if (!current_monitor->getreg.term || /* Already expected or */
+ current_monitor->getreg.term_cmd) /* ack expected */
+ monitor_expect_prompt (NULL, 0); /* get response */
-/* FIXME-someday! merge these two. */
+ monitor_supply_register (regno, regbuf);
+}
+/* Sometimes, it takes several commands to dump the registers */
+/* This is a primitive for use by variations of monitor interfaces in
+ case they need to compose the operation.
+ */
int
-monitor_xfer_inferior_memory (memaddr, myaddr, len, write, target)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int write;
- struct target_ops *target; /* ignored */
+monitor_dump_reg_block (char *block_cmd)
{
- if (write)
- return monitor_write_inferior_memory (memaddr, myaddr, len);
- else
- return monitor_read_inferior_memory (memaddr, myaddr, len);
+ char buf[TARGET_BUF_SIZE];
+ int resp_len;
+ monitor_printf (block_cmd);
+ resp_len = monitor_expect_prompt (buf, sizeof (buf));
+ parse_register_dump (buf, resp_len);
+ return 1;
}
-void
-monitor_kill (args, from_tty)
- char *args;
- int from_tty;
-{
- return; /* ignore attempts to kill target system */
-}
-/* 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. */
+/* Read the remote registers into the block regs. */
+/* Call the specific function if it has been provided */
-void
-monitor_mourn_inferior ()
+static void
+monitor_dump_regs (void)
{
- remove_breakpoints ();
- generic_mourn_inferior (); /* Do all the proper things now */
+ char buf[TARGET_BUF_SIZE];
+ int resp_len;
+ if (current_monitor->dumpregs)
+ (*(current_monitor->dumpregs)) (); /* call supplied function */
+ else if (current_monitor->dump_registers) /* default version */
+ {
+ 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 */
}
-#define MAX_MONITOR_BREAKPOINTS 16
-
-extern int memory_breakpoint_size;
-static CORE_ADDR breakaddr[MAX_MONITOR_BREAKPOINTS] = {0};
-
-/* Tell the monitor to add a breakpoint. */
-
-int
-monitor_insert_breakpoint (addr, shadow)
- CORE_ADDR addr;
- char *shadow;
+static void
+monitor_fetch_registers (int regno)
{
- int i;
-
- debuglogs (1, "monitor_insert_breakpoint() addr = 0x%x", addr);
-
- for (i = 0; i <= MAX_MONITOR_BREAKPOINTS; i++)
+ monitor_debug ("MON fetchregs\n");
+ if (current_monitor->getreg.cmd)
{
- if (breakaddr[i] == 0)
+ if (regno >= 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;
+ monitor_fetch_register (regno);
+ return;
}
- }
- fprintf (stderr, "Too many breakpoints (> 16) for monitor\n");
- return 1;
+ for (regno = 0; regno < NUM_REGS; regno++)
+ monitor_fetch_register (regno);
+ }
+ else
+ {
+ monitor_dump_regs ();
+ }
}
-/* Tell the monitor to remove a breakpoint. */
+/* Store register REGNO, or all if REGNO == 0. Return errno value. */
-int
-monitor_remove_breakpoint (addr, shadow)
- CORE_ADDR addr;
- char *shadow;
+static void
+monitor_store_register (int regno)
{
- int i;
-
- debuglogs (1, "monitor_remove_breakpoint() addr = 0x%x", addr);
+ char *name;
+ ULONGEST val;
- for (i = 0; i < MAX_MONITOR_BREAKPOINTS; i++)
+ name = current_monitor->regnames[regno];
+ if (!name || (*name == '\0'))
{
- 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;
- }
+ monitor_debug ("MON Cannot store unknown register\n");
+ return;
}
- fprintf (stderr, "Can't find breakpoint associated with 0x%x\n", addr);
- return 1;
-}
-/* monitor_load -- load a file. This file determines which of the
- * supported formats to use. The current types are:
- * FIXME: not all types supported yet.
- * default - reads any file using bfd and writes it to memory. This
- * is really slow.
- * srec - reads binary file using bfd and writes it as an
- * ascii srecord.
- * xmodem-bin - reads a binary file using bfd, and downloads it
- * using xmodem protocol.
- * xmodem-srec - reads a binary file using bfd, and after converting
- * it downloads it as an srecord using xmodem protocol.
- * ascii-srec - reads a ascii srecord file and downloads it
- * without a change.
- * ascii-xmodem - reads a ascii file and downloads using xmodem
- * protocol.
- */
+ val = read_register (regno);
+ monitor_debug ("MON storeg %d %s\n", regno,
+ phex (val, REGISTER_RAW_SIZE (regno)));
-void
-monitor_load (file, fromtty)
- char *file;
- int fromtty;
-{
- debuglogs (1, "Loading %s to monitor", file);
+ /* send the register deposit command */
- /* default, load a binary */
- if (STREQ (loadtype_str, "default"))
- {
- gr_load_image (file, fromtty); /* by writing it into memory */
- return;
- }
+ if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
+ monitor_printf (current_monitor->setreg.cmd, val, name);
+ else if (current_monitor->flags & MO_SETREG_INTERACTIVE)
+ monitor_printf (current_monitor->setreg.cmd, name);
+ else
+ monitor_printf (current_monitor->setreg.cmd, name, val);
- /* load an srecord by converting */
- if ((STREQ (loadtype_str, "srec")) && STREQ (loadproto_str, "xmodem"))
+ if (current_monitor->setreg.term)
{
- monitor_load_srec (file, XMODEM);
- return;
+ monitor_debug ("EXP setreg.term\n");
+ monitor_expect (current_monitor->setreg.term, NULL, 0);
+ if (current_monitor->flags & MO_SETREG_INTERACTIVE)
+ monitor_printf ("%s\r", paddr_nz (val));
+ monitor_expect_prompt (NULL, 0);
}
-
- /* load an srecord by converting */
- if (STREQ (loadtype_str, "srec"))
+ else
+ monitor_expect_prompt (NULL, 0);
+ if (current_monitor->setreg.term_cmd) /* Mode exit required */
{
- monitor_load_srec (file, 0); /* if from a binary */
- return;
+ monitor_debug ("EXP setreg_termcmd\n");
+ monitor_printf ("%s", current_monitor->setreg.term_cmd);
+ monitor_expect_prompt (NULL, 0);
}
+} /* monitor_store_register */
- /* load an srecord by converting */
- if (STREQ (loadtype_str, "none"))
- {
- error ("Unimplemented");
- return;
- }
+/* Store the remote registers. */
- /* load an srecord file */
- if (STREQ (loadproto_str, "none"))
+static void
+monitor_store_registers (int regno)
+{
+ if (regno >= 0)
{
- monitor_load_ascii_srec (file, fromtty); /* if from a binary */
+ monitor_store_register (regno);
return;
}
- if (STREQ (loadproto_str, "xmodem"))
- {
- monitor_load_srec (file, XMODEM);
- return;
- }
+ for (regno = 0; regno < NUM_REGS; regno++)
+ monitor_store_register (regno);
}
-/* Download an ASCII srecord file. */
+/* Get ready to modify the registers array. On machines which store
+ individual registers, this doesn't need to do anything. On machines
+ which store all the registers in one fell swoop, this makes sure
+ that registers contains all the registers from the program being
+ debugged. */
-#define DOWNLOAD_LINE_SIZE 100
+static void
+monitor_prepare_to_store (void)
+{
+ /* Do nothing, since we can store individual regs */
+}
static void
-monitor_load_ascii_srec (file, fromtty)
- char *file;
- int fromtty;
+monitor_files_info (struct target_ops *ops)
+{
+ printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
+}
+
+static int
+monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
- FILE *download;
- char buf[DOWNLOAD_LINE_SIZE];
- int i, bytes_read;
+ unsigned int val, hostval;
+ char *cmd;
+ int i;
- debuglogs (1, "Loading an ASCII srecord file, %s.", file);
+ monitor_debug ("MON write %d %s\n", len, paddr (memaddr));
- download = fopen (file, "r");
- if (download == NULL)
- {
- error ("%s does not exist", file);
- return;
- }
+ if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
+ memaddr = ADDR_BITS_REMOVE (memaddr);
+
+ /* Use memory fill command for leading 0 bytes. */
- printf_monitor (LOAD_CMD);
- sleep (1);
- while (!feof (download))
+ if (current_monitor->fill)
{
- bytes_read = fread (buf, sizeof (char), DOWNLOAD_LINE_SIZE, download);
- if (hashmark)
- {
- putchar ('.');
- fflush (stdout);
- }
- if (SERIAL_WRITE (monitor_desc, buf, bytes_read))
- {
- fprintf (stderr, "SERIAL_WRITE failed: (while downloading) %s\n",
- safe_strerror (errno));
+ for (i = 0; i < len; i++)
+ if (myaddr[i] != 0)
break;
- }
- i = 0;
- while (i++ <=200) {} ; /* Ugly HACK, probably needs flow control */
- if (bytes_read < DOWNLOAD_LINE_SIZE)
+
+ if (i > 4) /* More than 4 zeros is worth doing */
{
- if (!feof (download))
- error ("Only read %d bytes\n", bytes_read);
- break;
+ monitor_debug ("MON FILL %d\n", i);
+ if (current_monitor->flags & MO_FILL_USES_ADDR)
+ monitor_printf (current_monitor->fill, memaddr, (memaddr + i) - 1, 0);
+ else
+ monitor_printf (current_monitor->fill, memaddr, i, 0);
+
+ monitor_expect_prompt (NULL, 0);
+
+ return i;
}
}
-
- if (hashmark)
- putchar ('\n');
- if (!feof (download))
- error ("Never got EOF while downloading");
- expect_prompt (1);
- fclose (download);
-}
+#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;
+ }
-/* 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. */
+ val = extract_unsigned_integer (myaddr, len);
-void
-monitor_command (args, fromtty)
- char *args;
- int fromtty;
-{
- char *p;
+ if (len == 4)
+ {
+ hostval = *(unsigned int *) myaddr;
+ monitor_debug ("Hostval(%08x) val(%08x)\n", hostval, val);
+ }
- p = PROMPT;
- debuglogs (1, "monitor_command (args=%s)", args);
+ if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
+ monitor_printf_noecho (cmd, memaddr, val);
+ else if (current_monitor->flags & MO_SETMEM_INTERACTIVE)
+ {
- if (monitor_desc == NULL)
- error ("monitor target not open.");
+ monitor_printf_noecho (cmd, memaddr);
- /* Send the command. Note that if no args were supplied, then we're
- just sending the monitor a newline, which is sometimes useful. */
+ if (current_monitor->setmem.term)
+ {
+ monitor_debug ("EXP setmem.term");
+ monitor_expect (current_monitor->setmem.term, NULL, 0);
+ monitor_printf ("%x\r", val);
+ }
+ if (current_monitor->setmem.term_cmd)
+ { /* Emit this to get out of the memory editing state */
+ monitor_printf ("%s", current_monitor->setmem.term_cmd);
+ /* Drop through to expecting a prompt */
+ }
+ }
+ else
+ monitor_printf (cmd, memaddr, val);
- printf_monitor ("%s\n", (args ? args : ""));
+ monitor_expect_prompt (NULL, 0);
- expect_prompt (0);
+ return len;
}
-/* Download a binary file by converting it to srecords. This
- will also use xmodem to download the resulting file.
-
- A download goes like this when using xmodem:
- Receiver: Sender
- NAK ---------->
- <-------- (packet) [SOH|1|1|data|SUM]
- ACK ---------->
- <-------- (packet) [SOH|2|2|data|SUM]
- ACK ---------->
- <-------- EOT
- ACK ---------->
-
- ACK = 0x06
- NAK = 0x15
- EOT = 0x04
- */
-static void
-monitor_load_srec (args, protocol)
- char *args;
- int protocol;
+static int
+monitor_write_even_block (CORE_ADDR memaddr, char *myaddr, int len)
{
- bfd *abfd;
- asection *s;
- char *buffer, srec[1024];
- char packet[XMODEM_PACKETSIZE];
- int i;
- int retries;
- int type = 0; /* default to a type 0, header record */
- int srec_frame = 57; /* FIXME: this must be 57 There is 12 bytes
- of header, and 2 bytes of checksum at the end.
- The problem is an xmodem packet holds exactly
- 128 bytes. */
+ unsigned int val;
+ int written = 0;;
+ /* Enter the sub mode */
+ monitor_printf (current_monitor->setmem.cmdl, memaddr);
+ monitor_expect_prompt (NULL, 0);
- abfd = bfd_openr (args, 0);
- if (!abfd)
+ while (len)
{
- printf_filtered ("Unable to open file %s\n", args);
- return;
+ val = extract_unsigned_integer (myaddr, 4); /* REALLY */
+ monitor_printf ("%x\r", val);
+ myaddr += 4;
+ memaddr += 4;
+ written += 4;
+ monitor_debug (" @ %s\n", paddr (memaddr));
+ /* If we wanted to, here we could validate the address */
+ monitor_expect_prompt (NULL, 0);
}
+ /* Now exit the sub mode */
+ monitor_printf (current_monitor->getreg.term_cmd);
+ monitor_expect_prompt (NULL, 0);
+ return written;
+}
+
- if (bfd_check_format (abfd, bfd_object) == 0)
+static int
+monitor_write_memory_bytes (CORE_ADDR memaddr, char *myaddr, int len)
+{
+ unsigned char val;
+ int written = 0;
+ if (len == 0)
+ return 0;
+ /* Enter the sub mode */
+ monitor_printf (current_monitor->setmem.cmdb, memaddr);
+ monitor_expect_prompt (NULL, 0);
+ while (len)
{
- printf_filtered ("File is not an object file\n");
- return;
+ val = *myaddr;
+ monitor_printf ("%x\r", val);
+ myaddr++;
+ memaddr++;
+ written++;
+ /* If we wanted to, here we could validate the address */
+ monitor_expect_prompt (NULL, 0);
+ len--;
}
-
- printf_monitor (LOAD_CMD); /* tell the monitor to load */
- sleep (3);
- /* get the NAK from the target */
- if (protocol == XMODEM)
+ /* Now exit the sub mode */
+ monitor_printf (current_monitor->getreg.term_cmd);
+ monitor_expect_prompt (NULL, 0);
+ return written;
+}
+
+
+static void
+longlongendswap (unsigned char *a)
+{
+ int i, j;
+ unsigned char x;
+ i = 0;
+ j = 7;
+ while (i < 4)
{
- if (GETNAK)
- {
- debuglogs (3, "Got the NAK to start loading");
- }
- else
- {
- printf_monitor ("%c", EOT);
- debuglogs (3, "Never got the NAK to start loading");
- error ("Never got the NAK to start loading");
- }
+ x = *(a + i);
+ *(a + i) = *(a + j);
+ *(a + j) = x;
+ i++, j--;
+ }
+}
+/* Format 32 chars of long long value, advance the pointer */
+static char *hexlate = "0123456789abcdef";
+static char *
+longlong_hexchars (unsigned long long value,
+ char *outbuff)
+{
+ if (value == 0)
+ {
+ *outbuff++ = '0';
+ return outbuff;
}
-
- s = abfd->sections;
- while (s != (asection *) NULL)
+ else
{
- if (s->flags & SEC_LOAD)
+ static unsigned char disbuf[8]; /* disassembly buffer */
+ unsigned char *scan, *limit; /* loop controls */
+ unsigned char c, nib;
+ int leadzero = 1;
+ scan = disbuf;
+ limit = scan + 8;
+ {
+ unsigned long long *dp;
+ dp = (unsigned long long *) scan;
+ *dp = value;
+ }
+ longlongendswap (disbuf); /* FIXME: ONly on big endian hosts */
+ while (scan < limit)
{
- buffer = xmalloc (srec_frame);
-
- printf_filtered ("%s\t: 0x%4x .. 0x%4x ",
- s->name, s->vma, s->vma + s->_raw_size);
- fflush (stdout);
- for (i = 0; i < s->_raw_size; i += srec_frame)
+ c = *scan++; /* a byte of our long long value */
+ if (leadzero)
{
- if (srec_frame > s->_raw_size - i)
- srec_frame = s->_raw_size - i;
-
- bfd_get_section_contents (abfd, s, buffer, i, srec_frame);
- monitor_make_srec (srec, type, s->vma + i, buffer, srec_frame);
- /* send a packet using xmodem */
- if (protocol == XMODEM)
- {
- make_xmodem_packet (packet, srec, XMODEM_DATASIZE);
- write_monitor (packet, XMODEM_PACKETSIZE+1);
- retries = 0;
- while (retries++ <= 3)
- {
- /* Resend packet */
- if (GETNAK)
- {
- debuglogs (3, "Got a NAK, resending packet");
- sleep (1);
- /* send it again */
- write_monitor (packet, XMODEM_PACKETSIZE+1);
- if (GETACK) /* ACKnowledged, get next data chunk */
- break;
- }
- else
- { /* assume we got an ACK */
- if (hashmark)
- {
- putc_unfiltered ('#');
- gdb_flush (gdb_stdout);
- }
- debuglogs (3, "Got an ACK, sending next packet");
- break;
- }
- }
- if (retries >= 4)
- { /* too many tries, must be hosed */
- printf_monitor ("%c", EOT);
- error ("Never got a ACK after sending an xmodem packet");
- }
- }
+ if (c == 0)
+ continue;
else
- { /* no protocols at all */
- printf_monitor ("%s\n", srec);
- }
- if (hashmark)
- {
- putc_unfiltered ('#');
- gdb_flush (gdb_stdout);
- }
- type = 3; /* switch to a 4 byte address record */
- fflush (gdb_stdout);
+ leadzero = 0; /* henceforth we print even zeroes */
}
- free (buffer);
- }
- else
- {
- debuglogs (3, "%s doesn't need to be loaded", s->name);
+ nib = c >> 4; /* high nibble bits */
+ *outbuff++ = hexlate[nib];
+ nib = c & 0x0f; /* low nibble bits */
+ *outbuff++ = hexlate[nib];
}
- s = s->next;
+ return outbuff;
}
- putc_unfiltered ('\n');
-
- /* Write a type 7 terminator record. no data for a type 7, and there
- is no data, so len is 0. */
+} /* longlong_hexchars */
- if (protocol == XMODEM)
+
+
+/* I am only going to call this when writing virtual byte streams.
+ Which possably entails endian conversions
+ */
+static int
+monitor_write_memory_longlongs (CORE_ADDR memaddr, char *myaddr, int len)
+{
+ static char hexstage[20]; /* At least 16 digits required, plus null */
+ char *endstring;
+ long long *llptr;
+ long long value;
+ int written = 0;
+ llptr = (unsigned long long *) myaddr;
+ if (len == 0)
+ return 0;
+ monitor_printf (current_monitor->setmem.cmdll, memaddr);
+ monitor_expect_prompt (NULL, 0);
+ while (len >= 8)
{
- /* send a packet using xmodem */
- monitor_make_srec (srec, 7, abfd->start_address, "", 0);
- make_xmodem_packet (packet, srec, XMODEM_DATASIZE);
- write_monitor (packet, XMODEM_PACKETSIZE+1);
+ value = *llptr;
+ endstring = longlong_hexchars (*llptr, hexstage);
+ *endstring = '\0'; /* NUll terminate for printf */
+ monitor_printf ("%s\r", hexstage);
+ llptr++;
+ memaddr += 8;
+ written += 8;
+ /* If we wanted to, here we could validate the address */
+ monitor_expect_prompt (NULL, 0);
+ len -= 8;
}
- else
+ /* Now exit the sub mode */
+ monitor_printf (current_monitor->getreg.term_cmd);
+ monitor_expect_prompt (NULL, 0);
+ return written;
+} /* */
+
+
+
+/* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
+/* This is for the large blocks of memory which may occur in downloading.
+ And for monitors which use interactive entry,
+ And for monitors which do not have other downloading methods.
+ Without this, we will end up calling monitor_write_memory many times
+ and do the entry and exit of the sub mode many times
+ This currently assumes...
+ MO_SETMEM_INTERACTIVE
+ ! MO_NO_ECHO_ON_SETMEM
+ To use this, the you have to patch the monitor_cmds block with
+ this function. Otherwise, its not tuned up for use by all
+ monitor variations.
+ */
+
+static int
+monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len)
+{
+ int written;
+ written = 0;
+ /* FIXME: This would be a good place to put the zero test */
+#if 1
+ if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
{
- monitor_make_srec (srec, 7, abfd->start_address, "", 0);
- printf_monitor ("%s\n", srec);
+ return monitor_write_memory_longlongs (memaddr, myaddr, len);
}
- if (protocol == XMODEM)
+#endif
+#if 0
+ if (len > 4)
{
- printf_monitor ("%c", EOT);
- if (!GETACK)
- error ("Never got ACK after sending EOT");
+ int sublen;
+ written = monitor_write_even_block (memaddr, myaddr, len);
+ /* Adjust calling parameters by written amount */
+ memaddr += written;
+ myaddr += written;
+ len -= written;
}
-
- if (hashmark)
- putc_unfiltered ('\n');
-
- expect_prompt ();
+#endif
+ written = monitor_write_memory_bytes (memaddr, myaddr, len);
+ return written;
}
-/* Get an ACK or a NAK from the target. returns 1 (true) or 0 (false)
- This is for xmodem. ANy string starting with "***" is an error
- message from the target. Here's a few from the WinBond w89k
- "Cougar" PA board:
- *** Too many errors found.
- *** Bad command
- *** Command syntax error
- */
+/* 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. */
-int
-getacknak (byte)
- int byte;
+static int
+monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
{
- char character;
+ unsigned int val;
+ char membuf[sizeof (int) * 2 + 1];
+ char *p;
+ char *cmd;
int i;
-
- i = 0;
- while (i++ < 60)
- {
- character = (char) readchar (0);
- if ((character == 0xfffffffe) || (character == 0x7f))
- { /* empty uart */
- if (sr_get_debug () > 3)
- putchar ('.');
- fflush (stdout);
- sleep (1);
- continue;
- }
- if (character == CANCEL)
- { /* target aborted load */
- expect_prompt (0);
- error ("Got a CANCEL from the target.");
+
+ monitor_debug ("MON read single\n");
+#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;
+ }
+ else
+#endif
+ if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
+ {
+ len = 4;
+ cmd = current_monitor->getmem.cmdl;
+ }
+ 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 memory value. Otherwise, we just start
+ searching from the start of the buf. */
+
+ if (current_monitor->getmem.resp_delim)
+ {
+ monitor_debug ("EXP getmem.resp_delim\n");
+ 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
+ monitor_error ("monitor_read_memory_single",
+ "bad response from monitor",
+ 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;
+
+ monitor_error ("monitor_read_memory_single",
+ "bad response from monitor",
+ memaddr, i, membuf, c);
}
- if (character == '*')
- { /* look for missed error message */
- expect_prompt (0);
- error ("Got an error message from the target");
- }
- debuglogs (3, "Got a %s (0x%x or \'%c\'), expecting a %s.\n",
- (character == ACK) ? "ACK"
- : (character == NAK) ? "NAK"
- : "BOGUS",
- character, character, (byte == ACK) ? "ACK" : "NAK");
- if (character == byte) /* got what we wanted */
- return 1;
- if (character == ((byte == ACK) ? NAK : ACK))
- { /* got the opposite */
- debuglogs (3, "Got the opposite, wanted 0x%x, got a 0x%x",
- byte, character);
- return 0;
+
+ 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);
}
- sleep (1);
}
+ else
+ monitor_expect_prompt (NULL, 0); /* get response */
+
+ p = membuf;
+ val = strtoul (membuf, &p, 16);
- return 0;
+ if (val == 0 && membuf == p)
+ monitor_error ("monitor_read_memory_single",
+ "bad value from monitor",
+ memaddr, 0, membuf, 0);
+
+ /* supply register stores in target byte order, so swap here */
+
+ store_unsigned_integer (myaddr, len, val);
+
+ return len;
}
-/*
- * monitor_make_srec -- make an srecord. This writes each line, one at a
- * time, each with it's own header and trailer line.
- * An srecord looks like this:
- *
- * byte count-+ address
- * start ---+ | | data +- checksum
- * | | | |
- * S01000006F6B692D746573742E73726563E4
- * S315000448600000000000000000FC00005900000000E9
- * S31A0004000023C1400037DE00F023604000377B009020825000348D
- * S30B0004485A0000000000004E
- * S70500040000F6
- *
- * S<type><length><address><data><checksum>
- *
- * Where
- * - length
- * is the number of bytes following upto the checksum. Note that
- * this is not the number of chars following, since it takes two
- * chars to represent a byte.
- * - type
- * is one of:
- * 0) header record
- * 1) two byte address data record
- * 2) three byte address data record
- * 3) four byte address data record
- * 7) four byte address termination record
- * 8) three byte address termination record
- * 9) two byte address termination record
- *
- * - address
- * is the start address of the data following, or in the case of
- * a termination record, the start address of the image
- * - data
- * is the data.
- * - checksum
- * is the sum of all the raw byte data in the record, from the length
- * upwards, modulo 256 and subtracted from 255.
- */
+/* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
+ memory at MEMADDR. Returns length moved. Currently, we do no more
+ than 16 bytes at a time. */
static int
-monitor_make_srec (buffer, type, memaddr, myaddr, len)
- char *buffer;
- int type;
- CORE_ADDR memaddr;
- unsigned char *myaddr;
- int len;
+monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
- int checksum;
+ unsigned int val;
+ char buf[512];
+ char *p, *p1;
+ int resp_len;
int i;
- char *buf;
-
- buf = buffer;
- debuglogs (4, "monitor_make_srec (buffer=0x%x, type=%d, memaddr=0x%x, len=%d",
- buffer, type, memaddr, len);
- checksum = 0;
-
- /* Create the header for the srec. 4 is the number of bytes in the address,
- and 1 is the number of bytes in the count. */
-
- if (type == 0) /* FIXME: type 0 is optional */
- type = 3; /* so use data as it works */
- sprintf (buf, "S%d%02X%08X", type, len + 4 + 1, memaddr);
- buf += 12;
-
- checksum += (len + 4 + 1 /* calculate the checksum */
- + (memaddr & 0xff)
- + ((memaddr >> 8) & 0xff)
- + ((memaddr >> 16) & 0xff)
- + ((memaddr >> 24) & 0xff));
-
- /* build the srecord */
- for (i = 0; i < len; i++)
+ CORE_ADDR dumpaddr;
+
+ if (len <= 0)
{
- sprintf (buf, "%02X", myaddr[i]);
- checksum += myaddr[i];
- buf += 2;
+ monitor_debug ("Zero length call to monitor_read_memory\n");
+ return 0;
}
- sprintf(buf, "%02X", ~checksum & 0xff); /* add the checksum */
- debuglogs (3, "srec is \"%s\"", buffer);
-
- return 0;
-}
+ monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
+ paddr_nz (memaddr), (long) myaddr, len);
-/* Take 128 bytes of data and make a packet out of it.
- *
- * Each packet looks like this:
- * +-----+-------+-------+------+-----+
- * | SOH | Seq1. | Seq2. | data | SUM |
- * +-----+-------+-------+------+-----+
- * SOH = 0x01
- * Seq1 = The sequence number.
- * Seq2 = The complement of the sequence number.
- * Data = A 128 bytes of data.
- * SUM = Add the contents of the 128 bytes and use the low-order
- * 8 bits of the result.
- */
+ if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
+ memaddr = ADDR_BITS_REMOVE (memaddr);
-static void
-make_xmodem_packet (packet, data, len)
- unsigned char *packet;
- unsigned char *data;
- int len;
-{
- static int sequence = 1;
- int i, sum;
- unsigned char *buf;
-
- buf = data;
- /* build the packet header */
- packet[0] = SOH;
- packet[1] = sequence;
- packet[2] = 255 - sequence;
- sequence++;
+ if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
+ return monitor_read_memory_single (memaddr, myaddr, len);
+
+ len = min (len, 16);
+
+ /* Some dumpers align the first data with the preceeding 16
+ byte boundary. Some print blanks and start at the
+ requested boundary. EXACT_DUMPADDR
+ */
+
+ dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
+ ? memaddr : memaddr & ~0x0f;
+
+ /* 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;
+
+ /* send the memory examine command */
+
+ if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
+ monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len);
+ else if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
+ monitor_printf (current_monitor->getmem.cmdb, dumpaddr);
+ 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)
+ monitor_error ("monitor_read_memory",
+ "excessive response from monitor",
+ memaddr, resp_len, buf, 0);
+
+ 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;
+ monitor_debug ("MON getmem.resp_delim %s\n", current_monitor->getmem.resp_delim);
+
+ memset (&resp_strings, 0, sizeof (struct re_registers));
+ tmp = strlen (p);
+ retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
+ &resp_strings);
+
+ if (retval < 0)
+ monitor_error ("monitor_read_memory",
+ "bad response from monitor",
+ memaddr, resp_len, buf, 0);
+
+ p += resp_strings.end[0];
#if 0
- packet[2] = ~sequence++; /* the complement is the sequence checksum */
+ p = strstr (p, current_monitor->getmem.resp_delim);
+ if (!p)
+ monitor_error ("monitor_read_memory",
+ "bad response from monitor",
+ memaddr, resp_len, buf, 0);
+ p += strlen (current_monitor->getmem.resp_delim);
#endif
-
- sum = 0; /* calculate the data checksum */
- for (i = 3; i <= len + 2; i++) {
- packet[i] = *buf;
- sum += *buf;
- buf++;
- }
+ }
+ monitor_debug ("MON scanning %d ,%lx '%s'\n", len, (long) p, p);
+ if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
+ {
+ char c;
+ int fetched = 0;
+ i = len;
+ c = *p;
- /* add padding for the rest of the packet */
- for (i = len+1 ; i <= XMODEM_DATASIZE ; i++)
- packet[i] = '0';
- packet[XMODEM_PACKETSIZE] = sum & 0xff; /* add the checksum */
+ while (!(c == '\000' || c == '\n' || c == '\r') && i > 0)
+ {
+ if (isxdigit (c))
+ {
+ if ((dumpaddr >= memaddr) && (i > 0))
+ {
+ val = fromhex (c) * 16 + fromhex (*(p + 1));
+ *myaddr++ = val;
+ if (monitor_debug_p || remote_debug)
+ fprintf_unfiltered (gdb_stdlog, "[%02x]", val);
+ --i;
+ fetched++;
+ }
+ ++dumpaddr;
+ ++p;
+ }
+ ++p; /* skip a blank or other non hex char */
+ c = *p;
+ }
+ if (fetched == 0)
+ error ("Failed to read via monitor");
+ if (monitor_debug_p || remote_debug)
+ fprintf_unfiltered (gdb_stdlog, "\n");
+ return fetched; /* Return the number of bytes actually read */
+ }
+ monitor_debug ("MON scanning bytes\n");
- if (sr_get_debug () > 4)
+ for (i = len; i > 0; i--)
{
- debuglogs (4, "The xmodem checksum is %d (0x%x)\n",
- sum & 0xff, sum & 0xff);
- print_xmodem_packet (packet);
+ /* 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')
+ monitor_error ("monitor_read_memory",
+ "badly terminated response from monitor",
+ memaddr, resp_len, buf, 0);
+ p++;
+ }
+
+ val = strtoul (p, &p1, 16);
+
+ if (val == 0 && p == p1)
+ monitor_error ("monitor_read_memory",
+ "bad value from monitor",
+ memaddr, resp_len, buf, 0);
+
+ *myaddr++ = val;
+
+ if (i == 1)
+ break;
+
+ p = p1;
}
+
+ return len;
}
-/* Print the packet as a debug check. */
+/* Transfer LEN bytes between target address MEMADDR and GDB address
+ MYADDR. Returns 0 for success, errno code for failure. TARGET is
+ unused. */
-static void
-print_xmodem_packet (packet)
- char *packet;
+static int
+monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+ struct target_ops *target)
{
- int i;
- static int lastseq;
- int sum;
+ int res;
- /* take apart the packet header the packet header */
- if (packet[0] == SOH)
- printf ("SOH");
- else
- error ("xmodem: SOH is wrong");
-
- /* check the sequence */
- if (packet[1] != 0)
- {
- lastseq = packet[1];
- if (packet[2] != ~lastseq)
- error ("xmodem: Sequence checksum is wrong");
+ if (write)
+ {
+ if (current_monitor->flags & MO_HAS_BLOCKWRITES)
+ res = monitor_write_memory_block(memaddr, myaddr, len);
else
- printf_filtered (" %d %d", lastseq, ~lastseq);
+ res = monitor_write_memory(memaddr, myaddr, len);
+ }
+ else
+ {
+ res = monitor_read_memory(memaddr, myaddr, len);
}
-
- /* check the data checksum */
- sum = 0;
- for (i = 3; i <= XMODEM_DATASIZE; i++)
- sum += packet[i];
- /* ignore the data */
-#if 0
- printf (" [128 bytes of data] %d\n", sum & 0xff);
-#endif
- printf_filtered (" [%s] %d\n", packet, sum & 0xff);
+ return res;
+}
+
+static void
+monitor_kill (void)
+{
+ 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. */
- if ((packet[XMODEM_PACKETSIZE] & 0xff) != (sum & 0xff))
- debuglogs (4, "xmodem: data checksum wrong, got a %d",
- packet[XMODEM_PACKETSIZE] & 0xff);
+static void
+monitor_create_inferior (char *exec_file, char *args, char **env)
+{
+ if (args && (*args != '\000'))
+ error ("Args are not supported by the monitor.");
- putchar ('\n');
+ first_time = 1;
+ clear_proceed_status ();
+ proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0);
}
-/* Make a GDB packet. The data is always ASCII.
- * A debug packet whose contents are <data>
- * is encapsulated for transmission in the form:
- *
- * $ <data> # CSUM1 CSUM2
- *
- * <data> must be ASCII alphanumeric and cannot include characters
- * '$' or '#'. If <data> starts with two characters followed by
- * ':', then the existing stubs interpret this as a sequence number.
- *
- * CSUM1 and CSUM2 are ascii hex representation of an 8-bit
- * checksum of <data>, the most significant nibble is sent first.
- * the hex digits 0-9,a-f are used. */
+/* 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. */
static void
-make_gdb_packet (buf, data)
- char *buf, *data;
+monitor_mourn_inferior (void)
+{
+ unpush_target (targ_ops);
+ generic_mourn_inferior (); /* Do all the proper things now */
+}
+
+/* Tell the monitor to add a breakpoint. */
+
+static int
+monitor_insert_breakpoint (CORE_ADDR addr, char *shadow)
{
int i;
- unsigned char csum = 0;
- int cnt;
- char *p;
+ unsigned char *bp;
+ int bplen;
- debuglogs (3, "make_gdb_packet(%s)\n", data);
- cnt = strlen (data);
- if (cnt > PBUFSIZ)
- error ("make_gdb_packet(): to much data\n");
+ monitor_debug ("MON inst bkpt %s\n", paddr (addr));
+ if (current_monitor->set_break == NULL)
+ error ("No set_break defined for this monitor");
- /* start with the packet header */
- p = buf;
- *p++ = '$';
+ if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
+ addr = ADDR_BITS_REMOVE (addr);
- /* calculate the checksum */
- for (i = 0; i < cnt; i++)
+ /* Determine appropriate breakpoint size for this address. */
+ bp = memory_breakpoint_from_pc (&addr, &bplen);
+
+ for (i = 0; i < current_monitor->num_breakpoints; i++)
{
- csum += data[i];
- *p++ = data[i];
+ if (breakaddr[i] == 0)
+ {
+ breakaddr[i] = addr;
+ monitor_read_memory (addr, shadow, bplen);
+ monitor_printf (current_monitor->set_break, addr);
+ monitor_expect_prompt (NULL, 0);
+ return 0;
+ }
}
- /* terminate the data with a '#' */
- *p++ = '#';
-
- /* add the checksum as two ascii digits */
- *p++ = tohex ((csum >> 4) & 0xf);
- *p++ = tohex (csum & 0xf);
- *p = 0x0; /* Null terminator on string */
+ error ("Too many breakpoints (> %d) for monitor.", current_monitor->num_breakpoints);
}
-/* Send a GDB packet to the target with error handling. We get a '+'
- (ACK) back if the packet is received and the checksum
- matches. Otherwise a '-' (NAK) is returned. It returns a 1 for a
- successful transmition, or a 0 for a failure. */
+/* Tell the monitor to remove a breakpoint. */
-int
-monitor_send_packet (packet)
- char *packet;
+static int
+monitor_remove_breakpoint (CORE_ADDR addr, char *shadow)
{
- int c, retries, i;
- char junk[PBUFSIZ];
+ int i;
- retries = 0;
+ monitor_debug ("MON rmbkpt %s\n", paddr (addr));
+ if (current_monitor->clr_break == NULL)
+ error ("No clr_break defined for this monitor");
-#if 0
- /* scan the packet to make sure it only contains valid characters.
- this may sound silly, but sometimes a garbled packet will hang
- the target board. We scan the whole thing, then print the error
- message.
- */
- for (i = 0; i < strlen(packet); i++) {
- debuglogs (5, "monitor_send_packet(): Scanning \'%c\'\n", packet[i]);
- /* legit hex numbers or command */
- if ((isxdigit(packet[i])) || (isalpha(packet[i])))
- continue;
- switch (packet[i]) {
- case '+': /* ACK */
- case '-': /* NAK */
- case '#': /* end of packet */
- case '$': /* start of packet */
- continue;
- default: /* bogus character */
- retries++;
- debuglogs (4, "monitor_send_packet(): Found a non-ascii digit \'%c\' in the packet.\n", packet[i]);
- }
- }
-#endif
-
- if (retries > 0)
- error ("Can't send packet, found %d non-ascii characters", retries);
-
- /* ok, try to send the packet */
- retries = 0;
- while (retries <= 10)
- {
- printf_monitor ("%s", packet);
-
- /* read until either a timeout occurs (-2) or '+' is read */
- while (retries <= 10)
+ if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
+ addr = ADDR_BITS_REMOVE (addr);
+
+ for (i = 0; i < current_monitor->num_breakpoints; i++)
+ {
+ if (breakaddr[i] == addr)
{
- c = readchar (timeout);
- debuglogs (3, "Reading a GDB protocol packet... Got a '%c'\n", c);
- switch (c)
- {
- case '+':
- debuglogs (3, "Got Ack\n");
- return 1;
- case SERIAL_TIMEOUT:
- debuglogs (3, "Timed out reading serial port\n");
- break; /* Retransmit buffer */
- case '-':
- debuglogs (3, "Got NAK\n");
- break; /* FIXME: (maybe) was a continue */
- case '$':
- /* It's probably an old response, or the echo of our
- command. just gobble up the packet and ignore it. */
- debuglogs (3, "Got a junk packet\n");
- do
- {
- c = readchar (timeout);
- junk[i++] = c;
- } while (c != '#');
- c = readchar (timeout);
- junk[i++] = c;
- c = readchar (timeout);
- junk[i++] = c;
- junk[i++] = '\0';
- debuglogs (3, "Reading a junk packet, got a \"%s\"\n", junk);
- continue; /* Now, go look for next packet */
- default:
- continue;
- }
- retries++;
- debuglogs (3, "Retransmitting packet \"%s\"\n", packet);
- break; /* Here to retransmit */
+ 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 if (current_monitor->flags & MO_CLR_BREAK_1_BASED)
+ monitor_printf (current_monitor->clr_break, i + 1);
+ else
+ monitor_printf (current_monitor->clr_break, i);
+ monitor_expect_prompt (NULL, 0);
+ return 0;
}
- } /* outer while */
- return 0;
+ }
+ fprintf_unfiltered (gdb_stderr,
+ "Can't find breakpoint associated with 0x%s\n",
+ paddr_nz (addr));
+ return 1;
}
-/* Get a GDB packet from the target. Basically we read till we see a
- '#', then check the checksum. It returns a 1 if it's gotten a
- packet, or a 0 it the packet wasn't transmitted correctly. */
+/* 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. */
-int
-monitor_get_packet (packet)
- char *packet;
+static int
+monitor_wait_srec_ack (void)
{
- int c;
- int retries;
- unsigned char csum;
- unsigned char pktcsum;
- char *bp;
-
- csum = 0;
- bp = packet;
+ int ch;
- memset (packet, 1, PBUFSIZ);
- retries = 0;
- while (retries <= 10)
+ if (current_monitor->flags & MO_SREC_ACK_PLUS)
{
- do
- {
- c = readchar (timeout);
- if (c == SERIAL_TIMEOUT)
- {
- debuglogs (3, "monitor_get_packet: got time out from serial port.\n");
- }
- debuglogs (3, "Waiting for a '$', got a %c\n", c);
- } while (c != '$');
-
- retries = 0;
- while (retries <= 10)
- {
- c = readchar (timeout);
- debuglogs (3, "monitor_get_packet: got a '%c'\n", c);
- switch (c)
- {
- case SERIAL_TIMEOUT:
- debuglogs (3, "Timeout in mid-packet, retrying\n");
- return 0;
- case '$':
- debuglogs (3, "Saw new packet start in middle of old one\n");
- return 0; /* Start a new packet, count retries */
- case '#':
- *bp = '\0';
- pktcsum = from_hex (readchar (timeout)) << 4;
- pktcsum |= from_hex (readchar (timeout));
- if (csum == pktcsum)
- {
- debuglogs (3, "\nGDB packet checksum correct, packet data is \"%s\",\n", packet);
- printf_monitor ("+");
- expect_prompt (1);
- return 1;
- }
- debuglogs (3, "Bad checksum, sentsum=0x%x, csum=0x%x\n", pktcsum, csum);
- return 0;
- case '*': /* Run length encoding */
- debuglogs (5, "Run length encoding in packet\n");
- csum += c;
- c = readchar (timeout);
- csum += c;
- c = c - ' ' + 3; /* Compute repeat count */
-
- if (c > 0 && c < 255 && bp + c - 1 < packet + PBUFSIZ - 1)
- {
- memset (bp, *(bp - 1), c);
- bp += c;
- continue;
- }
- *bp = '\0';
- printf_filtered ("Repeat count %d too large for buffer.\n", c);
- return 0;
-
- default:
- if ((!isxdigit (c)) && (!ispunct (c)))
- debuglogs (4, "Got a non-ascii digit \'%c\'.\\n", c);
- if (bp < packet + PBUFSIZ - 1)
- {
- *bp++ = c;
- csum += c;
- continue;
- }
-
- *bp = '\0';
- puts_filtered ("Remote packet too long.\n");
- return 0;
- }
- }
+ return (readchar (timeout) == '+');
}
+ else if (current_monitor->flags & MO_SREC_ACK_ROTATE)
+ {
+ /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
+ if ((ch = readchar (1)) < 0)
+ return 0;
+ if ((ch = readchar (1)) < 0)
+ return 0;
+ if ((ch = readchar (1)) < 0)
+ return 0;
+ if ((ch = readchar (1)) < 0)
+ return 0;
+ }
+ return 1;
}
-/* Convert an ascii number represented by 8 digits to a hex value. */
+/* monitor_load -- download a file. */
-static unsigned long
-ascii2hexword (mem)
- unsigned char *mem;
+static void
+monitor_load (char *file, int from_tty)
{
- unsigned long val;
- int i;
- char buf[9];
+ monitor_debug ("MON load\n");
- val = 0;
- for (i = 0; i < 8; i++)
- {
- val <<= 4;
- if (mem[i] >= 'A' && mem[i] <= 'F')
- val = val + mem[i] - 'A' + 10;
- if (mem[i] >= 'a' && mem[i] <= 'f')
- val = val + mem[i] - 'a' + 10;
- if (mem[i] >= '0' && mem[i] <= '9')
- val = val + mem[i] - '0';
- buf[i] = mem[i];
- }
- buf[8] = '\0';
- debuglogs (4, "ascii2hexword() got a 0x%x from %s(%x).\n", val, buf, mem);
- return val;
+ if (current_monitor->load_routine)
+ current_monitor->load_routine (monitor_desc, file, hashmark);
+ else
+ { /* The default is ascii S-records */
+ int n;
+ unsigned long load_offset;
+ char buf[128];
+
+ /* enable user to specify address for downloading as 2nd arg to load */
+ n = sscanf (file, "%s 0x%lx", buf, &load_offset);
+ if (n > 1)
+ file = buf;
+ else
+ load_offset = 0;
+
+ monitor_printf (current_monitor->load);
+ if (current_monitor->loadresp)
+ monitor_expect (current_monitor->loadresp, NULL, 0);
+
+ load_srec (monitor_desc, file, (bfd_vma) load_offset,
+ 32, SREC_ALL, hashmark,
+ current_monitor->flags & MO_SREC_ACK ?
+ monitor_wait_srec_ack : NULL);
+
+ monitor_expect_prompt (NULL, 0);
+ }
+
+/* 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 ();
+}
+
+static void
+monitor_stop (void)
+{
+ monitor_debug ("MON stop\n");
+ 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);
}
-/* Convert a hex value to an ascii number represented by 8 digits. */
+/* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
+ in OUTPUT until the prompt is seen. FIXME: We read the characters
+ ourseleves here cause of a nasty echo. */
-static char *
-hexword2ascii (mem, num)
- unsigned char *mem;
- unsigned long num;
+static void
+monitor_rcmd (char *command,
+ struct ui_file *outbuf)
{
- int i;
-
- debuglogs (4, "hexword2ascii() converting %x ", num);
- for (i = 7; i >= 0; i--)
- {
- mem[i] = tohex ((num >> 4) & 0xf);
- mem[i] = tohex (num & 0xf);
- num = num >> 4;
- }
- mem[8] = '\0';
- debuglogs (4, "\tto a %s", mem);
+ char *p;
+ int resp_len;
+ char buf[1000];
+
+ if (monitor_desc == NULL)
+ error ("monitor target not open.");
+
+ 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. */
+
+ monitor_printf ("%s\r", (command ? command : ""));
+
+ resp_len = monitor_expect_prompt (buf, sizeof buf);
+
+ fputs_unfiltered (buf, outbuf); /* Output the response */
}
/* Convert hex digit A to a number. */
+#if 0
static int
-from_hex (a)
- int a;
-{
- if (a == 0)
- return 0;
-
- debuglogs (4, "from_hex got a 0x%x(%c)\n",a,a);
+from_hex (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);
}
+#endif
+
+char *
+monitor_get_dev_name (void)
+{
+ return dev_name;
+}
-/* Convert number NIB to a hex digit. */
+static struct target_ops monitor_ops;
-static int
-tohex (nib)
- int nib;
+static void
+init_base_monitor_ops (void)
{
- if (nib < 10)
- return '0' + nib;
- else
- return 'a' + nib - 10;
+ monitor_ops.to_shortname = NULL;
+ monitor_ops.to_longname = NULL;
+ monitor_ops.to_doc = NULL;
+ monitor_ops.to_open = NULL;
+ monitor_ops.to_close = monitor_close;
+ monitor_ops.to_attach = NULL;
+ monitor_ops.to_post_attach = NULL;
+ monitor_ops.to_require_attach = NULL;
+ monitor_ops.to_detach = monitor_detach;
+ monitor_ops.to_require_detach = NULL;
+ monitor_ops.to_resume = monitor_resume;
+ monitor_ops.to_wait = monitor_wait;
+ monitor_ops.to_post_wait = NULL;
+ monitor_ops.to_fetch_registers = monitor_fetch_registers;
+ monitor_ops.to_store_registers = monitor_store_registers;
+ monitor_ops.to_prepare_to_store = monitor_prepare_to_store;
+ monitor_ops.to_xfer_memory = monitor_xfer_memory;
+ monitor_ops.to_files_info = monitor_files_info;
+ monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
+ monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
+ monitor_ops.to_terminal_init = 0;
+ monitor_ops.to_terminal_inferior = 0;
+ monitor_ops.to_terminal_ours_for_output = 0;
+ monitor_ops.to_terminal_ours = 0;
+ monitor_ops.to_terminal_info = 0;
+ monitor_ops.to_kill = monitor_kill;
+ monitor_ops.to_load = monitor_load;
+ monitor_ops.to_lookup_symbol = 0;
+ monitor_ops.to_create_inferior = monitor_create_inferior;
+ monitor_ops.to_post_startup_inferior = NULL;
+ monitor_ops.to_acknowledge_created_inferior = NULL;
+ monitor_ops.to_clone_and_follow_inferior = NULL;
+ monitor_ops.to_post_follow_inferior_by_clone = NULL;
+ monitor_ops.to_insert_fork_catchpoint = NULL;
+ monitor_ops.to_remove_fork_catchpoint = NULL;
+ monitor_ops.to_insert_vfork_catchpoint = NULL;
+ monitor_ops.to_remove_vfork_catchpoint = NULL;
+ monitor_ops.to_has_forked = NULL;
+ monitor_ops.to_has_vforked = NULL;
+ monitor_ops.to_can_follow_vfork_prior_to_exec = NULL;
+ monitor_ops.to_post_follow_vfork = NULL;
+ monitor_ops.to_insert_exec_catchpoint = NULL;
+ monitor_ops.to_remove_exec_catchpoint = NULL;
+ monitor_ops.to_has_execd = NULL;
+ monitor_ops.to_reported_exec_events_per_exec_call = NULL;
+ monitor_ops.to_has_exited = NULL;
+ monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
+ monitor_ops.to_can_run = 0;
+ monitor_ops.to_notice_signals = 0;
+ monitor_ops.to_thread_alive = 0;
+ monitor_ops.to_stop = monitor_stop;
+ monitor_ops.to_rcmd = monitor_rcmd;
+ monitor_ops.to_pid_to_exec_file = NULL;
+ monitor_ops.to_core_file_to_sym_file = NULL;
+ monitor_ops.to_stratum = process_stratum;
+ monitor_ops.DONT_USE = 0;
+ monitor_ops.to_has_all_memory = 1;
+ monitor_ops.to_has_memory = 1;
+ monitor_ops.to_has_stack = 1;
+ monitor_ops.to_has_registers = 1;
+ monitor_ops.to_has_execution = 1;
+ monitor_ops.to_sections = 0;
+ monitor_ops.to_sections_end = 0;
+ monitor_ops.to_magic = OPS_MAGIC;
+} /* init_base_monitor_ops */
+
+/* Init the target_ops structure pointed at by OPS */
+
+void
+init_monitor_ops (struct target_ops *ops)
+{
+ if (monitor_ops.to_magic != OPS_MAGIC)
+ init_base_monitor_ops ();
+
+ memcpy (ops, &monitor_ops, sizeof monitor_ops);
}
/* Define additional commands that are usually only used by monitors. */
void
-_initialize_remote_monitors ()
+_initialize_remote_monitors (void)
{
- struct cmd_list_element *c;
-
- /* this sets the type of download protocol */
- c = add_set_cmd ("remoteloadprotocol", no_class, var_string, (char *)&loadproto_str,
- "Set the type of the remote load protocol.\n", &setlist);
- c->function.sfunc = set_loadproto_command;
- add_show_from_set (c, &showlist);
- loadproto_str = savestring ("none", 5);
-
- /* this sets the conversion type when loading */
- c = add_set_cmd ("remoteloadtype", 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 ("srec", 5);
-
+ init_base_monitor_ops ();
add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
- (char *)&hashmark,
+ (char *) &hashmark,
"Set display of activity while downloading a file.\n\
-When enabled, a period \'.\' is displayed.",
- &setlist),
+When enabled, a hashmark \'#\' is displayed.",
+ &setlist),
&showlist);
- add_com ("monitor", class_obscure, monitor_command,
- "Send a command to the debug monitor.");
+ add_show_from_set
+ (add_set_cmd ("monitor", no_class, var_zinteger,
+ (char *) &monitor_debug_p,
+ "Set debugging of remote monitor communication.\n\
+When enabled, communication between GDB and the remote monitor\n\
+is displayed.", &setdebuglist),
+ &showdebuglist);
}
projects / deliverable / binutils-gdb.git / blobdiff