X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fmonitor.c;h=7e3580e1b11e819a9bd50f7120b6337200085946;hb=e1e9e218c189882084a89fdee655a0a523efbaf8;hp=031c0e3073d19f7e778f8170fa48225c45109360;hpb=3f9ef4ffe974cc974e462e057ce7412dbdf7ea59;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/monitor.c b/gdb/monitor.c index 031c0e3073..7e3580e1b1 100644 --- a/gdb/monitor.c +++ b/gdb/monitor.c @@ -1,359 +1,650 @@ /* Remote debugging interface for boot monitors, for GDB. - Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc. - Contributed by Cygnus Support. Written by Rob Savoye for Cygnus. + Copyright 1990-1993, 1995-1997, 1999-2000, 2001 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. -*/ + 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 #include -#include +#include +#include "gdb_string.h" #include #include "command.h" #include "serial.h" #include "monitor.h" -#include "remote-utils.h" - -#ifdef HAVE_TERMIO -# define TERMINAL struct termios -#else -# define TERMINAL struct sgttyb +#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 mem_attrib *attrib, + 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); -extern void make_xmodem_packet(); -extern void print_xmodem_packet(); +static struct monitor_ops *current_monitor; -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" */ -static int hashmark; /* flag set by "set hash" */ +static int timeout = 30; -#define LOG_FILE "monitor.log" -#if defined (LOG_FILE) -FILE *log_file; -#endif +static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait() */ -static int timeout = 24; +static void (*ofunc) (); /* Old SIGINT signal handler */ + +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. */ -/* - * Descriptor for I/O to remote machine. Initialize it to NULL so that - * monitor_open knows that we don't have a file open when the program starts. - */ static serial_t monitor_desc = NULL; -/* sets the download protocol, choices are srec, generic, boot */ -char *loadtype; -static char *loadtype_str; -static char *loadproto_str; -static void set_loadtype_command(); -static void set_loadproto_command(); -static void monitor_load_srec(); -static int monitor_write_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. - */ +/* 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[200]; - int i; + 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. */ + +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); +} - pattern = va_arg(args, char *); +/* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses - vsprintf(buf, pattern, args); + 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. - debuglogs (1, "printf_monitor(), Sending: \"%s\".", buf); + 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. - if (SERIAL_WRITE(monitor_desc, buf, strlen(buf))) - fprintf(stderr, "SERIAL_WRITE failed: %s\n", safe_strerror(errno)); -} -/* - * write_monitor -- 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) +{ + 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'; +} + + +/* monitor_printf_noecho -- Send data to monitor, but don't expect an echo. + Works just like printf. */ + +void +monitor_printf_noecho (char *pattern,...) { - 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); + va_list args; + char sndbuf[2000]; + int len; + + va_start (args, pattern); + + monitor_vsprintf (sndbuf, pattern, args); + len = strlen (sndbuf); + if (len + 1 > sizeof sndbuf) + internal_error (__FILE__, __LINE__, "failed internal consistency check"); + + if (monitor_debug_p) + { + 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); + } + + monitor_write (sndbuf, len); } -/* - * debuglogs -- 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. - */ -static void -debuglogs(va_alist) - va_dcl +/* monitor_printf -- Send data to monitor and check the echo. Works just like + printf. */ + +void +monitor_printf (char *pattern,...) { va_list args; - char *pattern, *p; - char buf[200]; - char newbuf[300]; - int level, i; - - va_start(args); - - level = va_arg(args, int); /* get the debug level */ - if ((level <0) || (level > 100)) { - error ("Bad argument passed to debuglogs(), needs debug level"); - return; - } - - 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++) { - 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]; - } - - if (buf[i] < 26) { /* modify control characters */ - *p++ = '^'; - *p++ = buf[i] + 'A'; - continue; - } - } - *p = '\0'; /* terminate the string */ - - if (sr_get_debug() > level) - puts (newbuf); - -#ifdef LOG_FILE /* write to the monitor log */ - if (log_file != 0x0) { - fputs (newbuf, log_file); - fputc ('\n', log_file); - fflush (log_file); - } -#endif + char sndbuf[2000]; + int len; + + va_start (args, pattern); + + monitor_vsprintf (sndbuf, pattern, args); + + len = strlen (sndbuf); + if (len + 1 > sizeof sndbuf) + internal_error (__FILE__, __LINE__, "failed internal consistency check"); + + if (monitor_debug_p) + { + char *safe_string = (char *) alloca ((len * 4) + 1); + monitor_printable_string (safe_string, sndbuf, 0); + fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string); + } + + 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); } -/* readchar -- 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) +{ + 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. */ + +int +monitor_readchar (void) { int c; + int looping; - c = SERIAL_READCHAR(monitor_desc, timeout); + do + { + looping = 0; + c = SERIAL_READCHAR (monitor_desc, timeout); - if (sr_get_debug() > 5) - putchar(c & 0x7f); + if (c >= 0) + c &= 0xff; /* don't lose bit 7 */ + } + while (looping); -#ifdef LOG_FILE - if (isascii (c)) - putc(c & 0x7f, log_file); -#endif + if (c >= 0) + return c; + + if (c == SERIAL_TIMEOUT) + error ("Timeout reading from remote system."); + + perror_with_name ("remote-monitor"); +} + + +/* Read a character from the remote system, doing all the fancy + timeout stuff. */ + +static int +readchar (int timeout) +{ + int c; + static enum + { + last_random, last_nl, last_cr, last_crnl + } + state = last_random; + int looping; + + do + { + looping = 0; + c = SERIAL_READCHAR (monitor_desc, timeout); + + if (c >= 0) + { + c &= 0x7f; + /* This seems to interfere with proper function of the + input stream */ + if (monitor_debug_p || remote_debug) + { + char buf[2]; + buf[0] = c; + buf[1] = '\0'; + puts_debug ("read -->", buf, "<--"); + } + + } + + /* Canonicialize \n\r combinations into one \r */ + if ((current_monitor->flags & MO_HANDLE_NL) != 0) + { + if ((c == '\r' && state == last_nl) + || (c == '\n' && state == last_cr)) + { + state = last_crnl; + looping = 1; + } + else if (c == '\r') + state = last_cr; + else if (c != '\n') + state = last_random; + else + { + state = last_nl; + c = '\r'; + } + } + } + while (looping); if (c >= 0) - return c & 0x7f; - - 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); + return c; + + 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 - } - perror_with_name("remote-monitor"); + error ("Timeout reading from remote system."); + + perror_with_name ("remote-monitor"); } -/* - * expect -- scan input from the remote system, until STRING is found. - * If DISCARD is non-zero, then discard non-matching input, else print - * it out. Let the user break out immediately. - */ -static void -expect (string, discard) - char *string; - int discard; +/* Scan input from the remote system, until STRING is found. If BUF is non- + zero, then collect input until we have collected either STRING or BUFLEN-1 + chars. In either case we terminate BUF with a 0. If input overflows BUF + because STRING can't be found, return -1, else return number of chars in BUF + (minus the terminating NUL). Note that in the non-overflow case, STRING + will be at the end of BUF. */ + +int +monitor_expect (char *string, char *buf, int buflen) { char *p = string; + int obuflen = buflen; int c; + extern struct target_ops *targ_ops; + 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); + } - debuglogs (1, "Expecting \"%s\".", string); + immediate_quit++; + while (1) + { + if (buf) + { + if (buflen < 2) + { + *buf = '\000'; + immediate_quit--; + return -1; + } - immediate_quit = 1; - while (1) { - c = readchar(timeout); - if (!isascii (c)) - continue; - if (c == *p++) { - if (*p == '\0') { - immediate_quit = 0; - debuglogs (4, "Matched"); - return; - } - } else { - if (!discard) { - fwrite(string, 1, (p - 1) - string, stdout); - putchar((char)c); - fflush(stdout); - } - p = string; + c = readchar (timeout); + if (c == '\000') + continue; + *buf++ = c; + buflen--; + } + else + c = readchar (timeout); + + /* Don't expect any ^C sent to be echoed */ + + if (*p == '\003' || c == *p) + { + p++; + if (*p == '\0') + { + immediate_quit--; + + if (buf) + { + *buf++ = '\000'; + return obuflen - buflen; + } + else + return 0; + } + } + 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 + { + /* 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; + } + } +} + +/* Search for a regexp. */ + +static int +monitor_expect_regexp (struct re_pattern_buffer *pat, char *buf, int buflen) +{ + char *mybuf; + char *p; + monitor_debug ("MON Expecting regexp\n"); + if (buf) + mybuf = buf; + else + { + mybuf = alloca (TARGET_BUF_SIZE); + buflen = TARGET_BUF_SIZE; + } + + p = mybuf; + while (1) + { + int retval; + + if (p - mybuf >= buflen) + { /* Buffer about to overflow */ + +/* On overflow, we copy the upper half of the buffer to the lower half. Not + great, but it usually works... */ + + memcpy (mybuf, mybuf + buflen / 2, buflen / 2); + p = mybuf + buflen / 2; + } + + *p++ = readchar (timeout); + + retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL); + if (retval >= 0) + return 1; } - } } /* Keep discarding input until we see the MONITOR prompt. @@ -362,451 +653,722 @@ expect (string, discard) 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 expect_prompt(). Exception: monitor_resume does not - wait for the prompt, because the terminal is being handed over - to the inferior. However, the next thing which happens after that - is a monitor_wait which does wait for the prompt. - Note that this includes abnormal exit, e.g. error(). This is - necessary to prevent getting into states from which we can't - recover. */ -static void -expect_prompt(discard) - int discard; -{ - expect (PROMPT, discard); -} + 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. */ -/* - * junk -- ignore junk characters. Returns a 1 if junk, 0 otherwise - */ -static int -junk(ch) - char ch; +int +monitor_expect_prompt (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; - } + monitor_debug ("MON Expecting prompt\n"); + return monitor_expect (current_monitor->prompt, buf, buflen); } -/* - * get_hex_digit -- Get a hex digit from the remote system & return its value. - * If ignore is nonzero, ignore spaces, newline & tabs. - */ -static int -get_hex_digit(ignore) - int ignore; +/* Get N 32-bit words from remote, each preceded by a space, and put + them in registers starting at REGNO. */ + +#if 0 +static unsigned long +get_hex_word (void) { - static int ch; - while (1) { - ch = readchar(timeout); - if (junk(ch)) - continue; - if (sr_get_debug() > 4) - debuglogs (4, "get_hex_digit() got a 0x%x(%c)", ch, ch); - - if (ch >= '0' && ch <= '9') - return ch - '0'; - else if (ch >= 'A' && ch <= 'F') - return ch - 'A' + 10; - else if (ch >= 'a' && ch <= 'f') - return ch - 'a' + 10; - else if (ch == ' ' && ignore) - ; - else { - expect_prompt(1); - error("Invalid hex digit from remote system. (0x%x)", ch); - } - } + unsigned long val; + int i; + int ch; + + do + ch = readchar (timeout); + while (isspace (ch)); + + val = from_hex (ch); + + for (i = 7; i >= 1; i--) + { + ch = readchar (timeout); + if (!isxdigit (ch)) + break; + val = (val << 4) | from_hex (ch); + } + + return val; } +#endif -/* get_hex_byte -- Get a byte from monitor and put it in *BYT. - * Accept any number leading spaces. - */ static void -get_hex_byte (byt) - char *byt; +compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern, + char *fastmap) { - int val; - - val = get_hex_digit (1) << 4; - debuglogs (4, "get_hex_digit() -- Read first nibble 0x%x", val); - - val |= get_hex_digit (0); - debuglogs (4, "get_hex_digit() -- Read second nibble 0x%x", val); - *byt = val; - - debuglogs (4, "get_hex_digit() -- Read a 0x%x", val); -} + int tmp; + const char *val; -/* - * get_hex_word -- Get N 32-bit words from remote, each preceded by a space, - * and put them in registers starting at REGNO. - */ -static int -get_hex_word () -{ - long val; - int i; + compiled_pattern->fastmap = fastmap; - val = 0; - for (i = 0; i < 8; i++) - val = (val << 4) + get_hex_digit (i == 0); - - debuglogs (4, "get_hex_word() got a 0x%x.", val); + tmp = re_set_syntax (RE_SYNTAX_EMACS); + val = re_compile_pattern (pattern, + strlen (pattern), + compiled_pattern); + re_set_syntax (tmp); - return val; + if (val) + error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern, val); + + if (fastmap) + re_compile_fastmap (compiled_pattern); } -/* This is called not only when we first attach, but also when the - user types "run" after having attached. */ +/* Open a connection to a remote debugger. NAME is the filename used + for communication. */ + void -monitor_create_inferior (execfile, args, env) - char *execfile; - char *args; - char **env; +monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty) { - int entry_pt; + char *name; + char **p; + + if (mon_ops->magic != MONITOR_OPS_MAGIC) + error ("Magic number of monitor_ops struct wrong."); - if (args && *args) - error("Can't pass arguments to remote MONITOR process"); + targ_ops = mon_ops->target; + name = targ_ops->to_shortname; + + 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 (execfile == 0 || exec_bfd == 0) - error("No exec file specified"); + target_preopen (from_tty); - entry_pt = (int) bfd_get_start_address (exec_bfd); + /* Setup pattern for register dump */ - debuglogs (1, "create_inferior(exexfile=%s, args=%s, env=%s)", execfile, args, env); + if (mon_ops->register_pattern) + compile_pattern (mon_ops->register_pattern, ®ister_pattern, + register_fastmap); -/* The "process" (board) is already stopped awaiting our commands, and - the program is already downloaded. We just set its PC and go. */ + if (mon_ops->getmem.resp_delim) + compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern, + getmem_resp_delim_fastmap); - clear_proceed_status (); + unpush_target (targ_ops); - /* Tell wait_for_inferior that we've started a new process. */ - init_wait_for_inferior (); + if (dev_name) + xfree (dev_name); + dev_name = xstrdup (args); - /* Set up the "saved terminal modes" of the inferior - based on what modes we are starting it with. */ - target_terminal_init (); + monitor_desc = SERIAL_OPEN (dev_name); - /* Install inferior's terminal modes. */ - target_terminal_inferior (); + if (!monitor_desc) + perror_with_name (dev_name); - /* insert_step_breakpoint (); FIXME, do we need this? */ + if (baud_rate != -1) + { + if (SERIAL_SETBAUDRATE (monitor_desc, baud_rate)) + { + SERIAL_CLOSE (monitor_desc); + perror_with_name (dev_name); + } + } - /* Let 'er rip... */ - proceed ((CORE_ADDR)entry_pt, TARGET_SIGNAL_DEFAULT, 0); -} + SERIAL_RAW (monitor_desc); -/* - * monitor_open -- open a connection to a remote debugger. - * NAME is the filename used for communication. - */ -static int baudrate = 9600; -static char dev_name[100]; + SERIAL_FLUSH_INPUT (monitor_desc); -void -monitor_open(args, name, from_tty) - char *args; - char *name; - int from_tty; -{ + /* some systems only work with 2 stop bits */ - if (args == NULL) - 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); + SERIAL_SETSTOPBITS (monitor_desc, mon_ops->stopbits); -/* if (is_open) */ - monitor_close(0); + current_monitor = mon_ops; - strcpy(dev_name, args); - monitor_desc = SERIAL_OPEN(dev_name); + /* See if we can wake up the monitor. First, try sending a stop sequence, + then send the init strings. Last, remove all breakpoints. */ - if (monitor_desc == NULL) - perror_with_name(dev_name); - - if (baud_rate != -1) { - if (SERIAL_SETBAUDRATE (monitor_desc, baud_rate)) { - SERIAL_CLOSE (monitor_desc); - perror_with_name (name); - } - } - - SERIAL_RAW(monitor_desc); - -#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 + 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); + } + } /* wake up the monitor and see if it's alive */ - printf_monitor(INIT_CMD); - expect_prompt(1); /* See if we get a prompt */ + for (p = mon_ops->init; *p != NULL; p++) + { + /* Some of the characters we send may not be echoed, + but we hope to get a prompt at the end of it all. */ - /* try again to be sure */ - printf_monitor(INIT_CMD); - expect_prompt(1); /* See if we get a prompt */ + 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) + { + 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 */ + + 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); -/* - * monitor_close -- Close out all files and local state before this - * target loses control. - */ + push_target (targ_ops); -void -monitor_close (quitting) - int quitting; -{ - SERIAL_CLOSE(monitor_desc); - monitor_desc = NULL; + inferior_pid = 42000; /* Make run command think we are busy... */ - debuglogs (1, "monitor_close (quitting=%d)", quitting); + /* Give monitor_wait something to read */ -#if defined (LOG_FILE) - if (log_file) { - if (ferror(log_file)) - fprintf(stderr, "Error writing log file.\n"); - if (fclose(log_file) != 0) - fprintf(stderr, "Error closing log file.\n"); - } -#endif + monitor_printf (current_monitor->line_term); + + start_remote (); } -/* - * monitor_detach -- terminate the open connection to the remote - * debugger. Use this when you want to detach and do something - * else with your gdb. - */ +/* Close out all files and local state before this target loses + control. */ + void -monitor_detach (from_tty) - int from_tty; +monitor_close (int quitting) { + if (monitor_desc) + SERIAL_CLOSE (monitor_desc); + + /* Free breakpoint memory */ + if (breakaddr != NULL) + { + xfree (breakaddr); + breakaddr = NULL; + } - 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); + monitor_desc = NULL; } -/* - * monitor_attach -- attach GDB to the target. - */ -void -monitor_attach (args, from_tty) - char *args; - int from_tty; +/* Terminate the open connection to the remote debugger. Use this + when you want to detach and do something else with your gdb. */ + +static void +monitor_detach (char *args, int from_tty) { + pop_target (); /* calls monitor_close to do the real work */ if (from_tty) - printf ("Starting remote %s debugging\n", target_shortname); - - debuglogs (1, "monitor_attach (args=%s)", args); - - printf_monitor (GO_CMD); - /* swallow the echo. */ - expect (GO_CMD, 1); + printf_unfiltered ("Ending remote %s debugging\n", target_shortname); } - -/* - * monitor_resume -- Tell the remote machine to resume. - */ -void -monitor_resume (pid, step, sig) - int pid, step; - enum target_signal sig; -{ - debuglogs (1, "monitor_resume (step=%d, sig=%d)", step, sig); - if (step) { - printf_monitor (STEP_CMD); - } else { - printf_monitor (CONT_CMD); - } -} +/* Convert VALSTR into the target byte-ordered value of REGNO and store it. */ -/* - * monitor_wait -- Wait until the remote machine stops, then return, - * storing status in status just as `wait' would. - */ -int -monitor_wait (pid, status) - int pid; - struct target_waitstatus *status; +char * +monitor_supply_register (int regno, char *valstr) { - int old_timeout = timeout; + ULONGEST val; + unsigned char regbuf[MAX_REGISTER_RAW_SIZE]; + char *p; - debuglogs(1, "monitor_wait (), printing extraneous text."); - - status->kind = TARGET_WAITKIND_EXITED; - status->value.integer = 0; + 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); - timeout = 0; /* Don't time out -- user program is running. */ + if (*p != '\0') + error ("monitor_supply_register (%d): bad value from monitor: %s.", + regno, valstr); - expect_prompt(0); /* Wait for prompt, outputting extraneous text */ - debuglogs (4, "monitor_wait(), got the prompt."); + /* supply register stores in target byte order, so swap here */ - status->kind = TARGET_WAITKIND_STOPPED; - status->value.sig = TARGET_SIGNAL_TRAP; + store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val); - timeout = old_timeout; + supply_register (regno, regbuf); - return 0; + return p; } -/* Return the name of register number regno in the form input and output by - monitor. Currently, register_names just happens to contain exactly what - monitor wants. Lets take advantage of that just as long as possible! */ +/* Tell the remote machine to resume. */ -static char * -get_reg_name (regno) - int regno; +static void +monitor_resume (int pid, int step, enum target_signal sig) { - static char buf[50]; - const char *p; - char *b; - - b = buf; - - if (regno < 0) - return (""); - - for (p = REGNAMES(regno); *p; p++) - *b++ = tolower(*p); - - *b = '\000'; + /* 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) + monitor_printf (current_monitor->step); + else + { + 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; + } +} - debuglogs (5, "Got name \"%s\" from regno #%d.", buf, regno); +/* 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. */ - return buf; +static void +parse_register_dump (char *buf, int len) +{ + 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; + + memset (®ister_strings, 0, sizeof (struct re_registers)); + + if (re_search (®ister_pattern, buf, len, 0, len, + ®ister_strings) == -1) + break; + + 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]; + + current_monitor->supply_register (regname, regnamelen, val, vallen); + + buf += register_strings.end[0]; + len -= register_strings.end[0]; + } } -/* - * monitor_fetch_registers -- read the remote registers into the - * block regs. - */ -void -monitor_fetch_registers () +/* Send ^C to target to halt it. Target will respond, and send us a + packet. */ + +static void +monitor_interrupt (int signo) { - int regno; + /* If this doesn't work, try more severe steps. */ + signal (signo, monitor_interrupt_twice); - /* yeah yeah, i know this is horribly inefficient. but it isn't done - very often... i'll clean it up later. */ + if (monitor_debug_p || remote_debug) + fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n"); - for (regno = 0; regno <= PC_REGNUM; regno++) - monitor_fetch_register(regno); + target_stop (); } -/* - * monitor_fetch_register -- fetch register REGNO, or all registers if REGNO - * is -1. Returns errno value. - */ -void -monitor_fetch_register (regno) - int regno; +/* The user typed ^C twice. */ + +static void +monitor_interrupt_twice (int signo) { - int val, j; + signal (signo, ofunc); - debuglogs (1, "monitor_fetch_register (reg=%s)", get_reg_name (regno)); + monitor_interrupt_query (); - if (regno < 0) { - monitor_fetch_registers (); - } else { - char *name = get_reg_name (regno); - if (STREQ(name, "")) - return; - printf_monitor (ROMCMD(GET_REG), name); /* send the command */ - expect (name, 1); /* then strip the leading garbage */ - if (*ROMDELIM(GET_REG) != 0) { /* if there's a delimiter */ - expect (ROMDELIM(GET_REG), 1); - } - - val = get_hex_word(); /* get the value, ignore junk */ - supply_register (regno, (char *) &val); - - if (*ROMDELIM(GET_REG) != 0) { -/*** expect (ROMRES(GET_REG)); ***/ - printf_monitor (CMD_END); - } - expect_prompt (1); - } - return; + signal (signo, monitor_interrupt); } -/* Store the remote registers from the contents of the block REGS. */ +/* Ask the user what to do when an interrupt is received. */ -void -monitor_store_registers () +static void +monitor_interrupt_query (void) { - int regno; + target_terminal_ours (); - debuglogs (1, "monitor_store_registers()"); + if (query ("Interrupted while waiting for the program.\n\ +Give up (and stop debugging it)? ")) + { + target_mourn_inferior (); + return_to_top_level (RETURN_QUIT); + } - for (regno = 0; regno <= PC_REGNUM; regno++) - monitor_store_register(regno); + target_terminal_inferior (); +} - registers_changed (); +static void +monitor_wait_cleanup (void *old_timeout) +{ + timeout = *(int *) old_timeout; + signal (SIGINT, ofunc); + in_monitor_wait = 0; } -/* - * monitor_store_register -- store register REGNO, or all if REGNO == 0. - * return errno value. - */ + + void -monitor_store_register (regno) - int regno; +monitor_wait_filter (char *buf, + int bufmax, + int *ext_resp_len, + struct target_waitstatus *status +) +{ + int resp_len; + do + { + resp_len = monitor_expect_prompt (buf, bufmax); + *ext_resp_len = resp_len; + + if (resp_len <= 0) + fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf); + } + while (resp_len < 0); + + /* 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; + + for (i = 0; i < resp_len - 1; i++) + if (buf[i] == 0x0f) + putchar_unfiltered (buf[++i]); + } +} + + + +/* 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 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 + /* 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 + + ofunc = (void (*)()) signal (SIGINT, monitor_interrupt); + + if (current_monitor->wait_filter) + (*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status); + else + monitor_wait_filter (buf, sizeof (buf), &resp_len, status); + +#if 0 /* Transferred to monitor wait filter */ + do + { + resp_len = monitor_expect_prompt (buf, sizeof (buf)); + + if (resp_len <= 0) + fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf); + } + while (resp_len < 0); + + /* 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; + + for (i = 0; i < resp_len - 1; i++) + if (buf[i] == 0x0f) + putchar_unfiltered (buf[++i]); + } +#endif + + signal (SIGINT, ofunc); + + timeout = old_timeout; +#if 0 + if (dump_reg_flag && current_monitor->dump_registers) + { + dump_reg_flag = 0; + monitor_printf (current_monitor->dump_registers); + resp_len = monitor_expect_prompt (buf, sizeof (buf)); + } + + if (current_monitor->register_pattern) + parse_register_dump (buf, resp_len); +#else + monitor_debug ("Wait fetching registers after stop\n"); + monitor_dump_regs (); +#endif + + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_TRAP; + + discard_cleanups (old_chain); + + in_monitor_wait = 0; + + return inferior_pid; +} + +/* Fetch register REGNO, or all registers if REGNO is -1. Returns + errno value. */ + +static void +monitor_fetch_register (int regno) { char *name; + char *zerobuf; + char *regbuf; int i; - i = read_register(regno); + regbuf = alloca (MAX_REGISTER_RAW_SIZE * 2 + 1); + zerobuf = alloca (MAX_REGISTER_RAW_SIZE); + memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE); - debuglogs (1, "monitor_store_register (regno=%d)", regno); + name = current_monitor->regnames[regno]; + monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)"); - if (regno < 0) - monitor_store_registers (); - else { - debuglogs (3, "Setting register %s to 0x%x", get_reg_name (regno), read_register (regno)); - - name = get_reg_name (regno); - if (STREQ(name, "")) + if (!name || (*name == '\0')) + { + monitor_debug ("No register known for %d\n", regno); + supply_register (regno, zerobuf); return; - printf_monitor (ROMCMD(SET_REG), name, read_register(regno)); - expect (name, 1); /* strip the leading garbage */ - if (*ROMDELIM(SET_REG) != 0) { /* if there's a delimiter */ - expect (ROMDELIM(SET_REG), 1); - get_hex_word(1); - printf_monitor ("%d%s\n", i, CMD_END); - } - expect_prompt (1); - } - return; - -#if 0 - printf_monitor (SET_REG, get_reg_name (regno), - read_register (regno)); - expect_prompt (1); } -#endif + + /* send the register examine command */ + + monitor_printf (current_monitor->getreg.cmd, name); + + /* If RESP_DELIM is specified, we search for that as a leading + delimiter for the register value. Otherwise, we just start + searching from the start of the buf. */ + + if (current_monitor->getreg.resp_delim) + { + monitor_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) + { + monitor_debug ("EXP getreg.resp_delim\n"); + monitor_expect (current_monitor->getreg.resp_delim, NULL, 0); + } + } + + /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */ + if (current_monitor->flags & MO_HEX_PREFIX) + { + int c; + c = readchar (timeout); + while (c == ' ') + c = readchar (timeout); + if ((c == '0') && ((c = readchar (timeout)) == 'x')) + ; + else + error ("Bad value returned from monitor while fetching register %x.", + regno); + } + + /* Read upto the maximum number of hex digits for this register, skipping + spaces, but stop reading if something else is seen. Some monitors + like to drop leading zeros. */ + + for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++) + { + int c; + c = readchar (timeout); + while (c == ' ') + c = readchar (timeout); + + if (!isxdigit (c)) + break; + + regbuf[i] = c; + } + + regbuf[i] = '\000'; /* terminate the number */ + monitor_debug ("REGVAL '%s'\n", regbuf); + + /* If TERM is present, we wait for that to show up. Also, (if TERM + is present), we will send TERM_CMD if that is present. In any + case, we collect all of the output into buf, and then wait for + the normal prompt. */ + + if (current_monitor->getreg.term) + { + monitor_debug ("EXP getreg.term\n"); + monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */ + } + + if (current_monitor->getreg.term_cmd) + { + monitor_debug ("EMIT getreg.term.cmd\n"); + monitor_printf (current_monitor->getreg.term_cmd); + } + if (!current_monitor->getreg.term || /* Already expected or */ + current_monitor->getreg.term_cmd) /* ack expected */ + monitor_expect_prompt (NULL, 0); /* get response */ + + 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_dump_reg_block (char *block_cmd) +{ + 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; +} + + +/* Read the remote registers into the block regs. */ +/* Call the specific function if it has been provided */ + +static void +monitor_dump_regs (void) +{ + 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 + internal_error (__FILE__, __LINE__, "failed internal consistency check"); /* Need some way to read registers */ +} + +static void +monitor_fetch_registers (int regno) +{ + monitor_debug ("MON fetchregs\n"); + if (current_monitor->getreg.cmd) + { + if (regno >= 0) + { + monitor_fetch_register (regno); + return; + } + + for (regno = 0; regno < NUM_REGS; regno++) + monitor_fetch_register (regno); + } + else + { + monitor_dump_regs (); + } +} + +/* Store register REGNO, or all if REGNO == 0. Return errno value. */ + +static void +monitor_store_register (int regno) +{ + char *name; + ULONGEST val; + + name = current_monitor->regnames[regno]; + if (!name || (*name == '\0')) + { + monitor_debug ("MON Cannot store unknown register\n"); + return; + } + + val = read_register (regno); + monitor_debug ("MON storeg %d %s\n", regno, + phex (val, REGISTER_RAW_SIZE (regno))); + + /* send the register deposit command */ + + 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); + + if (current_monitor->setreg.term) + { + 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); + } + else + monitor_expect_prompt (NULL, 0); + if (current_monitor->setreg.term_cmd) /* Mode exit required */ + { + monitor_debug ("EXP setreg_termcmd\n"); + monitor_printf ("%s", current_monitor->setreg.term_cmd); + monitor_expect_prompt (NULL, 0); + } +} /* monitor_store_register */ + +/* Store the remote registers. */ + +static void +monitor_store_registers (int regno) +{ + if (regno >= 0) + { + monitor_store_register (regno); + return; + } + + for (regno = 0; regno < NUM_REGS; regno++) + monitor_store_register (regno); } /* Get ready to modify the registers array. On machines which store @@ -815,146 +1377,656 @@ monitor_store_register (regno) that registers contains all the registers from the program being debugged. */ -void -monitor_prepare_to_store () +static void +monitor_prepare_to_store (void) { /* Do nothing, since we can store individual regs */ } -void -monitor_files_info () +static void +monitor_files_info (struct target_ops *ops) { - printf ("\tAttached to %s at %d baud.\n", - dev_name, baudrate); + printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate); } -/* - * monitor_write_inferior_memory -- Copy LEN bytes of data from debugger - * memory at MYADDR to inferior's memory at MEMADDR. Returns length moved. - */ -int -monitor_write_inferior_memory (memaddr, myaddr, len) - CORE_ADDR memaddr; - unsigned char *myaddr; - int len; +static int +monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len) { + unsigned int val, hostval; + char *cmd; int i; - char buf[10]; - - debuglogs (1, "monitor_write_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr, myaddr, len); - - for (i = 0; i < len; i++) { - printf_monitor (ROMCMD(SET_MEM), memaddr + i, myaddr[i] ); - if (*ROMDELIM(SET_MEM) != 0) { /* if there's a delimiter */ - expect (ROMDELIM(SET_MEM), 1); - expect (CMD_DELIM); - printf_monitor ("%x", myaddr[i]); - } -/*** 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 ("MON write %d %s\n", len, paddr (memaddr)); + + if (current_monitor->flags & MO_ADDR_BITS_REMOVE) + memaddr = ADDR_BITS_REMOVE (memaddr); + + /* Use memory fill command for leading 0 bytes. */ + + if (current_monitor->fill) + { + for (i = 0; i < len; i++) + if (myaddr[i] != 0) + break; + + if (i > 4) /* More than 4 zeros is worth doing */ + { + 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 0 + /* Can't actually use long longs if VAL is an int (nice idea, though). */ + if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll) + { + len = 8; + cmd = current_monitor->setmem.cmdll; + } + else +#endif + if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl) + { + len = 4; + cmd = current_monitor->setmem.cmdl; + } + else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw) + { + len = 2; + cmd = current_monitor->setmem.cmdw; + } + else + { + len = 1; + cmd = current_monitor->setmem.cmdb; + } + + val = extract_unsigned_integer (myaddr, len); + + if (len == 4) + { + hostval = *(unsigned int *) myaddr; + monitor_debug ("Hostval(%08x) val(%08x)\n", hostval, val); + } + + + if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM) + monitor_printf_noecho (cmd, memaddr, val); + else if (current_monitor->flags & MO_SETMEM_INTERACTIVE) + { + + monitor_printf_noecho (cmd, memaddr); + + 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); + + monitor_expect_prompt (NULL, 0); + return len; } -/* - * monitor_read_inferior_memory -- read LEN bytes from inferior memory - * at MEMADDR. Put the result at debugger address MYADDR. Returns - * length moved. - */ -int -monitor_read_inferior_memory(memaddr, myaddr, len) - CORE_ADDR memaddr; - char *myaddr; - int len; + +static int +monitor_write_even_block (CORE_ADDR memaddr, char *myaddr, int len) { - int i, j; - char buf[20]; - - /* Number of bytes read so far. */ - int count; - - /* Starting address of this pass. */ - unsigned long startaddr; - - /* Number of bytes to read in this pass. */ - int len_this_pass; - - debuglogs (1, "monitor_read_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr, myaddr, len); - - /* Note that this code works correctly if startaddr is just less - than UINT_MAX (well, really CORE_ADDR_MAX if there was such a - thing). That is, something like - monitor_read_bytes (CORE_ADDR_MAX - 4, foo, 4) - works--it never adds len To memaddr and gets 0. */ - /* However, something like - monitor_read_bytes (CORE_ADDR_MAX - 3, foo, 4) - doesn't need to work. Detect it and give up if there's an attempt - to do that. */ - if (((memaddr - 1) + len) < memaddr) { - errno = EIO; + unsigned int val; + int written = 0;; + /* Enter the sub mode */ + monitor_printf (current_monitor->setmem.cmdl, memaddr); + monitor_expect_prompt (NULL, 0); + + while (len) + { + 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; +} + + +static int +monitor_write_memory_bytes (CORE_ADDR memaddr, char *myaddr, int len) +{ + unsigned char val; + int written = 0; + if (len == 0) return 0; - } - - startaddr = memaddr; - count = 0; - while (count < len) { - len_this_pass = 16; - if ((startaddr % 16) != 0) - len_this_pass -= startaddr % 16; - if (len_this_pass > (len - count)) - len_this_pass = (len - count); - - debuglogs (3, "Display %d bytes at %x", len_this_pass, startaddr); - - for (i = 0; i < len_this_pass; i++) { - printf_monitor (ROMCMD(GET_MEM), startaddr, startaddr); - sprintf (buf, ROMCMD(GET_MEM), startaddr, startaddr); - if (*ROMDELIM(GET_MEM) != 0) { /* if there's a delimiter */ - expect (ROMDELIM(GET_MEM), 1); - } else { - sprintf (buf, ROMCMD(GET_MEM), startaddr, startaddr); - expect (buf,1); /* get the command echo */ - get_hex_word(1); /* strip away the address */ - } - get_hex_byte (&myaddr[count++]); /* get the value at this address */ + /* Enter the sub mode */ + monitor_printf (current_monitor->setmem.cmdb, memaddr); + monitor_expect_prompt (NULL, 0); + while (len) + { + 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--; + } + /* Now exit the sub mode */ + monitor_printf (current_monitor->getreg.term_cmd); + monitor_expect_prompt (NULL, 0); + return written; +} - if (*ROMDELIM(GET_MEM) != 0) { - printf_monitor (CMD_END); + +static void +longlongendswap (unsigned char *a) +{ + int i, j; + unsigned char x; + i = 0; + j = 7; + while (i < 4) + { + 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; + } + else + { + 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; } - expect_prompt (1); - startaddr += 1; + longlongendswap (disbuf); /* FIXME: ONly on big endian hosts */ + while (scan < limit) + { + c = *scan++; /* a byte of our long long value */ + if (leadzero) + { + if (c == 0) + continue; + else + leadzero = 0; /* henceforth we print even zeroes */ + } + nib = c >> 4; /* high nibble bits */ + *outbuff++ = hexlate[nib]; + nib = c & 0x0f; /* low nibble bits */ + *outbuff++ = hexlate[nib]; + } + return outbuff; + } +} /* longlong_hexchars */ + + + +/* 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) + { + 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; } - } + /* 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) + { + return monitor_write_memory_longlongs (memaddr, myaddr, len); + } +#endif +#if 0 + if (len > 4) + { + int sublen; + written = monitor_write_even_block (memaddr, myaddr, len); + /* Adjust calling parameters by written amount */ + memaddr += written; + myaddr += written; + len -= written; + } +#endif + written = monitor_write_memory_bytes (memaddr, myaddr, len); + return written; +} + +/* This is an alternate form of monitor_read_memory which is used for monitors + which can only read a single byte/word/etc. at a time. */ + +static int +monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len) +{ + unsigned int val; + char membuf[sizeof (int) * 2 + 1]; + char *p; + char *cmd; + int i; + + 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); + } + + membuf[i] = c; + } + + membuf[i] = '\000'; /* terminate the number */ + +/* If TERM is present, we wait for that to show up. Also, (if TERM is + present), we will send TERM_CMD if that is present. In any case, we collect + all of the output into buf, and then wait for the normal prompt. */ + + if (current_monitor->getmem.term) + { + monitor_expect (current_monitor->getmem.term, NULL, 0); /* get response */ + + if (current_monitor->getmem.term_cmd) + { + monitor_printf (current_monitor->getmem.term_cmd); + monitor_expect_prompt (NULL, 0); + } + } + else + monitor_expect_prompt (NULL, 0); /* get response */ + + p = membuf; + val = strtoul (membuf, &p, 16); + + if (val == 0 && membuf == p) + 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; } -/* FIXME-someday! merge these two. */ -int -monitor_xfer_inferior_memory (memaddr, myaddr, len, write, target) - CORE_ADDR memaddr; - char *myaddr; - int len; - int write; - struct target_ops *target; /* ignored */ +/* 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_read_memory (CORE_ADDR memaddr, char *myaddr, int len) { + unsigned int val; + char buf[512]; + char *p, *p1; + int resp_len; + int i; + CORE_ADDR dumpaddr; + + if (len <= 0) + { + monitor_debug ("Zero length call to monitor_read_memory\n"); + return 0; + } + + monitor_debug ("MON read block ta(%s) ha(%lx) %d\n", + paddr_nz (memaddr), (long) myaddr, len); + + if (current_monitor->flags & MO_ADDR_BITS_REMOVE) + memaddr = ADDR_BITS_REMOVE (memaddr); + + 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 + 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 + } + 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; + + + 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"); + + for (i = len; i > 0; i--) + { + /* Skip non-hex chars, but bomb on end of string and newlines */ + + while (1) + { + if (isxdigit (*p)) + break; + + if (*p == '\000' || *p == '\n' || *p == '\r') + 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; +} + +/* Transfer LEN bytes between target address MEMADDR and GDB address + MYADDR. Returns 0 for success, errno code for failure. TARGET is + unused. */ + +static int +monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, + struct mem_attrib *attrib ATTRIBUTE_UNUSED, + struct target_ops *target ATTRIBUTE_UNUSED) +{ + int res; + if (write) - return monitor_write_inferior_memory (memaddr, myaddr, len); + { + if (current_monitor->flags & MO_HAS_BLOCKWRITES) + res = monitor_write_memory_block(memaddr, myaddr, len); + else + res = monitor_write_memory(memaddr, myaddr, len); + } else - return monitor_read_inferior_memory (memaddr, myaddr, len); + { + res = monitor_read_memory(memaddr, myaddr, len); + } + + return res; } -void -monitor_kill (args, from_tty) - char *args; - int from_tty; +static void +monitor_kill (void) { - return; /* ignore attempts to kill target system */ + return; /* ignore attempts to kill target system */ +} + +/* All we actually do is set the PC to the start address of exec_bfd, and start + the program at that point. */ + +static void +monitor_create_inferior (char *exec_file, char *args, char **env) +{ + if (args && (*args != '\000')) + error ("Args are not supported by the monitor."); + + first_time = 1; + clear_proceed_status (); + proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0); } /* Clean up when a program exits. @@ -962,585 +2034,320 @@ monitor_kill (args, from_tty) run again without a download. Don't leave it full of breakpoint instructions. */ -void -monitor_mourn_inferior () +static void +monitor_mourn_inferior (void) { - remove_breakpoints (); + unpush_target (targ_ops); generic_mourn_inferior (); /* Do all the proper things now */ } -#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. */ -/* - * monitor_insert_breakpoint -- add a breakpoint - */ -int -monitor_insert_breakpoint (addr, shadow) - CORE_ADDR addr; - char *shadow; +static int +monitor_insert_breakpoint (CORE_ADDR addr, char *shadow) { int i; - - debuglogs (1, "monitor_insert_breakpoint() addr = 0x%x", addr); - - for (i = 0; i <= MAX_MONITOR_BREAKPOINTS; i++) { - if (breakaddr[i] == 0) { - breakaddr[i] = addr; - if (sr_get_debug() > 4) - printf ("Breakpoint at %x\n", addr); - monitor_read_inferior_memory(addr, shadow, memory_breakpoint_size); - printf_monitor(SET_BREAK_CMD, addr); - expect_prompt(1); - return 0; + unsigned char *bp; + int bplen; + + monitor_debug ("MON inst bkpt %s\n", paddr (addr)); + if (current_monitor->set_break == NULL) + error ("No set_break defined for this monitor"); + + if (current_monitor->flags & MO_ADDR_BITS_REMOVE) + addr = ADDR_BITS_REMOVE (addr); + + /* Determine appropriate breakpoint size for this address. */ + bp = memory_breakpoint_from_pc (&addr, &bplen); + + for (i = 0; i < current_monitor->num_breakpoints; 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; + } } - } - fprintf(stderr, "Too many breakpoints (> 16) for monitor\n"); - return 1; + error ("Too many breakpoints (> %d) for monitor.", current_monitor->num_breakpoints); } -/* - * _remove_breakpoint -- Tell the monitor to remove a breakpoint - */ -int -monitor_remove_breakpoint (addr, shadow) - CORE_ADDR addr; - char *shadow; +/* Tell the monitor to remove a breakpoint. */ + +static int +monitor_remove_breakpoint (CORE_ADDR addr, char *shadow) { int i; - debuglogs (1, "monitor_remove_breakpoint() addr = 0x%x", addr); + monitor_debug ("MON rmbkpt %s\n", paddr (addr)); + if (current_monitor->clr_break == NULL) + error ("No clr_break defined for this monitor"); + + 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) + { + 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; + } + } + fprintf_unfiltered (gdb_stderr, + "Can't find breakpoint associated with 0x%s\n", + paddr_nz (addr)); + return 1; +} + +/* 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. */ - for (i = 0; i < MAX_MONITOR_BREAKPOINTS; i++) { - if (breakaddr[i] == addr) { - breakaddr[i] = 0; - /* some monitors remove breakpoints based on the address */ - if (CLR_BREAK_ADDR) - printf_monitor(CLR_BREAK_CMD, addr); - else - printf_monitor(CLR_BREAK_CMD, i); - expect_prompt(1); - return 0; +static int +monitor_wait_srec_ack (void) +{ + int ch; + + if (current_monitor->flags & MO_SREC_ACK_PLUS) + { + 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; } - } - 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. - */ -void -monitor_load (file, fromtty) - char *file; - int fromtty; +/* monitor_load -- download a file. */ + +static void +monitor_load (char *file, int from_tty) { - FILE *download; - int i, bytes_read; + monitor_debug ("MON load\n"); + + 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); - debuglogs (1, "Loading %s to monitor", file); + load_srec (monitor_desc, file, (bfd_vma) load_offset, + 32, SREC_ALL, hashmark, + current_monitor->flags & MO_SREC_ACK ? + monitor_wait_srec_ack : NULL); - if (STREQ (loadtype_str, "default")) { /* default, load a binary */ - gr_load_image (file, fromtty); /* by writing it into memory */ - } + monitor_expect_prompt (NULL, 0); + } + +/* Finally, make the PC point at the start address */ - if (STREQ (loadtype_str, "srec")) { /* load an srecord by converting */ - monitor_load_srec(file, 0); /* if from a binary */ - } + if (exec_bfd) + write_pc (bfd_get_start_address (exec_bfd)); - if (STREQ (loadtype_str, "none")) { /* load an srecord by converting */ - error ("Unimplemented"); - } + inferior_pid = 0; /* No process now */ - if (STREQ (loadproto_str, "none")) { /* load an srecord file */ - monitor_load_ascii_srec(file, fromtty); /* if from a binary */ - } +/* 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... */ - if (STREQ (loadproto_str, "xmodem")) { /* load an srecord using the */ - monitor_load_srec(file, XMODEM); - } + clear_symtab_users (); } -/* - * monitor_load_ascii_srec -- download an ASCII srecord file. - */ -#define DOWNLOAD_LINE_SIZE 100 -int -monitor_load_ascii_srec (file, fromtty) - char *file; - int fromtty; +static void +monitor_stop (void) { - FILE *download; - char buf[DOWNLOAD_LINE_SIZE]; - int i, bytes_read; - - debuglogs (1, "Loading an ASCII srecord file, %s.", file); - - download = fopen (file, "r"); - if (download == NULL) { - error ("%s Does not exist", file); - return; - } - - printf_monitor (LOAD_CMD); - sleep(1); - while (!feof (download)) { - 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)); - break; - } - i = 0; - while (i++ <=200) {} ; /* Ugly HACK, probably needs flow control */ - if (bytes_read < DOWNLOAD_LINE_SIZE) { - if (!feof (download)) - error ("Only read %d bytes\n", bytes_read); - break; - } - } - - if (hashmark) { - putchar ('\n'); - } - if (!feof (download)) - error ("Never got EOF while downloading"); - expect_prompt(1); - fclose (download); + 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); } -/* - * monitor_command -- put a command string, in args, out to MONITOR. - * Output from MONITOR is placed on the users terminal until the - * prompt is seen. FIXME: We read the charcters ourseleves here - * cause of a nasty echo. - */ -void -monitor_command (args, fromtty) - char *args; - int fromtty; -{ +/* 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 void +monitor_rcmd (char *command, + struct ui_file *outbuf) +{ char *p; - char c, cp; - p = PROMPT; - - debuglogs (1, "monitor_command (args=%s)", args); + int resp_len; + char buf[1000]; if (monitor_desc == NULL) - error("monitor target not open."); + error ("monitor target not open."); - if (!args) - error("Missing command."); - - printf_monitor ("%s\n", args); + p = current_monitor->prompt; - expect_prompt(0); -} + /* Send the command. Note that if no args were supplied, then we're + just sending the monitor a newline, which is sometimes useful. */ -/* - * monitor_load_srec -- 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; -{ - bfd *abfd; - asection *s; - char buffer[1024]; - char 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. */ - - abfd = bfd_openr (args, 0); - if (!abfd) { - printf_filtered ("Unable to open file %s\n", args); - return; - } - - if (bfd_check_format (abfd, bfd_object) == 0) { - printf_filtered ("File is not an object file\n"); - return; - } - - printf_monitor (LOAD_CMD); /* tell the monitor to load */ - if (protocol == XMODEM) { /* get the NAK from the target */ - 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"); - } - } - - s = abfd->sections; - while (s != (asection *) NULL) { - if (s->flags & SEC_LOAD) { - char *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) { - 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); - if (protocol == XMODEM) { /* send a packet using xmodem */ - make_xmodem_packet (packet, srec, XMODEM_DATASIZE); - write_monitor (packet, XMODEM_PACKETSIZE+1); - retries = 0; - while (retries++ <= 3) { - if (GETNAK) { /* Resend packet */ - debuglogs (3, "Got a NAK, resending packet"); - sleep(1); - write_monitor (packet, XMODEM_PACKETSIZE+1); /* send it again */ - if (GETACK) /* ACKnowledged, get next data chunk */ - break; - } - } - if (retries >= 4) { /* too many tries, must be hosed */ - printf_monitor ("%c", EOT); - error ("Never got a ACK after sending an xmodem packet"); - } - } else { /* no protocols at all */ - printf_monitor ("%s\n", srec); - } - if (hashmark) - printf_filtered ("#"); - type = 3; /* switch to a 4 byte address record */ - fflush (stdout); - } - printf_filtered ("\n"); - free (buffer); - } else { - debuglogs (3, "%s doesn't need to be loaded", s->name); - } - s = s->next; - } - - /* - write a type 7 terminator record. no data for a type 7, - and there is no data, so len is 0. - */ - monitor_make_srec (srec, 7, abfd->start_address, "", 0); - printf_monitor ("%s\n", srec); - if (protocol == XMODEM) { - printf_monitor ("%c", EOT); - if (!GETACK) - error ("Never got ACK after sending EOT"); - } - - if (hashmark) - putchar ('\n'); - - expect_prompt (); + monitor_printf ("%s\r", (command ? command : "")); + + resp_len = monitor_expect_prompt (buf, sizeof buf); + + fputs_unfiltered (buf, outbuf); /* Output the response */ } -/* - * getacknak -- 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 - */ -int -getacknak (byte) - int byte; +/* Convert hex digit A to a number. */ + +#if 0 +static int +from_hex (int a) { - char character; - 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."); - } - 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; - } - sleep (1); - } - return 0; + 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 -/* - * 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
- * - * 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. - */ -int -monitor_make_srec (buffer, type, memaddr, myaddr, len) - char *buffer; - int type; - CORE_ADDR memaddr; - unsigned char *myaddr; - int len; +char * +monitor_get_dev_name (void) { - int checksum; - 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)); - - for (i = 0; i < len; i++) { /* build the srecord */ - sprintf (buf, "%02X", myaddr[i]); - checksum += myaddr[i]; - buf += 2; - } - - sprintf(buf, "%02X", ~checksum & 0xff); /* add the checksum */ - debuglogs (3, "srec is \"%s\"", buffer); - - return(0); + return dev_name; } -/* - * make_xmodem_packet -- this takes a 128 bytes of data and makes 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. - */ -void -make_xmodem_packet (packet, data, len) - unsigned char packet[]; - unsigned char *data; - int len; +static struct target_ops monitor_ops; + +static void +init_base_monitor_ops (void) { - 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 0 - packet[2] = ~sequence++; /* the complement is the sequence checksum */ -#endif - - sum = 0; /* calculate the data checksum */ - for (i = 3; i <= len + 2; i++) { - packet[i] = *buf; - sum += *buf; - buf++; - } - - for (i = len+1 ; i <= XMODEM_DATASIZE ; i++) { /* add padding for the rest of the packet */ - packet[i] = '0'; - } - - packet[XMODEM_PACKETSIZE] = sum & 0xff; /* add the checksum */ - - if (sr_get_debug() > 4) - debuglogs (4, "The xmodem checksum is %d (0x%x)\n", sum & 0xff, sum & 0xff); - print_xmodem_packet (packet); -} + 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 */ -/* - * print_xmodem_packet -- print the packet as a debug check - */ void -print_xmodem_packet(packet) - char packet[]; +init_monitor_ops (struct target_ops *ops) { - int i; - static int lastseq; - int sum; - - /* take apart the packet header the packet header */ - if (packet[0] == SOH) { - ("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"); - else - printf_filtered (" %d %d", lastseq, ~lastseq); - } - - /* 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); + if (monitor_ops.to_magic != OPS_MAGIC) + init_base_monitor_ops (); - if ((packet[XMODEM_PACKETSIZE] & 0xff) != (sum & 0xff)) { - debuglogs (4, "xmodem: data checksum wrong, got a %d", packet[XMODEM_PACKETSIZE] & 0xff); - } - putchar ('\n'); + memcpy (ops, &monitor_ops, sizeof monitor_ops); } -/* - * _initialize_remote_monitors -- setup a few addtitional commands that - * are usually only used by monitors. - */ +/* 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); - /* generic monitor command */ - 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); }