X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fmonitor.c;h=5bff3d35fa6a87bf2c81341aa26a334fe4ff107f;hb=24b06219744627c597d799c1aafb2b2322ac3c3e;hp=3a50c9887aa7dbbe748c78cd96e58cf831fac375;hpb=4ce44c668ddc0a909c3f081d98c68bea90a93af9;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/monitor.c b/gdb/monitor.c index 3a50c9887a..5bff3d35fa 100644 --- a/gdb/monitor.c +++ b/gdb/monitor.c @@ -1,6 +1,8 @@ /* Remote debugging interface for boot monitors, for GDB. - Copyright 1990, 1991, 1992, 1993, 1995, 1996, 1997, 1999 - Free Software Foundation, Inc. + + Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, + 1999, 2000, 2001, 2002 Free Software Foundation, Inc. + Contributed by Cygnus Support. Written by Rob Savoye for Cygnus. Resurrected from the ashes by Stu Grossman. @@ -18,13 +20,13 @@ 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. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, 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 @@ -41,7 +43,7 @@ #include "defs.h" #include "gdbcore.h" #include "target.h" -#include "wait.h" +#include "exceptions.h" #include #include #include "gdb_string.h" @@ -51,58 +53,58 @@ #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 void monitor_vsprintf PARAMS ((char *sndbuf, char *pattern, va_list args)); +static void monitor_vsprintf (char *sndbuf, char *pattern, va_list args); -static int readchar PARAMS ((int timeout)); +static int readchar (int timeout); -static void monitor_fetch_register PARAMS ((int regno)); -static void monitor_store_register PARAMS ((int regno)); +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 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)); +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, gdb_byte *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, gdb_byte *shadow); +static int monitor_remove_breakpoint (CORE_ADDR addr, gdb_byte *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 PARAMS ((int a)); -static unsigned long get_hex_word PARAMS ((void)); +static int from_hex (int a); +static unsigned long get_hex_word (void); #endif -static void parse_register_dump PARAMS ((char *, int)); +static void parse_register_dump (char *, int); static struct monitor_ops *current_monitor; @@ -120,7 +122,7 @@ static CORE_ADDR *breakaddr; 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 */ @@ -130,10 +132,15 @@ 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? */ @@ -147,7 +154,7 @@ 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 + when determining if debug information is printed. Perhaps this could be simplified. */ static void @@ -238,16 +245,15 @@ monitor_error (char *function, char *message, monitor_printable_string (safe_string, string, real_len); if (final_char) - error ("%s (0x%s): %s: %s%c", function, paddr_nz (memaddr), message, safe_string, final_char); + 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); + error (_("%s (0x%s): %s: %s"), function, paddr_nz (memaddr), message, safe_string); } /* Convert hex digit A to a number. */ static int -fromhex (a) - int a; +fromhex (int a) { if (a >= '0' && a <= '9') return a - '0'; @@ -256,7 +262,7 @@ fromhex (a) else if (a >= 'A' && a <= 'F') return a - 'A' + 10; else - error ("Invalid hex digit %d", a); + error (_("Invalid hex digit %d"), a); } /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses @@ -274,10 +280,7 @@ fromhex (a) */ static void -monitor_vsprintf (sndbuf, pattern, args) - char *sndbuf; - char *pattern; - va_list args; +monitor_vsprintf (char *sndbuf, char *pattern, va_list args) { char format[10]; char fmt; @@ -343,7 +346,7 @@ monitor_printf_noecho (char *pattern,...) len = strlen (sndbuf); if (len + 1 > sizeof sndbuf) - abort (); + internal_error (__FILE__, __LINE__, _("failed internal consistency check")); if (monitor_debug_p) { @@ -371,7 +374,7 @@ monitor_printf (char *pattern,...) len = strlen (sndbuf); if (len + 1 > sizeof sndbuf) - abort (); + internal_error (__FILE__, __LINE__, _("failed internal consistency check")); if (monitor_debug_p) { @@ -394,12 +397,10 @@ monitor_printf (char *pattern,...) /* Write characters to the remote system. */ void -monitor_write (buf, buflen) - char *buf; - int buflen; +monitor_write (char *buf, int buflen) { - if (SERIAL_WRITE (monitor_desc, buf, buflen)) - fprintf_unfiltered (gdb_stderr, "SERIAL_WRITE failed: %s\n", + if (serial_write (monitor_desc, buf, buflen)) + fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n", safe_strerror (errno)); } @@ -409,7 +410,7 @@ monitor_write (buf, buflen) and without printing remote debug information. */ int -monitor_readchar () +monitor_readchar (void) { int c; int looping; @@ -417,7 +418,7 @@ monitor_readchar () do { looping = 0; - c = SERIAL_READCHAR (monitor_desc, timeout); + c = serial_readchar (monitor_desc, timeout); if (c >= 0) c &= 0xff; /* don't lose bit 7 */ @@ -428,9 +429,9 @@ monitor_readchar () return c; if (c == SERIAL_TIMEOUT) - error ("Timeout reading from remote system."); + error (_("Timeout reading from remote system.")); - perror_with_name ("remote-monitor"); + perror_with_name (_("remote-monitor")); } @@ -438,8 +439,7 @@ monitor_readchar () timeout stuff. */ static int -readchar (timeout) - int timeout; +readchar (int timeout) { int c; static enum @@ -452,7 +452,7 @@ readchar (timeout) do { looping = 0; - c = SERIAL_READCHAR (monitor_desc, timeout); + c = serial_readchar (monitor_desc, timeout); if (c >= 0) { @@ -500,13 +500,13 @@ readchar (timeout) if (in_monitor_wait) /* Watchdog went off */ { target_mourn_inferior (); - error ("GDB serial timeout has expired. Target detached.\n"); + error (_("GDB serial timeout has expired. Target detached.")); } else #endif - error ("Timeout reading from remote system."); + error (_("Timeout reading from remote system.")); - perror_with_name ("remote-monitor"); + perror_with_name (_("remote-monitor")); } /* Scan input from the remote system, until STRING is found. If BUF is non- @@ -517,15 +517,11 @@ 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; if (monitor_debug_p) { @@ -534,7 +530,7 @@ monitor_expect (string, buf, buflen) fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string); } - immediate_quit = 1; + immediate_quit++; while (1) { if (buf) @@ -542,7 +538,7 @@ monitor_expect (string, buf, buflen) if (buflen < 2) { *buf = '\000'; - immediate_quit = 0; + immediate_quit--; return -1; } @@ -562,7 +558,7 @@ monitor_expect (string, buf, buflen) p++; if (*p == '\0') { - immediate_quit = 0; + immediate_quit--; if (buf) { @@ -573,12 +569,6 @@ monitor_expect (string, buf, buflen) return 0; } } - else if ((c == '\021' || c == '\023') && - (STREQ (targ_ops->to_shortname, "m32r") - || STREQ (targ_ops->to_shortname, "mon2000"))) - { /* m32r monitor emits random DC1/DC3 chars */ - continue; - } else { /* We got a character that doesn't match the string. We need to @@ -625,10 +615,7 @@ 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; @@ -679,9 +666,7 @@ 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); @@ -692,7 +677,7 @@ monitor_expect_prompt (buf, buflen) #if 0 static unsigned long -get_hex_word () +get_hex_word (void) { unsigned long val; int i; @@ -717,10 +702,8 @@ get_hex_word () #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; const char *val; @@ -734,7 +717,7 @@ compile_pattern (pattern, compiled_pattern, fastmap) re_set_syntax (tmp); if (val) - error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern, val); + error (_("compile_pattern: Can't compile pattern string `%s': %s!"), pattern, val); if (fastmap) re_compile_fastmap (compiled_pattern); @@ -744,23 +727,20 @@ 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; char **p; if (mon_ops->magic != MONITOR_OPS_MAGIC) - error ("Magic number of monitor_ops struct wrong."); + 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); + 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); @@ -774,33 +754,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_raw (monitor_desc); - SERIAL_FLUSH_INPUT (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; @@ -830,7 +818,7 @@ monitor_open (args, mon_ops, from_tty) monitor_expect_prompt (NULL, 0); } - SERIAL_FLUSH_INPUT (monitor_desc); + serial_flush_input (monitor_desc); /* Alloc breakpoints */ if (mon_ops->set_break != NULL) @@ -851,20 +839,16 @@ monitor_open (args, mon_ops, from_tty) } if (from_tty) - printf_unfiltered ("Remote target %s connected to %s\n", name, dev_name); + printf_unfiltered (_("Remote target %s connected to %s\n"), name, dev_name); push_target (targ_ops); - inferior_pid = 42000; /* Make run command think we are busy... */ + 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); - 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 (); } @@ -872,16 +856,15 @@ 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) { - free (breakaddr); + xfree (breakaddr); breakaddr = NULL; } @@ -892,24 +875,20 @@ 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) - printf_unfiltered ("Ending remote %s debugging\n", target_shortname); + 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; +monitor_supply_register (int regno, char *valstr) { ULONGEST val; - unsigned char regbuf[MAX_REGISTER_RAW_SIZE]; + unsigned char regbuf[MAX_REGISTER_SIZE]; char *p; val = 0; @@ -937,31 +916,23 @@ monitor_supply_register (regno, valstr) } monitor_debug ("Supplying Register %d %s\n", regno, valstr); - if (*p != '\0') - error ("monitor_supply_register (%d): bad value from monitor: %s.", + 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); + store_unsigned_integer (regbuf, register_size (current_gdbarch, regno), val); - supply_register (regno, regbuf); + regcache_raw_supply (current_regcache, 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; +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"); @@ -973,7 +944,6 @@ monitor_resume (pid, step, sig) dump_reg_flag = 1; return; } - dcache_flush (remote_dcache); if (step) monitor_printf (current_monitor->step); else @@ -993,9 +963,7 @@ monitor_resume (pid, step, sig) string which are passed down to monitor specific code. */ static void -parse_register_dump (buf, len) - char *buf; - int len; +parse_register_dump (char *buf, int len) { monitor_debug ("MON Parsing register dump\n"); while (1) @@ -1028,8 +996,7 @@ 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); @@ -1043,8 +1010,7 @@ monitor_interrupt (signo) /* The user typed ^C twice. */ static void -monitor_interrupt_twice (signo) - int signo; +monitor_interrupt_twice (int signo) { signal (signo, ofunc); @@ -1056,7 +1022,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 (); @@ -1064,15 +1030,14 @@ monitor_interrupt_query () Give up (and stop debugging it)? ")) { target_mourn_inferior (); - return_to_top_level (RETURN_QUIT); + deprecated_throw_reason (RETURN_QUIT); } target_terminal_inferior (); } static void -monitor_wait_cleanup (old_timeout) - void *old_timeout; +monitor_wait_cleanup (void *old_timeout) { timeout = *(int *) old_timeout; signal (SIGINT, ofunc); @@ -1081,12 +1046,11 @@ monitor_wait_cleanup (old_timeout) -void +static void monitor_wait_filter (char *buf, int bufmax, int *ext_resp_len, - struct target_waitstatus *status -) + struct target_waitstatus *status) { int resp_len; do @@ -1117,10 +1081,8 @@ monitor_wait_filter (char *buf, /* 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[TARGET_BUF_SIZE]; @@ -1196,29 +1158,34 @@ 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]; + const char *name; + char *zerobuf; + char *regbuf; int i; - name = current_monitor->regnames[regno]; + regbuf = alloca (MAX_REGISTER_SIZE * 2 + 1); + zerobuf = alloca (MAX_REGISTER_SIZE); + memset (zerobuf, 0, MAX_REGISTER_SIZE); + + if (current_monitor->regname != NULL) + name = current_monitor->regname (regno); + else + name = current_monitor->regnames[regno]; monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)"); if (!name || (*name == '\0')) { monitor_debug ("No register known for %d\n", regno); - supply_register (regno, zerobuf); + regcache_raw_supply (current_regcache, regno, zerobuf); return; } @@ -1253,7 +1220,7 @@ monitor_fetch_register (regno) if ((c == '0') && ((c = readchar (timeout)) == 'x')) ; else - error ("Bad value returned from monitor while fetching register %x.", + error (_("Bad value returned from monitor while fetching register %x."), regno); } @@ -1261,7 +1228,7 @@ monitor_fetch_register (regno) 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++) + for (i = 0; i < register_size (current_gdbarch, regno) * 2; i++) { int c; c = readchar (timeout); @@ -1320,7 +1287,7 @@ monitor_dump_reg_block (char *block_cmd) /* Call the specific function if it has been provided */ static void -monitor_dump_regs () +monitor_dump_regs (void) { char buf[TARGET_BUF_SIZE]; int resp_len; @@ -1333,12 +1300,11 @@ monitor_dump_regs () 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) { monitor_debug ("MON fetchregs\n"); if (current_monitor->getreg.cmd) @@ -1361,13 +1327,16 @@ monitor_fetch_registers (regno) /* 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; + const char *name; ULONGEST val; - - name = current_monitor->regnames[regno]; + + if (current_monitor->regname != NULL) + name = current_monitor->regname (regno); + else + name = current_monitor->regnames[regno]; + if (!name || (*name == '\0')) { monitor_debug ("MON Cannot store unknown register\n"); @@ -1375,7 +1344,8 @@ monitor_store_register (regno) } val = read_register (regno); - monitor_debug ("MON storeg %d %s\n", regno, preg (val)); + monitor_debug ("MON storeg %d %s\n", regno, + phex (val, register_size (current_gdbarch, regno))); /* send the register deposit command */ @@ -1386,6 +1356,13 @@ monitor_store_register (regno) else monitor_printf (current_monitor->setreg.cmd, name, val); + 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"); @@ -1407,8 +1384,7 @@ monitor_store_register (regno) /* Store the remote registers. */ static void -monitor_store_registers (regno) - int regno; +monitor_store_registers (int regno) { if (regno >= 0) { @@ -1427,23 +1403,19 @@ 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); + 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, hostval; char *cmd; @@ -1517,6 +1489,12 @@ monitor_write_memory (memaddr, myaddr, len) 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"); @@ -1539,40 +1517,7 @@ monitor_write_memory (memaddr, myaddr, 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; - 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 (memaddr, myaddr, len) - CORE_ADDR memaddr; - char *myaddr; - int len; +monitor_write_memory_bytes (CORE_ADDR memaddr, char *myaddr, int len) { unsigned char val; int written = 0; @@ -1664,10 +1609,7 @@ longlong_hexchars (unsigned long long value, Which possably entails endian conversions */ static int -monitor_write_memory_longlongs (memaddr, myaddr, len) - CORE_ADDR memaddr; - char *myaddr; - int len; +monitor_write_memory_longlongs (CORE_ADDR memaddr, char *myaddr, int len) { static char hexstage[20]; /* At least 16 digits required, plus null */ char *endstring; @@ -1715,10 +1657,7 @@ monitor_write_memory_longlongs (memaddr, myaddr, len) */ static int -monitor_write_memory_block (memaddr, myaddr, len) - CORE_ADDR memaddr; - char *myaddr; - int len; +monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len) { int written; written = 0; @@ -1728,17 +1667,6 @@ monitor_write_memory_block (memaddr, myaddr, len) { 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; @@ -1748,16 +1676,12 @@ monitor_write_memory_block (memaddr, myaddr, len) 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 *p; char *cmd; - int i; monitor_debug ("MON read single\n"); #if 0 @@ -1817,29 +1741,31 @@ monitor_read_memory_single (memaddr, myaddr, len) else monitor_error ("monitor_read_memory_single", "bad response from monitor", - memaddr, i, membuf, c); + 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; - monitor_error ("monitor_read_memory_single", - "bad response from monitor", - 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 @@ -1878,10 +1804,7 @@ monitor_read_memory_single (memaddr, myaddr, len) 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; char buf[512]; @@ -1944,7 +1867,7 @@ monitor_read_memory (memaddr, myaddr, len) 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); } @@ -2013,7 +1936,7 @@ monitor_read_memory (memaddr, myaddr, len) c = *p; } if (fetched == 0) - error ("Failed to read via monitor"); + 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 */ @@ -2054,19 +1977,33 @@ 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, gdb_byte *myaddr, int len, int write, + struct mem_attrib *attrib, struct target_ops *target) { - 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 */ } @@ -2075,13 +2012,11 @@ monitor_kill () 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, + int from_tty) { if (args && (*args != '\000')) - error ("Args are not supported by the monitor."); + error (_("Args are not supported by the monitor.")); first_time = 1; clear_proceed_status (); @@ -2094,7 +2029,7 @@ 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 */ @@ -2103,23 +2038,21 @@ monitor_mourn_inferior () /* 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, gdb_byte *shadow) { int i; - unsigned char *bp; + const 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"); + 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); + bp = gdbarch_breakpoint_from_pc (current_gdbarch, &addr, &bplen); for (i = 0; i < current_monitor->num_breakpoints; i++) { @@ -2133,21 +2066,19 @@ monitor_insert_breakpoint (addr, shadow) } } - error ("Too many breakpoints (> %d) for monitor.", current_monitor->num_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, gdb_byte *shadow) { int i; monitor_debug ("MON rmbkpt %s\n", paddr (addr)); if (current_monitor->clr_break == NULL) - error ("No clr_break defined for this monitor"); + error (_("No clr_break defined for this monitor")); if (current_monitor->flags & MO_ADDR_BITS_REMOVE) addr = ADDR_BITS_REMOVE (addr); @@ -2178,7 +2109,7 @@ 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) { int ch; @@ -2204,11 +2135,8 @@ monitor_wait_srec_ack () /* 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) @@ -2238,28 +2166,31 @@ monitor_load (file, from_tty) 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); } @@ -2270,14 +2201,14 @@ monitor_stop () static void monitor_rcmd (char *command, - struct gdb_file *outbuf) + struct ui_file *outbuf) { char *p; int resp_len; char buf[1000]; if (monitor_desc == NULL) - error ("monitor target not open."); + error (_("monitor target not open.")); p = current_monitor->prompt; @@ -2295,8 +2226,7 @@ monitor_rcmd (char *command, #if 0 static int -from_hex (a) - int a; +from_hex (int a) { if (a >= '0' && a <= '9') return a - '0'; @@ -2305,12 +2235,12 @@ from_hex (a) if (a >= 'A' && a <= 'F') return a - 'A' + 10; - error ("Reply contains invalid hex digit 0x%x", a); + error (_("Reply contains invalid hex digit 0x%x"), a); } #endif char * -monitor_get_dev_name () +monitor_get_dev_name (void) { return dev_name; } @@ -2320,77 +2250,36 @@ 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.deprecated_xfer_memory = monitor_xfer_memory; monitor_ops.to_files_info = monitor_files_info; monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint; monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint; - monitor_ops.to_terminal_init = 0; - monitor_ops.to_terminal_inferior = 0; - monitor_ops.to_terminal_ours_for_output = 0; - monitor_ops.to_terminal_ours = 0; - monitor_ops.to_terminal_info = 0; monitor_ops.to_kill = monitor_kill; monitor_ops.to_load = monitor_load; - monitor_ops.to_lookup_symbol = 0; monitor_ops.to_create_inferior = monitor_create_inferior; - monitor_ops.to_post_startup_inferior = NULL; - monitor_ops.to_acknowledge_created_inferior = NULL; - monitor_ops.to_clone_and_follow_inferior = NULL; - monitor_ops.to_post_follow_inferior_by_clone = NULL; - monitor_ops.to_insert_fork_catchpoint = NULL; - monitor_ops.to_remove_fork_catchpoint = NULL; - monitor_ops.to_insert_vfork_catchpoint = NULL; - monitor_ops.to_remove_vfork_catchpoint = NULL; - monitor_ops.to_has_forked = NULL; - monitor_ops.to_has_vforked = NULL; - monitor_ops.to_can_follow_vfork_prior_to_exec = NULL; - monitor_ops.to_post_follow_vfork = NULL; - monitor_ops.to_insert_exec_catchpoint = NULL; - monitor_ops.to_remove_exec_catchpoint = NULL; - monitor_ops.to_has_execd = NULL; - monitor_ops.to_reported_exec_events_per_exec_call = NULL; - monitor_ops.to_has_exited = NULL; monitor_ops.to_mourn_inferior = monitor_mourn_inferior; - monitor_ops.to_can_run = 0; - monitor_ops.to_notice_signals = 0; - monitor_ops.to_thread_alive = 0; monitor_ops.to_stop = monitor_stop; monitor_ops.to_rcmd = monitor_rcmd; - monitor_ops.to_pid_to_exec_file = NULL; - monitor_ops.to_core_file_to_sym_file = NULL; monitor_ops.to_stratum = process_stratum; - monitor_ops.DONT_USE = 0; monitor_ops.to_has_all_memory = 1; monitor_ops.to_has_memory = 1; monitor_ops.to_has_stack = 1; monitor_ops.to_has_registers = 1; monitor_ops.to_has_execution = 1; - monitor_ops.to_sections = 0; - monitor_ops.to_sections_end = 0; monitor_ops.to_magic = OPS_MAGIC; } /* init_base_monitor_ops */ /* Init the target_ops structure pointed at by OPS */ void -init_monitor_ops (ops) - struct target_ops *ops; +init_monitor_ops (struct target_ops *ops) { if (monitor_ops.to_magic != OPS_MAGIC) init_base_monitor_ops (); @@ -2400,26 +2289,26 @@ init_monitor_ops (ops) /* Define additional commands that are usually only used by monitors. */ +extern initialize_file_ftype _initialize_remote_monitors; /* -Wmissing-prototypes */ + 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, - "Set display of activity while downloading a file.\n\ -When enabled, a hashmark \'#\' is displayed.", - &setlist), - &showlist); - -#if 0 - /* FIXME: cagney/1999-10-07: Wait until there is a generic ``set - debug ...'' rather than another ``set ...debug'' command. */ - add_show_from_set - (add_set_cmd ("monitordebug", no_class, var_zinteger, - (char *) &monitor_debug_p, - "Set debugging of remote monitor communication.\n\ + add_setshow_boolean_cmd ("hash", no_class, &hashmark, _("\ +Set display of activity while downloading a file."), _("\ +Show display of activity while downloading a file."), _("\ +When enabled, a hashmark \'#\' is displayed."), + NULL, + NULL, /* FIXME: i18n: */ + &setlist, &showlist); + + add_setshow_zinteger_cmd ("monitor", no_class, &monitor_debug_p, _("\ +Set debugging of remote monitor communication."), _("\ +Show debugging of remote monitor communication."), _("\ When enabled, communication between GDB and the remote monitor\n\ -is displayed.", &setlist), - &showlist); -#endif +is displayed."), + NULL, + NULL, /* FIXME: i18n: */ + &setdebuglist, &showdebuglist); }