X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fmonitor.c;h=cd4f045375ebbb44c54b1f59207d9bd265beaa09;hb=ba3e8e46435a896352acc4be831145dfec819f5f;hp=7e3580e1b11e819a9bd50f7120b6337200085946;hpb=e1e9e218c189882084a89fdee655a0a523efbaf8;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/monitor.c b/gdb/monitor.c index 7e3580e1b1..cd4f045375 100644 --- a/gdb/monitor.c +++ b/gdb/monitor.c @@ -1,5 +1,8 @@ /* Remote debugging interface for boot monitors, for GDB. - Copyright 1990-1993, 1995-1997, 1999-2000, 2001 Free Software Foundation, Inc. + + Copyright 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. @@ -51,6 +54,7 @@ #include "inferior.h" #include "gdb_regex.h" #include "srec.h" +#include "regcache.h" static char *dev_name; static struct target_ops *targ_ops; @@ -65,13 +69,13 @@ static void monitor_store_register (int regno); static void monitor_printable_string (char *newstr, char *oldstr, int len); static void monitor_error (char *function, char *message, CORE_ADDR memaddr, int len, char *string, int final_char); static void monitor_detach (char *args, int from_tty); -static void monitor_resume (int pid, int step, enum target_signal sig); +static void monitor_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 int monitor_wait (int pid, struct target_waitstatus *status); +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); @@ -117,7 +121,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 */ @@ -127,6 +131,12 @@ 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. */ @@ -388,8 +398,8 @@ monitor_printf (char *pattern,...) void 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)); } @@ -407,7 +417,7 @@ monitor_readchar (void) 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 */ @@ -441,7 +451,7 @@ readchar (int timeout) do { looping = 0; - c = SERIAL_READCHAR (monitor_desc, timeout); + c = serial_readchar (monitor_desc, timeout); if (c >= 0) { @@ -511,7 +521,6 @@ 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) { @@ -559,12 +568,6 @@ monitor_expect (char *string, char *buf, int 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 @@ -750,33 +753,41 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int 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) 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; @@ -806,7 +817,7 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int 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) @@ -831,7 +842,7 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty) push_target (targ_ops); - inferior_pid = 42000; /* Make run command think we are busy... */ + inferior_ptid = pid_to_ptid (42000); /* Make run command think we are busy... */ /* Give monitor_wait something to read */ @@ -847,7 +858,7 @@ void monitor_close (int quitting) { if (monitor_desc) - SERIAL_CLOSE (monitor_desc); + serial_close (monitor_desc); /* Free breakpoint memory */ if (breakaddr != NULL) @@ -876,7 +887,7 @@ char * 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; @@ -904,13 +915,13 @@ monitor_supply_register (int regno, char *valstr) } monitor_debug ("Supplying Register %d %s\n", regno, valstr); - if (*p != '\0') + 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, DEPRECATED_REGISTER_RAW_SIZE (regno), val); supply_register (regno, regbuf); @@ -920,7 +931,7 @@ monitor_supply_register (int regno, char *valstr) /* Tell the remote machine to resume. */ static void -monitor_resume (int pid, int 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"); @@ -1018,7 +1029,7 @@ monitor_interrupt_query (void) Give up (and stop debugging it)? ")) { target_mourn_inferior (); - return_to_top_level (RETURN_QUIT); + throw_exception (RETURN_QUIT); } target_terminal_inferior (); @@ -1034,12 +1045,11 @@ monitor_wait_cleanup (void *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 @@ -1070,8 +1080,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 (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]; @@ -1147,7 +1157,7 @@ monitor_wait (int pid, struct target_waitstatus *status) in_monitor_wait = 0; - return inferior_pid; + return inferior_ptid; } /* Fetch register REGNO, or all registers if REGNO is -1. Returns @@ -1156,16 +1166,19 @@ monitor_wait (int pid, struct target_waitstatus *status) static void monitor_fetch_register (int regno) { - char *name; + const char *name; char *zerobuf; char *regbuf; int i; - regbuf = alloca (MAX_REGISTER_RAW_SIZE * 2 + 1); - zerobuf = alloca (MAX_REGISTER_RAW_SIZE); - memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE); + regbuf = alloca (MAX_REGISTER_SIZE * 2 + 1); + zerobuf = alloca (MAX_REGISTER_SIZE); + memset (zerobuf, 0, MAX_REGISTER_SIZE); - name = current_monitor->regnames[regno]; + 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')) @@ -1214,7 +1227,7 @@ monitor_fetch_register (int 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 < DEPRECATED_REGISTER_RAW_SIZE (regno) * 2; i++) { int c; c = readchar (timeout); @@ -1315,10 +1328,14 @@ monitor_fetch_registers (int regno) static void 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"); @@ -1327,7 +1344,7 @@ monitor_store_register (int regno) val = read_register (regno); monitor_debug ("MON storeg %d %s\n", regno, - phex (val, REGISTER_RAW_SIZE (regno))); + phex (val, DEPRECATED_REGISTER_RAW_SIZE (regno))); /* send the register deposit command */ @@ -1338,6 +1355,13 @@ monitor_store_register (int 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"); @@ -1464,6 +1488,12 @@ monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int 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"); @@ -1485,33 +1515,6 @@ monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len) } -static int -monitor_write_even_block (CORE_ADDR memaddr, char *myaddr, int len) -{ - unsigned int val; - int written = 0;; - /* Enter the sub mode */ - monitor_printf (current_monitor->setmem.cmdl, memaddr); - monitor_expect_prompt (NULL, 0); - - while (len) - { - val = extract_unsigned_integer (myaddr, 4); /* REALLY */ - monitor_printf ("%x\r", val); - myaddr += 4; - memaddr += 4; - written += 4; - monitor_debug (" @ %s\n", paddr (memaddr)); - /* If we wanted to, here we could validate the address */ - monitor_expect_prompt (NULL, 0); - } - /* Now exit the sub mode */ - monitor_printf (current_monitor->getreg.term_cmd); - monitor_expect_prompt (NULL, 0); - return written; -} - - static int monitor_write_memory_bytes (CORE_ADDR memaddr, char *myaddr, int len) { @@ -1663,17 +1666,6 @@ monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int 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; @@ -1689,7 +1681,6 @@ monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len) char membuf[sizeof (int) * 2 + 1]; char *p; char *cmd; - int i; monitor_debug ("MON read single\n"); #if 0 @@ -1749,29 +1740,31 @@ monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int 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 @@ -1873,7 +1866,7 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int 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); } @@ -1989,8 +1982,7 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len) static int monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, - struct mem_attrib *attrib ATTRIBUTE_UNUSED, - struct target_ops *target ATTRIBUTE_UNUSED) + struct mem_attrib *attrib, struct target_ops *target) { int res; @@ -2047,7 +2039,7 @@ static int monitor_insert_breakpoint (CORE_ADDR addr, char *shadow) { int i; - unsigned char *bp; + const unsigned char *bp; int bplen; monitor_debug ("MON inst bkpt %s\n", paddr (addr)); @@ -2058,7 +2050,7 @@ monitor_insert_breakpoint (CORE_ADDR addr, char *shadow) 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++) { @@ -2172,20 +2164,23 @@ monitor_load (char *file, int 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 @@ -2193,7 +2188,7 @@ 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); } @@ -2253,19 +2248,10 @@ 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; @@ -2273,49 +2259,18 @@ init_base_monitor_ops (void) 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 */ @@ -2332,6 +2287,8 @@ init_monitor_ops (struct target_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 (void) {