1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990, 1991, 1992, 1993, 1995, 1996, 1997, 1999
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
5 Resurrected from the ashes by Stu Grossman.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* This file was derived from various remote-* modules. It is a collection
25 of generic support functions so GDB can talk directly to a ROM based
26 monitor. This saves use from having to hack an exception based handler
27 into existance, and makes for quick porting.
29 This module talks to a debug monitor called 'MONITOR', which
30 We communicate with MONITOR via either a direct serial line, or a TCP
31 (or possibly TELNET) stream to a terminal multiplexor,
32 which in turn talks to the target board. */
34 /* FIXME 32x64: This code assumes that registers and addresses are at
35 most 32 bits long. If they can be larger, you will need to declare
36 values as LONGEST and use %llx or some such to print values when
37 building commands to send to the monitor. Since we don't know of
38 any actual 64-bit targets with ROM monitors that use this code,
39 it's not an issue right now. -sts 4/18/96 */
45 #ifdef ANSI_PROTOTYPES
52 #include "gdb_string.h"
53 #include <sys/types.h>
59 #include "gnu-regex.h"
63 static char *dev_name;
64 static struct target_ops *targ_ops;
66 static void monitor_vsprintf PARAMS ((char *sndbuf, char *pattern, va_list args));
68 static int readchar PARAMS ((int timeout));
70 static void monitor_command PARAMS ((char *args, int fromtty));
72 static void monitor_fetch_register PARAMS ((int regno));
73 static void monitor_store_register PARAMS ((int regno));
75 static int monitor_printable_string PARAMS ((char *newstr, char *oldstr));
76 static void monitor_error PARAMS ((char *format, CORE_ADDR memaddr, int len, char *string, int final_char));
77 static void monitor_detach PARAMS ((char *args, int from_tty));
78 static void monitor_resume PARAMS ((int pid, int step, enum target_signal sig));
79 static void monitor_interrupt PARAMS ((int signo));
80 static void monitor_interrupt_twice PARAMS ((int signo));
81 static void monitor_interrupt_query PARAMS ((void));
82 static void monitor_wait_cleanup PARAMS ((void *old_timeout));
84 static int monitor_wait PARAMS ((int pid, struct target_waitstatus * status));
85 static void monitor_fetch_registers PARAMS ((int regno));
86 static void monitor_store_registers PARAMS ((int regno));
87 static void monitor_prepare_to_store PARAMS ((void));
88 static int monitor_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len, int write, struct target_ops * target));
89 static void monitor_files_info PARAMS ((struct target_ops * ops));
90 static int monitor_insert_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
91 static int monitor_remove_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
92 static void monitor_kill PARAMS ((void));
93 static void monitor_load PARAMS ((char *file, int from_tty));
94 static void monitor_mourn_inferior PARAMS ((void));
95 static void monitor_stop PARAMS ((void));
97 static int monitor_read_memory PARAMS ((CORE_ADDR addr, char *myaddr, int len));
98 static int monitor_write_memory PARAMS ((CORE_ADDR addr, char *myaddr, int len));
99 static int monitor_write_memory_bytes PARAMS ((CORE_ADDR addr,
100 char *myaddr, int len));
101 static int monitor_write_memory_block PARAMS ((
105 static int monitor_expect_regexp PARAMS ((struct re_pattern_buffer * pat,
106 char *buf, int buflen));
107 static void monitor_dump_regs PARAMS ((void));
109 static int from_hex PARAMS ((int a));
110 static unsigned long get_hex_word PARAMS ((void));
112 static void parse_register_dump PARAMS ((char *, int));
114 static struct monitor_ops *current_monitor;
116 static int hashmark; /* flag set by "set hash" */
118 static int timeout = 30;
120 static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait() */
122 static void (*ofunc) (); /* Old SIGINT signal handler */
124 static CORE_ADDR *breakaddr;
126 /* Extra remote debugging for developing a new rom monitor variation */
127 #if ! defined(EXTRA_RDEBUG)
128 #define EXTRA_RDEBUG 0
130 #define RDEBUG(stuff) { if (EXTRA_RDEBUG && remote_debug) printf stuff ; }
132 /* Descriptor for I/O to remote machine. Initialize it to NULL so
133 that monitor_open knows that we don't have a file open when the
136 static serial_t monitor_desc = NULL;
138 /* Pointer to regexp pattern matching data */
140 static struct re_pattern_buffer register_pattern;
141 static char register_fastmap[256];
143 static struct re_pattern_buffer getmem_resp_delim_pattern;
144 static char getmem_resp_delim_fastmap[256];
146 static int dump_reg_flag; /* Non-zero means do a dump_registers cmd when
147 monitor_wait wakes up. */
149 static DCACHE *remote_dcache;
150 static int first_time = 0; /* is this the first time we're executing after
151 gaving created the child proccess? */
153 /* Convert a string into a printable representation, Return # byte in the
157 monitor_printable_string (newstr, oldstr)
164 while ((ch = *oldstr++) != '\0')
174 sprintf (newstr, "\\x%02x", ch & 0xff);
211 return newstr - save;
214 /* Print monitor errors with a string, converting the string to printable
218 monitor_error (format, memaddr, len, string, final_char)
225 int real_len = (len == 0 && string != (char *) 0) ? strlen (string) : len;
226 char *safe_string = alloca ((real_len * 4) + 1);
229 int safe_len = monitor_printable_string (safe_string, string);
232 error (format, (int) memaddr, p - safe_string, safe_string, final_char);
234 error (format, (int) memaddr, p - safe_string, safe_string);
237 /* Convert hex digit A to a number. */
243 if (a >= '0' && a <= '9')
245 else if (a >= 'a' && a <= 'f')
247 else if (a >= 'A' && a <= 'F')
250 error ("Invalid hex digit %d", a);
253 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
255 This function exists to get around the problem that many host platforms
256 don't have a printf that can print 64-bit addresses. The %A format
257 specification is recognized as a special case, and causes the argument
258 to be printed as a 64-bit hexadecimal address.
260 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
261 If it is a '%s' format, the argument is a string; otherwise the
262 argument is assumed to be a long integer.
264 %% is also turned into a single %.
268 monitor_vsprintf (sndbuf, pattern, args)
281 for (p = pattern; *p; p++)
285 /* Copy the format specifier to a separate buffer. */
287 for (i = 1; *p >= '0' && *p <= '9' && i < (int) sizeof (format) - 2;
290 format[i] = fmt = *p;
291 format[i + 1] = '\0';
293 /* Fetch the next argument and print it. */
297 strcpy (sndbuf, "%");
300 arg_addr = va_arg (args, CORE_ADDR);
301 strcpy (sndbuf, paddr_nz (arg_addr));
304 arg_string = va_arg (args, char *);
305 sprintf (sndbuf, format, arg_string);
308 arg_int = va_arg (args, long);
309 sprintf (sndbuf, format, arg_int);
312 sndbuf += strlen (sndbuf);
321 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
322 Works just like printf. */
325 #ifdef ANSI_PROTOTYPES
326 monitor_printf_noecho (char *pattern,...)
328 monitor_printf_noecho (va_alist)
337 va_start (args, pattern);
341 pattern = va_arg (args, char *);
344 monitor_vsprintf (sndbuf, pattern, args);
346 len = strlen (sndbuf);
347 if (len + 1 > sizeof sndbuf)
351 if (remote_debug > 0)
352 puts_debug ("sent -->", sndbuf, "<--");
357 char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);
358 monitor_printable_string (safe_string, sndbuf);
359 printf ("sent[%s]\n", safe_string);
362 monitor_write (sndbuf, len);
365 /* monitor_printf -- Send data to monitor and check the echo. Works just like
369 #ifdef ANSI_PROTOTYPES
370 monitor_printf (char *pattern,...)
372 monitor_printf (va_alist)
380 #ifdef ANSI_PROTOTYPES
381 va_start (args, pattern);
385 pattern = va_arg (args, char *);
388 monitor_vsprintf (sndbuf, pattern, args);
390 len = strlen (sndbuf);
391 if (len + 1 > sizeof sndbuf)
395 if (remote_debug > 0)
396 puts_debug ("sent -->", sndbuf, "<--");
401 char *safe_string = (char *) alloca ((len * 4) + 1);
402 monitor_printable_string (safe_string, sndbuf);
403 printf ("sent[%s]\n", safe_string);
406 monitor_write (sndbuf, len);
408 /* We used to expect that the next immediate output was the characters we
409 just output, but sometimes some extra junk appeared before the characters
410 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
411 So, just start searching for what we sent, and skip anything unknown. */
412 RDEBUG (("ExpectEcho\n"))
413 monitor_expect (sndbuf, (char *) 0, 0);
417 /* Write characters to the remote system. */
420 monitor_write (buf, buflen)
424 if (SERIAL_WRITE (monitor_desc, buf, buflen))
425 fprintf_unfiltered (gdb_stderr, "SERIAL_WRITE failed: %s\n",
426 safe_strerror (errno));
430 /* Read a binary character from the remote system, doing all the fancy
431 timeout stuff, but without interpreting the character in any way,
432 and without printing remote debug information. */
443 c = SERIAL_READCHAR (monitor_desc, timeout);
446 c &= 0xff; /* don't lose bit 7 */
453 if (c == SERIAL_TIMEOUT)
454 error ("Timeout reading from remote system.");
456 perror_with_name ("remote-monitor");
460 /* Read a character from the remote system, doing all the fancy
470 last_random, last_nl, last_cr, last_crnl
478 c = SERIAL_READCHAR (monitor_desc, timeout);
484 /* This seems to interfere with proper function of the
486 if (remote_debug > 0)
491 puts_debug ("read -->", buf, "<--");
497 /* Canonicialize \n\r combinations into one \r */
498 if ((current_monitor->flags & MO_HANDLE_NL) != 0)
500 if ((c == '\r' && state == last_nl)
501 || (c == '\n' && state == last_cr))
522 if (c == SERIAL_TIMEOUT)
524 /* I fail to see how detaching here can be useful */
525 if (in_monitor_wait) /* Watchdog went off */
527 target_mourn_inferior ();
528 error ("GDB serial timeout has expired. Target detached.\n");
532 error ("Timeout reading from remote system.");
534 perror_with_name ("remote-monitor");
537 /* Scan input from the remote system, until STRING is found. If BUF is non-
538 zero, then collect input until we have collected either STRING or BUFLEN-1
539 chars. In either case we terminate BUF with a 0. If input overflows BUF
540 because STRING can't be found, return -1, else return number of chars in BUF
541 (minus the terminating NUL). Note that in the non-overflow case, STRING
542 will be at the end of BUF. */
545 monitor_expect (string, buf, buflen)
551 int obuflen = buflen;
553 extern struct target_ops *targ_ops;
558 char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
559 monitor_printable_string (safe_string, string);
560 printf ("MON Expecting '%s'\n", safe_string);
575 c = readchar (timeout);
582 c = readchar (timeout);
584 /* Don't expect any ^C sent to be echoed */
586 if (*p == '\003' || c == *p)
596 return obuflen - buflen;
602 else if ((c == '\021' || c == '\023') &&
603 (STREQ (targ_ops->to_shortname, "m32r")
604 || STREQ (targ_ops->to_shortname, "mon2000")))
605 { /* m32r monitor emits random DC1/DC3 chars */
610 /* We got a character that doesn't match the string. We need to
611 back up p, but how far? If we're looking for "..howdy" and the
612 monitor sends "...howdy"? There's certainly a match in there,
613 but when we receive the third ".", we won't find it if we just
614 restart the matching at the beginning of the string.
616 This is a Boyer-Moore kind of situation. We want to reset P to
617 the end of the longest prefix of STRING that is a suffix of
618 what we've read so far. In the example above, that would be
619 ".." --- the longest prefix of "..howdy" that is a suffix of
620 "...". This longest prefix could be the empty string, if C
621 is nowhere to be found in STRING.
623 If this longest prefix is not the empty string, it must contain
624 C, so let's search from the end of STRING for instances of C,
625 and see if the portion of STRING before that is a suffix of
626 what we read before C. Actually, we can search backwards from
627 p, since we know no prefix can be longer than that.
629 Note that we can use STRING itself, along with C, as a record
630 of what we've received so far. :) */
633 for (i = (p - string) - 1; i >= 0; i--)
636 /* Is this prefix a suffix of what we've read so far?
638 string[0 .. i-1] == string[p - i, p - 1]? */
639 if (! memcmp (string, p - i, i))
651 /* Search for a regexp. */
654 monitor_expect_regexp (pat, buf, buflen)
655 struct re_pattern_buffer *pat;
661 RDEBUG (("MON Expecting regexp\n"));
666 mybuf = alloca (1024);
675 if (p - mybuf >= buflen)
676 { /* Buffer about to overflow */
678 /* On overflow, we copy the upper half of the buffer to the lower half. Not
679 great, but it usually works... */
681 memcpy (mybuf, mybuf + buflen / 2, buflen / 2);
682 p = mybuf + buflen / 2;
685 *p++ = readchar (timeout);
687 retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL);
693 /* Keep discarding input until we see the MONITOR prompt.
695 The convention for dealing with the prompt is that you
697 o *then* wait for the prompt.
699 Thus the last thing that a procedure does with the serial line will
700 be an monitor_expect_prompt(). Exception: monitor_resume does not
701 wait for the prompt, because the terminal is being handed over to
702 the inferior. However, the next thing which happens after that is
703 a monitor_wait which does wait for the prompt. Note that this
704 includes abnormal exit, e.g. error(). This is necessary to prevent
705 getting into states from which we can't recover. */
708 monitor_expect_prompt (buf, buflen)
712 RDEBUG (("MON Expecting prompt\n"))
713 return monitor_expect (current_monitor->prompt, buf, buflen);
716 /* Get N 32-bit words from remote, each preceded by a space, and put
717 them in registers starting at REGNO. */
728 ch = readchar (timeout);
729 while (isspace (ch));
733 for (i = 7; i >= 1; i--)
735 ch = readchar (timeout);
738 val = (val << 4) | from_hex (ch);
746 compile_pattern (pattern, compiled_pattern, fastmap)
748 struct re_pattern_buffer *compiled_pattern;
754 compiled_pattern->fastmap = fastmap;
756 tmp = re_set_syntax (RE_SYNTAX_EMACS);
757 val = re_compile_pattern (pattern,
763 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern, val);
766 re_compile_fastmap (compiled_pattern);
769 /* Open a connection to a remote debugger. NAME is the filename used
770 for communication. */
773 monitor_open (args, mon_ops, from_tty)
775 struct monitor_ops *mon_ops;
781 if (mon_ops->magic != MONITOR_OPS_MAGIC)
782 error ("Magic number of monitor_ops struct wrong.");
784 targ_ops = mon_ops->target;
785 name = targ_ops->to_shortname;
788 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
789 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name, name);
791 target_preopen (from_tty);
793 /* Setup pattern for register dump */
795 if (mon_ops->register_pattern)
796 compile_pattern (mon_ops->register_pattern, ®ister_pattern,
799 if (mon_ops->getmem.resp_delim)
800 compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
801 getmem_resp_delim_fastmap);
803 unpush_target (targ_ops);
807 dev_name = strsave (args);
809 monitor_desc = SERIAL_OPEN (dev_name);
812 perror_with_name (dev_name);
816 if (SERIAL_SETBAUDRATE (monitor_desc, baud_rate))
818 SERIAL_CLOSE (monitor_desc);
819 perror_with_name (dev_name);
823 SERIAL_RAW (monitor_desc);
825 SERIAL_FLUSH_INPUT (monitor_desc);
827 /* some systems only work with 2 stop bits */
829 SERIAL_SETSTOPBITS (monitor_desc, mon_ops->stopbits);
831 current_monitor = mon_ops;
833 /* See if we can wake up the monitor. First, try sending a stop sequence,
834 then send the init strings. Last, remove all breakpoints. */
836 if (current_monitor->stop)
839 if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
841 RDEBUG (("EXP Open echo\n"));
842 monitor_expect_prompt (NULL, 0);
846 /* wake up the monitor and see if it's alive */
847 for (p = mon_ops->init; *p != NULL; p++)
849 /* Some of the characters we send may not be echoed,
850 but we hope to get a prompt at the end of it all. */
852 if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
855 monitor_printf_noecho (*p);
856 monitor_expect_prompt (NULL, 0);
859 SERIAL_FLUSH_INPUT (monitor_desc);
861 /* Alloc breakpoints */
862 if (mon_ops->set_break != NULL)
864 if (mon_ops->num_breakpoints == 0)
865 mon_ops->num_breakpoints = 8;
867 breakaddr = (CORE_ADDR *) xmalloc (mon_ops->num_breakpoints * sizeof (CORE_ADDR));
868 memset (breakaddr, 0, mon_ops->num_breakpoints * sizeof (CORE_ADDR));
871 /* Remove all breakpoints */
873 if (mon_ops->clr_all_break)
875 monitor_printf (mon_ops->clr_all_break);
876 monitor_expect_prompt (NULL, 0);
880 printf_unfiltered ("Remote target %s connected to %s\n", name, dev_name);
882 push_target (targ_ops);
884 inferior_pid = 42000; /* Make run command think we are busy... */
886 /* Give monitor_wait something to read */
888 monitor_printf (current_monitor->line_term);
890 if (current_monitor->flags & MO_HAS_BLOCKWRITES)
891 remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory_block);
893 remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory);
897 /* Close out all files and local state before this target loses
901 monitor_close (quitting)
905 SERIAL_CLOSE (monitor_desc);
907 /* Free breakpoint memory */
908 if (breakaddr != NULL)
917 /* Terminate the open connection to the remote debugger. Use this
918 when you want to detach and do something else with your gdb. */
921 monitor_detach (args, from_tty)
925 pop_target (); /* calls monitor_close to do the real work */
927 printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
930 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
933 monitor_supply_register (regno, valstr)
938 unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
941 val = strtoul (valstr, &p, 16);
942 RDEBUG (("Supplying Register %d %s\n", regno, valstr));
944 if (val == 0 && valstr == p)
945 error ("monitor_supply_register (%d): bad value from monitor: %s.",
948 /* supply register stores in target byte order, so swap here */
950 store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
952 supply_register (regno, regbuf);
957 /* Tell the remote machine to resume. */
960 flush_monitor_dcache ()
962 dcache_flush (remote_dcache);
966 monitor_resume (pid, step, sig)
968 enum target_signal sig;
970 /* Some monitors require a different command when starting a program */
971 RDEBUG (("MON resume\n"));
972 if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
975 monitor_printf ("run\r");
976 if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
980 dcache_flush (remote_dcache);
982 monitor_printf (current_monitor->step);
985 if (current_monitor->continue_hook)
986 (*current_monitor->continue_hook) ();
988 monitor_printf (current_monitor->cont);
989 if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
994 /* Parse the output of a register dump command. A monitor specific
995 regexp is used to extract individual register descriptions of the
996 form REG=VAL. Each description is split up into a name and a value
997 string which are passed down to monitor specific code. */
1000 parse_register_dump (buf, len)
1004 RDEBUG (("MON Parsing register dump\n"))
1007 int regnamelen, vallen;
1008 char *regname, *val;
1009 /* Element 0 points to start of register name, and element 1
1010 points to the start of the register value. */
1011 struct re_registers register_strings;
1013 memset (®ister_strings, 0, sizeof (struct re_registers));
1015 if (re_search (®ister_pattern, buf, len, 0, len,
1016 ®ister_strings) == -1)
1019 regnamelen = register_strings.end[1] - register_strings.start[1];
1020 regname = buf + register_strings.start[1];
1021 vallen = register_strings.end[2] - register_strings.start[2];
1022 val = buf + register_strings.start[2];
1024 current_monitor->supply_register (regname, regnamelen, val, vallen);
1026 buf += register_strings.end[0];
1027 len -= register_strings.end[0];
1031 /* Send ^C to target to halt it. Target will respond, and send us a
1035 monitor_interrupt (signo)
1038 /* If this doesn't work, try more severe steps. */
1039 signal (signo, monitor_interrupt_twice);
1042 printf_unfiltered ("monitor_interrupt called\n");
1047 /* The user typed ^C twice. */
1050 monitor_interrupt_twice (signo)
1053 signal (signo, ofunc);
1055 monitor_interrupt_query ();
1057 signal (signo, monitor_interrupt);
1060 /* Ask the user what to do when an interrupt is received. */
1063 monitor_interrupt_query ()
1065 target_terminal_ours ();
1067 if (query ("Interrupted while waiting for the program.\n\
1068 Give up (and stop debugging it)? "))
1070 target_mourn_inferior ();
1071 return_to_top_level (RETURN_QUIT);
1074 target_terminal_inferior ();
1078 monitor_wait_cleanup (old_timeout)
1081 timeout = *(int *) old_timeout;
1082 signal (SIGINT, ofunc);
1083 in_monitor_wait = 0;
1089 monitor_wait_filter (char *buf,
1092 struct target_waitstatus *status
1098 resp_len = monitor_expect_prompt (buf, bufmax);
1099 *ext_resp_len = resp_len;
1102 fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
1104 while (resp_len < 0);
1106 /* Print any output characters that were preceded by ^O. */
1107 /* FIXME - This would be great as a user settabgle flag */
1109 current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
1113 for (i = 0; i < resp_len - 1; i++)
1115 putchar_unfiltered (buf[++i]);
1121 /* Wait until the remote machine stops, then return, storing status in
1122 status just as `wait' would. */
1125 monitor_wait (pid, status)
1127 struct target_waitstatus *status;
1129 int old_timeout = timeout;
1132 struct cleanup *old_chain;
1134 status->kind = TARGET_WAITKIND_EXITED;
1135 status->value.integer = 0;
1137 old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
1138 RDEBUG (("MON wait\n"))
1141 /* This is somthing other than a maintenance command */
1142 in_monitor_wait = 1;
1143 timeout = watchdog > 0 ? watchdog : -1;
1145 timeout = -1; /* Don't time out -- user program is running. */
1148 ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
1150 if (current_monitor->wait_filter)
1151 (*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status);
1153 monitor_wait_filter (buf, sizeof (buf), &resp_len, status);
1155 #if 0 /* Transferred to monitor wait filter */
1158 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1161 fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
1163 while (resp_len < 0);
1165 /* Print any output characters that were preceded by ^O. */
1166 /* FIXME - This would be great as a user settabgle flag */
1168 current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
1172 for (i = 0; i < resp_len - 1; i++)
1174 putchar_unfiltered (buf[++i]);
1178 signal (SIGINT, ofunc);
1180 timeout = old_timeout;
1182 if (dump_reg_flag && current_monitor->dump_registers)
1185 monitor_printf (current_monitor->dump_registers);
1186 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1189 if (current_monitor->register_pattern)
1190 parse_register_dump (buf, resp_len);
1192 RDEBUG (("Wait fetching registers after stop\n"));
1193 monitor_dump_regs ();
1196 status->kind = TARGET_WAITKIND_STOPPED;
1197 status->value.sig = TARGET_SIGNAL_TRAP;
1199 discard_cleanups (old_chain);
1201 in_monitor_wait = 0;
1203 return inferior_pid;
1206 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1210 monitor_fetch_register (regno)
1214 static char zerobuf[MAX_REGISTER_RAW_SIZE] =
1216 char regbuf[MAX_REGISTER_RAW_SIZE * 2 + 1];
1219 name = current_monitor->regnames[regno];
1220 RDEBUG (("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)"))
1222 if (!name || (*name == '\0'))
1224 RDEBUG (("No register known for %d\n", regno))
1225 supply_register (regno, zerobuf);
1229 /* send the register examine command */
1231 monitor_printf (current_monitor->getreg.cmd, name);
1233 /* If RESP_DELIM is specified, we search for that as a leading
1234 delimiter for the register value. Otherwise, we just start
1235 searching from the start of the buf. */
1237 if (current_monitor->getreg.resp_delim)
1239 RDEBUG (("EXP getreg.resp_delim\n"))
1240 monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1241 /* Handle case of first 32 registers listed in pairs. */
1242 if (current_monitor->flags & MO_32_REGS_PAIRED
1243 && (regno & 1) != 0 && regno < 32)
1245 RDEBUG (("EXP getreg.resp_delim\n"));
1246 monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1250 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1251 if (current_monitor->flags & MO_HEX_PREFIX)
1254 c = readchar (timeout);
1256 c = readchar (timeout);
1257 if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1260 error ("Bad value returned from monitor while fetching register %x.",
1264 /* Read upto the maximum number of hex digits for this register, skipping
1265 spaces, but stop reading if something else is seen. Some monitors
1266 like to drop leading zeros. */
1268 for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
1271 c = readchar (timeout);
1273 c = readchar (timeout);
1281 regbuf[i] = '\000'; /* terminate the number */
1282 RDEBUG (("REGVAL '%s'\n", regbuf));
1284 /* If TERM is present, we wait for that to show up. Also, (if TERM
1285 is present), we will send TERM_CMD if that is present. In any
1286 case, we collect all of the output into buf, and then wait for
1287 the normal prompt. */
1289 if (current_monitor->getreg.term)
1291 RDEBUG (("EXP getreg.term\n"))
1292 monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */
1295 if (current_monitor->getreg.term_cmd)
1297 RDEBUG (("EMIT getreg.term.cmd\n"))
1298 monitor_printf (current_monitor->getreg.term_cmd);
1300 if (!current_monitor->getreg.term || /* Already expected or */
1301 current_monitor->getreg.term_cmd) /* ack expected */
1302 monitor_expect_prompt (NULL, 0); /* get response */
1304 monitor_supply_register (regno, regbuf);
1307 /* Sometimes, it takes several commands to dump the registers */
1308 /* This is a primitive for use by variations of monitor interfaces in
1309 case they need to compose the operation.
1312 monitor_dump_reg_block (char *block_cmd)
1316 monitor_printf (block_cmd);
1317 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1318 parse_register_dump (buf, resp_len);
1323 /* Read the remote registers into the block regs. */
1324 /* Call the specific function if it has been provided */
1327 monitor_dump_regs ()
1331 if (current_monitor->dumpregs)
1332 (*(current_monitor->dumpregs)) (); /* call supplied function */
1333 else if (current_monitor->dump_registers) /* default version */
1335 monitor_printf (current_monitor->dump_registers);
1336 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1337 parse_register_dump (buf, resp_len);
1340 abort (); /* Need some way to read registers */
1344 monitor_fetch_registers (regno)
1347 RDEBUG (("MON fetchregs\n"));
1348 if (current_monitor->getreg.cmd)
1352 monitor_fetch_register (regno);
1356 for (regno = 0; regno < NUM_REGS; regno++)
1357 monitor_fetch_register (regno);
1361 monitor_dump_regs ();
1365 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1368 monitor_store_register (regno)
1374 name = current_monitor->regnames[regno];
1375 if (!name || (*name == '\0'))
1377 RDEBUG (("MON Cannot store unknown register\n"))
1381 val = read_register (regno);
1382 RDEBUG (("MON storeg %d %08x\n", regno, (unsigned int) val))
1384 /* send the register deposit command */
1386 if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
1387 monitor_printf (current_monitor->setreg.cmd, val, name);
1388 else if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1389 monitor_printf (current_monitor->setreg.cmd, name);
1391 monitor_printf (current_monitor->setreg.cmd, name, val);
1393 if (current_monitor->setreg.term)
1395 RDEBUG (("EXP setreg.term\n"))
1396 monitor_expect (current_monitor->setreg.term, NULL, 0);
1397 if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1398 monitor_printf ("%x\r", val);
1399 monitor_expect_prompt (NULL, 0);
1402 monitor_expect_prompt (NULL, 0);
1403 if (current_monitor->setreg.term_cmd) /* Mode exit required */
1405 RDEBUG (("EXP setreg_termcmd\n"));
1406 monitor_printf ("%s", current_monitor->setreg.term_cmd);
1407 monitor_expect_prompt (NULL, 0);
1409 } /* monitor_store_register */
1411 /* Store the remote registers. */
1414 monitor_store_registers (regno)
1419 monitor_store_register (regno);
1423 for (regno = 0; regno < NUM_REGS; regno++)
1424 monitor_store_register (regno);
1427 /* Get ready to modify the registers array. On machines which store
1428 individual registers, this doesn't need to do anything. On machines
1429 which store all the registers in one fell swoop, this makes sure
1430 that registers contains all the registers from the program being
1434 monitor_prepare_to_store ()
1436 /* Do nothing, since we can store individual regs */
1440 monitor_files_info (ops)
1441 struct target_ops *ops;
1443 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
1447 monitor_write_memory (memaddr, myaddr, len)
1452 unsigned int val, hostval;
1456 RDEBUG (("MON write %d %08x\n", len, (unsigned long) memaddr))
1458 if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1459 memaddr = ADDR_BITS_REMOVE (memaddr);
1461 /* Use memory fill command for leading 0 bytes. */
1463 if (current_monitor->fill)
1465 for (i = 0; i < len; i++)
1469 if (i > 4) /* More than 4 zeros is worth doing */
1471 RDEBUG (("MON FILL %d\n", i))
1472 if (current_monitor->flags & MO_FILL_USES_ADDR)
1473 monitor_printf (current_monitor->fill, memaddr, (memaddr + i) - 1, 0);
1475 monitor_printf (current_monitor->fill, memaddr, i, 0);
1477 monitor_expect_prompt (NULL, 0);
1484 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1485 if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
1488 cmd = current_monitor->setmem.cmdll;
1492 if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
1495 cmd = current_monitor->setmem.cmdl;
1497 else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw)
1500 cmd = current_monitor->setmem.cmdw;
1505 cmd = current_monitor->setmem.cmdb;
1508 val = extract_unsigned_integer (myaddr, len);
1512 hostval = *(unsigned int *) myaddr;
1513 RDEBUG (("Hostval(%08x) val(%08x)\n", hostval, val));
1517 if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
1518 monitor_printf_noecho (cmd, memaddr, val);
1519 else if (current_monitor->flags & MO_SETMEM_INTERACTIVE)
1522 monitor_printf_noecho (cmd, memaddr);
1524 if (current_monitor->setmem.term)
1526 RDEBUG (("EXP setmem.term"));
1527 monitor_expect (current_monitor->setmem.term, NULL, 0);
1528 monitor_printf ("%x\r", val);
1530 if (current_monitor->setmem.term_cmd)
1531 { /* Emit this to get out of the memory editing state */
1532 monitor_printf ("%s", current_monitor->setmem.term_cmd);
1533 /* Drop through to expecting a prompt */
1537 monitor_printf (cmd, memaddr, val);
1539 monitor_expect_prompt (NULL, 0);
1546 monitor_write_even_block (memaddr, myaddr, len)
1553 /* Enter the sub mode */
1554 monitor_printf (current_monitor->setmem.cmdl, memaddr);
1555 monitor_expect_prompt (NULL, 0);
1559 val = extract_unsigned_integer (myaddr, 4); /* REALLY */
1560 monitor_printf ("%x\r", val);
1564 RDEBUG ((" @ %08x\n", memaddr))
1565 /* If we wanted to, here we could validate the address */
1566 monitor_expect_prompt (NULL, 0);
1568 /* Now exit the sub mode */
1569 monitor_printf (current_monitor->getreg.term_cmd);
1570 monitor_expect_prompt (NULL, 0);
1576 monitor_write_memory_bytes (memaddr, myaddr, len)
1585 /* Enter the sub mode */
1586 monitor_printf (current_monitor->setmem.cmdb, memaddr);
1587 monitor_expect_prompt (NULL, 0);
1591 monitor_printf ("%x\r", val);
1595 /* If we wanted to, here we could validate the address */
1596 monitor_expect_prompt (NULL, 0);
1599 /* Now exit the sub mode */
1600 monitor_printf (current_monitor->getreg.term_cmd);
1601 monitor_expect_prompt (NULL, 0);
1607 longlongendswap (unsigned char *a)
1616 *(a + i) = *(a + j);
1621 /* Format 32 chars of long long value, advance the pointer */
1622 static char *hexlate = "0123456789abcdef";
1624 longlong_hexchars (unsigned long long value,
1634 static unsigned char disbuf[8]; /* disassembly buffer */
1635 unsigned char *scan, *limit; /* loop controls */
1636 unsigned char c, nib;
1641 unsigned long long *dp;
1642 dp = (unsigned long long *) scan;
1645 longlongendswap (disbuf); /* FIXME: ONly on big endian hosts */
1646 while (scan < limit)
1648 c = *scan++; /* a byte of our long long value */
1654 leadzero = 0; /* henceforth we print even zeroes */
1656 nib = c >> 4; /* high nibble bits */
1657 *outbuff++ = hexlate[nib];
1658 nib = c & 0x0f; /* low nibble bits */
1659 *outbuff++ = hexlate[nib];
1663 } /* longlong_hexchars */
1667 /* I am only going to call this when writing virtual byte streams.
1668 Which possably entails endian conversions
1671 monitor_write_memory_longlongs (memaddr, myaddr, len)
1676 static char hexstage[20]; /* At least 16 digits required, plus null */
1681 llptr = (unsigned long long *) myaddr;
1684 monitor_printf (current_monitor->setmem.cmdll, memaddr);
1685 monitor_expect_prompt (NULL, 0);
1689 endstring = longlong_hexchars (*llptr, hexstage);
1690 *endstring = '\0'; /* NUll terminate for printf */
1691 monitor_printf ("%s\r", hexstage);
1695 /* If we wanted to, here we could validate the address */
1696 monitor_expect_prompt (NULL, 0);
1699 /* Now exit the sub mode */
1700 monitor_printf (current_monitor->getreg.term_cmd);
1701 monitor_expect_prompt (NULL, 0);
1707 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1708 /* This is for the large blocks of memory which may occur in downloading.
1709 And for monitors which use interactive entry,
1710 And for monitors which do not have other downloading methods.
1711 Without this, we will end up calling monitor_write_memory many times
1712 and do the entry and exit of the sub mode many times
1713 This currently assumes...
1714 MO_SETMEM_INTERACTIVE
1715 ! MO_NO_ECHO_ON_SETMEM
1716 To use this, the you have to patch the monitor_cmds block with
1717 this function. Otherwise, its not tuned up for use by all
1722 monitor_write_memory_block (memaddr, myaddr, len)
1729 /* FIXME: This would be a good place to put the zero test */
1731 if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
1733 return monitor_write_memory_longlongs (memaddr, myaddr, len);
1740 written = monitor_write_even_block (memaddr, myaddr, len);
1741 /* Adjust calling parameters by written amount */
1747 written = monitor_write_memory_bytes (memaddr, myaddr, len);
1751 /* This is an alternate form of monitor_read_memory which is used for monitors
1752 which can only read a single byte/word/etc. at a time. */
1755 monitor_read_memory_single (memaddr, myaddr, len)
1761 char membuf[sizeof (int) * 2 + 1];
1766 RDEBUG (("MON read single\n"));
1768 /* Can't actually use long longs (nice idea, though). In fact, the
1769 call to strtoul below will fail if it tries to convert a value
1770 that's too big to fit in a long. */
1771 if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
1774 cmd = current_monitor->getmem.cmdll;
1778 if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
1781 cmd = current_monitor->getmem.cmdl;
1783 else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->getmem.cmdw)
1786 cmd = current_monitor->getmem.cmdw;
1791 cmd = current_monitor->getmem.cmdb;
1794 /* Send the examine command. */
1796 monitor_printf (cmd, memaddr);
1798 /* If RESP_DELIM is specified, we search for that as a leading
1799 delimiter for the memory value. Otherwise, we just start
1800 searching from the start of the buf. */
1802 if (current_monitor->getmem.resp_delim)
1804 RDEBUG (("EXP getmem.resp_delim\n"));
1805 monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
1808 /* Now, read the appropriate number of hex digits for this loc,
1811 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1812 if (current_monitor->flags & MO_HEX_PREFIX)
1816 c = readchar (timeout);
1818 c = readchar (timeout);
1819 if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1822 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1823 memaddr, i, membuf, c);
1825 for (i = 0; i < len * 2; i++)
1831 c = readchar (timeout);
1837 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1838 memaddr, i, membuf, c);
1844 membuf[i] = '\000'; /* terminate the number */
1846 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1847 present), we will send TERM_CMD if that is present. In any case, we collect
1848 all of the output into buf, and then wait for the normal prompt. */
1850 if (current_monitor->getmem.term)
1852 monitor_expect (current_monitor->getmem.term, NULL, 0); /* get response */
1854 if (current_monitor->getmem.term_cmd)
1856 monitor_printf (current_monitor->getmem.term_cmd);
1857 monitor_expect_prompt (NULL, 0);
1861 monitor_expect_prompt (NULL, 0); /* get response */
1864 val = strtoul (membuf, &p, 16);
1866 if (val == 0 && membuf == p)
1867 monitor_error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
1868 memaddr, 0, membuf, 0);
1870 /* supply register stores in target byte order, so swap here */
1872 store_unsigned_integer (myaddr, len, val);
1877 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1878 memory at MEMADDR. Returns length moved. Currently, we do no more
1879 than 16 bytes at a time. */
1882 monitor_read_memory (memaddr, myaddr, len)
1896 RDEBUG (("Zero length call to monitor_read_memory\n"));
1901 printf ("MON read block ta(%08x) ha(%08x) %d\n",
1902 (unsigned long) memaddr, (unsigned long) myaddr, len);
1904 if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1905 memaddr = ADDR_BITS_REMOVE (memaddr);
1907 if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
1908 return monitor_read_memory_single (memaddr, myaddr, len);
1910 len = min (len, 16);
1912 /* Some dumpers align the first data with the preceeding 16
1913 byte boundary. Some print blanks and start at the
1914 requested boundary. EXACT_DUMPADDR
1917 dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
1918 ? memaddr : memaddr & ~0x0f;
1920 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1921 if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
1922 len = ((memaddr + len) & ~0xf) - memaddr;
1924 /* send the memory examine command */
1926 if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
1927 monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len);
1928 else if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1929 monitor_printf (current_monitor->getmem.cmdb, dumpaddr);
1931 monitor_printf (current_monitor->getmem.cmdb, memaddr, len);
1933 /* If TERM is present, we wait for that to show up. Also, (if TERM
1934 is present), we will send TERM_CMD if that is present. In any
1935 case, we collect all of the output into buf, and then wait for
1936 the normal prompt. */
1938 if (current_monitor->getmem.term)
1940 resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf); /* get response */
1943 monitor_error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
1944 memaddr, resp_len, buf, 0);
1946 if (current_monitor->getmem.term_cmd)
1948 SERIAL_WRITE (monitor_desc, current_monitor->getmem.term_cmd,
1949 strlen (current_monitor->getmem.term_cmd));
1950 monitor_expect_prompt (NULL, 0);
1954 resp_len = monitor_expect_prompt (buf, sizeof buf); /* get response */
1958 /* If RESP_DELIM is specified, we search for that as a leading
1959 delimiter for the values. Otherwise, we just start searching
1960 from the start of the buf. */
1962 if (current_monitor->getmem.resp_delim)
1965 struct re_registers resp_strings;
1966 RDEBUG (("MON getmem.resp_delim %s\n", current_monitor->getmem.resp_delim));
1968 memset (&resp_strings, 0, sizeof (struct re_registers));
1970 retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
1974 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1975 memaddr, resp_len, buf, 0);
1977 p += resp_strings.end[0];
1979 p = strstr (p, current_monitor->getmem.resp_delim);
1981 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1982 memaddr, resp_len, buf, 0);
1983 p += strlen (current_monitor->getmem.resp_delim);
1987 printf ("MON scanning %d ,%08x '%s'\n", len, p, p);
1988 if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1996 while (!(c == '\000' || c == '\n' || c == '\r') && i > 0)
2000 if ((dumpaddr >= memaddr) && (i > 0))
2002 val = fromhex (c) * 16 + fromhex (*(p + 1));
2005 printf ("[%02x]", val);
2012 ++p; /* skip a blank or other non hex char */
2016 error ("Failed to read via monitor");
2019 return fetched; /* Return the number of bytes actually read */
2021 RDEBUG (("MON scanning bytes\n"));
2023 for (i = len; i > 0; i--)
2025 /* Skip non-hex chars, but bomb on end of string and newlines */
2032 if (*p == '\000' || *p == '\n' || *p == '\r')
2033 monitor_error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s",
2034 memaddr, resp_len, buf, 0);
2038 val = strtoul (p, &p1, 16);
2040 if (val == 0 && p == p1)
2041 monitor_error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.",
2042 memaddr, resp_len, buf, 0);
2056 monitor_xfer_memory (memaddr, myaddr, len, write, target)
2061 struct target_ops *target; /* ignored */
2063 return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, write);
2069 return; /* ignore attempts to kill target system */
2072 /* All we actually do is set the PC to the start address of exec_bfd, and start
2073 the program at that point. */
2076 monitor_create_inferior (exec_file, args, env)
2081 if (args && (*args != '\000'))
2082 error ("Args are not supported by the monitor.");
2085 clear_proceed_status ();
2086 proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0);
2089 /* Clean up when a program exits.
2090 The program actually lives on in the remote processor's RAM, and may be
2091 run again without a download. Don't leave it full of breakpoint
2095 monitor_mourn_inferior ()
2097 unpush_target (targ_ops);
2098 generic_mourn_inferior (); /* Do all the proper things now */
2101 /* Tell the monitor to add a breakpoint. */
2104 monitor_insert_breakpoint (addr, shadow)
2112 RDEBUG (("MON inst bkpt %08x\n", addr))
2113 if (current_monitor->set_break == NULL)
2114 error ("No set_break defined for this monitor");
2116 if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
2117 addr = ADDR_BITS_REMOVE (addr);
2119 /* Determine appropriate breakpoint size for this address. */
2120 bp = memory_breakpoint_from_pc (&addr, &bplen);
2122 for (i = 0; i < current_monitor->num_breakpoints; i++)
2124 if (breakaddr[i] == 0)
2126 breakaddr[i] = addr;
2127 monitor_read_memory (addr, shadow, bplen);
2128 monitor_printf (current_monitor->set_break, addr);
2129 monitor_expect_prompt (NULL, 0);
2134 error ("Too many breakpoints (> %d) for monitor.", current_monitor->num_breakpoints);
2137 /* Tell the monitor to remove a breakpoint. */
2140 monitor_remove_breakpoint (addr, shadow)
2146 RDEBUG (("MON rmbkpt %08x\n", addr))
2147 if (current_monitor->clr_break == NULL)
2148 error ("No clr_break defined for this monitor");
2150 if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
2151 addr = ADDR_BITS_REMOVE (addr);
2153 for (i = 0; i < current_monitor->num_breakpoints; i++)
2155 if (breakaddr[i] == addr)
2158 /* some monitors remove breakpoints based on the address */
2159 if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
2160 monitor_printf (current_monitor->clr_break, addr);
2161 else if (current_monitor->flags & MO_CLR_BREAK_1_BASED)
2162 monitor_printf (current_monitor->clr_break, i + 1);
2164 monitor_printf (current_monitor->clr_break, i);
2165 monitor_expect_prompt (NULL, 0);
2169 fprintf_unfiltered (gdb_stderr,
2170 "Can't find breakpoint associated with 0x%x\n", addr);
2174 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2175 an S-record. Return non-zero if the ACK is received properly. */
2178 monitor_wait_srec_ack ()
2182 if (current_monitor->flags & MO_SREC_ACK_PLUS)
2184 return (readchar (timeout) == '+');
2186 else if (current_monitor->flags & MO_SREC_ACK_ROTATE)
2188 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2189 if ((ch = readchar (1)) < 0)
2191 if ((ch = readchar (1)) < 0)
2193 if ((ch = readchar (1)) < 0)
2195 if ((ch = readchar (1)) < 0)
2201 /* monitor_load -- download a file. */
2204 monitor_load (file, from_tty)
2208 dcache_flush (remote_dcache);
2209 RDEBUG (("MON load\n"))
2211 if (current_monitor->load_routine)
2212 current_monitor->load_routine (monitor_desc, file, hashmark);
2214 { /* The default is ascii S-records */
2216 unsigned long load_offset;
2219 /* enable user to specify address for downloading as 2nd arg to load */
2220 n = sscanf (file, "%s 0x%lx", buf, &load_offset);
2226 monitor_printf (current_monitor->load);
2227 if (current_monitor->loadresp)
2228 monitor_expect (current_monitor->loadresp, NULL, 0);
2230 load_srec (monitor_desc, file, (bfd_vma) load_offset,
2231 32, SREC_ALL, hashmark,
2232 current_monitor->flags & MO_SREC_ACK ?
2233 monitor_wait_srec_ack : NULL);
2235 monitor_expect_prompt (NULL, 0);
2238 /* Finally, make the PC point at the start address */
2241 write_pc (bfd_get_start_address (exec_bfd));
2243 inferior_pid = 0; /* No process now */
2245 /* This is necessary because many things were based on the PC at the time that
2246 we attached to the monitor, which is no longer valid now that we have loaded
2247 new code (and just changed the PC). Another way to do this might be to call
2248 normal_stop, except that the stack may not be valid, and things would get
2249 horribly confused... */
2251 clear_symtab_users ();
2257 RDEBUG (("MON stop\n"));
2258 if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
2259 SERIAL_SEND_BREAK (monitor_desc);
2260 if (current_monitor->stop)
2261 monitor_printf_noecho (current_monitor->stop);
2264 /* Put a command string, in args, out to MONITOR. Output from MONITOR
2265 is placed on the users terminal until the prompt is seen. FIXME: We
2266 read the characters ourseleves here cause of a nasty echo. */
2269 monitor_command (args, from_tty)
2277 if (monitor_desc == NULL)
2278 error ("monitor target not open.");
2280 p = current_monitor->prompt;
2282 /* Send the command. Note that if no args were supplied, then we're
2283 just sending the monitor a newline, which is sometimes useful. */
2285 monitor_printf ("%s\r", (args ? args : ""));
2287 resp_len = monitor_expect_prompt (buf, sizeof buf);
2289 fputs_unfiltered (buf, gdb_stdout); /* Output the response */
2292 /* Convert hex digit A to a number. */
2299 if (a >= '0' && a <= '9')
2301 if (a >= 'a' && a <= 'f')
2302 return a - 'a' + 10;
2303 if (a >= 'A' && a <= 'F')
2304 return a - 'A' + 10;
2306 error ("Reply contains invalid hex digit 0x%x", a);
2311 monitor_get_dev_name ()
2316 static struct target_ops monitor_ops;
2319 init_base_monitor_ops (void)
2321 monitor_ops.to_shortname = NULL;
2322 monitor_ops.to_longname = NULL;
2323 monitor_ops.to_doc = NULL;
2324 monitor_ops.to_open = NULL;
2325 monitor_ops.to_close = monitor_close;
2326 monitor_ops.to_attach = NULL;
2327 monitor_ops.to_post_attach = NULL;
2328 monitor_ops.to_require_attach = NULL;
2329 monitor_ops.to_detach = monitor_detach;
2330 monitor_ops.to_require_detach = NULL;
2331 monitor_ops.to_resume = monitor_resume;
2332 monitor_ops.to_wait = monitor_wait;
2333 monitor_ops.to_post_wait = NULL;
2334 monitor_ops.to_fetch_registers = monitor_fetch_registers;
2335 monitor_ops.to_store_registers = monitor_store_registers;
2336 monitor_ops.to_prepare_to_store = monitor_prepare_to_store;
2337 monitor_ops.to_xfer_memory = monitor_xfer_memory;
2338 monitor_ops.to_files_info = monitor_files_info;
2339 monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
2340 monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
2341 monitor_ops.to_terminal_init = 0;
2342 monitor_ops.to_terminal_inferior = 0;
2343 monitor_ops.to_terminal_ours_for_output = 0;
2344 monitor_ops.to_terminal_ours = 0;
2345 monitor_ops.to_terminal_info = 0;
2346 monitor_ops.to_kill = monitor_kill;
2347 monitor_ops.to_load = monitor_load;
2348 monitor_ops.to_lookup_symbol = 0;
2349 monitor_ops.to_create_inferior = monitor_create_inferior;
2350 monitor_ops.to_post_startup_inferior = NULL;
2351 monitor_ops.to_acknowledge_created_inferior = NULL;
2352 monitor_ops.to_clone_and_follow_inferior = NULL;
2353 monitor_ops.to_post_follow_inferior_by_clone = NULL;
2354 monitor_ops.to_insert_fork_catchpoint = NULL;
2355 monitor_ops.to_remove_fork_catchpoint = NULL;
2356 monitor_ops.to_insert_vfork_catchpoint = NULL;
2357 monitor_ops.to_remove_vfork_catchpoint = NULL;
2358 monitor_ops.to_has_forked = NULL;
2359 monitor_ops.to_has_vforked = NULL;
2360 monitor_ops.to_can_follow_vfork_prior_to_exec = NULL;
2361 monitor_ops.to_post_follow_vfork = NULL;
2362 monitor_ops.to_insert_exec_catchpoint = NULL;
2363 monitor_ops.to_remove_exec_catchpoint = NULL;
2364 monitor_ops.to_has_execd = NULL;
2365 monitor_ops.to_reported_exec_events_per_exec_call = NULL;
2366 monitor_ops.to_has_exited = NULL;
2367 monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
2368 monitor_ops.to_can_run = 0;
2369 monitor_ops.to_notice_signals = 0;
2370 monitor_ops.to_thread_alive = 0;
2371 monitor_ops.to_stop = monitor_stop;
2372 monitor_ops.to_pid_to_exec_file = NULL;
2373 monitor_ops.to_core_file_to_sym_file = NULL;
2374 monitor_ops.to_stratum = process_stratum;
2375 monitor_ops.DONT_USE = 0;
2376 monitor_ops.to_has_all_memory = 1;
2377 monitor_ops.to_has_memory = 1;
2378 monitor_ops.to_has_stack = 1;
2379 monitor_ops.to_has_registers = 1;
2380 monitor_ops.to_has_execution = 1;
2381 monitor_ops.to_sections = 0;
2382 monitor_ops.to_sections_end = 0;
2383 monitor_ops.to_magic = OPS_MAGIC;
2384 } /* init_base_monitor_ops */
2386 /* Init the target_ops structure pointed at by OPS */
2389 init_monitor_ops (ops)
2390 struct target_ops *ops;
2392 if (monitor_ops.to_magic != OPS_MAGIC)
2393 init_base_monitor_ops ();
2395 memcpy (ops, &monitor_ops, sizeof monitor_ops);
2398 /* Define additional commands that are usually only used by monitors. */
2401 _initialize_remote_monitors ()
2403 init_base_monitor_ops ();
2404 add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
2406 "Set display of activity while downloading a file.\n\
2407 When enabled, a hashmark \'#\' is displayed.",
2411 add_com ("monitor", class_obscure, monitor_command,
2412 "Send a command to the debug monitor.");