X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fmonitor.c;h=b78496a9e806220d3d9b1103d42ba1d4cfa461d8;hb=fefd0a378f5aff09fb63003bc2a6bb2e2d66ffee;hp=b7a56aa57d33c65b3205b240a0576f58ac2b2dba;hpb=15f13cd0ec997774dc369e260889d7184619821b;p=binutils-gdb.git diff --git a/gdb/monitor.c b/gdb/monitor.c index b7a56aa57d3..b78496a9e80 100644 --- a/gdb/monitor.c +++ b/gdb/monitor.c @@ -1,29 +1,30 @@ /* Remote debugging interface for boot monitors, for GDB. - Copyright 1990, 1991, 1992, 1993, 1995, 1996 - Free Software Foundation, Inc. + Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 @@ -40,12 +41,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "defs.h" #include "gdbcore.h" #include "target.h" -#include "wait.h" -#ifdef ANSI_PROTOTYPES -#include -#else -#include -#endif #include #include #include "gdb_string.h" @@ -55,48 +50,58 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "monitor.h" #include "gdbcmd.h" #include "inferior.h" -#include "gnu-regex.h" -#include "dcache.h" +#include "gdb_regex.h" #include "srec.h" +#include "regcache.h" static char *dev_name; static struct target_ops *targ_ops; -static int readchar PARAMS ((int timeout)); - -static void monitor_command PARAMS ((char *args, int fromtty)); - -static void monitor_fetch_register PARAMS ((int regno)); -static void monitor_store_register PARAMS ((int regno)); - -static void monitor_detach PARAMS ((char *args, int from_tty)); -static void monitor_resume PARAMS ((int pid, int step, enum target_signal sig)); -static void monitor_interrupt PARAMS ((int signo)); -static void monitor_interrupt_twice PARAMS ((int signo)); -static void monitor_interrupt_query PARAMS ((void)); -static void monitor_wait_cleanup PARAMS ((int old_timeout)); - -static int monitor_wait PARAMS ((int pid, struct target_waitstatus *status)); -static void monitor_fetch_registers PARAMS ((int regno)); -static void monitor_store_registers PARAMS ((int regno)); -static void monitor_prepare_to_store PARAMS ((void)); -static int monitor_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len, int write, struct target_ops *target)); -static void monitor_files_info PARAMS ((struct target_ops *ops)); -static int monitor_insert_breakpoint PARAMS ((CORE_ADDR addr, char *shadow)); -static int monitor_remove_breakpoint PARAMS ((CORE_ADDR addr, char *shadow)); -static void monitor_kill PARAMS ((void)); -static void monitor_load PARAMS ((char *file, int from_tty)); -static void monitor_mourn_inferior PARAMS ((void)); -static void monitor_stop PARAMS ((void)); -static void monitor_debug PARAMS ((char *prefix, char *string, char *suffix)); - -static int monitor_read_memory PARAMS ((CORE_ADDR addr, char *myaddr,int len)); -static int monitor_write_memory PARAMS ((CORE_ADDR addr, char *myaddr,int len)); - -static int monitor_expect_regexp PARAMS ((struct re_pattern_buffer *pat, - char *buf, int buflen)); -static int from_hex PARAMS ((int a)); -static unsigned long get_hex_word PARAMS ((void)); +static 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 (ptid_t ptid, 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 ptid_t monitor_wait (ptid_t ptid, 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); static struct monitor_ops *current_monitor; @@ -106,13 +111,15 @@ static int timeout = 30; static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait() */ -static void (*ofunc)(); /* Old SIGINT signal handler */ +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. */ -static serial_t monitor_desc = NULL; +static struct serial *monitor_desc = NULL; /* Pointer to regexp pattern matching data */ @@ -122,183 +129,341 @@ static char register_fastmap[256]; static struct re_pattern_buffer getmem_resp_delim_pattern; static char getmem_resp_delim_fastmap[256]; +static struct re_pattern_buffer setmem_resp_delim_pattern; +static char setmem_resp_delim_fastmap[256]; + +static struct re_pattern_buffer setreg_resp_delim_pattern; +static char setreg_resp_delim_fastmap[256]; + static int dump_reg_flag; /* Non-zero means do a dump_registers cmd when monitor_wait wakes up. */ -static DCACHE *remote_dcache; -static int first_time=0; /* is this the first time we're executing after - gaving created the child proccess? */ +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 +monitor_debug (const char *fmt, ...) +{ + if (monitor_debug_p) + { + va_list args; + va_start (args, fmt); + vfprintf_filtered (gdb_stdlog, fmt, args); + va_end (args); + } +} + -/* monitor_debug is like fputs_unfiltered, except it prints special - characters in printable fashion. */ +/* 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 -monitor_debug (prefix, string, suffix) - char *prefix; - char *string; - char *suffix; +monitor_printable_string (char *newstr, char *oldstr, int len) { int ch; + int i; - /* print prefix and suffix after each line */ - static int new_line=1; - static char *prev_prefix = ""; - static char *prev_suffix = ""; + if (len <= 0) + len = strlen (oldstr); - /* if the prefix is changing, print the previous suffix, a new line, - and the new prefix */ - if (strcmp(prev_prefix, prefix) != 0 && !new_line) + for (i = 0; i < len; i++) { - fputs_unfiltered (prev_suffix, gdb_stderr); - fputs_unfiltered ("\n", gdb_stderr); - fputs_unfiltered (prefix, gdb_stderr); + 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; + } } - prev_prefix = prefix; - prev_suffix = suffix; - /* print prefix if last char was a newline*/ + *newstr++ = '\0'; +} - if (new_line == 1) { - fputs_unfiltered (prefix, gdb_stderr); - new_line=0; - } - if (strchr(string,'\n')) /* save state for next call */ - new_line=1; +/* Print monitor errors with a string, converting the string to printable + representation. */ - while ((ch = *string++) != '\0') - { - switch (ch) { - default: - if (isprint (ch)) - fputc_unfiltered (ch, gdb_stderr); +static void +monitor_error (char *function, char *message, + CORE_ADDR memaddr, int len, char *string, int final_char) +{ + 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); - else - fprintf_unfiltered (gdb_stderr, "\\%03o", ch); + 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); +} - break; +/* Convert hex digit A to a number. */ - case '\\': fputs_unfiltered ("\\\\", gdb_stderr); break; - case '\b': fputs_unfiltered ("\\b", gdb_stderr); break; - case '\f': fputs_unfiltered ("\\f", gdb_stderr); break; - case '\n': fputs_unfiltered ("\\n", gdb_stderr); break; - case '\r': fputs_unfiltered ("\\r", gdb_stderr); break; - case '\t': fputs_unfiltered ("\\t", gdb_stderr); break; - case '\v': fputs_unfiltered ("\\v", gdb_stderr); break; - } - } +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); +} - if (new_line==1) { /* print suffix if last char was a newline */ - fputs_unfiltered (suffix, gdb_stderr); - fputs_unfiltered ("\n", gdb_stderr); - } +/* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses + + 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. + + 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. + + %% is also turned into a single %. + */ + +static void +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 -#ifdef ANSI_PROTOTYPES -monitor_printf_noecho (char *pattern, ...) -#else -monitor_printf_noecho (va_alist) - va_dcl -#endif +monitor_printf_noecho (char *pattern,...) { va_list args; char sndbuf[2000]; int len; -#if ANSI_PROTOTYPES va_start (args, pattern); -#else - char *pattern; - va_start (args); - pattern = va_arg (args, char *); -#endif - vsprintf (sndbuf, pattern, args); - - if (remote_debug > 0) - monitor_debug ("sent -->", sndbuf, "<--"); + monitor_vsprintf (sndbuf, pattern, args); len = strlen (sndbuf); - if (len + 1 > sizeof sndbuf) - abort (); + internal_error (__FILE__, __LINE__, "failed internal consistency check"); - if (SERIAL_WRITE(monitor_desc, sndbuf, len)) - fprintf_unfiltered (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno)); + 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); } /* monitor_printf -- Send data to monitor and check the echo. Works just like printf. */ void -#ifdef ANSI_PROTOTYPES -monitor_printf (char *pattern, ...) -#else -monitor_printf (va_alist) - va_dcl -#endif +monitor_printf (char *pattern,...) { va_list args; char sndbuf[2000]; int len; -#ifdef ANSI_PROTOTYPES va_start (args, pattern); -#else - char *pattern; - va_start (args); - pattern = va_arg (args, char *); -#endif - - vsprintf (sndbuf, pattern, args); - if (remote_debug > 0) - monitor_debug ("sent -->", sndbuf, "<--"); + monitor_vsprintf (sndbuf, pattern, args); len = strlen (sndbuf); - if (len + 1 > sizeof sndbuf) - abort (); + internal_error (__FILE__, __LINE__, "failed internal consistency check"); - if (SERIAL_WRITE(monitor_desc, sndbuf, len)) - fprintf_unfiltered (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno)); + 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_expect (sndbuf, (char *)0, 0); + monitor_debug ("ExpectEcho\n"); + monitor_expect (sndbuf, (char *) 0, 0); +} + + +/* 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; + + do + { + looping = 0; + c = serial_readchar (monitor_desc, timeout); + + if (c >= 0) + c &= 0xff; /* don't lose bit 7 */ + } + while (looping); + + 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 (timeout) - int timeout; +readchar (int timeout) { int c; - static enum { last_random, last_nl, last_cr, last_crnl } state = last_random; + static enum + { + last_random, last_nl, last_cr, last_crnl + } + state = last_random; int looping; do { looping = 0; - c = SERIAL_READCHAR (monitor_desc, timeout); + c = serial_readchar (monitor_desc, timeout); if (c >= 0) { c &= 0x7f; - if (remote_debug > 0) + /* 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'; - monitor_debug ("read -->", buf, "<--"); + puts_debug ("read -->", buf, "<--"); } + } /* Canonicialize \n\r combinations into one \r */ @@ -327,11 +492,12 @@ readchar (timeout) return c; if (c == SERIAL_TIMEOUT) -#ifdef MAINTENANCE_CMDS +#if 0 + /* I fail to see how detaching here can be useful */ if (in_monitor_wait) /* Watchdog went off */ { target_mourn_inferior (); - error ("Watchdog has expired. Target detached.\n"); + error ("GDB serial timeout has expired. Target detached.\n"); } else #endif @@ -348,17 +514,21 @@ readchar (timeout) will be at the end of BUF. */ int -monitor_expect (string, buf, buflen) - char *string; - char *buf; - int buflen; +monitor_expect (char *string, char *buf, int buflen) { char *p = string; int obuflen = buflen; int c; extern struct target_ops *targ_ops; - immediate_quit = 1; + if (monitor_debug_p) + { + char *safe_string = (char *) alloca ((strlen (string) * 4) + 1); + monitor_printable_string (safe_string, string, 0); + fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string); + } + + immediate_quit++; while (1) { if (buf) @@ -366,7 +536,7 @@ monitor_expect (string, buf, buflen) if (buflen < 2) { *buf = '\000'; - immediate_quit = 0; + immediate_quit--; return -1; } @@ -380,13 +550,13 @@ monitor_expect (string, buf, buflen) c = readchar (timeout); /* Don't expect any ^C sent to be echoed */ - + if (*p == '\003' || c == *p) { p++; if (*p == '\0') { - immediate_quit = 0; + immediate_quit--; if (buf) { @@ -398,15 +568,50 @@ monitor_expect (string, buf, buflen) } } else if ((c == '\021' || c == '\023') && - (strcmp(targ_ops->to_shortname, "m32r") == 0)) - { /* m32r monitor emits random DC1/DC3 chars */ + (STREQ (targ_ops->to_shortname, "m32r") + || STREQ (targ_ops->to_shortname, "mon2000"))) + { /* m32r monitor emits random DC1/DC3 chars */ continue; } else { - p = string; - if (c == *p) - p++; + /* 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; } } } @@ -414,20 +619,17 @@ monitor_expect (string, buf, buflen) /* Search for a regexp. */ static int -monitor_expect_regexp (pat, buf, buflen) - struct re_pattern_buffer *pat; - char *buf; - int buflen; +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 (1024); - buflen = 1024; + mybuf = alloca (TARGET_BUF_SIZE); + buflen = TARGET_BUF_SIZE; } p = mybuf; @@ -468,18 +670,18 @@ monitor_expect_regexp (pat, buf, buflen) getting into states from which we can't recover. */ int -monitor_expect_prompt (buf, buflen) - char *buf; - int buflen; +monitor_expect_prompt (char *buf, int buflen) { + monitor_debug ("MON Expecting prompt\n"); return monitor_expect (current_monitor->prompt, buf, buflen); } /* Get N 32-bit words from remote, each preceded by a space, and put them in registers starting at REGNO. */ +#if 0 static unsigned long -get_hex_word () +get_hex_word (void) { unsigned long val; int i; @@ -487,7 +689,7 @@ get_hex_word () do ch = readchar (timeout); - while (isspace(ch)); + while (isspace (ch)); val = from_hex (ch); @@ -501,15 +703,14 @@ get_hex_word () return val; } +#endif static void -compile_pattern (pattern, compiled_pattern, fastmap) - char *pattern; - struct re_pattern_buffer *compiled_pattern; - char *fastmap; +compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern, + char *fastmap) { int tmp; - char *val; + const char *val; compiled_pattern->fastmap = fastmap; @@ -530,13 +731,9 @@ compile_pattern (pattern, compiled_pattern, fastmap) for communication. */ void -monitor_open (args, mon_ops, from_tty) - char *args; - struct monitor_ops *mon_ops; - int from_tty; +monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty) { char *name; - int i; char **p; if (mon_ops->magic != MONITOR_OPS_MAGIC) @@ -561,33 +758,41 @@ monitor_open (args, mon_ops, from_tty) compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern, getmem_resp_delim_fastmap); + if (mon_ops->setmem.resp_delim) + compile_pattern (mon_ops->setmem.resp_delim, &setmem_resp_delim_pattern, + setmem_resp_delim_fastmap); + + if (mon_ops->setreg.resp_delim) + compile_pattern (mon_ops->setreg.resp_delim, &setreg_resp_delim_pattern, + setreg_resp_delim_fastmap); + unpush_target (targ_ops); if (dev_name) - free (dev_name); - dev_name = strsave (args); + xfree (dev_name); + dev_name = xstrdup (args); - monitor_desc = SERIAL_OPEN (dev_name); + monitor_desc = serial_open (dev_name); if (!monitor_desc) perror_with_name (dev_name); if (baud_rate != -1) { - if (SERIAL_SETBAUDRATE (monitor_desc, baud_rate)) + if (serial_setbaudrate (monitor_desc, baud_rate)) { - SERIAL_CLOSE (monitor_desc); + serial_close (monitor_desc); perror_with_name (dev_name); } } - - SERIAL_RAW (monitor_desc); - SERIAL_FLUSH_INPUT (monitor_desc); + serial_raw (monitor_desc); + + serial_flush_input (monitor_desc); /* some systems only work with 2 stop bits */ - SERIAL_SETSTOPBITS (monitor_desc, mon_ops->stopbits); + serial_setstopbits (monitor_desc, mon_ops->stopbits); current_monitor = mon_ops; @@ -598,25 +803,36 @@ monitor_open (args, mon_ops, from_tty) { monitor_stop (); if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0) - { - monitor_expect_prompt (NULL, 0); - } + { + monitor_debug ("EXP Open echo\n"); + monitor_expect_prompt (NULL, 0); + } } /* wake up the monitor and see if it's alive */ for (p = mon_ops->init; *p != NULL; p++) { /* Some of the characters we send may not be echoed, - but we hope to get a prompt at the end of it all. */ - + but we hope to get a prompt at the end of it all. */ + if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0) - monitor_printf(*p); + monitor_printf (*p); else - monitor_printf_noecho (*p); + monitor_printf_noecho (*p); monitor_expect_prompt (NULL, 0); } - SERIAL_FLUSH_INPUT (monitor_desc); + 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 */ @@ -631,14 +847,12 @@ monitor_open (args, mon_ops, from_tty) push_target (targ_ops); - inferior_pid = 42000; /* Make run command think we are busy... */ + inferior_ptid = pid_to_ptid (42000); /* Make run command think we are busy... */ /* Give monitor_wait something to read */ monitor_printf (current_monitor->line_term); - remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory); - start_remote (); } @@ -646,11 +860,18 @@ monitor_open (args, mon_ops, from_tty) control. */ void -monitor_close (quitting) - int quitting; +monitor_close (int quitting) { if (monitor_desc) - SERIAL_CLOSE (monitor_desc); + serial_close (monitor_desc); + + /* Free breakpoint memory */ + if (breakaddr != NULL) + { + xfree (breakaddr); + breakaddr = NULL; + } + monitor_desc = NULL; } @@ -658,9 +879,7 @@ monitor_close (quitting) when you want to detach and do something else with your gdb. */ static void -monitor_detach (args, from_tty) - char *args; - int from_tty; +monitor_detach (char *args, int from_tty) { pop_target (); /* calls monitor_close to do the real work */ if (from_tty) @@ -670,15 +889,36 @@ monitor_detach (args, from_tty) /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */ char * -monitor_supply_register (regno, valstr) - int regno; - char *valstr; +monitor_supply_register (int regno, char *valstr) { - unsigned int val; + ULONGEST val; unsigned char regbuf[MAX_REGISTER_RAW_SIZE]; char *p; - val = strtoul (valstr, &p, 16); + val = 0; + p = valstr; + while (p && *p != '\0') + { + if (*p == '\r' || *p == '\n') + { + while (*p != '\0') + p++; + break; + } + if (isspace (*p)) + { + p++; + continue; + } + if (!isxdigit (*p) && *p != 'x') + { + break; + } + + val <<= 4; + val += fromhex (*p++); + } + monitor_debug ("Supplying Register %d %s\n", regno, valstr); if (val == 0 && valstr == p) error ("monitor_supply_register (%d): bad value from monitor: %s.", @@ -696,25 +936,26 @@ monitor_supply_register (regno, valstr) /* Tell the remote machine to resume. */ static void -monitor_resume (pid, step, sig) - int pid, step; - enum target_signal sig; +monitor_resume (ptid_t ptid, int step, enum target_signal sig) { /* Some monitors require a different command when starting a program */ + monitor_debug ("MON resume\n"); if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1) { first_time = 0; monitor_printf ("run\r"); if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT) - dump_reg_flag = 1; + dump_reg_flag = 1; return; } - dcache_flush (remote_dcache); if (step) monitor_printf (current_monitor->step); else { - monitor_printf (current_monitor->cont); + if (current_monitor->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; } @@ -725,19 +966,20 @@ monitor_resume (pid, step, sig) form REG=VAL. Each description is split up into a name and a value string which are passed down to monitor specific code. */ -static char * -parse_register_dump (buf, len) - char *buf; - int len; +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. */ + 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; @@ -758,14 +1000,13 @@ parse_register_dump (buf, len) packet. */ static void -monitor_interrupt (signo) - int signo; +monitor_interrupt (int signo) { /* If this doesn't work, try more severe steps. */ signal (signo, monitor_interrupt_twice); - - if (remote_debug) - printf_unfiltered ("monitor_interrupt called\n"); + + if (monitor_debug_p || remote_debug) + fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n"); target_stop (); } @@ -773,11 +1014,10 @@ monitor_interrupt (signo) /* The user typed ^C twice. */ static void -monitor_interrupt_twice (signo) - int signo; +monitor_interrupt_twice (int signo) { signal (signo, ofunc); - + monitor_interrupt_query (); signal (signo, monitor_interrupt); @@ -786,7 +1026,7 @@ monitor_interrupt_twice (signo) /* Ask the user what to do when an interrupt is received. */ static void -monitor_interrupt_query () +monitor_interrupt_query (void) { target_terminal_ours (); @@ -801,34 +1041,68 @@ Give up (and stop debugging it)? ")) } static void -monitor_wait_cleanup (old_timeout) - int old_timeout; +monitor_wait_cleanup (void *old_timeout) { - timeout = old_timeout; + timeout = *(int *) old_timeout; signal (SIGINT, ofunc); in_monitor_wait = 0; } + + +void +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 (pid, status) - int pid; - struct target_waitstatus *status; +static ptid_t +monitor_wait (ptid_t ptid, struct target_waitstatus *status) { int old_timeout = timeout; - char buf[1024]; + 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); + old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout); + monitor_debug ("MON wait\n"); -#ifdef MAINTENANCE_CMDS - in_monitor_wait = 1; +#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. */ @@ -836,6 +1110,12 @@ monitor_wait (pid, status) 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)); @@ -845,20 +1125,36 @@ monitor_wait (pid, status) } 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; @@ -867,25 +1163,30 @@ monitor_wait (pid, status) in_monitor_wait = 0; - return inferior_pid; + return inferior_ptid; } /* Fetch register REGNO, or all registers if REGNO is -1. Returns errno value. */ static void -monitor_fetch_register (regno) - int regno; +monitor_fetch_register (int regno) { char *name; - static char zerobuf[MAX_REGISTER_RAW_SIZE] = {0}; - char regbuf[MAX_REGISTER_RAW_SIZE * 2 + 1]; + char *zerobuf; + char *regbuf; int i; + regbuf = alloca (MAX_REGISTER_RAW_SIZE * 2 + 1); + zerobuf = alloca (MAX_REGISTER_RAW_SIZE); + memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE); + name = current_monitor->regnames[regno]; + monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)"); - if (!name) + if (!name || (*name == '\0')) { + monitor_debug ("No register known for %d\n", regno); supply_register (regno, zerobuf); return; } @@ -899,10 +1200,20 @@ monitor_fetch_register (regno) searching from the start of the buf. */ if (current_monitor->getreg.resp_delim) - monitor_expect (current_monitor->getreg.resp_delim, NULL, 0); + { + 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) + if (current_monitor->flags & MO_HEX_PREFIX) { int c; c = readchar (timeout); @@ -911,8 +1222,8 @@ monitor_fetch_register (regno) if ((c == '0') && ((c = readchar (timeout)) == 'x')) ; else - error ("Bad value returned from monitor while fetching register %x.", - regno); + error ("Bad value returned from monitor while fetching register %x.", + regno); } /* Read upto the maximum number of hex digits for this register, skipping @@ -933,6 +1244,7 @@ monitor_fetch_register (regno) } 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 @@ -941,42 +1253,63 @@ monitor_fetch_register (regno) if (current_monitor->getreg.term) { - monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */ + monitor_debug ("EXP getreg.term\n"); + monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */ + } - if (current_monitor->getreg.term_cmd) - { - monitor_printf (current_monitor->getreg.term_cmd); - monitor_expect_prompt (NULL, 0); - } + if (current_monitor->getreg.term_cmd) + { + monitor_debug ("EMIT getreg.term.cmd\n"); + monitor_printf (current_monitor->getreg.term_cmd); } - else - monitor_expect_prompt (NULL, 0); /* get response */ + 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 () +static void +monitor_dump_regs (void) { - char buf[1024]; + char buf[TARGET_BUF_SIZE]; int resp_len; - - if (current_monitor->dump_registers) + if (current_monitor->dumpregs) + (*(current_monitor->dumpregs)) (); /* call supplied function */ + else if (current_monitor->dump_registers) /* default version */ { monitor_printf (current_monitor->dump_registers); resp_len = monitor_expect_prompt (buf, sizeof (buf)); parse_register_dump (buf, resp_len); } else - abort(); /* Need some way to read registers */ + internal_error (__FILE__, __LINE__, "failed internal consistency check"); /* Need some way to read registers */ } static void -monitor_fetch_registers (regno) - int regno; +monitor_fetch_registers (int regno) { - if (current_monitor->getreg.cmd) + monitor_debug ("MON fetchregs\n"); + if (current_monitor->getreg.cmd) { if (regno >= 0) { @@ -987,46 +1320,69 @@ monitor_fetch_registers (regno) for (regno = 0; regno < NUM_REGS; regno++) monitor_fetch_register (regno); } - else { - monitor_dump_regs (); - } + else + { + monitor_dump_regs (); + } } /* Store register REGNO, or all if REGNO == 0. Return errno value. */ static void -monitor_store_register (regno) - int regno; +monitor_store_register (int regno) { char *name; - unsigned int val; + ULONGEST val; name = current_monitor->regnames[regno]; - if (!name) - return; + 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 */ + /* 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); -/* It's possible that there are actually some monitors out there that - will prompt you when you set a register. In that case, you may - need to add some code here to deal with TERM and TERM_CMD (see - monitor_fetch_register to get an idea of what's needed...) */ - - monitor_expect_prompt (NULL, 0); -} + if (current_monitor->setreg.resp_delim) + { + monitor_debug ("EXP setreg.resp_delim\n"); + monitor_expect_regexp (&setreg_resp_delim_pattern, NULL, 0); + if (current_monitor->flags & MO_SETREG_INTERACTIVE) + monitor_printf ("%s\r", paddr_nz (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 (regno) - int regno; +monitor_store_registers (int regno) { if (regno >= 0) { @@ -1045,28 +1401,29 @@ monitor_store_registers (regno) debugged. */ static void -monitor_prepare_to_store () +monitor_prepare_to_store (void) { /* Do nothing, since we can store individual regs */ } static void -monitor_files_info (ops) - struct target_ops *ops; +monitor_files_info (struct target_ops *ops) { printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate); } static int -monitor_write_memory (memaddr, myaddr, len) - CORE_ADDR memaddr; - char *myaddr; - int len; +monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len) { - unsigned int val; + unsigned int val, hostval; char *cmd; int i; + 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) @@ -1077,8 +1434,9 @@ monitor_write_memory (memaddr, myaddr, len) 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, 0); + monitor_printf (current_monitor->fill, memaddr, (memaddr + i) - 1, 0); else monitor_printf (current_monitor->fill, memaddr, i, 0); @@ -1115,8 +1473,38 @@ monitor_write_memory (memaddr, myaddr, len) 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.resp_delim) + { + monitor_debug ("EXP setmem.resp_delim"); + monitor_expect_regexp (&setmem_resp_delim_pattern, NULL, 0); + monitor_printf ("%x\r", val); + } + 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); @@ -1125,21 +1513,213 @@ monitor_write_memory (memaddr, myaddr, len) return len; } + +static int +monitor_write_even_block (CORE_ADDR memaddr, char *myaddr, int len) +{ + 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; + /* 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; +} + + +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; + } + 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 (memaddr, myaddr, len) - CORE_ADDR memaddr; - char *myaddr; - int len; +monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len) { unsigned int val; - char membuf[sizeof(int) * 2 + 1]; + 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 @@ -1176,13 +1756,16 @@ monitor_read_memory_single (memaddr, myaddr, len) searching from the start of the buf. */ if (current_monitor->getmem.resp_delim) - monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0); + { + 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) + if (current_monitor->flags & MO_HEX_PREFIX) { int c; @@ -1192,29 +1775,33 @@ monitor_read_memory_single (memaddr, myaddr, len) if ((c == '0') && ((c = readchar (timeout)) == 'x')) ; else - error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.", - memaddr, i, membuf, c); + monitor_error ("monitor_read_memory_single", + "bad response from monitor", + memaddr, 0, NULL, 0); } - for (i = 0; i < len * 2; i++) - { - int c; - - while (1) - { - c = readchar (timeout); - if (isxdigit (c)) - break; - if (c == ' ') - continue; - - error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.", - memaddr, i, membuf, c); - } + { + int i; + 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, 0); + } membuf[i] = c; } - - membuf[i] = '\000'; /* terminate the number */ + 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 @@ -1222,7 +1809,7 @@ monitor_read_memory_single (memaddr, myaddr, len) if (current_monitor->getmem.term) { - monitor_expect (current_monitor->getmem.term, NULL, 0); /* get response */ + monitor_expect (current_monitor->getmem.term, NULL, 0); /* get response */ if (current_monitor->getmem.term_cmd) { @@ -1231,14 +1818,15 @@ monitor_read_memory_single (memaddr, myaddr, len) } } else - monitor_expect_prompt (NULL, 0); /* get response */ + monitor_expect_prompt (NULL, 0); /* get response */ p = membuf; val = strtoul (membuf, &p, 16); if (val == 0 && membuf == p) - error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.", - memaddr, membuf); + monitor_error ("monitor_read_memory_single", + "bad value from monitor", + memaddr, 0, membuf, 0); /* supply register stores in target byte order, so swap here */ @@ -1247,29 +1835,45 @@ monitor_read_memory_single (memaddr, myaddr, len) return len; } -/* Copy LEN bytes of data from debugger memory at MYADDR to inferior's memory - at MEMADDR. Returns length moved. Currently, we only do one byte at a - time. */ +/* 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 (memaddr, myaddr, len) - CORE_ADDR memaddr; - char *myaddr; - int len; +monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len) { unsigned int val; - unsigned char regbuf[MAX_REGISTER_RAW_SIZE]; char buf[512]; char *p, *p1; - char *name; 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; @@ -1277,7 +1881,9 @@ monitor_read_memory (memaddr, myaddr, len) /* send the memory examine command */ if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE) - monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len - 1); + 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); @@ -1288,21 +1894,22 @@ monitor_read_memory (memaddr, myaddr, len) if (current_monitor->getmem.term) { - resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf); /* get response */ + resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf); /* get response */ if (resp_len <= 0) - error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.", - memaddr, resp_len, buf); + 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, + 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 */ + resp_len = monitor_expect_prompt (buf, sizeof buf); /* get response */ p = buf; @@ -1314,24 +1921,63 @@ monitor_read_memory (memaddr, myaddr, len) { 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) - error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.", - memaddr, resp_len, buf); + 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) - error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.", - memaddr, resp_len, buf); + 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--) { @@ -1341,16 +1987,20 @@ monitor_read_memory (memaddr, myaddr, len) { if (isxdigit (*p)) break; + if (*p == '\000' || *p == '\n' || *p == '\r') - error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s", memaddr, resp_len, buf); + 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) - error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.", memaddr, - resp_len, buf); + monitor_error ("monitor_read_memory", + "bad value from monitor", + memaddr, resp_len, buf, 0); *myaddr++ = val; @@ -1363,31 +2013,43 @@ monitor_read_memory (memaddr, myaddr, len) 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 (memaddr, myaddr, len, write, target) - CORE_ADDR memaddr; - char *myaddr; - int len; - int write; - struct target_ops *target; /* ignored */ +monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, + struct mem_attrib *attrib ATTRIBUTE_UNUSED, + struct target_ops *target ATTRIBUTE_UNUSED) { - return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, write); + int res; + + if (write) + { + if (current_monitor->flags & MO_HAS_BLOCKWRITES) + res = monitor_write_memory_block(memaddr, myaddr, len); + else + res = monitor_write_memory(memaddr, myaddr, len); + } + else + { + res = monitor_read_memory(memaddr, myaddr, len); + } + + return res; } static void -monitor_kill () +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 (exec_file, args, env) - char *exec_file; - char *args; - char **env; +monitor_create_inferior (char *exec_file, char *args, char **env) { if (args && (*args != '\000')) error ("Args are not supported by the monitor."); @@ -1403,71 +2065,79 @@ monitor_create_inferior (exec_file, args, env) instructions. */ static void -monitor_mourn_inferior () +monitor_mourn_inferior (void) { unpush_target (targ_ops); generic_mourn_inferior (); /* Do all the proper things now */ } -#define NUM_MONITOR_BREAKPOINTS 8 - -static CORE_ADDR breakaddr[NUM_MONITOR_BREAKPOINTS] = {0}; - /* Tell the monitor to add a breakpoint. */ static int -monitor_insert_breakpoint (addr, shadow) - CORE_ADDR addr; - char *shadow; +monitor_insert_breakpoint (CORE_ADDR addr, char *shadow) { int i; - /* This is only used to compute the size of a breakpoint. */ -#ifdef BREAKPOINT - static unsigned char break_insn[] = BREAKPOINT; -#else - /* In the bi-endian case we assume breakpoints are the same size. */ - static unsigned char break_insn[] = BIG_BREAKPOINT; -#endif + 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); - for (i = 0; i < NUM_MONITOR_BREAKPOINTS; i++) + /* 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, sizeof (break_insn)); + monitor_read_memory (addr, shadow, bplen); monitor_printf (current_monitor->set_break, addr); monitor_expect_prompt (NULL, 0); return 0; } } - error ("Too many breakpoints (> %d) for monitor.", NUM_MONITOR_BREAKPOINTS); + error ("Too many breakpoints (> %d) for monitor.", current_monitor->num_breakpoints); } /* Tell the monitor to remove a breakpoint. */ static int -monitor_remove_breakpoint (addr, shadow) - CORE_ADDR addr; - char *shadow; +monitor_remove_breakpoint (CORE_ADDR addr, char *shadow) { int i; - for (i = 0; i < NUM_MONITOR_BREAKPOINTS; i++) + 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) + 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 (stderr, "Can't find breakpoint associated with 0x%x\n", addr); + fprintf_unfiltered (gdb_stderr, + "Can't find breakpoint associated with 0x%s\n", + paddr_nz (addr)); return 1; } @@ -1475,72 +2145,99 @@ monitor_remove_breakpoint (addr, shadow) an S-record. Return non-zero if the ACK is received properly. */ static int -monitor_wait_srec_ack () +monitor_wait_srec_ack (void) { - /* FIXME: eventually we'll want to be able to handle acknowledgements - of something other than a '+' character. Right now this is only - going to work for EST visionICE. */ - return readchar (timeout) == '+'; + 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; + } + return 1; } /* monitor_load -- download a file. */ static void -monitor_load (file, from_tty) - char *file; - int from_tty; +monitor_load (char *file, int from_tty) { - dcache_flush (remote_dcache); + 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); -/* FIXME Should add arg here for load_offset (already done for generic_load) */ - load_srec (monitor_desc, file, 32, SREC_ALL, hashmark, + load_srec (monitor_desc, file, (bfd_vma) load_offset, + 32, SREC_ALL, hashmark, current_monitor->flags & MO_SREC_ACK ? - monitor_wait_srec_ack : NULL); + monitor_wait_srec_ack : NULL); monitor_expect_prompt (NULL, 0); } -/* Finally, make the PC point at the start address */ - + /* Finally, make the PC point at the start address */ if (exec_bfd) write_pc (bfd_get_start_address (exec_bfd)); - inferior_pid = 0; /* No process now */ - -/* This is necessary because many things were based on the PC at the time that - we attached to the monitor, which is no longer valid now that we have loaded - new code (and just changed the PC). Another way to do this might be to call - normal_stop, except that the stack may not be valid, and things would get - horribly confused... */ - - clear_symtab_users (); + /* There used to be code here which would clear inferior_ptid and + call clear_symtab_users. None of that should be necessary: + monitor targets should behave like remote protocol targets, and + since generic_load does none of those things, this function + shouldn't either. + + Furthermore, clearing inferior_ptid is *incorrect*. After doing + a load, we still have a valid connection to the monitor, with a + live processor state to fiddle with. The user can type + `continue' or `jump *start' and make the program run. If they do + these things, however, GDB will be talking to a running program + while inferior_ptid is null_ptid; this makes things like + reinit_frame_cache very confused. */ } static void -monitor_stop () +monitor_stop (void) { + monitor_debug ("MON stop\n"); if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0) - SERIAL_SEND_BREAK (monitor_desc); + serial_send_break (monitor_desc); if (current_monitor->stop) monitor_printf_noecho (current_monitor->stop); } -/* Put a command string, in args, out to MONITOR. Output from MONITOR - is placed on the users terminal until the prompt is seen. FIXME: We - read the characters ourseleves here cause of a nasty echo. */ +/* 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_command (args, from_tty) - char *args; - int from_tty; +monitor_rcmd (char *command, + struct ui_file *outbuf) { char *p; int resp_len; @@ -1554,19 +2251,19 @@ monitor_command (args, from_tty) /* Send the command. Note that if no args were supplied, then we're just sending the monitor a newline, which is sometimes useful. */ - monitor_printf ("%s\r", (args ? args : "")); + monitor_printf ("%s\r", (command ? command : "")); resp_len = monitor_expect_prompt (buf, sizeof buf); - fputs_unfiltered (buf, gdb_stdout); /* Output the response */ + fputs_unfiltered (buf, outbuf); /* Output the response */ } /* Convert hex digit A to a number. */ +#if 0 static int -from_hex (a) - int a; -{ +from_hex (int a) +{ if (a >= '0' && a <= '9') return a - '0'; if (a >= 'a' && a <= 'f') @@ -1576,72 +2273,113 @@ from_hex (a) error ("Reply contains invalid hex digit 0x%x", a); } +#endif + +char * +monitor_get_dev_name (void) +{ + return dev_name; +} -static struct target_ops monitor_ops = +static struct target_ops monitor_ops; + +static void +init_base_monitor_ops (void) { - NULL, /* to_shortname */ - NULL, /* to_longname */ - NULL, /* to_doc */ - NULL, /* to_open */ - monitor_close, /* to_close */ - NULL, /* to_attach */ - monitor_detach, /* to_detach */ - monitor_resume, /* to_resume */ - monitor_wait, /* to_wait */ - monitor_fetch_registers, /* to_fetch_registers */ - monitor_store_registers, /* to_store_registers */ - monitor_prepare_to_store, /* to_prepare_to_store */ - monitor_xfer_memory, /* to_xfer_memory */ - monitor_files_info, /* to_files_info */ - monitor_insert_breakpoint, /* to_insert_breakpoint */ - monitor_remove_breakpoint, /* to_remove_breakpoint */ - 0, /* to_terminal_init */ - 0, /* to_terminal_inferior */ - 0, /* to_terminal_ours_for_output */ - 0, /* to_terminal_ours */ - 0, /* to_terminal_info */ - monitor_kill, /* to_kill */ - monitor_load, /* to_load */ - 0, /* to_lookup_symbol */ - monitor_create_inferior, /* to_create_inferior */ - monitor_mourn_inferior, /* to_mourn_inferior */ - 0, /* to_can_run */ - 0, /* to_notice_signals */ - 0, /* to_thread_alive */ - monitor_stop, /* to_stop */ - process_stratum, /* to_stratum */ - 0, /* to_next */ - 1, /* to_has_all_memory */ - 1, /* to_has_memory */ - 1, /* to_has_stack */ - 1, /* to_has_registers */ - 1, /* to_has_execution */ - 0, /* sections */ - 0, /* sections_end */ - OPS_MAGIC /* to_magic */ -}; + 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_stratum = process_stratum; + monitor_ops.DONT_USE = 0; + monitor_ops.to_has_all_memory = 1; + monitor_ops.to_has_memory = 1; + monitor_ops.to_has_stack = 1; + monitor_ops.to_has_registers = 1; + monitor_ops.to_has_execution = 1; + monitor_ops.to_sections = 0; + monitor_ops.to_sections_end = 0; + monitor_ops.to_magic = OPS_MAGIC; +} /* init_base_monitor_ops */ /* Init the target_ops structure pointed at by OPS */ void -init_monitor_ops (ops) - struct target_ops *ops; +init_monitor_ops (struct target_ops *ops) { + if (monitor_ops.to_magic != OPS_MAGIC) + init_base_monitor_ops (); + memcpy (ops, &monitor_ops, sizeof monitor_ops); } /* Define additional commands that are usually only used by monitors. */ void -_initialize_remote_monitors () +_initialize_remote_monitors (void) { + 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 hashmark \'#\' is displayed.", - &setlist), + &setlist), &showlist); - add_com ("monitor", class_obscure, monitor_command, - "Send a command to the debug monitor."); + add_show_from_set + (add_set_cmd ("monitor", no_class, var_zinteger, + (char *) &monitor_debug_p, + "Set debugging of remote monitor communication.\n\ +When enabled, communication between GDB and the remote monitor\n\ +is displayed.", &setdebuglist), + &showdebuglist); }