1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990-1993, 1995-1997, 1999-2000 Free Software Foundation, Inc.
3 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
4 Resurrected from the ashes by Stu Grossman.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* This file was derived from various remote-* modules. It is a collection
24 of generic support functions so GDB can talk directly to a ROM based
25 monitor. This saves use from having to hack an exception based handler
26 into existance, and makes for quick porting.
28 This module talks to a debug monitor called 'MONITOR', which
29 We communicate with MONITOR via either a direct serial line, or a TCP
30 (or possibly TELNET) stream to a terminal multiplexor,
31 which in turn talks to the target board. */
33 /* FIXME 32x64: This code assumes that registers and addresses are at
34 most 32 bits long. If they can be larger, you will need to declare
35 values as LONGEST and use %llx or some such to print values when
36 building commands to send to the monitor. Since we don't know of
37 any actual 64-bit targets with ROM monitors that use this code,
38 it's not an issue right now. -sts 4/18/96 */
46 #include "gdb_string.h"
47 #include <sys/types.h>
53 #include "gdb_regex.h"
57 static char *dev_name;
58 static struct target_ops *targ_ops;
60 static void monitor_vsprintf PARAMS ((char *sndbuf, char *pattern, va_list args));
62 static int readchar PARAMS ((int timeout));
64 static void monitor_fetch_register PARAMS ((int regno));
65 static void monitor_store_register PARAMS ((int regno));
67 static void monitor_printable_string (char *newstr, char *oldstr, int len);
68 static void monitor_error (char *function, char *message, CORE_ADDR memaddr, int len, char *string, int final_char);
69 static void monitor_detach PARAMS ((char *args, int from_tty));
70 static void monitor_resume PARAMS ((int pid, int step, enum target_signal sig));
71 static void monitor_interrupt PARAMS ((int signo));
72 static void monitor_interrupt_twice PARAMS ((int signo));
73 static void monitor_interrupt_query PARAMS ((void));
74 static void monitor_wait_cleanup PARAMS ((void *old_timeout));
76 static int monitor_wait PARAMS ((int pid, struct target_waitstatus * status));
77 static void monitor_fetch_registers PARAMS ((int regno));
78 static void monitor_store_registers PARAMS ((int regno));
79 static void monitor_prepare_to_store PARAMS ((void));
80 static int monitor_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len, int write, struct target_ops * target));
81 static void monitor_files_info PARAMS ((struct target_ops * ops));
82 static int monitor_insert_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
83 static int monitor_remove_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
84 static void monitor_kill PARAMS ((void));
85 static void monitor_load PARAMS ((char *file, int from_tty));
86 static void monitor_mourn_inferior PARAMS ((void));
87 static void monitor_stop PARAMS ((void));
89 static int monitor_read_memory PARAMS ((CORE_ADDR addr, char *myaddr, int len));
90 static int monitor_write_memory PARAMS ((CORE_ADDR addr, char *myaddr, int len));
91 static int monitor_write_memory_bytes PARAMS ((CORE_ADDR addr,
92 char *myaddr, int len));
93 static int monitor_write_memory_block PARAMS ((
97 static int monitor_expect_regexp PARAMS ((struct re_pattern_buffer * pat,
98 char *buf, int buflen));
99 static void monitor_dump_regs PARAMS ((void));
101 static int from_hex PARAMS ((int a));
102 static unsigned long get_hex_word PARAMS ((void));
104 static void parse_register_dump PARAMS ((char *, int));
106 static struct monitor_ops *current_monitor;
108 static int hashmark; /* flag set by "set hash" */
110 static int timeout = 30;
112 static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait() */
114 static void (*ofunc) (); /* Old SIGINT signal handler */
116 static CORE_ADDR *breakaddr;
118 /* Descriptor for I/O to remote machine. Initialize it to NULL so
119 that monitor_open knows that we don't have a file open when the
122 static serial_t monitor_desc = NULL;
124 /* Pointer to regexp pattern matching data */
126 static struct re_pattern_buffer register_pattern;
127 static char register_fastmap[256];
129 static struct re_pattern_buffer getmem_resp_delim_pattern;
130 static char getmem_resp_delim_fastmap[256];
132 static int dump_reg_flag; /* Non-zero means do a dump_registers cmd when
133 monitor_wait wakes up. */
135 static DCACHE *remote_dcache;
136 static int first_time = 0; /* is this the first time we're executing after
137 gaving created the child proccess? */
139 #define TARGET_BUF_SIZE 2048
141 /* Monitor specific debugging information. Typically only useful to
142 the developer of a new monitor interface. */
144 static void monitor_debug (const char *fmt, ...) ATTR_FORMAT(printf, 1, 2);
146 static int monitor_debug_p = 0;
148 /* NOTE: This file alternates between monitor_debug_p and remote_debug
149 when determining if debug information is printed. Perhaphs this
150 could be simplified. */
153 monitor_debug (const char *fmt, ...)
158 va_start (args, fmt);
159 vfprintf_filtered (gdb_stdlog, fmt, args);
165 /* Convert a string into a printable representation, Return # byte in
166 the new string. When LEN is >0 it specifies the size of the
167 string. Otherwize strlen(oldstr) is used. */
170 monitor_printable_string (char *newstr, char *oldstr, int len)
176 len = strlen (oldstr);
178 for (i = 0; i < len; i++)
189 sprintf (newstr, "\\x%02x", ch & 0xff);
228 /* Print monitor errors with a string, converting the string to printable
232 monitor_error (char *function, char *message,
233 CORE_ADDR memaddr, int len, char *string, int final_char)
235 int real_len = (len == 0 && string != (char *) 0) ? strlen (string) : len;
236 char *safe_string = alloca ((real_len * 4) + 1);
237 monitor_printable_string (safe_string, string, real_len);
240 error ("%s (0x%s): %s: %s%c", function, paddr_nz (memaddr), message, safe_string, final_char);
242 error ("%s (0x%s): %s: %s", function, paddr_nz (memaddr), message, safe_string);
245 /* Convert hex digit A to a number. */
251 if (a >= '0' && a <= '9')
253 else if (a >= 'a' && a <= 'f')
255 else if (a >= 'A' && a <= 'F')
258 error ("Invalid hex digit %d", a);
261 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
263 This function exists to get around the problem that many host platforms
264 don't have a printf that can print 64-bit addresses. The %A format
265 specification is recognized as a special case, and causes the argument
266 to be printed as a 64-bit hexadecimal address.
268 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
269 If it is a '%s' format, the argument is a string; otherwise the
270 argument is assumed to be a long integer.
272 %% is also turned into a single %.
276 monitor_vsprintf (sndbuf, pattern, args)
289 for (p = pattern; *p; p++)
293 /* Copy the format specifier to a separate buffer. */
295 for (i = 1; *p >= '0' && *p <= '9' && i < (int) sizeof (format) - 2;
298 format[i] = fmt = *p;
299 format[i + 1] = '\0';
301 /* Fetch the next argument and print it. */
305 strcpy (sndbuf, "%");
308 arg_addr = va_arg (args, CORE_ADDR);
309 strcpy (sndbuf, paddr_nz (arg_addr));
312 arg_string = va_arg (args, char *);
313 sprintf (sndbuf, format, arg_string);
316 arg_int = va_arg (args, long);
317 sprintf (sndbuf, format, arg_int);
320 sndbuf += strlen (sndbuf);
329 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
330 Works just like printf. */
333 monitor_printf_noecho (char *pattern,...)
339 va_start (args, pattern);
341 monitor_vsprintf (sndbuf, pattern, args);
343 len = strlen (sndbuf);
344 if (len + 1 > sizeof sndbuf)
349 char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);
350 monitor_printable_string (safe_string, sndbuf, 0);
351 fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
354 monitor_write (sndbuf, len);
357 /* monitor_printf -- Send data to monitor and check the echo. Works just like
361 monitor_printf (char *pattern,...)
367 va_start (args, pattern);
369 monitor_vsprintf (sndbuf, pattern, args);
371 len = strlen (sndbuf);
372 if (len + 1 > sizeof sndbuf)
377 char *safe_string = (char *) alloca ((len * 4) + 1);
378 monitor_printable_string (safe_string, sndbuf, 0);
379 fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
382 monitor_write (sndbuf, len);
384 /* We used to expect that the next immediate output was the characters we
385 just output, but sometimes some extra junk appeared before the characters
386 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
387 So, just start searching for what we sent, and skip anything unknown. */
388 monitor_debug ("ExpectEcho\n");
389 monitor_expect (sndbuf, (char *) 0, 0);
393 /* Write characters to the remote system. */
396 monitor_write (buf, buflen)
400 if (SERIAL_WRITE (monitor_desc, buf, buflen))
401 fprintf_unfiltered (gdb_stderr, "SERIAL_WRITE failed: %s\n",
402 safe_strerror (errno));
406 /* Read a binary character from the remote system, doing all the fancy
407 timeout stuff, but without interpreting the character in any way,
408 and without printing remote debug information. */
419 c = SERIAL_READCHAR (monitor_desc, timeout);
422 c &= 0xff; /* don't lose bit 7 */
429 if (c == SERIAL_TIMEOUT)
430 error ("Timeout reading from remote system.");
432 perror_with_name ("remote-monitor");
436 /* Read a character from the remote system, doing all the fancy
446 last_random, last_nl, last_cr, last_crnl
454 c = SERIAL_READCHAR (monitor_desc, timeout);
459 /* This seems to interfere with proper function of the
461 if (monitor_debug_p || remote_debug)
466 puts_debug ("read -->", buf, "<--");
471 /* Canonicialize \n\r combinations into one \r */
472 if ((current_monitor->flags & MO_HANDLE_NL) != 0)
474 if ((c == '\r' && state == last_nl)
475 || (c == '\n' && state == last_cr))
496 if (c == SERIAL_TIMEOUT)
498 /* I fail to see how detaching here can be useful */
499 if (in_monitor_wait) /* Watchdog went off */
501 target_mourn_inferior ();
502 error ("GDB serial timeout has expired. Target detached.\n");
506 error ("Timeout reading from remote system.");
508 perror_with_name ("remote-monitor");
511 /* Scan input from the remote system, until STRING is found. If BUF is non-
512 zero, then collect input until we have collected either STRING or BUFLEN-1
513 chars. In either case we terminate BUF with a 0. If input overflows BUF
514 because STRING can't be found, return -1, else return number of chars in BUF
515 (minus the terminating NUL). Note that in the non-overflow case, STRING
516 will be at the end of BUF. */
519 monitor_expect (string, buf, buflen)
525 int obuflen = buflen;
527 extern struct target_ops *targ_ops;
531 char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
532 monitor_printable_string (safe_string, string, 0);
533 fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
548 c = readchar (timeout);
555 c = readchar (timeout);
557 /* Don't expect any ^C sent to be echoed */
559 if (*p == '\003' || c == *p)
569 return obuflen - buflen;
575 else if ((c == '\021' || c == '\023') &&
576 (STREQ (targ_ops->to_shortname, "m32r")
577 || STREQ (targ_ops->to_shortname, "mon2000")))
578 { /* m32r monitor emits random DC1/DC3 chars */
583 /* We got a character that doesn't match the string. We need to
584 back up p, but how far? If we're looking for "..howdy" and the
585 monitor sends "...howdy"? There's certainly a match in there,
586 but when we receive the third ".", we won't find it if we just
587 restart the matching at the beginning of the string.
589 This is a Boyer-Moore kind of situation. We want to reset P to
590 the end of the longest prefix of STRING that is a suffix of
591 what we've read so far. In the example above, that would be
592 ".." --- the longest prefix of "..howdy" that is a suffix of
593 "...". This longest prefix could be the empty string, if C
594 is nowhere to be found in STRING.
596 If this longest prefix is not the empty string, it must contain
597 C, so let's search from the end of STRING for instances of C,
598 and see if the portion of STRING before that is a suffix of
599 what we read before C. Actually, we can search backwards from
600 p, since we know no prefix can be longer than that.
602 Note that we can use STRING itself, along with C, as a record
603 of what we've received so far. :) */
606 for (i = (p - string) - 1; i >= 0; i--)
609 /* Is this prefix a suffix of what we've read so far?
611 string[0 .. i-1] == string[p - i, p - 1]? */
612 if (! memcmp (string, p - i, i))
624 /* Search for a regexp. */
627 monitor_expect_regexp (pat, buf, buflen)
628 struct re_pattern_buffer *pat;
634 monitor_debug ("MON Expecting regexp\n");
639 mybuf = alloca (TARGET_BUF_SIZE);
640 buflen = TARGET_BUF_SIZE;
648 if (p - mybuf >= buflen)
649 { /* Buffer about to overflow */
651 /* On overflow, we copy the upper half of the buffer to the lower half. Not
652 great, but it usually works... */
654 memcpy (mybuf, mybuf + buflen / 2, buflen / 2);
655 p = mybuf + buflen / 2;
658 *p++ = readchar (timeout);
660 retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL);
666 /* Keep discarding input until we see the MONITOR prompt.
668 The convention for dealing with the prompt is that you
670 o *then* wait for the prompt.
672 Thus the last thing that a procedure does with the serial line will
673 be an monitor_expect_prompt(). Exception: monitor_resume does not
674 wait for the prompt, because the terminal is being handed over to
675 the inferior. However, the next thing which happens after that is
676 a monitor_wait which does wait for the prompt. Note that this
677 includes abnormal exit, e.g. error(). This is necessary to prevent
678 getting into states from which we can't recover. */
681 monitor_expect_prompt (buf, buflen)
685 monitor_debug ("MON Expecting prompt\n");
686 return monitor_expect (current_monitor->prompt, buf, buflen);
689 /* Get N 32-bit words from remote, each preceded by a space, and put
690 them in registers starting at REGNO. */
701 ch = readchar (timeout);
702 while (isspace (ch));
706 for (i = 7; i >= 1; i--)
708 ch = readchar (timeout);
711 val = (val << 4) | from_hex (ch);
719 compile_pattern (pattern, compiled_pattern, fastmap)
721 struct re_pattern_buffer *compiled_pattern;
727 compiled_pattern->fastmap = fastmap;
729 tmp = re_set_syntax (RE_SYNTAX_EMACS);
730 val = re_compile_pattern (pattern,
736 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern, val);
739 re_compile_fastmap (compiled_pattern);
742 /* Open a connection to a remote debugger. NAME is the filename used
743 for communication. */
746 monitor_open (args, mon_ops, from_tty)
748 struct monitor_ops *mon_ops;
754 if (mon_ops->magic != MONITOR_OPS_MAGIC)
755 error ("Magic number of monitor_ops struct wrong.");
757 targ_ops = mon_ops->target;
758 name = targ_ops->to_shortname;
761 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
762 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name, name);
764 target_preopen (from_tty);
766 /* Setup pattern for register dump */
768 if (mon_ops->register_pattern)
769 compile_pattern (mon_ops->register_pattern, ®ister_pattern,
772 if (mon_ops->getmem.resp_delim)
773 compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
774 getmem_resp_delim_fastmap);
776 unpush_target (targ_ops);
780 dev_name = strsave (args);
782 monitor_desc = SERIAL_OPEN (dev_name);
785 perror_with_name (dev_name);
789 if (SERIAL_SETBAUDRATE (monitor_desc, baud_rate))
791 SERIAL_CLOSE (monitor_desc);
792 perror_with_name (dev_name);
796 SERIAL_RAW (monitor_desc);
798 SERIAL_FLUSH_INPUT (monitor_desc);
800 /* some systems only work with 2 stop bits */
802 SERIAL_SETSTOPBITS (monitor_desc, mon_ops->stopbits);
804 current_monitor = mon_ops;
806 /* See if we can wake up the monitor. First, try sending a stop sequence,
807 then send the init strings. Last, remove all breakpoints. */
809 if (current_monitor->stop)
812 if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
814 monitor_debug ("EXP Open echo\n");
815 monitor_expect_prompt (NULL, 0);
819 /* wake up the monitor and see if it's alive */
820 for (p = mon_ops->init; *p != NULL; p++)
822 /* Some of the characters we send may not be echoed,
823 but we hope to get a prompt at the end of it all. */
825 if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
828 monitor_printf_noecho (*p);
829 monitor_expect_prompt (NULL, 0);
832 SERIAL_FLUSH_INPUT (monitor_desc);
834 /* Alloc breakpoints */
835 if (mon_ops->set_break != NULL)
837 if (mon_ops->num_breakpoints == 0)
838 mon_ops->num_breakpoints = 8;
840 breakaddr = (CORE_ADDR *) xmalloc (mon_ops->num_breakpoints * sizeof (CORE_ADDR));
841 memset (breakaddr, 0, mon_ops->num_breakpoints * sizeof (CORE_ADDR));
844 /* Remove all breakpoints */
846 if (mon_ops->clr_all_break)
848 monitor_printf (mon_ops->clr_all_break);
849 monitor_expect_prompt (NULL, 0);
853 printf_unfiltered ("Remote target %s connected to %s\n", name, dev_name);
855 push_target (targ_ops);
857 inferior_pid = 42000; /* Make run command think we are busy... */
859 /* Give monitor_wait something to read */
861 monitor_printf (current_monitor->line_term);
863 if (current_monitor->flags & MO_HAS_BLOCKWRITES)
864 remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory_block);
866 remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory);
870 /* Close out all files and local state before this target loses
874 monitor_close (quitting)
878 SERIAL_CLOSE (monitor_desc);
880 /* Free breakpoint memory */
881 if (breakaddr != NULL)
890 /* Terminate the open connection to the remote debugger. Use this
891 when you want to detach and do something else with your gdb. */
894 monitor_detach (args, from_tty)
898 pop_target (); /* calls monitor_close to do the real work */
900 printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
903 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
906 monitor_supply_register (regno, valstr)
911 unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
916 while (p && *p != '\0')
918 if (*p == '\r' || *p == '\n')
929 if (!isxdigit (*p) && *p != 'x')
935 val += fromhex (*p++);
937 monitor_debug ("Supplying Register %d %s\n", regno, valstr);
940 error ("monitor_supply_register (%d): bad value from monitor: %s.",
943 /* supply register stores in target byte order, so swap here */
945 store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
947 supply_register (regno, regbuf);
952 /* Tell the remote machine to resume. */
955 flush_monitor_dcache ()
957 dcache_flush (remote_dcache);
961 monitor_resume (pid, step, sig)
963 enum target_signal sig;
965 /* Some monitors require a different command when starting a program */
966 monitor_debug ("MON resume\n");
967 if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
970 monitor_printf ("run\r");
971 if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
975 dcache_flush (remote_dcache);
977 monitor_printf (current_monitor->step);
980 if (current_monitor->continue_hook)
981 (*current_monitor->continue_hook) ();
983 monitor_printf (current_monitor->cont);
984 if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
989 /* Parse the output of a register dump command. A monitor specific
990 regexp is used to extract individual register descriptions of the
991 form REG=VAL. Each description is split up into a name and a value
992 string which are passed down to monitor specific code. */
995 parse_register_dump (buf, len)
999 monitor_debug ("MON Parsing register dump\n");
1002 int regnamelen, vallen;
1003 char *regname, *val;
1004 /* Element 0 points to start of register name, and element 1
1005 points to the start of the register value. */
1006 struct re_registers register_strings;
1008 memset (®ister_strings, 0, sizeof (struct re_registers));
1010 if (re_search (®ister_pattern, buf, len, 0, len,
1011 ®ister_strings) == -1)
1014 regnamelen = register_strings.end[1] - register_strings.start[1];
1015 regname = buf + register_strings.start[1];
1016 vallen = register_strings.end[2] - register_strings.start[2];
1017 val = buf + register_strings.start[2];
1019 current_monitor->supply_register (regname, regnamelen, val, vallen);
1021 buf += register_strings.end[0];
1022 len -= register_strings.end[0];
1026 /* Send ^C to target to halt it. Target will respond, and send us a
1030 monitor_interrupt (signo)
1033 /* If this doesn't work, try more severe steps. */
1034 signal (signo, monitor_interrupt_twice);
1036 if (monitor_debug_p || remote_debug)
1037 fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
1042 /* The user typed ^C twice. */
1045 monitor_interrupt_twice (signo)
1048 signal (signo, ofunc);
1050 monitor_interrupt_query ();
1052 signal (signo, monitor_interrupt);
1055 /* Ask the user what to do when an interrupt is received. */
1058 monitor_interrupt_query ()
1060 target_terminal_ours ();
1062 if (query ("Interrupted while waiting for the program.\n\
1063 Give up (and stop debugging it)? "))
1065 target_mourn_inferior ();
1066 return_to_top_level (RETURN_QUIT);
1069 target_terminal_inferior ();
1073 monitor_wait_cleanup (old_timeout)
1076 timeout = *(int *) old_timeout;
1077 signal (SIGINT, ofunc);
1078 in_monitor_wait = 0;
1084 monitor_wait_filter (char *buf,
1087 struct target_waitstatus *status
1093 resp_len = monitor_expect_prompt (buf, bufmax);
1094 *ext_resp_len = resp_len;
1097 fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
1099 while (resp_len < 0);
1101 /* Print any output characters that were preceded by ^O. */
1102 /* FIXME - This would be great as a user settabgle flag */
1103 if (monitor_debug_p || remote_debug
1104 || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
1108 for (i = 0; i < resp_len - 1; i++)
1110 putchar_unfiltered (buf[++i]);
1116 /* Wait until the remote machine stops, then return, storing status in
1117 status just as `wait' would. */
1120 monitor_wait (pid, status)
1122 struct target_waitstatus *status;
1124 int old_timeout = timeout;
1125 char buf[TARGET_BUF_SIZE];
1127 struct cleanup *old_chain;
1129 status->kind = TARGET_WAITKIND_EXITED;
1130 status->value.integer = 0;
1132 old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
1133 monitor_debug ("MON wait\n");
1136 /* This is somthing other than a maintenance command */
1137 in_monitor_wait = 1;
1138 timeout = watchdog > 0 ? watchdog : -1;
1140 timeout = -1; /* Don't time out -- user program is running. */
1143 ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
1145 if (current_monitor->wait_filter)
1146 (*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status);
1148 monitor_wait_filter (buf, sizeof (buf), &resp_len, status);
1150 #if 0 /* Transferred to monitor wait filter */
1153 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1156 fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
1158 while (resp_len < 0);
1160 /* Print any output characters that were preceded by ^O. */
1161 /* FIXME - This would be great as a user settabgle flag */
1162 if (monitor_debug_p || remote_debug
1163 || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
1167 for (i = 0; i < resp_len - 1; i++)
1169 putchar_unfiltered (buf[++i]);
1173 signal (SIGINT, ofunc);
1175 timeout = old_timeout;
1177 if (dump_reg_flag && current_monitor->dump_registers)
1180 monitor_printf (current_monitor->dump_registers);
1181 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1184 if (current_monitor->register_pattern)
1185 parse_register_dump (buf, resp_len);
1187 monitor_debug ("Wait fetching registers after stop\n");
1188 monitor_dump_regs ();
1191 status->kind = TARGET_WAITKIND_STOPPED;
1192 status->value.sig = TARGET_SIGNAL_TRAP;
1194 discard_cleanups (old_chain);
1196 in_monitor_wait = 0;
1198 return inferior_pid;
1201 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1205 monitor_fetch_register (regno)
1213 regbuf = alloca (MAX_REGISTER_RAW_SIZE * 2 + 1);
1214 zerobuf = alloca (MAX_REGISTER_RAW_SIZE);
1215 memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE);
1217 name = current_monitor->regnames[regno];
1218 monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
1220 if (!name || (*name == '\0'))
1222 monitor_debug ("No register known for %d\n", regno);
1223 supply_register (regno, zerobuf);
1227 /* send the register examine command */
1229 monitor_printf (current_monitor->getreg.cmd, name);
1231 /* If RESP_DELIM is specified, we search for that as a leading
1232 delimiter for the register value. Otherwise, we just start
1233 searching from the start of the buf. */
1235 if (current_monitor->getreg.resp_delim)
1237 monitor_debug ("EXP getreg.resp_delim\n");
1238 monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1239 /* Handle case of first 32 registers listed in pairs. */
1240 if (current_monitor->flags & MO_32_REGS_PAIRED
1241 && (regno & 1) != 0 && regno < 32)
1243 monitor_debug ("EXP getreg.resp_delim\n");
1244 monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1248 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1249 if (current_monitor->flags & MO_HEX_PREFIX)
1252 c = readchar (timeout);
1254 c = readchar (timeout);
1255 if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1258 error ("Bad value returned from monitor while fetching register %x.",
1262 /* Read upto the maximum number of hex digits for this register, skipping
1263 spaces, but stop reading if something else is seen. Some monitors
1264 like to drop leading zeros. */
1266 for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
1269 c = readchar (timeout);
1271 c = readchar (timeout);
1279 regbuf[i] = '\000'; /* terminate the number */
1280 monitor_debug ("REGVAL '%s'\n", regbuf);
1282 /* If TERM is present, we wait for that to show up. Also, (if TERM
1283 is present), we will send TERM_CMD if that is present. In any
1284 case, we collect all of the output into buf, and then wait for
1285 the normal prompt. */
1287 if (current_monitor->getreg.term)
1289 monitor_debug ("EXP getreg.term\n");
1290 monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */
1293 if (current_monitor->getreg.term_cmd)
1295 monitor_debug ("EMIT getreg.term.cmd\n");
1296 monitor_printf (current_monitor->getreg.term_cmd);
1298 if (!current_monitor->getreg.term || /* Already expected or */
1299 current_monitor->getreg.term_cmd) /* ack expected */
1300 monitor_expect_prompt (NULL, 0); /* get response */
1302 monitor_supply_register (regno, regbuf);
1305 /* Sometimes, it takes several commands to dump the registers */
1306 /* This is a primitive for use by variations of monitor interfaces in
1307 case they need to compose the operation.
1310 monitor_dump_reg_block (char *block_cmd)
1312 char buf[TARGET_BUF_SIZE];
1314 monitor_printf (block_cmd);
1315 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1316 parse_register_dump (buf, resp_len);
1321 /* Read the remote registers into the block regs. */
1322 /* Call the specific function if it has been provided */
1325 monitor_dump_regs ()
1327 char buf[TARGET_BUF_SIZE];
1329 if (current_monitor->dumpregs)
1330 (*(current_monitor->dumpregs)) (); /* call supplied function */
1331 else if (current_monitor->dump_registers) /* default version */
1333 monitor_printf (current_monitor->dump_registers);
1334 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1335 parse_register_dump (buf, resp_len);
1338 abort (); /* Need some way to read registers */
1342 monitor_fetch_registers (regno)
1345 monitor_debug ("MON fetchregs\n");
1346 if (current_monitor->getreg.cmd)
1350 monitor_fetch_register (regno);
1354 for (regno = 0; regno < NUM_REGS; regno++)
1355 monitor_fetch_register (regno);
1359 monitor_dump_regs ();
1363 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1366 monitor_store_register (regno)
1372 name = current_monitor->regnames[regno];
1373 if (!name || (*name == '\0'))
1375 monitor_debug ("MON Cannot store unknown register\n");
1379 val = read_register (regno);
1380 monitor_debug ("MON storeg %d %s\n", regno,
1381 phex (val, REGISTER_RAW_SIZE (regno)));
1383 /* send the register deposit command */
1385 if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
1386 monitor_printf (current_monitor->setreg.cmd, val, name);
1387 else if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1388 monitor_printf (current_monitor->setreg.cmd, name);
1390 monitor_printf (current_monitor->setreg.cmd, name, val);
1392 if (current_monitor->setreg.term)
1394 monitor_debug ("EXP setreg.term\n");
1395 monitor_expect (current_monitor->setreg.term, NULL, 0);
1396 if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1397 monitor_printf ("%s\r", paddr_nz (val));
1398 monitor_expect_prompt (NULL, 0);
1401 monitor_expect_prompt (NULL, 0);
1402 if (current_monitor->setreg.term_cmd) /* Mode exit required */
1404 monitor_debug ("EXP setreg_termcmd\n");
1405 monitor_printf ("%s", current_monitor->setreg.term_cmd);
1406 monitor_expect_prompt (NULL, 0);
1408 } /* monitor_store_register */
1410 /* Store the remote registers. */
1413 monitor_store_registers (regno)
1418 monitor_store_register (regno);
1422 for (regno = 0; regno < NUM_REGS; regno++)
1423 monitor_store_register (regno);
1426 /* Get ready to modify the registers array. On machines which store
1427 individual registers, this doesn't need to do anything. On machines
1428 which store all the registers in one fell swoop, this makes sure
1429 that registers contains all the registers from the program being
1433 monitor_prepare_to_store ()
1435 /* Do nothing, since we can store individual regs */
1439 monitor_files_info (ops)
1440 struct target_ops *ops;
1442 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
1446 monitor_write_memory (memaddr, myaddr, len)
1451 unsigned int val, hostval;
1455 monitor_debug ("MON write %d %s\n", len, paddr (memaddr));
1457 if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1458 memaddr = ADDR_BITS_REMOVE (memaddr);
1460 /* Use memory fill command for leading 0 bytes. */
1462 if (current_monitor->fill)
1464 for (i = 0; i < len; i++)
1468 if (i > 4) /* More than 4 zeros is worth doing */
1470 monitor_debug ("MON FILL %d\n", i);
1471 if (current_monitor->flags & MO_FILL_USES_ADDR)
1472 monitor_printf (current_monitor->fill, memaddr, (memaddr + i) - 1, 0);
1474 monitor_printf (current_monitor->fill, memaddr, i, 0);
1476 monitor_expect_prompt (NULL, 0);
1483 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1484 if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
1487 cmd = current_monitor->setmem.cmdll;
1491 if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
1494 cmd = current_monitor->setmem.cmdl;
1496 else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw)
1499 cmd = current_monitor->setmem.cmdw;
1504 cmd = current_monitor->setmem.cmdb;
1507 val = extract_unsigned_integer (myaddr, len);
1511 hostval = *(unsigned int *) myaddr;
1512 monitor_debug ("Hostval(%08x) val(%08x)\n", hostval, val);
1516 if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
1517 monitor_printf_noecho (cmd, memaddr, val);
1518 else if (current_monitor->flags & MO_SETMEM_INTERACTIVE)
1521 monitor_printf_noecho (cmd, memaddr);
1523 if (current_monitor->setmem.term)
1525 monitor_debug ("EXP setmem.term");
1526 monitor_expect (current_monitor->setmem.term, NULL, 0);
1527 monitor_printf ("%x\r", val);
1529 if (current_monitor->setmem.term_cmd)
1530 { /* Emit this to get out of the memory editing state */
1531 monitor_printf ("%s", current_monitor->setmem.term_cmd);
1532 /* Drop through to expecting a prompt */
1536 monitor_printf (cmd, memaddr, val);
1538 monitor_expect_prompt (NULL, 0);
1545 monitor_write_even_block (memaddr, myaddr, len)
1552 /* Enter the sub mode */
1553 monitor_printf (current_monitor->setmem.cmdl, memaddr);
1554 monitor_expect_prompt (NULL, 0);
1558 val = extract_unsigned_integer (myaddr, 4); /* REALLY */
1559 monitor_printf ("%x\r", val);
1563 monitor_debug (" @ %s\n", paddr (memaddr));
1564 /* If we wanted to, here we could validate the address */
1565 monitor_expect_prompt (NULL, 0);
1567 /* Now exit the sub mode */
1568 monitor_printf (current_monitor->getreg.term_cmd);
1569 monitor_expect_prompt (NULL, 0);
1575 monitor_write_memory_bytes (memaddr, myaddr, len)
1584 /* Enter the sub mode */
1585 monitor_printf (current_monitor->setmem.cmdb, memaddr);
1586 monitor_expect_prompt (NULL, 0);
1590 monitor_printf ("%x\r", val);
1594 /* If we wanted to, here we could validate the address */
1595 monitor_expect_prompt (NULL, 0);
1598 /* Now exit the sub mode */
1599 monitor_printf (current_monitor->getreg.term_cmd);
1600 monitor_expect_prompt (NULL, 0);
1606 longlongendswap (unsigned char *a)
1615 *(a + i) = *(a + j);
1620 /* Format 32 chars of long long value, advance the pointer */
1621 static char *hexlate = "0123456789abcdef";
1623 longlong_hexchars (unsigned long long value,
1633 static unsigned char disbuf[8]; /* disassembly buffer */
1634 unsigned char *scan, *limit; /* loop controls */
1635 unsigned char c, nib;
1640 unsigned long long *dp;
1641 dp = (unsigned long long *) scan;
1644 longlongendswap (disbuf); /* FIXME: ONly on big endian hosts */
1645 while (scan < limit)
1647 c = *scan++; /* a byte of our long long value */
1653 leadzero = 0; /* henceforth we print even zeroes */
1655 nib = c >> 4; /* high nibble bits */
1656 *outbuff++ = hexlate[nib];
1657 nib = c & 0x0f; /* low nibble bits */
1658 *outbuff++ = hexlate[nib];
1662 } /* longlong_hexchars */
1666 /* I am only going to call this when writing virtual byte streams.
1667 Which possably entails endian conversions
1670 monitor_write_memory_longlongs (memaddr, myaddr, len)
1675 static char hexstage[20]; /* At least 16 digits required, plus null */
1680 llptr = (unsigned long long *) myaddr;
1683 monitor_printf (current_monitor->setmem.cmdll, memaddr);
1684 monitor_expect_prompt (NULL, 0);
1688 endstring = longlong_hexchars (*llptr, hexstage);
1689 *endstring = '\0'; /* NUll terminate for printf */
1690 monitor_printf ("%s\r", hexstage);
1694 /* If we wanted to, here we could validate the address */
1695 monitor_expect_prompt (NULL, 0);
1698 /* Now exit the sub mode */
1699 monitor_printf (current_monitor->getreg.term_cmd);
1700 monitor_expect_prompt (NULL, 0);
1706 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1707 /* This is for the large blocks of memory which may occur in downloading.
1708 And for monitors which use interactive entry,
1709 And for monitors which do not have other downloading methods.
1710 Without this, we will end up calling monitor_write_memory many times
1711 and do the entry and exit of the sub mode many times
1712 This currently assumes...
1713 MO_SETMEM_INTERACTIVE
1714 ! MO_NO_ECHO_ON_SETMEM
1715 To use this, the you have to patch the monitor_cmds block with
1716 this function. Otherwise, its not tuned up for use by all
1721 monitor_write_memory_block (memaddr, myaddr, len)
1728 /* FIXME: This would be a good place to put the zero test */
1730 if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
1732 return monitor_write_memory_longlongs (memaddr, myaddr, len);
1739 written = monitor_write_even_block (memaddr, myaddr, len);
1740 /* Adjust calling parameters by written amount */
1746 written = monitor_write_memory_bytes (memaddr, myaddr, len);
1750 /* This is an alternate form of monitor_read_memory which is used for monitors
1751 which can only read a single byte/word/etc. at a time. */
1754 monitor_read_memory_single (memaddr, myaddr, len)
1760 char membuf[sizeof (int) * 2 + 1];
1765 monitor_debug ("MON read single\n");
1767 /* Can't actually use long longs (nice idea, though). In fact, the
1768 call to strtoul below will fail if it tries to convert a value
1769 that's too big to fit in a long. */
1770 if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
1773 cmd = current_monitor->getmem.cmdll;
1777 if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
1780 cmd = current_monitor->getmem.cmdl;
1782 else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->getmem.cmdw)
1785 cmd = current_monitor->getmem.cmdw;
1790 cmd = current_monitor->getmem.cmdb;
1793 /* Send the examine command. */
1795 monitor_printf (cmd, memaddr);
1797 /* If RESP_DELIM is specified, we search for that as a leading
1798 delimiter for the memory value. Otherwise, we just start
1799 searching from the start of the buf. */
1801 if (current_monitor->getmem.resp_delim)
1803 monitor_debug ("EXP getmem.resp_delim\n");
1804 monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
1807 /* Now, read the appropriate number of hex digits for this loc,
1810 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1811 if (current_monitor->flags & MO_HEX_PREFIX)
1815 c = readchar (timeout);
1817 c = readchar (timeout);
1818 if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1821 monitor_error ("monitor_read_memory_single",
1822 "bad response from monitor",
1823 memaddr, i, membuf, c);
1825 for (i = 0; i < len * 2; i++)
1831 c = readchar (timeout);
1837 monitor_error ("monitor_read_memory_single",
1838 "bad response from monitor",
1839 memaddr, i, membuf, c);
1845 membuf[i] = '\000'; /* terminate the number */
1847 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1848 present), we will send TERM_CMD if that is present. In any case, we collect
1849 all of the output into buf, and then wait for the normal prompt. */
1851 if (current_monitor->getmem.term)
1853 monitor_expect (current_monitor->getmem.term, NULL, 0); /* get response */
1855 if (current_monitor->getmem.term_cmd)
1857 monitor_printf (current_monitor->getmem.term_cmd);
1858 monitor_expect_prompt (NULL, 0);
1862 monitor_expect_prompt (NULL, 0); /* get response */
1865 val = strtoul (membuf, &p, 16);
1867 if (val == 0 && membuf == p)
1868 monitor_error ("monitor_read_memory_single",
1869 "bad value from monitor",
1870 memaddr, 0, membuf, 0);
1872 /* supply register stores in target byte order, so swap here */
1874 store_unsigned_integer (myaddr, len, val);
1879 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1880 memory at MEMADDR. Returns length moved. Currently, we do no more
1881 than 16 bytes at a time. */
1884 monitor_read_memory (memaddr, myaddr, len)
1898 monitor_debug ("Zero length call to monitor_read_memory\n");
1902 monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
1903 paddr_nz (memaddr), (long) myaddr, len);
1905 if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1906 memaddr = ADDR_BITS_REMOVE (memaddr);
1908 if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
1909 return monitor_read_memory_single (memaddr, myaddr, len);
1911 len = min (len, 16);
1913 /* Some dumpers align the first data with the preceeding 16
1914 byte boundary. Some print blanks and start at the
1915 requested boundary. EXACT_DUMPADDR
1918 dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
1919 ? memaddr : memaddr & ~0x0f;
1921 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1922 if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
1923 len = ((memaddr + len) & ~0xf) - memaddr;
1925 /* send the memory examine command */
1927 if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
1928 monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len);
1929 else if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1930 monitor_printf (current_monitor->getmem.cmdb, dumpaddr);
1932 monitor_printf (current_monitor->getmem.cmdb, memaddr, len);
1934 /* If TERM is present, we wait for that to show up. Also, (if TERM
1935 is present), we will send TERM_CMD if that is present. In any
1936 case, we collect all of the output into buf, and then wait for
1937 the normal prompt. */
1939 if (current_monitor->getmem.term)
1941 resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf); /* get response */
1944 monitor_error ("monitor_read_memory",
1945 "excessive response from monitor",
1946 memaddr, resp_len, buf, 0);
1948 if (current_monitor->getmem.term_cmd)
1950 SERIAL_WRITE (monitor_desc, current_monitor->getmem.term_cmd,
1951 strlen (current_monitor->getmem.term_cmd));
1952 monitor_expect_prompt (NULL, 0);
1956 resp_len = monitor_expect_prompt (buf, sizeof buf); /* get response */
1960 /* If RESP_DELIM is specified, we search for that as a leading
1961 delimiter for the values. Otherwise, we just start searching
1962 from the start of the buf. */
1964 if (current_monitor->getmem.resp_delim)
1967 struct re_registers resp_strings;
1968 monitor_debug ("MON getmem.resp_delim %s\n", current_monitor->getmem.resp_delim);
1970 memset (&resp_strings, 0, sizeof (struct re_registers));
1972 retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
1976 monitor_error ("monitor_read_memory",
1977 "bad response from monitor",
1978 memaddr, resp_len, buf, 0);
1980 p += resp_strings.end[0];
1982 p = strstr (p, current_monitor->getmem.resp_delim);
1984 monitor_error ("monitor_read_memory",
1985 "bad response from monitor",
1986 memaddr, resp_len, buf, 0);
1987 p += strlen (current_monitor->getmem.resp_delim);
1990 monitor_debug ("MON scanning %d ,%lx '%s'\n", len, (long) p, p);
1991 if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1999 while (!(c == '\000' || c == '\n' || c == '\r') && i > 0)
2003 if ((dumpaddr >= memaddr) && (i > 0))
2005 val = fromhex (c) * 16 + fromhex (*(p + 1));
2007 if (monitor_debug_p || remote_debug)
2008 fprintf_unfiltered (gdb_stdlog, "[%02x]", val);
2015 ++p; /* skip a blank or other non hex char */
2019 error ("Failed to read via monitor");
2020 if (monitor_debug_p || remote_debug)
2021 fprintf_unfiltered (gdb_stdlog, "\n");
2022 return fetched; /* Return the number of bytes actually read */
2024 monitor_debug ("MON scanning bytes\n");
2026 for (i = len; i > 0; i--)
2028 /* Skip non-hex chars, but bomb on end of string and newlines */
2035 if (*p == '\000' || *p == '\n' || *p == '\r')
2036 monitor_error ("monitor_read_memory",
2037 "badly terminated response from monitor",
2038 memaddr, resp_len, buf, 0);
2042 val = strtoul (p, &p1, 16);
2044 if (val == 0 && p == p1)
2045 monitor_error ("monitor_read_memory",
2046 "bad value from monitor",
2047 memaddr, resp_len, buf, 0);
2061 monitor_xfer_memory (memaddr, myaddr, len, write, target)
2066 struct target_ops *target; /* ignored */
2068 return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, write);
2074 return; /* ignore attempts to kill target system */
2077 /* All we actually do is set the PC to the start address of exec_bfd, and start
2078 the program at that point. */
2081 monitor_create_inferior (exec_file, args, env)
2086 if (args && (*args != '\000'))
2087 error ("Args are not supported by the monitor.");
2090 clear_proceed_status ();
2091 proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0);
2094 /* Clean up when a program exits.
2095 The program actually lives on in the remote processor's RAM, and may be
2096 run again without a download. Don't leave it full of breakpoint
2100 monitor_mourn_inferior ()
2102 unpush_target (targ_ops);
2103 generic_mourn_inferior (); /* Do all the proper things now */
2106 /* Tell the monitor to add a breakpoint. */
2109 monitor_insert_breakpoint (addr, shadow)
2117 monitor_debug ("MON inst bkpt %s\n", paddr (addr));
2118 if (current_monitor->set_break == NULL)
2119 error ("No set_break defined for this monitor");
2121 if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
2122 addr = ADDR_BITS_REMOVE (addr);
2124 /* Determine appropriate breakpoint size for this address. */
2125 bp = memory_breakpoint_from_pc (&addr, &bplen);
2127 for (i = 0; i < current_monitor->num_breakpoints; i++)
2129 if (breakaddr[i] == 0)
2131 breakaddr[i] = addr;
2132 monitor_read_memory (addr, shadow, bplen);
2133 monitor_printf (current_monitor->set_break, addr);
2134 monitor_expect_prompt (NULL, 0);
2139 error ("Too many breakpoints (> %d) for monitor.", current_monitor->num_breakpoints);
2142 /* Tell the monitor to remove a breakpoint. */
2145 monitor_remove_breakpoint (addr, shadow)
2151 monitor_debug ("MON rmbkpt %s\n", paddr (addr));
2152 if (current_monitor->clr_break == NULL)
2153 error ("No clr_break defined for this monitor");
2155 if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
2156 addr = ADDR_BITS_REMOVE (addr);
2158 for (i = 0; i < current_monitor->num_breakpoints; i++)
2160 if (breakaddr[i] == addr)
2163 /* some monitors remove breakpoints based on the address */
2164 if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
2165 monitor_printf (current_monitor->clr_break, addr);
2166 else if (current_monitor->flags & MO_CLR_BREAK_1_BASED)
2167 monitor_printf (current_monitor->clr_break, i + 1);
2169 monitor_printf (current_monitor->clr_break, i);
2170 monitor_expect_prompt (NULL, 0);
2174 fprintf_unfiltered (gdb_stderr,
2175 "Can't find breakpoint associated with 0x%s\n",
2180 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2181 an S-record. Return non-zero if the ACK is received properly. */
2184 monitor_wait_srec_ack ()
2188 if (current_monitor->flags & MO_SREC_ACK_PLUS)
2190 return (readchar (timeout) == '+');
2192 else if (current_monitor->flags & MO_SREC_ACK_ROTATE)
2194 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2195 if ((ch = readchar (1)) < 0)
2197 if ((ch = readchar (1)) < 0)
2199 if ((ch = readchar (1)) < 0)
2201 if ((ch = readchar (1)) < 0)
2207 /* monitor_load -- download a file. */
2210 monitor_load (file, from_tty)
2214 dcache_flush (remote_dcache);
2215 monitor_debug ("MON load\n");
2217 if (current_monitor->load_routine)
2218 current_monitor->load_routine (monitor_desc, file, hashmark);
2220 { /* The default is ascii S-records */
2222 unsigned long load_offset;
2225 /* enable user to specify address for downloading as 2nd arg to load */
2226 n = sscanf (file, "%s 0x%lx", buf, &load_offset);
2232 monitor_printf (current_monitor->load);
2233 if (current_monitor->loadresp)
2234 monitor_expect (current_monitor->loadresp, NULL, 0);
2236 load_srec (monitor_desc, file, (bfd_vma) load_offset,
2237 32, SREC_ALL, hashmark,
2238 current_monitor->flags & MO_SREC_ACK ?
2239 monitor_wait_srec_ack : NULL);
2241 monitor_expect_prompt (NULL, 0);
2244 /* Finally, make the PC point at the start address */
2247 write_pc (bfd_get_start_address (exec_bfd));
2249 inferior_pid = 0; /* No process now */
2251 /* This is necessary because many things were based on the PC at the time that
2252 we attached to the monitor, which is no longer valid now that we have loaded
2253 new code (and just changed the PC). Another way to do this might be to call
2254 normal_stop, except that the stack may not be valid, and things would get
2255 horribly confused... */
2257 clear_symtab_users ();
2263 monitor_debug ("MON stop\n");
2264 if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
2265 SERIAL_SEND_BREAK (monitor_desc);
2266 if (current_monitor->stop)
2267 monitor_printf_noecho (current_monitor->stop);
2270 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2271 in OUTPUT until the prompt is seen. FIXME: We read the characters
2272 ourseleves here cause of a nasty echo. */
2275 monitor_rcmd (char *command,
2276 struct ui_file *outbuf)
2282 if (monitor_desc == NULL)
2283 error ("monitor target not open.");
2285 p = current_monitor->prompt;
2287 /* Send the command. Note that if no args were supplied, then we're
2288 just sending the monitor a newline, which is sometimes useful. */
2290 monitor_printf ("%s\r", (command ? command : ""));
2292 resp_len = monitor_expect_prompt (buf, sizeof buf);
2294 fputs_unfiltered (buf, outbuf); /* Output the response */
2297 /* Convert hex digit A to a number. */
2304 if (a >= '0' && a <= '9')
2306 if (a >= 'a' && a <= 'f')
2307 return a - 'a' + 10;
2308 if (a >= 'A' && a <= 'F')
2309 return a - 'A' + 10;
2311 error ("Reply contains invalid hex digit 0x%x", a);
2316 monitor_get_dev_name ()
2321 static struct target_ops monitor_ops;
2324 init_base_monitor_ops (void)
2326 monitor_ops.to_shortname = NULL;
2327 monitor_ops.to_longname = NULL;
2328 monitor_ops.to_doc = NULL;
2329 monitor_ops.to_open = NULL;
2330 monitor_ops.to_close = monitor_close;
2331 monitor_ops.to_attach = NULL;
2332 monitor_ops.to_post_attach = NULL;
2333 monitor_ops.to_require_attach = NULL;
2334 monitor_ops.to_detach = monitor_detach;
2335 monitor_ops.to_require_detach = NULL;
2336 monitor_ops.to_resume = monitor_resume;
2337 monitor_ops.to_wait = monitor_wait;
2338 monitor_ops.to_post_wait = NULL;
2339 monitor_ops.to_fetch_registers = monitor_fetch_registers;
2340 monitor_ops.to_store_registers = monitor_store_registers;
2341 monitor_ops.to_prepare_to_store = monitor_prepare_to_store;
2342 monitor_ops.to_xfer_memory = monitor_xfer_memory;
2343 monitor_ops.to_files_info = monitor_files_info;
2344 monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
2345 monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
2346 monitor_ops.to_terminal_init = 0;
2347 monitor_ops.to_terminal_inferior = 0;
2348 monitor_ops.to_terminal_ours_for_output = 0;
2349 monitor_ops.to_terminal_ours = 0;
2350 monitor_ops.to_terminal_info = 0;
2351 monitor_ops.to_kill = monitor_kill;
2352 monitor_ops.to_load = monitor_load;
2353 monitor_ops.to_lookup_symbol = 0;
2354 monitor_ops.to_create_inferior = monitor_create_inferior;
2355 monitor_ops.to_post_startup_inferior = NULL;
2356 monitor_ops.to_acknowledge_created_inferior = NULL;
2357 monitor_ops.to_clone_and_follow_inferior = NULL;
2358 monitor_ops.to_post_follow_inferior_by_clone = NULL;
2359 monitor_ops.to_insert_fork_catchpoint = NULL;
2360 monitor_ops.to_remove_fork_catchpoint = NULL;
2361 monitor_ops.to_insert_vfork_catchpoint = NULL;
2362 monitor_ops.to_remove_vfork_catchpoint = NULL;
2363 monitor_ops.to_has_forked = NULL;
2364 monitor_ops.to_has_vforked = NULL;
2365 monitor_ops.to_can_follow_vfork_prior_to_exec = NULL;
2366 monitor_ops.to_post_follow_vfork = NULL;
2367 monitor_ops.to_insert_exec_catchpoint = NULL;
2368 monitor_ops.to_remove_exec_catchpoint = NULL;
2369 monitor_ops.to_has_execd = NULL;
2370 monitor_ops.to_reported_exec_events_per_exec_call = NULL;
2371 monitor_ops.to_has_exited = NULL;
2372 monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
2373 monitor_ops.to_can_run = 0;
2374 monitor_ops.to_notice_signals = 0;
2375 monitor_ops.to_thread_alive = 0;
2376 monitor_ops.to_stop = monitor_stop;
2377 monitor_ops.to_rcmd = monitor_rcmd;
2378 monitor_ops.to_pid_to_exec_file = NULL;
2379 monitor_ops.to_core_file_to_sym_file = NULL;
2380 monitor_ops.to_stratum = process_stratum;
2381 monitor_ops.DONT_USE = 0;
2382 monitor_ops.to_has_all_memory = 1;
2383 monitor_ops.to_has_memory = 1;
2384 monitor_ops.to_has_stack = 1;
2385 monitor_ops.to_has_registers = 1;
2386 monitor_ops.to_has_execution = 1;
2387 monitor_ops.to_sections = 0;
2388 monitor_ops.to_sections_end = 0;
2389 monitor_ops.to_magic = OPS_MAGIC;
2390 } /* init_base_monitor_ops */
2392 /* Init the target_ops structure pointed at by OPS */
2395 init_monitor_ops (ops)
2396 struct target_ops *ops;
2398 if (monitor_ops.to_magic != OPS_MAGIC)
2399 init_base_monitor_ops ();
2401 memcpy (ops, &monitor_ops, sizeof monitor_ops);
2404 /* Define additional commands that are usually only used by monitors. */
2407 _initialize_remote_monitors ()
2409 init_base_monitor_ops ();
2410 add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
2412 "Set display of activity while downloading a file.\n\
2413 When enabled, a hashmark \'#\' is displayed.",
2418 (add_set_cmd ("monitor", no_class, var_zinteger,
2419 (char *) &monitor_debug_p,
2420 "Set debugging of remote monitor communication.\n\
2421 When enabled, communication between GDB and the remote monitor\n\
2422 is displayed.", &setdebuglist),