1 /* Remote debugging interface for boot monitors, for GDB.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 2000, 2001, 2002, 2006, 2007 Free Software Foundation, Inc.
6 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
7 Resurrected from the ashes by Stu Grossman.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 Boston, MA 02110-1301, USA. */
26 /* This file was derived from various remote-* modules. It is a collection
27 of generic support functions so GDB can talk directly to a ROM based
28 monitor. This saves use from having to hack an exception based handler
29 into existence, and makes for quick porting.
31 This module talks to a debug monitor called 'MONITOR', which
32 We communicate with MONITOR via either a direct serial line, or a TCP
33 (or possibly TELNET) stream to a terminal multiplexor,
34 which in turn talks to the target board. */
36 /* FIXME 32x64: This code assumes that registers and addresses are at
37 most 32 bits long. If they can be larger, you will need to declare
38 values as LONGEST and use %llx or some such to print values when
39 building commands to send to the monitor. Since we don't know of
40 any actual 64-bit targets with ROM monitors that use this code,
41 it's not an issue right now. -sts 4/18/96 */
46 #include "exceptions.h"
49 #include "gdb_string.h"
50 #include <sys/types.h>
56 #include "gdb_regex.h"
60 static char *dev_name;
61 static struct target_ops *targ_ops;
63 static void monitor_interrupt_query (void);
64 static void monitor_interrupt_twice (int);
65 static void monitor_stop (void);
66 static void monitor_dump_regs (void);
69 static int from_hex (int a);
72 static struct monitor_ops *current_monitor;
74 static int hashmark; /* flag set by "set hash" */
76 static int timeout = 30;
78 static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait() */
80 static void (*ofunc) (); /* Old SIGINT signal handler */
82 static CORE_ADDR *breakaddr;
84 /* Descriptor for I/O to remote machine. Initialize it to NULL so
85 that monitor_open knows that we don't have a file open when the
88 static struct serial *monitor_desc = NULL;
90 /* Pointer to regexp pattern matching data */
92 static struct re_pattern_buffer register_pattern;
93 static char register_fastmap[256];
95 static struct re_pattern_buffer getmem_resp_delim_pattern;
96 static char getmem_resp_delim_fastmap[256];
98 static struct re_pattern_buffer setmem_resp_delim_pattern;
99 static char setmem_resp_delim_fastmap[256];
101 static struct re_pattern_buffer setreg_resp_delim_pattern;
102 static char setreg_resp_delim_fastmap[256];
104 static int dump_reg_flag; /* Non-zero means do a dump_registers cmd when
105 monitor_wait wakes up. */
107 static int first_time = 0; /* is this the first time we're executing after
108 gaving created the child proccess? */
110 #define TARGET_BUF_SIZE 2048
112 /* Monitor specific debugging information. Typically only useful to
113 the developer of a new monitor interface. */
115 static void monitor_debug (const char *fmt, ...) ATTR_FORMAT(printf, 1, 2);
117 static int monitor_debug_p = 0;
119 /* NOTE: This file alternates between monitor_debug_p and remote_debug
120 when determining if debug information is printed. Perhaps this
121 could be simplified. */
124 monitor_debug (const char *fmt, ...)
129 va_start (args, fmt);
130 vfprintf_filtered (gdb_stdlog, fmt, args);
136 /* Convert a string into a printable representation, Return # byte in
137 the new string. When LEN is >0 it specifies the size of the
138 string. Otherwize strlen(oldstr) is used. */
141 monitor_printable_string (char *newstr, char *oldstr, int len)
147 len = strlen (oldstr);
149 for (i = 0; i < len; i++)
160 sprintf (newstr, "\\x%02x", ch & 0xff);
199 /* Print monitor errors with a string, converting the string to printable
203 monitor_error (char *function, char *message,
204 CORE_ADDR memaddr, int len, char *string, int final_char)
206 int real_len = (len == 0 && string != (char *) 0) ? strlen (string) : len;
207 char *safe_string = alloca ((real_len * 4) + 1);
208 monitor_printable_string (safe_string, string, real_len);
211 error (_("%s (0x%s): %s: %s%c"), function, paddr_nz (memaddr), message, safe_string, final_char);
213 error (_("%s (0x%s): %s: %s"), function, paddr_nz (memaddr), message, safe_string);
216 /* Convert hex digit A to a number. */
221 if (a >= '0' && a <= '9')
223 else if (a >= 'a' && a <= 'f')
225 else if (a >= 'A' && a <= 'F')
228 error (_("Invalid hex digit %d"), a);
231 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
233 This function exists to get around the problem that many host platforms
234 don't have a printf that can print 64-bit addresses. The %A format
235 specification is recognized as a special case, and causes the argument
236 to be printed as a 64-bit hexadecimal address.
238 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
239 If it is a '%s' format, the argument is a string; otherwise the
240 argument is assumed to be a long integer.
242 %% is also turned into a single %.
246 monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
256 for (p = pattern; *p; p++)
260 /* Copy the format specifier to a separate buffer. */
262 for (i = 1; *p >= '0' && *p <= '9' && i < (int) sizeof (format) - 2;
265 format[i] = fmt = *p;
266 format[i + 1] = '\0';
268 /* Fetch the next argument and print it. */
272 strcpy (sndbuf, "%");
275 arg_addr = va_arg (args, CORE_ADDR);
276 strcpy (sndbuf, paddr_nz (arg_addr));
279 arg_string = va_arg (args, char *);
280 sprintf (sndbuf, format, arg_string);
283 arg_int = va_arg (args, long);
284 sprintf (sndbuf, format, arg_int);
287 sndbuf += strlen (sndbuf);
296 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
297 Works just like printf. */
300 monitor_printf_noecho (char *pattern,...)
306 va_start (args, pattern);
308 monitor_vsprintf (sndbuf, pattern, args);
310 len = strlen (sndbuf);
311 if (len + 1 > sizeof sndbuf)
312 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
316 char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);
317 monitor_printable_string (safe_string, sndbuf, 0);
318 fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
321 monitor_write (sndbuf, len);
324 /* monitor_printf -- Send data to monitor and check the echo. Works just like
328 monitor_printf (char *pattern,...)
334 va_start (args, pattern);
336 monitor_vsprintf (sndbuf, pattern, args);
338 len = strlen (sndbuf);
339 if (len + 1 > sizeof sndbuf)
340 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
344 char *safe_string = (char *) alloca ((len * 4) + 1);
345 monitor_printable_string (safe_string, sndbuf, 0);
346 fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
349 monitor_write (sndbuf, len);
351 /* We used to expect that the next immediate output was the characters we
352 just output, but sometimes some extra junk appeared before the characters
353 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
354 So, just start searching for what we sent, and skip anything unknown. */
355 monitor_debug ("ExpectEcho\n");
356 monitor_expect (sndbuf, (char *) 0, 0);
360 /* Write characters to the remote system. */
363 monitor_write (char *buf, int buflen)
365 if (serial_write (monitor_desc, buf, buflen))
366 fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n",
367 safe_strerror (errno));
371 /* Read a binary character from the remote system, doing all the fancy
372 timeout stuff, but without interpreting the character in any way,
373 and without printing remote debug information. */
376 monitor_readchar (void)
384 c = serial_readchar (monitor_desc, timeout);
387 c &= 0xff; /* don't lose bit 7 */
394 if (c == SERIAL_TIMEOUT)
395 error (_("Timeout reading from remote system."));
397 perror_with_name (_("remote-monitor"));
401 /* Read a character from the remote system, doing all the fancy
405 readchar (int timeout)
410 last_random, last_nl, last_cr, last_crnl
418 c = serial_readchar (monitor_desc, timeout);
423 /* This seems to interfere with proper function of the
425 if (monitor_debug_p || remote_debug)
430 puts_debug ("read -->", buf, "<--");
435 /* Canonicialize \n\r combinations into one \r */
436 if ((current_monitor->flags & MO_HANDLE_NL) != 0)
438 if ((c == '\r' && state == last_nl)
439 || (c == '\n' && state == last_cr))
460 if (c == SERIAL_TIMEOUT)
462 /* I fail to see how detaching here can be useful */
463 if (in_monitor_wait) /* Watchdog went off */
465 target_mourn_inferior ();
466 error (_("GDB serial timeout has expired. Target detached."));
470 error (_("Timeout reading from remote system."));
472 perror_with_name (_("remote-monitor"));
475 /* Scan input from the remote system, until STRING is found. If BUF is non-
476 zero, then collect input until we have collected either STRING or BUFLEN-1
477 chars. In either case we terminate BUF with a 0. If input overflows BUF
478 because STRING can't be found, return -1, else return number of chars in BUF
479 (minus the terminating NUL). Note that in the non-overflow case, STRING
480 will be at the end of BUF. */
483 monitor_expect (char *string, char *buf, int buflen)
486 int obuflen = buflen;
491 char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
492 monitor_printable_string (safe_string, string, 0);
493 fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
508 c = readchar (timeout);
515 c = readchar (timeout);
517 /* Don't expect any ^C sent to be echoed */
519 if (*p == '\003' || c == *p)
529 return obuflen - buflen;
537 /* We got a character that doesn't match the string. We need to
538 back up p, but how far? If we're looking for "..howdy" and the
539 monitor sends "...howdy"? There's certainly a match in there,
540 but when we receive the third ".", we won't find it if we just
541 restart the matching at the beginning of the string.
543 This is a Boyer-Moore kind of situation. We want to reset P to
544 the end of the longest prefix of STRING that is a suffix of
545 what we've read so far. In the example above, that would be
546 ".." --- the longest prefix of "..howdy" that is a suffix of
547 "...". This longest prefix could be the empty string, if C
548 is nowhere to be found in STRING.
550 If this longest prefix is not the empty string, it must contain
551 C, so let's search from the end of STRING for instances of C,
552 and see if the portion of STRING before that is a suffix of
553 what we read before C. Actually, we can search backwards from
554 p, since we know no prefix can be longer than that.
556 Note that we can use STRING itself, along with C, as a record
557 of what we've received so far. :) */
560 for (i = (p - string) - 1; i >= 0; i--)
563 /* Is this prefix a suffix of what we've read so far?
565 string[0 .. i-1] == string[p - i, p - 1]? */
566 if (! memcmp (string, p - i, i))
578 /* Search for a regexp. */
581 monitor_expect_regexp (struct re_pattern_buffer *pat, char *buf, int buflen)
585 monitor_debug ("MON Expecting regexp\n");
590 mybuf = alloca (TARGET_BUF_SIZE);
591 buflen = TARGET_BUF_SIZE;
599 if (p - mybuf >= buflen)
600 { /* Buffer about to overflow */
602 /* On overflow, we copy the upper half of the buffer to the lower half. Not
603 great, but it usually works... */
605 memcpy (mybuf, mybuf + buflen / 2, buflen / 2);
606 p = mybuf + buflen / 2;
609 *p++ = readchar (timeout);
611 retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL);
617 /* Keep discarding input until we see the MONITOR prompt.
619 The convention for dealing with the prompt is that you
621 o *then* wait for the prompt.
623 Thus the last thing that a procedure does with the serial line will
624 be an monitor_expect_prompt(). Exception: monitor_resume does not
625 wait for the prompt, because the terminal is being handed over to
626 the inferior. However, the next thing which happens after that is
627 a monitor_wait which does wait for the prompt. Note that this
628 includes abnormal exit, e.g. error(). This is necessary to prevent
629 getting into states from which we can't recover. */
632 monitor_expect_prompt (char *buf, int buflen)
634 monitor_debug ("MON Expecting prompt\n");
635 return monitor_expect (current_monitor->prompt, buf, buflen);
638 /* Get N 32-bit words from remote, each preceded by a space, and put
639 them in registers starting at REGNO. */
650 ch = readchar (timeout);
651 while (isspace (ch));
655 for (i = 7; i >= 1; i--)
657 ch = readchar (timeout);
660 val = (val << 4) | from_hex (ch);
668 compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern,
674 compiled_pattern->fastmap = fastmap;
676 tmp = re_set_syntax (RE_SYNTAX_EMACS);
677 val = re_compile_pattern (pattern,
683 error (_("compile_pattern: Can't compile pattern string `%s': %s!"), pattern, val);
686 re_compile_fastmap (compiled_pattern);
689 /* Open a connection to a remote debugger. NAME is the filename used
690 for communication. */
693 monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
698 if (mon_ops->magic != MONITOR_OPS_MAGIC)
699 error (_("Magic number of monitor_ops struct wrong."));
701 targ_ops = mon_ops->target;
702 name = targ_ops->to_shortname;
705 error (_("Use `target %s DEVICE-NAME' to use a serial port, or \n\
706 `target %s HOST-NAME:PORT-NUMBER' to use a network connection."), name, name);
708 target_preopen (from_tty);
710 /* Setup pattern for register dump */
712 if (mon_ops->register_pattern)
713 compile_pattern (mon_ops->register_pattern, ®ister_pattern,
716 if (mon_ops->getmem.resp_delim)
717 compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
718 getmem_resp_delim_fastmap);
720 if (mon_ops->setmem.resp_delim)
721 compile_pattern (mon_ops->setmem.resp_delim, &setmem_resp_delim_pattern,
722 setmem_resp_delim_fastmap);
724 if (mon_ops->setreg.resp_delim)
725 compile_pattern (mon_ops->setreg.resp_delim, &setreg_resp_delim_pattern,
726 setreg_resp_delim_fastmap);
728 unpush_target (targ_ops);
732 dev_name = xstrdup (args);
734 monitor_desc = serial_open (dev_name);
737 perror_with_name (dev_name);
741 if (serial_setbaudrate (monitor_desc, baud_rate))
743 serial_close (monitor_desc);
744 perror_with_name (dev_name);
748 serial_raw (monitor_desc);
750 serial_flush_input (monitor_desc);
752 /* some systems only work with 2 stop bits */
754 serial_setstopbits (monitor_desc, mon_ops->stopbits);
756 current_monitor = mon_ops;
758 /* See if we can wake up the monitor. First, try sending a stop sequence,
759 then send the init strings. Last, remove all breakpoints. */
761 if (current_monitor->stop)
764 if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
766 monitor_debug ("EXP Open echo\n");
767 monitor_expect_prompt (NULL, 0);
771 /* wake up the monitor and see if it's alive */
772 for (p = mon_ops->init; *p != NULL; p++)
774 /* Some of the characters we send may not be echoed,
775 but we hope to get a prompt at the end of it all. */
777 if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
780 monitor_printf_noecho (*p);
781 monitor_expect_prompt (NULL, 0);
784 serial_flush_input (monitor_desc);
786 /* Alloc breakpoints */
787 if (mon_ops->set_break != NULL)
789 if (mon_ops->num_breakpoints == 0)
790 mon_ops->num_breakpoints = 8;
792 breakaddr = (CORE_ADDR *) xmalloc (mon_ops->num_breakpoints * sizeof (CORE_ADDR));
793 memset (breakaddr, 0, mon_ops->num_breakpoints * sizeof (CORE_ADDR));
796 /* Remove all breakpoints */
798 if (mon_ops->clr_all_break)
800 monitor_printf (mon_ops->clr_all_break);
801 monitor_expect_prompt (NULL, 0);
805 printf_unfiltered (_("Remote target %s connected to %s\n"), name, dev_name);
807 push_target (targ_ops);
809 inferior_ptid = pid_to_ptid (42000); /* Make run command think we are busy... */
811 /* Give monitor_wait something to read */
813 monitor_printf (current_monitor->line_term);
815 start_remote (from_tty);
818 /* Close out all files and local state before this target loses
822 monitor_close (int quitting)
825 serial_close (monitor_desc);
827 /* Free breakpoint memory */
828 if (breakaddr != NULL)
837 /* Terminate the open connection to the remote debugger. Use this
838 when you want to detach and do something else with your gdb. */
841 monitor_detach (char *args, int from_tty)
843 pop_target (); /* calls monitor_close to do the real work */
845 printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname);
848 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
851 monitor_supply_register (int regno, char *valstr)
854 unsigned char regbuf[MAX_REGISTER_SIZE];
859 while (p && *p != '\0')
861 if (*p == '\r' || *p == '\n')
872 if (!isxdigit (*p) && *p != 'x')
878 val += fromhex (*p++);
880 monitor_debug ("Supplying Register %d %s\n", regno, valstr);
882 if (val == 0 && valstr == p)
883 error (_("monitor_supply_register (%d): bad value from monitor: %s."),
886 /* supply register stores in target byte order, so swap here */
888 store_unsigned_integer (regbuf, register_size (current_gdbarch, regno), val);
890 regcache_raw_supply (current_regcache, regno, regbuf);
895 /* Tell the remote machine to resume. */
898 monitor_resume (ptid_t ptid, int step, enum target_signal sig)
900 /* Some monitors require a different command when starting a program */
901 monitor_debug ("MON resume\n");
902 if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
905 monitor_printf ("run\r");
906 if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
911 monitor_printf (current_monitor->step);
914 if (current_monitor->continue_hook)
915 (*current_monitor->continue_hook) ();
917 monitor_printf (current_monitor->cont);
918 if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
923 /* Parse the output of a register dump command. A monitor specific
924 regexp is used to extract individual register descriptions of the
925 form REG=VAL. Each description is split up into a name and a value
926 string which are passed down to monitor specific code. */
929 parse_register_dump (char *buf, int len)
931 monitor_debug ("MON Parsing register dump\n");
934 int regnamelen, vallen;
936 /* Element 0 points to start of register name, and element 1
937 points to the start of the register value. */
938 struct re_registers register_strings;
940 memset (®ister_strings, 0, sizeof (struct re_registers));
942 if (re_search (®ister_pattern, buf, len, 0, len,
943 ®ister_strings) == -1)
946 regnamelen = register_strings.end[1] - register_strings.start[1];
947 regname = buf + register_strings.start[1];
948 vallen = register_strings.end[2] - register_strings.start[2];
949 val = buf + register_strings.start[2];
951 current_monitor->supply_register (regname, regnamelen, val, vallen);
953 buf += register_strings.end[0];
954 len -= register_strings.end[0];
958 /* Send ^C to target to halt it. Target will respond, and send us a
962 monitor_interrupt (int signo)
964 /* If this doesn't work, try more severe steps. */
965 signal (signo, monitor_interrupt_twice);
967 if (monitor_debug_p || remote_debug)
968 fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
973 /* The user typed ^C twice. */
976 monitor_interrupt_twice (int signo)
978 signal (signo, ofunc);
980 monitor_interrupt_query ();
982 signal (signo, monitor_interrupt);
985 /* Ask the user what to do when an interrupt is received. */
988 monitor_interrupt_query (void)
990 target_terminal_ours ();
992 if (query ("Interrupted while waiting for the program.\n\
993 Give up (and stop debugging it)? "))
995 target_mourn_inferior ();
996 deprecated_throw_reason (RETURN_QUIT);
999 target_terminal_inferior ();
1003 monitor_wait_cleanup (void *old_timeout)
1005 timeout = *(int *) old_timeout;
1006 signal (SIGINT, ofunc);
1007 in_monitor_wait = 0;
1013 monitor_wait_filter (char *buf,
1016 struct target_waitstatus *status)
1021 resp_len = monitor_expect_prompt (buf, bufmax);
1022 *ext_resp_len = resp_len;
1025 fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
1027 while (resp_len < 0);
1029 /* Print any output characters that were preceded by ^O. */
1030 /* FIXME - This would be great as a user settabgle flag */
1031 if (monitor_debug_p || remote_debug
1032 || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
1036 for (i = 0; i < resp_len - 1; i++)
1038 putchar_unfiltered (buf[++i]);
1044 /* Wait until the remote machine stops, then return, storing status in
1045 status just as `wait' would. */
1048 monitor_wait (ptid_t ptid, struct target_waitstatus *status)
1050 int old_timeout = timeout;
1051 char buf[TARGET_BUF_SIZE];
1053 struct cleanup *old_chain;
1055 status->kind = TARGET_WAITKIND_EXITED;
1056 status->value.integer = 0;
1058 old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
1059 monitor_debug ("MON wait\n");
1062 /* This is somthing other than a maintenance command */
1063 in_monitor_wait = 1;
1064 timeout = watchdog > 0 ? watchdog : -1;
1066 timeout = -1; /* Don't time out -- user program is running. */
1069 ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
1071 if (current_monitor->wait_filter)
1072 (*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status);
1074 monitor_wait_filter (buf, sizeof (buf), &resp_len, status);
1076 #if 0 /* Transferred to monitor wait filter */
1079 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1082 fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
1084 while (resp_len < 0);
1086 /* Print any output characters that were preceded by ^O. */
1087 /* FIXME - This would be great as a user settabgle flag */
1088 if (monitor_debug_p || remote_debug
1089 || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
1093 for (i = 0; i < resp_len - 1; i++)
1095 putchar_unfiltered (buf[++i]);
1099 signal (SIGINT, ofunc);
1101 timeout = old_timeout;
1103 if (dump_reg_flag && current_monitor->dump_registers)
1106 monitor_printf (current_monitor->dump_registers);
1107 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1110 if (current_monitor->register_pattern)
1111 parse_register_dump (buf, resp_len);
1113 monitor_debug ("Wait fetching registers after stop\n");
1114 monitor_dump_regs ();
1117 status->kind = TARGET_WAITKIND_STOPPED;
1118 status->value.sig = TARGET_SIGNAL_TRAP;
1120 discard_cleanups (old_chain);
1122 in_monitor_wait = 0;
1124 return inferior_ptid;
1127 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1131 monitor_fetch_register (int regno)
1138 regbuf = alloca (MAX_REGISTER_SIZE * 2 + 1);
1139 zerobuf = alloca (MAX_REGISTER_SIZE);
1140 memset (zerobuf, 0, MAX_REGISTER_SIZE);
1142 if (current_monitor->regname != NULL)
1143 name = current_monitor->regname (regno);
1145 name = current_monitor->regnames[regno];
1146 monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
1148 if (!name || (*name == '\0'))
1150 monitor_debug ("No register known for %d\n", regno);
1151 regcache_raw_supply (current_regcache, regno, zerobuf);
1155 /* send the register examine command */
1157 monitor_printf (current_monitor->getreg.cmd, name);
1159 /* If RESP_DELIM is specified, we search for that as a leading
1160 delimiter for the register value. Otherwise, we just start
1161 searching from the start of the buf. */
1163 if (current_monitor->getreg.resp_delim)
1165 monitor_debug ("EXP getreg.resp_delim\n");
1166 monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1167 /* Handle case of first 32 registers listed in pairs. */
1168 if (current_monitor->flags & MO_32_REGS_PAIRED
1169 && (regno & 1) != 0 && regno < 32)
1171 monitor_debug ("EXP getreg.resp_delim\n");
1172 monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1176 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1177 if (current_monitor->flags & MO_HEX_PREFIX)
1180 c = readchar (timeout);
1182 c = readchar (timeout);
1183 if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1186 error (_("Bad value returned from monitor while fetching register %x."),
1190 /* Read upto the maximum number of hex digits for this register, skipping
1191 spaces, but stop reading if something else is seen. Some monitors
1192 like to drop leading zeros. */
1194 for (i = 0; i < register_size (current_gdbarch, regno) * 2; i++)
1197 c = readchar (timeout);
1199 c = readchar (timeout);
1207 regbuf[i] = '\000'; /* terminate the number */
1208 monitor_debug ("REGVAL '%s'\n", regbuf);
1210 /* If TERM is present, we wait for that to show up. Also, (if TERM
1211 is present), we will send TERM_CMD if that is present. In any
1212 case, we collect all of the output into buf, and then wait for
1213 the normal prompt. */
1215 if (current_monitor->getreg.term)
1217 monitor_debug ("EXP getreg.term\n");
1218 monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */
1221 if (current_monitor->getreg.term_cmd)
1223 monitor_debug ("EMIT getreg.term.cmd\n");
1224 monitor_printf (current_monitor->getreg.term_cmd);
1226 if (!current_monitor->getreg.term || /* Already expected or */
1227 current_monitor->getreg.term_cmd) /* ack expected */
1228 monitor_expect_prompt (NULL, 0); /* get response */
1230 monitor_supply_register (regno, regbuf);
1233 /* Sometimes, it takes several commands to dump the registers */
1234 /* This is a primitive for use by variations of monitor interfaces in
1235 case they need to compose the operation.
1238 monitor_dump_reg_block (char *block_cmd)
1240 char buf[TARGET_BUF_SIZE];
1242 monitor_printf (block_cmd);
1243 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1244 parse_register_dump (buf, resp_len);
1249 /* Read the remote registers into the block regs. */
1250 /* Call the specific function if it has been provided */
1253 monitor_dump_regs (void)
1255 char buf[TARGET_BUF_SIZE];
1257 if (current_monitor->dumpregs)
1258 (*(current_monitor->dumpregs)) (); /* call supplied function */
1259 else if (current_monitor->dump_registers) /* default version */
1261 monitor_printf (current_monitor->dump_registers);
1262 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1263 parse_register_dump (buf, resp_len);
1266 internal_error (__FILE__, __LINE__, _("failed internal consistency check")); /* Need some way to read registers */
1270 monitor_fetch_registers (int regno)
1272 monitor_debug ("MON fetchregs\n");
1273 if (current_monitor->getreg.cmd)
1277 monitor_fetch_register (regno);
1281 for (regno = 0; regno < NUM_REGS; regno++)
1282 monitor_fetch_register (regno);
1286 monitor_dump_regs ();
1290 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1293 monitor_store_register (int regno)
1298 if (current_monitor->regname != NULL)
1299 name = current_monitor->regname (regno);
1301 name = current_monitor->regnames[regno];
1303 if (!name || (*name == '\0'))
1305 monitor_debug ("MON Cannot store unknown register\n");
1309 val = read_register (regno);
1310 monitor_debug ("MON storeg %d %s\n", regno,
1311 phex (val, register_size (current_gdbarch, regno)));
1313 /* send the register deposit command */
1315 if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
1316 monitor_printf (current_monitor->setreg.cmd, val, name);
1317 else if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1318 monitor_printf (current_monitor->setreg.cmd, name);
1320 monitor_printf (current_monitor->setreg.cmd, name, val);
1322 if (current_monitor->setreg.resp_delim)
1324 monitor_debug ("EXP setreg.resp_delim\n");
1325 monitor_expect_regexp (&setreg_resp_delim_pattern, NULL, 0);
1326 if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1327 monitor_printf ("%s\r", paddr_nz (val));
1329 if (current_monitor->setreg.term)
1331 monitor_debug ("EXP setreg.term\n");
1332 monitor_expect (current_monitor->setreg.term, NULL, 0);
1333 if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1334 monitor_printf ("%s\r", paddr_nz (val));
1335 monitor_expect_prompt (NULL, 0);
1338 monitor_expect_prompt (NULL, 0);
1339 if (current_monitor->setreg.term_cmd) /* Mode exit required */
1341 monitor_debug ("EXP setreg_termcmd\n");
1342 monitor_printf ("%s", current_monitor->setreg.term_cmd);
1343 monitor_expect_prompt (NULL, 0);
1345 } /* monitor_store_register */
1347 /* Store the remote registers. */
1350 monitor_store_registers (int regno)
1354 monitor_store_register (regno);
1358 for (regno = 0; regno < NUM_REGS; regno++)
1359 monitor_store_register (regno);
1362 /* Get ready to modify the registers array. On machines which store
1363 individual registers, this doesn't need to do anything. On machines
1364 which store all the registers in one fell swoop, this makes sure
1365 that registers contains all the registers from the program being
1369 monitor_prepare_to_store (void)
1371 /* Do nothing, since we can store individual regs */
1375 monitor_files_info (struct target_ops *ops)
1377 printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name, baud_rate);
1381 monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
1383 unsigned int val, hostval;
1387 monitor_debug ("MON write %d %s\n", len, paddr (memaddr));
1389 if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1390 memaddr = ADDR_BITS_REMOVE (memaddr);
1392 /* Use memory fill command for leading 0 bytes. */
1394 if (current_monitor->fill)
1396 for (i = 0; i < len; i++)
1400 if (i > 4) /* More than 4 zeros is worth doing */
1402 monitor_debug ("MON FILL %d\n", i);
1403 if (current_monitor->flags & MO_FILL_USES_ADDR)
1404 monitor_printf (current_monitor->fill, memaddr, (memaddr + i) - 1, 0);
1406 monitor_printf (current_monitor->fill, memaddr, i, 0);
1408 monitor_expect_prompt (NULL, 0);
1415 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1416 if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
1419 cmd = current_monitor->setmem.cmdll;
1423 if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
1426 cmd = current_monitor->setmem.cmdl;
1428 else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw)
1431 cmd = current_monitor->setmem.cmdw;
1436 cmd = current_monitor->setmem.cmdb;
1439 val = extract_unsigned_integer (myaddr, len);
1443 hostval = *(unsigned int *) myaddr;
1444 monitor_debug ("Hostval(%08x) val(%08x)\n", hostval, val);
1448 if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
1449 monitor_printf_noecho (cmd, memaddr, val);
1450 else if (current_monitor->flags & MO_SETMEM_INTERACTIVE)
1453 monitor_printf_noecho (cmd, memaddr);
1455 if (current_monitor->setmem.resp_delim)
1457 monitor_debug ("EXP setmem.resp_delim");
1458 monitor_expect_regexp (&setmem_resp_delim_pattern, NULL, 0);
1459 monitor_printf ("%x\r", val);
1461 if (current_monitor->setmem.term)
1463 monitor_debug ("EXP setmem.term");
1464 monitor_expect (current_monitor->setmem.term, NULL, 0);
1465 monitor_printf ("%x\r", val);
1467 if (current_monitor->setmem.term_cmd)
1468 { /* Emit this to get out of the memory editing state */
1469 monitor_printf ("%s", current_monitor->setmem.term_cmd);
1470 /* Drop through to expecting a prompt */
1474 monitor_printf (cmd, memaddr, val);
1476 monitor_expect_prompt (NULL, 0);
1483 monitor_write_memory_bytes (CORE_ADDR memaddr, char *myaddr, int len)
1489 /* Enter the sub mode */
1490 monitor_printf (current_monitor->setmem.cmdb, memaddr);
1491 monitor_expect_prompt (NULL, 0);
1495 monitor_printf ("%x\r", val);
1499 /* If we wanted to, here we could validate the address */
1500 monitor_expect_prompt (NULL, 0);
1503 /* Now exit the sub mode */
1504 monitor_printf (current_monitor->getreg.term_cmd);
1505 monitor_expect_prompt (NULL, 0);
1511 longlongendswap (unsigned char *a)
1520 *(a + i) = *(a + j);
1525 /* Format 32 chars of long long value, advance the pointer */
1526 static char *hexlate = "0123456789abcdef";
1528 longlong_hexchars (unsigned long long value,
1538 static unsigned char disbuf[8]; /* disassembly buffer */
1539 unsigned char *scan, *limit; /* loop controls */
1540 unsigned char c, nib;
1545 unsigned long long *dp;
1546 dp = (unsigned long long *) scan;
1549 longlongendswap (disbuf); /* FIXME: ONly on big endian hosts */
1550 while (scan < limit)
1552 c = *scan++; /* a byte of our long long value */
1558 leadzero = 0; /* henceforth we print even zeroes */
1560 nib = c >> 4; /* high nibble bits */
1561 *outbuff++ = hexlate[nib];
1562 nib = c & 0x0f; /* low nibble bits */
1563 *outbuff++ = hexlate[nib];
1567 } /* longlong_hexchars */
1571 /* I am only going to call this when writing virtual byte streams.
1572 Which possably entails endian conversions
1575 monitor_write_memory_longlongs (CORE_ADDR memaddr, char *myaddr, int len)
1577 static char hexstage[20]; /* At least 16 digits required, plus null */
1582 llptr = (unsigned long long *) myaddr;
1585 monitor_printf (current_monitor->setmem.cmdll, memaddr);
1586 monitor_expect_prompt (NULL, 0);
1590 endstring = longlong_hexchars (*llptr, hexstage);
1591 *endstring = '\0'; /* NUll terminate for printf */
1592 monitor_printf ("%s\r", hexstage);
1596 /* If we wanted to, here we could validate the address */
1597 monitor_expect_prompt (NULL, 0);
1600 /* Now exit the sub mode */
1601 monitor_printf (current_monitor->getreg.term_cmd);
1602 monitor_expect_prompt (NULL, 0);
1608 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1609 /* This is for the large blocks of memory which may occur in downloading.
1610 And for monitors which use interactive entry,
1611 And for monitors which do not have other downloading methods.
1612 Without this, we will end up calling monitor_write_memory many times
1613 and do the entry and exit of the sub mode many times
1614 This currently assumes...
1615 MO_SETMEM_INTERACTIVE
1616 ! MO_NO_ECHO_ON_SETMEM
1617 To use this, the you have to patch the monitor_cmds block with
1618 this function. Otherwise, its not tuned up for use by all
1623 monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len)
1627 /* FIXME: This would be a good place to put the zero test */
1629 if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
1631 return monitor_write_memory_longlongs (memaddr, myaddr, len);
1634 written = monitor_write_memory_bytes (memaddr, myaddr, len);
1638 /* This is an alternate form of monitor_read_memory which is used for monitors
1639 which can only read a single byte/word/etc. at a time. */
1642 monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
1645 char membuf[sizeof (int) * 2 + 1];
1649 monitor_debug ("MON read single\n");
1651 /* Can't actually use long longs (nice idea, though). In fact, the
1652 call to strtoul below will fail if it tries to convert a value
1653 that's too big to fit in a long. */
1654 if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
1657 cmd = current_monitor->getmem.cmdll;
1661 if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
1664 cmd = current_monitor->getmem.cmdl;
1666 else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->getmem.cmdw)
1669 cmd = current_monitor->getmem.cmdw;
1674 cmd = current_monitor->getmem.cmdb;
1677 /* Send the examine command. */
1679 monitor_printf (cmd, memaddr);
1681 /* If RESP_DELIM is specified, we search for that as a leading
1682 delimiter for the memory value. Otherwise, we just start
1683 searching from the start of the buf. */
1685 if (current_monitor->getmem.resp_delim)
1687 monitor_debug ("EXP getmem.resp_delim\n");
1688 monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
1691 /* Now, read the appropriate number of hex digits for this loc,
1694 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1695 if (current_monitor->flags & MO_HEX_PREFIX)
1699 c = readchar (timeout);
1701 c = readchar (timeout);
1702 if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1705 monitor_error ("monitor_read_memory_single",
1706 "bad response from monitor",
1707 memaddr, 0, NULL, 0);
1712 for (i = 0; i < len * 2; i++)
1718 c = readchar (timeout);
1724 monitor_error ("monitor_read_memory_single",
1725 "bad response from monitor",
1726 memaddr, i, membuf, 0);
1730 membuf[i] = '\000'; /* terminate the number */
1733 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1734 present), we will send TERM_CMD if that is present. In any case, we collect
1735 all of the output into buf, and then wait for the normal prompt. */
1737 if (current_monitor->getmem.term)
1739 monitor_expect (current_monitor->getmem.term, NULL, 0); /* get response */
1741 if (current_monitor->getmem.term_cmd)
1743 monitor_printf (current_monitor->getmem.term_cmd);
1744 monitor_expect_prompt (NULL, 0);
1748 monitor_expect_prompt (NULL, 0); /* get response */
1751 val = strtoul (membuf, &p, 16);
1753 if (val == 0 && membuf == p)
1754 monitor_error ("monitor_read_memory_single",
1755 "bad value from monitor",
1756 memaddr, 0, membuf, 0);
1758 /* supply register stores in target byte order, so swap here */
1760 store_unsigned_integer (myaddr, len, val);
1765 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1766 memory at MEMADDR. Returns length moved. Currently, we do no more
1767 than 16 bytes at a time. */
1770 monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
1781 monitor_debug ("Zero length call to monitor_read_memory\n");
1785 monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
1786 paddr_nz (memaddr), (long) myaddr, len);
1788 if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1789 memaddr = ADDR_BITS_REMOVE (memaddr);
1791 if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
1792 return monitor_read_memory_single (memaddr, myaddr, len);
1794 len = min (len, 16);
1796 /* Some dumpers align the first data with the preceeding 16
1797 byte boundary. Some print blanks and start at the
1798 requested boundary. EXACT_DUMPADDR
1801 dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
1802 ? memaddr : memaddr & ~0x0f;
1804 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1805 if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
1806 len = ((memaddr + len) & ~0xf) - memaddr;
1808 /* send the memory examine command */
1810 if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
1811 monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len);
1812 else if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1813 monitor_printf (current_monitor->getmem.cmdb, dumpaddr);
1815 monitor_printf (current_monitor->getmem.cmdb, memaddr, len);
1817 /* If TERM is present, we wait for that to show up. Also, (if TERM
1818 is present), we will send TERM_CMD if that is present. In any
1819 case, we collect all of the output into buf, and then wait for
1820 the normal prompt. */
1822 if (current_monitor->getmem.term)
1824 resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf); /* get response */
1827 monitor_error ("monitor_read_memory",
1828 "excessive response from monitor",
1829 memaddr, resp_len, buf, 0);
1831 if (current_monitor->getmem.term_cmd)
1833 serial_write (monitor_desc, current_monitor->getmem.term_cmd,
1834 strlen (current_monitor->getmem.term_cmd));
1835 monitor_expect_prompt (NULL, 0);
1839 resp_len = monitor_expect_prompt (buf, sizeof buf); /* get response */
1843 /* If RESP_DELIM is specified, we search for that as a leading
1844 delimiter for the values. Otherwise, we just start searching
1845 from the start of the buf. */
1847 if (current_monitor->getmem.resp_delim)
1850 struct re_registers resp_strings;
1851 monitor_debug ("MON getmem.resp_delim %s\n", current_monitor->getmem.resp_delim);
1853 memset (&resp_strings, 0, sizeof (struct re_registers));
1855 retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
1859 monitor_error ("monitor_read_memory",
1860 "bad response from monitor",
1861 memaddr, resp_len, buf, 0);
1863 p += resp_strings.end[0];
1865 p = strstr (p, current_monitor->getmem.resp_delim);
1867 monitor_error ("monitor_read_memory",
1868 "bad response from monitor",
1869 memaddr, resp_len, buf, 0);
1870 p += strlen (current_monitor->getmem.resp_delim);
1873 monitor_debug ("MON scanning %d ,%lx '%s'\n", len, (long) p, p);
1874 if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1882 while (!(c == '\000' || c == '\n' || c == '\r') && i > 0)
1886 if ((dumpaddr >= memaddr) && (i > 0))
1888 val = fromhex (c) * 16 + fromhex (*(p + 1));
1890 if (monitor_debug_p || remote_debug)
1891 fprintf_unfiltered (gdb_stdlog, "[%02x]", val);
1898 ++p; /* skip a blank or other non hex char */
1902 error (_("Failed to read via monitor"));
1903 if (monitor_debug_p || remote_debug)
1904 fprintf_unfiltered (gdb_stdlog, "\n");
1905 return fetched; /* Return the number of bytes actually read */
1907 monitor_debug ("MON scanning bytes\n");
1909 for (i = len; i > 0; i--)
1911 /* Skip non-hex chars, but bomb on end of string and newlines */
1918 if (*p == '\000' || *p == '\n' || *p == '\r')
1919 monitor_error ("monitor_read_memory",
1920 "badly terminated response from monitor",
1921 memaddr, resp_len, buf, 0);
1925 val = strtoul (p, &p1, 16);
1927 if (val == 0 && p == p1)
1928 monitor_error ("monitor_read_memory",
1929 "bad value from monitor",
1930 memaddr, resp_len, buf, 0);
1943 /* Transfer LEN bytes between target address MEMADDR and GDB address
1944 MYADDR. Returns 0 for success, errno code for failure. TARGET is
1948 monitor_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
1949 struct mem_attrib *attrib, struct target_ops *target)
1955 if (current_monitor->flags & MO_HAS_BLOCKWRITES)
1956 res = monitor_write_memory_block(memaddr, myaddr, len);
1958 res = monitor_write_memory(memaddr, myaddr, len);
1962 res = monitor_read_memory(memaddr, myaddr, len);
1971 return; /* ignore attempts to kill target system */
1974 /* All we actually do is set the PC to the start address of exec_bfd. */
1977 monitor_create_inferior (char *exec_file, char *args, char **env,
1980 if (args && (*args != '\000'))
1981 error (_("Args are not supported by the monitor."));
1984 clear_proceed_status ();
1985 write_pc (bfd_get_start_address (exec_bfd));
1988 /* Clean up when a program exits.
1989 The program actually lives on in the remote processor's RAM, and may be
1990 run again without a download. Don't leave it full of breakpoint
1994 monitor_mourn_inferior (void)
1996 unpush_target (targ_ops);
1997 generic_mourn_inferior (); /* Do all the proper things now */
2000 /* Tell the monitor to add a breakpoint. */
2003 monitor_insert_breakpoint (struct bp_target_info *bp_tgt)
2005 CORE_ADDR addr = bp_tgt->placed_address;
2007 const unsigned char *bp;
2010 monitor_debug ("MON inst bkpt %s\n", paddr (addr));
2011 if (current_monitor->set_break == NULL)
2012 error (_("No set_break defined for this monitor"));
2014 if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
2015 addr = ADDR_BITS_REMOVE (addr);
2017 /* Determine appropriate breakpoint size for this address. */
2018 bp = gdbarch_breakpoint_from_pc (current_gdbarch, &addr, &bplen);
2019 bp_tgt->placed_address = addr;
2020 bp_tgt->placed_size = bplen;
2022 for (i = 0; i < current_monitor->num_breakpoints; i++)
2024 if (breakaddr[i] == 0)
2026 breakaddr[i] = addr;
2027 monitor_printf (current_monitor->set_break, addr);
2028 monitor_expect_prompt (NULL, 0);
2033 error (_("Too many breakpoints (> %d) for monitor."), current_monitor->num_breakpoints);
2036 /* Tell the monitor to remove a breakpoint. */
2039 monitor_remove_breakpoint (struct bp_target_info *bp_tgt)
2041 CORE_ADDR addr = bp_tgt->placed_address;
2044 monitor_debug ("MON rmbkpt %s\n", paddr (addr));
2045 if (current_monitor->clr_break == NULL)
2046 error (_("No clr_break defined for this monitor"));
2048 for (i = 0; i < current_monitor->num_breakpoints; i++)
2050 if (breakaddr[i] == addr)
2053 /* some monitors remove breakpoints based on the address */
2054 if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
2055 monitor_printf (current_monitor->clr_break, addr);
2056 else if (current_monitor->flags & MO_CLR_BREAK_1_BASED)
2057 monitor_printf (current_monitor->clr_break, i + 1);
2059 monitor_printf (current_monitor->clr_break, i);
2060 monitor_expect_prompt (NULL, 0);
2064 fprintf_unfiltered (gdb_stderr,
2065 "Can't find breakpoint associated with 0x%s\n",
2070 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2071 an S-record. Return non-zero if the ACK is received properly. */
2074 monitor_wait_srec_ack (void)
2078 if (current_monitor->flags & MO_SREC_ACK_PLUS)
2080 return (readchar (timeout) == '+');
2082 else if (current_monitor->flags & MO_SREC_ACK_ROTATE)
2084 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2085 if ((ch = readchar (1)) < 0)
2087 if ((ch = readchar (1)) < 0)
2089 if ((ch = readchar (1)) < 0)
2091 if ((ch = readchar (1)) < 0)
2097 /* monitor_load -- download a file. */
2100 monitor_load (char *file, int from_tty)
2102 monitor_debug ("MON load\n");
2104 if (current_monitor->load_routine)
2105 current_monitor->load_routine (monitor_desc, file, hashmark);
2107 { /* The default is ascii S-records */
2109 unsigned long load_offset;
2112 /* enable user to specify address for downloading as 2nd arg to load */
2113 n = sscanf (file, "%s 0x%lx", buf, &load_offset);
2119 monitor_printf (current_monitor->load);
2120 if (current_monitor->loadresp)
2121 monitor_expect (current_monitor->loadresp, NULL, 0);
2123 load_srec (monitor_desc, file, (bfd_vma) load_offset,
2124 32, SREC_ALL, hashmark,
2125 current_monitor->flags & MO_SREC_ACK ?
2126 monitor_wait_srec_ack : NULL);
2128 monitor_expect_prompt (NULL, 0);
2131 /* Finally, make the PC point at the start address */
2133 write_pc (bfd_get_start_address (exec_bfd));
2135 /* There used to be code here which would clear inferior_ptid and
2136 call clear_symtab_users. None of that should be necessary:
2137 monitor targets should behave like remote protocol targets, and
2138 since generic_load does none of those things, this function
2141 Furthermore, clearing inferior_ptid is *incorrect*. After doing
2142 a load, we still have a valid connection to the monitor, with a
2143 live processor state to fiddle with. The user can type
2144 `continue' or `jump *start' and make the program run. If they do
2145 these things, however, GDB will be talking to a running program
2146 while inferior_ptid is null_ptid; this makes things like
2147 reinit_frame_cache very confused. */
2153 monitor_debug ("MON stop\n");
2154 if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
2155 serial_send_break (monitor_desc);
2156 if (current_monitor->stop)
2157 monitor_printf_noecho (current_monitor->stop);
2160 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2161 in OUTPUT until the prompt is seen. FIXME: We read the characters
2162 ourseleves here cause of a nasty echo. */
2165 monitor_rcmd (char *command,
2166 struct ui_file *outbuf)
2172 if (monitor_desc == NULL)
2173 error (_("monitor target not open."));
2175 p = current_monitor->prompt;
2177 /* Send the command. Note that if no args were supplied, then we're
2178 just sending the monitor a newline, which is sometimes useful. */
2180 monitor_printf ("%s\r", (command ? command : ""));
2182 resp_len = monitor_expect_prompt (buf, sizeof buf);
2184 fputs_unfiltered (buf, outbuf); /* Output the response */
2187 /* Convert hex digit A to a number. */
2193 if (a >= '0' && a <= '9')
2195 if (a >= 'a' && a <= 'f')
2196 return a - 'a' + 10;
2197 if (a >= 'A' && a <= 'F')
2198 return a - 'A' + 10;
2200 error (_("Reply contains invalid hex digit 0x%x"), a);
2205 monitor_get_dev_name (void)
2210 static struct target_ops monitor_ops;
2213 init_base_monitor_ops (void)
2215 monitor_ops.to_close = monitor_close;
2216 monitor_ops.to_detach = monitor_detach;
2217 monitor_ops.to_resume = monitor_resume;
2218 monitor_ops.to_wait = monitor_wait;
2219 monitor_ops.to_fetch_registers = monitor_fetch_registers;
2220 monitor_ops.to_store_registers = monitor_store_registers;
2221 monitor_ops.to_prepare_to_store = monitor_prepare_to_store;
2222 monitor_ops.deprecated_xfer_memory = monitor_xfer_memory;
2223 monitor_ops.to_files_info = monitor_files_info;
2224 monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
2225 monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
2226 monitor_ops.to_kill = monitor_kill;
2227 monitor_ops.to_load = monitor_load;
2228 monitor_ops.to_create_inferior = monitor_create_inferior;
2229 monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
2230 monitor_ops.to_stop = monitor_stop;
2231 monitor_ops.to_rcmd = monitor_rcmd;
2232 monitor_ops.to_stratum = process_stratum;
2233 monitor_ops.to_has_all_memory = 1;
2234 monitor_ops.to_has_memory = 1;
2235 monitor_ops.to_has_stack = 1;
2236 monitor_ops.to_has_registers = 1;
2237 monitor_ops.to_has_execution = 1;
2238 monitor_ops.to_magic = OPS_MAGIC;
2239 } /* init_base_monitor_ops */
2241 /* Init the target_ops structure pointed at by OPS */
2244 init_monitor_ops (struct target_ops *ops)
2246 if (monitor_ops.to_magic != OPS_MAGIC)
2247 init_base_monitor_ops ();
2249 memcpy (ops, &monitor_ops, sizeof monitor_ops);
2252 /* Define additional commands that are usually only used by monitors. */
2254 extern initialize_file_ftype _initialize_remote_monitors; /* -Wmissing-prototypes */
2257 _initialize_remote_monitors (void)
2259 init_base_monitor_ops ();
2260 add_setshow_boolean_cmd ("hash", no_class, &hashmark, _("\
2261 Set display of activity while downloading a file."), _("\
2262 Show display of activity while downloading a file."), _("\
2263 When enabled, a hashmark \'#\' is displayed."),
2265 NULL, /* FIXME: i18n: */
2266 &setlist, &showlist);
2268 add_setshow_zinteger_cmd ("monitor", no_class, &monitor_debug_p, _("\
2269 Set debugging of remote monitor communication."), _("\
2270 Show debugging of remote monitor communication."), _("\
2271 When enabled, communication between GDB and the remote monitor\n\
2274 NULL, /* FIXME: i18n: */
2275 &setdebuglist, &showdebuglist);