diff options
Diffstat (limited to 'gdb/monitor.c')
| -rw-r--r-- | gdb/monitor.c | 2296 |
1 files changed, 2296 insertions, 0 deletions
diff --git a/gdb/monitor.c b/gdb/monitor.c new file mode 100644 index 00000000000..dc47d8c02f3 --- /dev/null +++ b/gdb/monitor.c @@ -0,0 +1,2296 @@ +/* Remote debugging interface for boot monitors, for GDB. + Copyright 1990, 1991, 1992, 1993, 1995, 1996, 1997, 1999 + 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 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. + +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. + + This module talks to a debug monitor called 'MONITOR', which + We communicate with MONITOR via either a direct serial line, or a TCP + (or possibly TELNET) stream to a terminal multiplexor, + which in turn talks to the target board. */ + +/* FIXME 32x64: This code assumes that registers and addresses are at + most 32 bits long. If they can be larger, you will need to declare + values as LONGEST and use %llx or some such to print values when + building commands to send to the monitor. Since we don't know of + any actual 64-bit targets with ROM monitors that use this code, + it's not an issue right now. -sts 4/18/96 */ + +#include "defs.h" +#include "gdbcore.h" +#include "target.h" +#include "wait.h" +#ifdef ANSI_PROTOTYPES +#include <stdarg.h> +#else +#include <varargs.h> +#endif +#include <signal.h> +#include <ctype.h> +#include "gdb_string.h" +#include <sys/types.h> +#include "command.h" +#include "serial.h" +#include "monitor.h" +#include "gdbcmd.h" +#include "inferior.h" +#include "gnu-regex.h" +#include "dcache.h" +#include "srec.h" + +static char *dev_name; +static struct target_ops *targ_ops; + +static void monitor_vsprintf PARAMS ((char *sndbuf, char *pattern, va_list args)); + +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 int monitor_printable_string PARAMS ((char *newstr, char *oldstr)); +static void monitor_error PARAMS ((char *format, CORE_ADDR memaddr, int len, char *string, int final_char)); +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 ((void *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 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_write_memory_bytes PARAMS ((CORE_ADDR addr, + char *myaddr,int len)); +static int monitor_write_memory_block PARAMS(( + CORE_ADDR memaddr , + char * myaddr , + int len)) ; +static int monitor_expect_regexp PARAMS ((struct re_pattern_buffer *pat, + char *buf, int buflen)); +static void monitor_dump_regs PARAMS((void)) ; +#if 0 +static int from_hex PARAMS ((int a)); +static unsigned long get_hex_word PARAMS ((void)); +#endif +static void parse_register_dump PARAMS ((char *, int)); + +static struct monitor_ops *current_monitor; + +static int hashmark; /* flag set by "set hash" */ + +static int timeout = 30; + +static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait() */ + +static void (*ofunc)(); /* Old SIGINT signal handler */ + +/* Extra remote debugging for developing a new rom monitor variation */ +#if ! defined(EXTRA_RDEBUG) +#define EXTRA_RDEBUG 0 +#endif +#define RDEBUG(stuff) { if (EXTRA_RDEBUG && remote_debug) printf stuff ; } + +/* 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; + +/* Pointer to regexp pattern matching data */ + +static struct re_pattern_buffer register_pattern; +static char register_fastmap[256]; + +static struct re_pattern_buffer getmem_resp_delim_pattern; +static char getmem_resp_delim_fastmap[256]; + +static int dump_reg_flag; /* Non-zero means do a dump_registers cmd when + monitor_wait wakes up. */ + +static DCACHE *remote_dcache; +static int first_time=0; /* is this the first time we're executing after + gaving created the child proccess? */ + +/* Convert a string into a printable representation, Return # byte in the + new string. */ + +static int +monitor_printable_string (newstr, oldstr) + char *newstr; + char *oldstr; +{ + char *save = newstr; + int ch; + + while ((ch = *oldstr++) != '\0') + { + 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; + } + } + + *newstr++ = '\0'; + return newstr - save; +} + +/* Print monitor errors with a string, converting the string to printable + representation. */ + +static void +monitor_error (format, memaddr, len, string, final_char) + char *format; + 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); + char *p, *q; + int ch; + int safe_len = monitor_printable_string (safe_string, string); + + if (final_char) + error (format, (int)memaddr, p - safe_string, safe_string, final_char); + else + error (format, (int)memaddr, p - safe_string, safe_string); +} + +/* Convert hex digit A to a number. */ + +static int +fromhex (a) + 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); +} + +/* 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 (sndbuf, pattern, args) + 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 +{ + 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 + + monitor_vsprintf (sndbuf, pattern, args); + + len = strlen (sndbuf); + if (len + 1 > sizeof sndbuf) + abort (); + +#if 0 + if (remote_debug > 0) + puts_debug ("sent -->", sndbuf, "<--"); +#endif + if (EXTRA_RDEBUG + && remote_debug) + { + char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1); + monitor_printable_string (safe_string, sndbuf); + printf ("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 +{ + 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 + + monitor_vsprintf (sndbuf, pattern, args); + + len = strlen (sndbuf); + if (len + 1 > sizeof sndbuf) + abort (); + +#if 0 + if (remote_debug > 0) + puts_debug ("sent -->", sndbuf, "<--"); +#endif + if (EXTRA_RDEBUG + && remote_debug) + { + char *safe_string = (char *) alloca ((len * 4) + 1); + monitor_printable_string (safe_string, sndbuf); + printf ("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. */ + RDEBUG(("ExpectEcho\n")) + monitor_expect (sndbuf, (char *)0, 0); +} + + +/* Write characters to the remote system. */ + +void +monitor_write (buf, buflen) + 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 () +{ + 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; +{ + 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; +#if 0 + /* This seems to interfere with proper function of the + input stream */ + if (remote_debug > 0) + { + char buf[2]; + buf[0] = c; + buf[1] = '\0'; + puts_debug ("read -->", buf, "<--"); + } + +#endif + } + + /* Canonicialize \n\r combinations into one \r */ + if ((current_monitor->flags & MO_HANDLE_NL) != 0) + { + if ((c == '\r' && state == last_nl) + || (c == '\n' && state == last_cr)) + { + state = last_crnl; + looping = 1; + } + else if (c == '\r') + state = last_cr; + else if (c != '\n') + state = last_random; + else + { + state = last_nl; + c = '\r'; + } + } + } + while (looping); + + if (c >= 0) + return c; + + if (c == SERIAL_TIMEOUT) +#if 0 /* MAINTENANCE_CMDS */ + /* I fail to see how detaching here can be useful */ + if (in_monitor_wait) /* Watchdog went off */ + { + target_mourn_inferior (); + error ("GDB serial timeout has expired. Target detached.\n"); + } + else +#endif + error ("Timeout reading from remote system."); + + perror_with_name ("remote-monitor"); +} + +/* Scan input from the remote system, until STRING is found. If BUF is non- + zero, then collect input until we have collected either STRING or BUFLEN-1 + chars. In either case we terminate BUF with a 0. If input overflows BUF + because STRING can't be found, return -1, else return number of chars in BUF + (minus the terminating NUL). Note that in the non-overflow case, STRING + will be at the end of BUF. */ + +int +monitor_expect (string, buf, buflen) + char *string; + char *buf; + int buflen; +{ + char *p = string; + int obuflen = buflen; + int c; + extern struct target_ops *targ_ops; + + if (EXTRA_RDEBUG + && remote_debug) + { + char *safe_string = (char *) alloca ((strlen (string) * 4) + 1); + monitor_printable_string (safe_string, string); + printf ("MON Expecting '%s'\n", safe_string); + } + + immediate_quit = 1; + while (1) + { + if (buf) + { + if (buflen < 2) + { + *buf = '\000'; + immediate_quit = 0; + return -1; + } + + c = readchar (timeout); + if (c == '\000') + continue; + *buf++ = c; + buflen--; + } + else + c = readchar (timeout); + + /* Don't expect any ^C sent to be echoed */ + + if (*p == '\003' || c == *p) + { + p++; + if (*p == '\0') + { + immediate_quit = 0; + + if (buf) + { + *buf++ = '\000'; + return obuflen - buflen; + } + else + return 0; + } + } + else if ((c == '\021' || c == '\023') && + (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++; + } + } +} + +/* Search for a regexp. */ + +static int +monitor_expect_regexp (pat, buf, buflen) + struct re_pattern_buffer *pat; + char *buf; + int buflen; +{ + char *mybuf; + char *p; + RDEBUG(("MON Expecting regexp\n")) ; + if (buf) + mybuf = buf; + else + { + mybuf = alloca (1024); + buflen = 1024; + } + + p = mybuf; + while (1) + { + int retval; + + if (p - mybuf >= buflen) + { /* Buffer about to overflow */ + +/* On overflow, we copy the upper half of the buffer to the lower half. Not + great, but it usually works... */ + + memcpy (mybuf, mybuf + buflen / 2, buflen / 2); + p = mybuf + buflen / 2; + } + + *p++ = readchar (timeout); + + retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL); + if (retval >= 0) + return 1; + } +} + +/* Keep discarding input until we see the MONITOR prompt. + + The convention for dealing with the prompt is that you + o give your command + o *then* wait for the prompt. + + Thus the last thing that a procedure does with the serial line will + be an monitor_expect_prompt(). Exception: monitor_resume does not + wait for the prompt, because the terminal is being handed over to + the inferior. However, the next thing which happens after that is + a monitor_wait which does wait for the prompt. Note that this + includes abnormal exit, e.g. error(). This is necessary to prevent + getting into states from which we can't recover. */ + +int +monitor_expect_prompt (buf, buflen) + char *buf; + int buflen; +{ + RDEBUG(("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 () +{ + 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 + +static void +compile_pattern (pattern, compiled_pattern, fastmap) + char *pattern; + struct re_pattern_buffer *compiled_pattern; + char *fastmap; +{ + int tmp; + const char *val; + + compiled_pattern->fastmap = fastmap; + + tmp = re_set_syntax (RE_SYNTAX_EMACS); + val = re_compile_pattern (pattern, + strlen (pattern), + compiled_pattern); + re_set_syntax (tmp); + + if (val) + error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern, val); + + if (fastmap) + re_compile_fastmap (compiled_pattern); +} + +/* Open a connection to a remote debugger. NAME is the filename used + for communication. */ + +void +monitor_open (args, mon_ops, from_tty) + char *args; + struct monitor_ops *mon_ops; + int from_tty; +{ + char *name; + char **p; + + if (mon_ops->magic != MONITOR_OPS_MAGIC) + error ("Magic number of monitor_ops struct wrong."); + + targ_ops = mon_ops->target; + name = targ_ops->to_shortname; + + if (!args) + 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); + + target_preopen (from_tty); + + /* Setup pattern for register dump */ + + if (mon_ops->register_pattern) + compile_pattern (mon_ops->register_pattern, ®ister_pattern, + register_fastmap); + + if (mon_ops->getmem.resp_delim) + compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern, + getmem_resp_delim_fastmap); + + unpush_target (targ_ops); + + if (dev_name) + free (dev_name); + dev_name = strsave (args); + + monitor_desc = SERIAL_OPEN (dev_name); + + if (!monitor_desc) + perror_with_name (dev_name); + + if (baud_rate != -1) + { + if (SERIAL_SETBAUDRATE (monitor_desc, baud_rate)) + { + SERIAL_CLOSE (monitor_desc); + perror_with_name (dev_name); + } + } + + SERIAL_RAW (monitor_desc); + + SERIAL_FLUSH_INPUT (monitor_desc); + + /* some systems only work with 2 stop bits */ + + SERIAL_SETSTOPBITS (monitor_desc, mon_ops->stopbits); + + current_monitor = mon_ops; + + /* See if we can wake up the monitor. First, try sending a stop sequence, + then send the init strings. Last, remove all breakpoints. */ + + if (current_monitor->stop) + { + monitor_stop (); + if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0) + { + RDEBUG(("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. */ + + 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); + + /* 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_unfiltered ("Remote target %s connected to %s\n", name, dev_name); + + push_target (targ_ops); + + inferior_pid = 42000; /* Make run command think we are busy... */ + + /* Give monitor_wait something to read */ + + monitor_printf (current_monitor->line_term); + + if (current_monitor->flags & MO_HAS_BLOCKWRITES) + remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory_block); + else + remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory); + start_remote (); +} + +/* Close out all files and local state before this target loses + control. */ + +void +monitor_close (quitting) + int quitting; +{ + if (monitor_desc) + SERIAL_CLOSE (monitor_desc); + monitor_desc = NULL; +} + +/* Terminate the open connection to the remote debugger. Use this + when you want to detach and do something else with your gdb. */ + +static void +monitor_detach (args, from_tty) + char *args; + int from_tty; +{ + pop_target (); /* calls monitor_close to do the real work */ + if (from_tty) + printf_unfiltered ("Ending remote %s debugging\n", target_shortname); +} + +/* Convert VALSTR into the target byte-ordered value of REGNO and store it. */ + +char * +monitor_supply_register (regno, valstr) + int regno; + char *valstr; +{ + unsigned int val; + unsigned char regbuf[MAX_REGISTER_RAW_SIZE]; + char *p; + + val = strtoul (valstr, &p, 16); + RDEBUG(("Supplying Register %d %s\n",regno,valstr)) ; + + if (val == 0 && valstr == p) + error ("monitor_supply_register (%d): bad value from monitor: %s.", + regno, valstr); + + /* supply register stores in target byte order, so swap here */ + + store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val); + + supply_register (regno, regbuf); + + return p; +} + +/* Tell the remote machine to resume. */ + +void +flush_monitor_dcache () +{ + dcache_flush (remote_dcache); +} + +static void +monitor_resume (pid, step, sig) + int pid, step; + enum target_signal sig; +{ + /* Some monitors require a different command when starting a program */ + RDEBUG(("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; + } + dcache_flush (remote_dcache); + 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; + } +} + +/* 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. */ + +static void +parse_register_dump (buf, len) + char *buf; + int len; +{ + RDEBUG(("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]; + } +} + +/* Send ^C to target to halt it. Target will respond, and send us a + packet. */ + +static void +monitor_interrupt (signo) + 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"); + + target_stop (); +} + +/* The user typed ^C twice. */ + +static void +monitor_interrupt_twice (signo) + int signo; +{ + signal (signo, ofunc); + + monitor_interrupt_query (); + + signal (signo, monitor_interrupt); +} + +/* Ask the user what to do when an interrupt is received. */ + +static void +monitor_interrupt_query () +{ + target_terminal_ours (); + + if (query ("Interrupted while waiting for the program.\n\ +Give up (and stop debugging it)? ")) + { + target_mourn_inferior (); + return_to_top_level (RETURN_QUIT); + } + + target_terminal_inferior (); +} + +static void +monitor_wait_cleanup (old_timeout) + void *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 (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; +{ + int old_timeout = timeout; + char buf[1024]; + int resp_len; + struct cleanup *old_chain; + + status->kind = TARGET_WAITKIND_EXITED; + status->value.integer = 0; + + old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout); + RDEBUG(("MON wait\n")) + +#if 0 /* MAINTENANCE_CMDS */ + /* 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 (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 + RDEBUG(("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 (regno) + int regno; +{ + char *name; + static char zerobuf[MAX_REGISTER_RAW_SIZE] = {0}; + char regbuf[MAX_REGISTER_RAW_SIZE * 2 + 1]; + int i; + + name = current_monitor->regnames[regno]; + RDEBUG(("MON fetchreg %d '%s'\n",regno,name)) + + if (!name || (*name == '\0')) + { RDEBUG(("No register known for %d\n",regno)) + supply_register (regno, zerobuf); + return; + } + + /* 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) + { + RDEBUG(("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 == 1 && regno < 32) + { RDEBUG(("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 */ + RDEBUG(("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) + { + RDEBUG(("EXP getreg.term\n")) + monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */ + } + + if (current_monitor->getreg.term_cmd) + { RDEBUG(("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[1024]; + 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 () +{ + char buf[1024]; + int resp_len; + if (current_monitor->dumpregs) + (*(current_monitor->dumpregs))() ; /* call supplied function */ + else + if (current_monitor->dump_registers) /* default version */ + { monitor_printf (current_monitor->dump_registers); + resp_len = monitor_expect_prompt (buf, sizeof (buf)); + parse_register_dump (buf, resp_len); + } + else + abort(); /* Need some way to read registers */ +} + +static void +monitor_fetch_registers (regno) + int regno; +{ + RDEBUG(("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 (regno) + int regno; +{ + char *name; + unsigned int val; + + name = current_monitor->regnames[regno]; + if (!name || (*name == '\0')) + { RDEBUG(("MON Cannot store unknown register\n")) + return; + } + + val = read_register (regno); + RDEBUG(("MON storeg %d %08x\n",regno,(unsigned int)val)) + + /* 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) + { RDEBUG(("EXP setreg.term\n")) + monitor_expect (current_monitor->setreg.term, NULL, 0); + if (current_monitor->flags & MO_SETREG_INTERACTIVE) + monitor_printf ("%x\r", val); + monitor_expect_prompt (NULL, 0); + } + else + monitor_expect_prompt (NULL, 0); + if (current_monitor->setreg.term_cmd) /* Mode exit required */ + { RDEBUG(("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; +{ + 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 + individual registers, this doesn't need to do anything. On machines + which store all the registers in one fell swoop, this makes sure + that registers contains all the registers from the program being + debugged. */ + +static void +monitor_prepare_to_store () +{ + /* Do nothing, since we can store individual regs */ +} + +static void +monitor_files_info (ops) + 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; +{ + unsigned int val, hostval ; + char *cmd; + int i; + + RDEBUG(("MON write %d %08x\n",len,(unsigned long)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 */ + { + RDEBUG(("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 ; + RDEBUG(("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) + { RDEBUG(("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; +} + + +static int +monitor_write_even_block(memaddr,myaddr,len) + 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 ; + RDEBUG((" @ %08x\n",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(memaddr,myaddr,len) + 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(memaddr,myaddr,len) + 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(memaddr,myaddr,len) + 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; +{ + unsigned int val; + char membuf[sizeof(int) * 2 + 1]; + char *p; + char *cmd; + int i; + + RDEBUG(("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) + { RDEBUG(("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 (0x%x): bad response from monitor: %.*s%c.", + memaddr, i, membuf, c); + } + for (i = 0; i < len * 2; i++) + { + int c; + + while (1) + { + c = readchar (timeout); + if (isxdigit (c)) + break; + if (c == ' ') + continue; + + monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.", + memaddr, i, membuf, c); + } + + membuf[i] = c; + } + + membuf[i] = '\000'; /* terminate the number */ + +/* If TERM is present, we wait for that to show up. Also, (if TERM is + present), we will send TERM_CMD if that is present. In any case, we collect + all of the output into buf, and then wait for the normal prompt. */ + + if (current_monitor->getmem.term) + { + monitor_expect (current_monitor->getmem.term, NULL, 0); /* get response */ + + if (current_monitor->getmem.term_cmd) + { + monitor_printf (current_monitor->getmem.term_cmd); + monitor_expect_prompt (NULL, 0); + } + } + else + monitor_expect_prompt (NULL, 0); /* get response */ + + p = membuf; + val = strtoul (membuf, &p, 16); + + if (val == 0 && membuf == p) + monitor_error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.", + memaddr, 0, membuf, 0); + + /* supply register stores in target byte order, so swap here */ + + store_unsigned_integer (myaddr, len, val); + + return len; +} + +/* 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; +{ + unsigned int val; + char buf[512]; + char *p, *p1; + int resp_len; + int i; + CORE_ADDR dumpaddr; + + if (len <= 0) + { + RDEBUG (("Zero length call to monitor_read_memory\n")); + return 0; + } + + if (remote_debug) printf("MON read block ta(%08x) ha(%08x) %d\n", + (unsigned long) memaddr , (unsigned 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 - 1); + 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 (0x%x): excessive response from monitor: %.*s.", + 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; + RDEBUG(("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 (0x%x): bad response from monitor: %.*s.", + 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 (0x%x): bad response from monitor: %.*s.", + memaddr, resp_len, buf, 0); + p += strlen (current_monitor->getmem.resp_delim); +#endif + } + if (remote_debug) printf("MON scanning %d ,%08x '%s'\n",len,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 (remote_debug) printf("[%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 (remote_debug) printf("\n") ; + return fetched ; /* Return the number of bytes actually read */ + } + RDEBUG(("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 (0x%x): badly terminated response from monitor: %.*s", + memaddr, resp_len, buf, 0); + p++; + } + + val = strtoul (p, &p1, 16); + + if (val == 0 && p == p1) + monitor_error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.", + memaddr, resp_len, buf, 0); + + *myaddr++ = val; + + if (i == 1) + break; + + p = p1; + } + + return len; +} + +static int +monitor_xfer_memory (memaddr, myaddr, len, write, target) + CORE_ADDR memaddr; + char *myaddr; + int len; + int write; + struct target_ops *target; /* ignored */ +{ + return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, write); +} + +static void +monitor_kill () +{ + return; /* ignore attempts to kill target system */ +} + +/* All we actually do is set the PC to the start address of exec_bfd, and start + the program at that point. */ + +static void +monitor_create_inferior (exec_file, args, env) + char *exec_file; + char *args; + char **env; +{ + if (args && (*args != '\000')) + error ("Args are not supported by the monitor."); + + first_time = 1; + clear_proceed_status (); + proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0); +} + +/* Clean up when a program exits. + The program actually lives on in the remote processor's RAM, and may be + run again without a download. Don't leave it full of breakpoint + instructions. */ + +static void +monitor_mourn_inferior () +{ + 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; +{ + int i; + unsigned char *bp; + int bplen; + + RDEBUG(("MON inst bkpt %08x\n",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 < NUM_MONITOR_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; + } + } + + error ("Too many breakpoints (> %d) for monitor.", NUM_MONITOR_BREAKPOINTS); +} + +/* Tell the monitor to remove a breakpoint. */ + +static int +monitor_remove_breakpoint (addr, shadow) + CORE_ADDR addr; + char *shadow; +{ + int i; + + RDEBUG(("MON rmbkpt %08x\n",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 < NUM_MONITOR_BREAKPOINTS; i++) + { + if (breakaddr[i] == addr) + { + breakaddr[i] = 0; + /* some monitors remove breakpoints based on the address */ + if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR) + monitor_printf (current_monitor->clr_break, addr); + else 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%x\n", 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. */ + +static int +monitor_wait_srec_ack () +{ + int i, 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; +{ + dcache_flush (remote_dcache); + RDEBUG(("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); + + load_srec (monitor_desc, file, (bfd_vma) load_offset, + 32, SREC_ALL, hashmark, + current_monitor->flags & MO_SREC_ACK ? + monitor_wait_srec_ack : NULL); + + monitor_expect_prompt (NULL, 0); + } + +/* Finally, make the PC point at the start address */ + + if (exec_bfd) + write_pc (bfd_get_start_address (exec_bfd)); + + inferior_pid = 0; /* No process now */ + +/* This is necessary because many things were based on the PC at the time that + we attached to the monitor, which is no longer valid now that we have loaded + new code (and just changed the PC). Another way to do this might be to call + normal_stop, except that the stack may not be valid, and things would get + horribly confused... */ + + clear_symtab_users (); +} + +static void +monitor_stop () +{ + RDEBUG(("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); +} + +/* Put a command string, in args, out to MONITOR. Output from MONITOR + is placed on the users terminal until the prompt is seen. FIXME: We + read the characters ourseleves here cause of a nasty echo. */ + +static void +monitor_command (args, from_tty) + char *args; + int from_tty; +{ + char *p; + int resp_len; + char buf[1000]; + + if (monitor_desc == NULL) + error ("monitor target not open."); + + p = current_monitor->prompt; + + /* Send the command. Note that if no args were supplied, then we're + just sending the monitor a newline, which is sometimes useful. */ + + monitor_printf ("%s\r", (args ? args : "")); + + resp_len = monitor_expect_prompt (buf, sizeof buf); + + fputs_unfiltered (buf, gdb_stdout); /* Output the response */ +} + +/* Convert hex digit A to a number. */ + +#if 0 +static int +from_hex (a) + int a; +{ + if (a >= '0' && a <= '9') + return a - '0'; + if (a >= 'a' && a <= 'f') + return a - 'a' + 10; + if (a >= 'A' && a <= 'F') + return a - 'A' + 10; + + error ("Reply contains invalid hex digit 0x%x", a); +} +#endif + +char * +monitor_get_dev_name () +{ + return dev_name; +} + +static struct target_ops monitor_ops; + +static void +init_base_monitor_ops (void) +{ + 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_pid_to_exec_file = NULL; + monitor_ops.to_core_file_to_sym_file = NULL; + monitor_ops.to_stratum = process_stratum; + monitor_ops.DONT_USE = 0; + monitor_ops.to_has_all_memory = 1; + monitor_ops.to_has_memory = 1; + monitor_ops.to_has_stack = 1; + monitor_ops.to_has_registers = 1; + monitor_ops.to_has_execution = 1; + monitor_ops.to_sections = 0; + monitor_ops.to_sections_end = 0; + monitor_ops.to_magic = OPS_MAGIC; +} /* init_base_monitor_ops */ + +/* Init the target_ops structure pointed at by OPS */ + +void +init_monitor_ops (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 () +{ + init_base_monitor_ops (); + add_show_from_set (add_set_cmd ("hash", no_class, var_boolean, + (char *)&hashmark, + "Set display of activity while downloading a file.\n\ +When enabled, a hashmark \'#\' is displayed.", + &setlist), + &showlist); + + add_com ("monitor", class_obscure, monitor_command, + "Send a command to the debug monitor."); +} + + |