1 /* Remote debugging interface for boot monitors, for GDB.
3 Copyright (C) 1990-2014 Free Software Foundation, Inc.
5 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
6 Resurrected from the ashes by Stu Grossman.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
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 existence, 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 */
43 #include "exceptions.h"
47 #include <sys/types.h>
53 #include "gdb_regex.h"
56 #include "gdbthread.h"
57 #include "readline/readline.h"
59 static char *dev_name;
60 static struct target_ops *targ_ops;
62 static void monitor_interrupt_query (void);
63 static void monitor_interrupt_twice (int);
64 static void monitor_stop (ptid_t);
65 static void monitor_dump_regs (struct regcache *regcache);
68 static int from_hex (int a);
71 static struct monitor_ops *current_monitor;
73 static int hashmark; /* flag set by "set hash". */
75 static int timeout = 30;
77 static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait(). */
79 static void (*ofunc) (); /* Old SIGINT signal handler. */
81 static CORE_ADDR *breakaddr;
83 /* Descriptor for I/O to remote machine. Initialize it to NULL so
84 that monitor_open knows that we don't have a file open when the
87 static struct serial *monitor_desc = NULL;
89 /* Pointer to regexp pattern matching data. */
91 static struct re_pattern_buffer register_pattern;
92 static char register_fastmap[256];
94 static struct re_pattern_buffer getmem_resp_delim_pattern;
95 static char getmem_resp_delim_fastmap[256];
97 static struct re_pattern_buffer setmem_resp_delim_pattern;
98 static char setmem_resp_delim_fastmap[256];
100 static struct re_pattern_buffer setreg_resp_delim_pattern;
101 static char setreg_resp_delim_fastmap[256];
103 static int dump_reg_flag; /* Non-zero means do a dump_registers cmd when
104 monitor_wait wakes up. */
106 static int first_time = 0; /* Is this the first time we're
107 executing after gaving created the
111 /* This is the ptid we use while we're connected to a monitor. Its
112 value is arbitrary, as monitor targets don't have a notion of
113 processes or threads, but we need something non-null to place in
115 static ptid_t monitor_ptid;
117 #define TARGET_BUF_SIZE 2048
119 /* Monitor specific debugging information. Typically only useful to
120 the developer of a new monitor interface. */
122 static void monitor_debug (const char *fmt, ...) ATTRIBUTE_PRINTF (1, 2);
124 static unsigned int monitor_debug_p = 0;
126 /* NOTE: This file alternates between monitor_debug_p and remote_debug
127 when determining if debug information is printed. Perhaps this
128 could be simplified. */
131 monitor_debug (const char *fmt, ...)
137 va_start (args, fmt);
138 vfprintf_filtered (gdb_stdlog, fmt, args);
144 /* Convert a string into a printable representation, Return # byte in
145 the new string. When LEN is >0 it specifies the size of the
146 string. Otherwize strlen(oldstr) is used. */
149 monitor_printable_string (char *newstr, char *oldstr, int len)
155 len = strlen (oldstr);
157 for (i = 0; i < len; i++)
168 sprintf (newstr, "\\x%02x", ch & 0xff);
207 /* Print monitor errors with a string, converting the string to printable
211 monitor_error (char *function, char *message,
212 CORE_ADDR memaddr, int len, char *string, int final_char)
214 int real_len = (len == 0 && string != (char *) 0) ? strlen (string) : len;
215 char *safe_string = alloca ((real_len * 4) + 1);
217 monitor_printable_string (safe_string, string, real_len);
220 error (_("%s (%s): %s: %s%c"),
221 function, paddress (target_gdbarch (), memaddr),
222 message, safe_string, final_char);
224 error (_("%s (%s): %s: %s"),
225 function, paddress (target_gdbarch (), memaddr),
226 message, safe_string);
229 /* Convert hex digit A to a number. */
234 if (a >= '0' && a <= '9')
236 else if (a >= 'a' && a <= 'f')
238 else if (a >= 'A' && a <= 'F')
241 error (_("Invalid hex digit %d"), a);
244 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
246 This function exists to get around the problem that many host platforms
247 don't have a printf that can print 64-bit addresses. The %A format
248 specification is recognized as a special case, and causes the argument
249 to be printed as a 64-bit hexadecimal address.
251 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
252 If it is a '%s' format, the argument is a string; otherwise the
253 argument is assumed to be a long integer.
255 %% is also turned into a single %. */
258 monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
260 int addr_bit = gdbarch_addr_bit (target_gdbarch ());
269 for (p = pattern; *p; p++)
273 /* Copy the format specifier to a separate buffer. */
275 for (i = 1; *p >= '0' && *p <= '9' && i < (int) sizeof (format) - 2;
278 format[i] = fmt = *p;
279 format[i + 1] = '\0';
281 /* Fetch the next argument and print it. */
285 strcpy (sndbuf, "%");
288 arg_addr = va_arg (args, CORE_ADDR);
289 strcpy (sndbuf, phex_nz (arg_addr, addr_bit / 8));
292 arg_string = va_arg (args, char *);
293 sprintf (sndbuf, format, arg_string);
296 arg_int = va_arg (args, long);
297 sprintf (sndbuf, format, arg_int);
300 sndbuf += strlen (sndbuf);
309 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
310 Works just like printf. */
313 monitor_printf_noecho (char *pattern,...)
319 va_start (args, pattern);
321 monitor_vsprintf (sndbuf, pattern, args);
323 len = strlen (sndbuf);
324 if (len + 1 > sizeof sndbuf)
325 internal_error (__FILE__, __LINE__,
326 _("failed internal consistency check"));
330 char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);
332 monitor_printable_string (safe_string, sndbuf, 0);
333 fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
336 monitor_write (sndbuf, len);
339 /* monitor_printf -- Send data to monitor and check the echo. Works just like
343 monitor_printf (char *pattern,...)
349 va_start (args, pattern);
351 monitor_vsprintf (sndbuf, pattern, args);
353 len = strlen (sndbuf);
354 if (len + 1 > sizeof sndbuf)
355 internal_error (__FILE__, __LINE__,
356 _("failed internal consistency check"));
360 char *safe_string = (char *) alloca ((len * 4) + 1);
362 monitor_printable_string (safe_string, sndbuf, 0);
363 fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
366 monitor_write (sndbuf, len);
368 /* We used to expect that the next immediate output was the
369 characters we just output, but sometimes some extra junk appeared
370 before the characters we expected, like an extra prompt, or a
371 portmaster sending telnet negotiations. So, just start searching
372 for what we sent, and skip anything unknown. */
373 monitor_debug ("ExpectEcho\n");
374 monitor_expect (sndbuf, (char *) 0, 0);
378 /* Write characters to the remote system. */
381 monitor_write (char *buf, int buflen)
383 if (serial_write (monitor_desc, buf, buflen))
384 fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n",
385 safe_strerror (errno));
389 /* Read a binary character from the remote system, doing all the fancy
390 timeout stuff, but without interpreting the character in any way,
391 and without printing remote debug information. */
394 monitor_readchar (void)
402 c = serial_readchar (monitor_desc, timeout);
405 c &= 0xff; /* don't lose bit 7 */
412 if (c == SERIAL_TIMEOUT)
413 error (_("Timeout reading from remote system."));
415 perror_with_name (_("remote-monitor"));
419 /* Read a character from the remote system, doing all the fancy
423 readchar (int timeout)
428 last_random, last_nl, last_cr, last_crnl
436 c = serial_readchar (monitor_desc, timeout);
441 /* This seems to interfere with proper function of the
443 if (monitor_debug_p || remote_debug)
449 puts_debug ("read -->", buf, "<--");
454 /* Canonicialize \n\r combinations into one \r. */
455 if ((current_monitor->flags & MO_HANDLE_NL) != 0)
457 if ((c == '\r' && state == last_nl)
458 || (c == '\n' && state == last_cr))
479 if (c == SERIAL_TIMEOUT)
481 /* I fail to see how detaching here can be useful. */
482 if (in_monitor_wait) /* Watchdog went off. */
484 target_mourn_inferior ();
485 error (_("GDB serial timeout has expired. Target detached."));
489 error (_("Timeout reading from remote system."));
491 perror_with_name (_("remote-monitor"));
494 /* Scan input from the remote system, until STRING is found. If BUF is non-
495 zero, then collect input until we have collected either STRING or BUFLEN-1
496 chars. In either case we terminate BUF with a 0. If input overflows BUF
497 because STRING can't be found, return -1, else return number of chars in BUF
498 (minus the terminating NUL). Note that in the non-overflow case, STRING
499 will be at the end of BUF. */
502 monitor_expect (char *string, char *buf, int buflen)
505 int obuflen = buflen;
510 char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
511 monitor_printable_string (safe_string, string, 0);
512 fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
528 c = readchar (timeout);
535 c = readchar (timeout);
537 /* Don't expect any ^C sent to be echoed. */
539 if (*p == '\003' || c == *p)
549 return obuflen - buflen;
557 /* We got a character that doesn't match the string. We need to
558 back up p, but how far? If we're looking for "..howdy" and the
559 monitor sends "...howdy"? There's certainly a match in there,
560 but when we receive the third ".", we won't find it if we just
561 restart the matching at the beginning of the string.
563 This is a Boyer-Moore kind of situation. We want to reset P to
564 the end of the longest prefix of STRING that is a suffix of
565 what we've read so far. In the example above, that would be
566 ".." --- the longest prefix of "..howdy" that is a suffix of
567 "...". This longest prefix could be the empty string, if C
568 is nowhere to be found in STRING.
570 If this longest prefix is not the empty string, it must contain
571 C, so let's search from the end of STRING for instances of C,
572 and see if the portion of STRING before that is a suffix of
573 what we read before C. Actually, we can search backwards from
574 p, since we know no prefix can be longer than that.
576 Note that we can use STRING itself, along with C, as a record
577 of what we've received so far. :) */
580 for (i = (p - string) - 1; i >= 0; i--)
583 /* Is this prefix a suffix of what we've read so far?
585 string[0 .. i-1] == string[p - i, p - 1]? */
586 if (! memcmp (string, p - i, i))
598 /* Search for a regexp. */
601 monitor_expect_regexp (struct re_pattern_buffer *pat, char *buf, int buflen)
606 monitor_debug ("MON Expecting regexp\n");
611 mybuf = alloca (TARGET_BUF_SIZE);
612 buflen = TARGET_BUF_SIZE;
620 if (p - mybuf >= buflen)
621 { /* Buffer about to overflow. */
623 /* On overflow, we copy the upper half of the buffer to the lower half. Not
624 great, but it usually works... */
626 memcpy (mybuf, mybuf + buflen / 2, buflen / 2);
627 p = mybuf + buflen / 2;
630 *p++ = readchar (timeout);
632 retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL);
638 /* Keep discarding input until we see the MONITOR prompt.
640 The convention for dealing with the prompt is that you
642 o *then* wait for the prompt.
644 Thus the last thing that a procedure does with the serial line will
645 be an monitor_expect_prompt(). Exception: monitor_resume does not
646 wait for the prompt, because the terminal is being handed over to
647 the inferior. However, the next thing which happens after that is
648 a monitor_wait which does wait for the prompt. Note that this
649 includes abnormal exit, e.g. error(). This is necessary to prevent
650 getting into states from which we can't recover. */
653 monitor_expect_prompt (char *buf, int buflen)
655 monitor_debug ("MON Expecting prompt\n");
656 return monitor_expect (current_monitor->prompt, buf, buflen);
659 /* Get N 32-bit words from remote, each preceded by a space, and put
660 them in registers starting at REGNO. */
671 ch = readchar (timeout);
672 while (isspace (ch));
676 for (i = 7; i >= 1; i--)
678 ch = readchar (timeout);
681 val = (val << 4) | from_hex (ch);
689 compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern,
695 compiled_pattern->fastmap = fastmap;
697 tmp = re_set_syntax (RE_SYNTAX_EMACS);
698 val = re_compile_pattern (pattern,
704 error (_("compile_pattern: Can't compile pattern string `%s': %s!"),
708 re_compile_fastmap (compiled_pattern);
711 /* Open a connection to a remote debugger. NAME is the filename used
712 for communication. */
715 monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
719 struct inferior *inf;
721 if (mon_ops->magic != MONITOR_OPS_MAGIC)
722 error (_("Magic number of monitor_ops struct wrong."));
724 targ_ops = mon_ops->target;
725 name = targ_ops->to_shortname;
728 error (_("Use `target %s DEVICE-NAME' to use a serial port, or\n\
729 `target %s HOST-NAME:PORT-NUMBER' to use a network connection."), name, name);
731 target_preopen (from_tty);
733 /* Setup pattern for register dump. */
735 if (mon_ops->register_pattern)
736 compile_pattern (mon_ops->register_pattern, ®ister_pattern,
739 if (mon_ops->getmem.resp_delim)
740 compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
741 getmem_resp_delim_fastmap);
743 if (mon_ops->setmem.resp_delim)
744 compile_pattern (mon_ops->setmem.resp_delim, &setmem_resp_delim_pattern,
745 setmem_resp_delim_fastmap);
747 if (mon_ops->setreg.resp_delim)
748 compile_pattern (mon_ops->setreg.resp_delim, &setreg_resp_delim_pattern,
749 setreg_resp_delim_fastmap);
751 unpush_target (targ_ops);
755 dev_name = xstrdup (args);
757 monitor_desc = serial_open (dev_name);
760 perror_with_name (dev_name);
764 if (serial_setbaudrate (monitor_desc, baud_rate))
766 serial_close (monitor_desc);
767 perror_with_name (dev_name);
771 serial_raw (monitor_desc);
773 serial_flush_input (monitor_desc);
775 /* some systems only work with 2 stop bits. */
777 serial_setstopbits (monitor_desc, mon_ops->stopbits);
779 current_monitor = mon_ops;
781 /* See if we can wake up the monitor. First, try sending a stop sequence,
782 then send the init strings. Last, remove all breakpoints. */
784 if (current_monitor->stop)
786 monitor_stop (inferior_ptid);
787 if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
789 monitor_debug ("EXP Open echo\n");
790 monitor_expect_prompt (NULL, 0);
794 /* wake up the monitor and see if it's alive. */
795 for (p = mon_ops->init; *p != NULL; p++)
797 /* Some of the characters we send may not be echoed,
798 but we hope to get a prompt at the end of it all. */
800 if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
803 monitor_printf_noecho (*p);
804 monitor_expect_prompt (NULL, 0);
807 serial_flush_input (monitor_desc);
809 /* Alloc breakpoints */
810 if (mon_ops->set_break != NULL)
812 if (mon_ops->num_breakpoints == 0)
813 mon_ops->num_breakpoints = 8;
815 breakaddr = (CORE_ADDR *)
816 xmalloc (mon_ops->num_breakpoints * sizeof (CORE_ADDR));
817 memset (breakaddr, 0, mon_ops->num_breakpoints * sizeof (CORE_ADDR));
820 /* Remove all breakpoints. */
822 if (mon_ops->clr_all_break)
824 monitor_printf (mon_ops->clr_all_break);
825 monitor_expect_prompt (NULL, 0);
829 printf_unfiltered (_("Remote target %s connected to %s\n"),
832 push_target (targ_ops);
837 /* Make run command think we are busy... */
838 inferior_ptid = monitor_ptid;
839 inf = current_inferior ();
840 inferior_appeared (inf, ptid_get_pid (inferior_ptid));
841 add_thread_silent (inferior_ptid);
843 /* Give monitor_wait something to read. */
845 monitor_printf (current_monitor->line_term);
847 init_wait_for_inferior ();
849 start_remote (from_tty);
852 /* Close out all files and local state before this target loses
859 serial_close (monitor_desc);
861 /* Free breakpoint memory. */
862 if (breakaddr != NULL)
870 delete_thread_silent (monitor_ptid);
871 delete_inferior_silent (ptid_get_pid (monitor_ptid));
874 /* Terminate the open connection to the remote debugger. Use this
875 when you want to detach and do something else with your gdb. */
878 monitor_detach (struct target_ops *ops, const char *args, int from_tty)
880 unpush_target (ops); /* calls monitor_close to do the real work. */
882 printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname);
885 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
888 monitor_supply_register (struct regcache *regcache, int regno, char *valstr)
890 struct gdbarch *gdbarch = get_regcache_arch (regcache);
891 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
893 unsigned char regbuf[MAX_REGISTER_SIZE];
898 while (p && *p != '\0')
900 if (*p == '\r' || *p == '\n')
911 if (!isxdigit (*p) && *p != 'x')
917 val += fromhex (*p++);
919 monitor_debug ("Supplying Register %d %s\n", regno, valstr);
921 if (val == 0 && valstr == p)
922 error (_("monitor_supply_register (%d): bad value from monitor: %s."),
925 /* supply register stores in target byte order, so swap here. */
927 store_unsigned_integer (regbuf, register_size (gdbarch, regno), byte_order,
930 regcache_raw_supply (regcache, regno, regbuf);
935 /* Tell the remote machine to resume. */
938 monitor_resume (struct target_ops *ops,
939 ptid_t ptid, int step, enum gdb_signal sig)
941 /* Some monitors require a different command when starting a program. */
942 monitor_debug ("MON resume\n");
943 if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
946 monitor_printf ("run\r");
947 if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
952 monitor_printf (current_monitor->step);
955 if (current_monitor->continue_hook)
956 (*current_monitor->continue_hook) ();
958 monitor_printf (current_monitor->cont);
959 if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
964 /* Parse the output of a register dump command. A monitor specific
965 regexp is used to extract individual register descriptions of the
966 form REG=VAL. Each description is split up into a name and a value
967 string which are passed down to monitor specific code. */
970 parse_register_dump (struct regcache *regcache, char *buf, int len)
972 monitor_debug ("MON Parsing register dump\n");
975 int regnamelen, vallen;
978 /* Element 0 points to start of register name, and element 1
979 points to the start of the register value. */
980 struct re_registers register_strings;
982 memset (®ister_strings, 0, sizeof (struct re_registers));
984 if (re_search (®ister_pattern, buf, len, 0, len,
985 ®ister_strings) == -1)
988 regnamelen = register_strings.end[1] - register_strings.start[1];
989 regname = buf + register_strings.start[1];
990 vallen = register_strings.end[2] - register_strings.start[2];
991 val = buf + register_strings.start[2];
993 current_monitor->supply_register (regcache, regname, regnamelen,
996 buf += register_strings.end[0];
997 len -= register_strings.end[0];
1001 /* Send ^C to target to halt it. Target will respond, and send us a
1005 monitor_interrupt (int signo)
1007 /* If this doesn't work, try more severe steps. */
1008 signal (signo, monitor_interrupt_twice);
1010 if (monitor_debug_p || remote_debug)
1011 fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
1013 target_stop (inferior_ptid);
1016 /* The user typed ^C twice. */
1019 monitor_interrupt_twice (int signo)
1021 signal (signo, ofunc);
1023 monitor_interrupt_query ();
1025 signal (signo, monitor_interrupt);
1028 /* Ask the user what to do when an interrupt is received. */
1031 monitor_interrupt_query (void)
1033 target_terminal_ours ();
1035 if (query (_("Interrupted while waiting for the program.\n\
1036 Give up (and stop debugging it)? ")))
1038 target_mourn_inferior ();
1042 target_terminal_inferior ();
1046 monitor_wait_cleanup (void *old_timeout)
1048 timeout = *(int *) old_timeout;
1049 signal (SIGINT, ofunc);
1050 in_monitor_wait = 0;
1056 monitor_wait_filter (char *buf,
1059 struct target_waitstatus *status)
1065 resp_len = monitor_expect_prompt (buf, bufmax);
1066 *ext_resp_len = resp_len;
1069 fprintf_unfiltered (gdb_stderr,
1070 "monitor_wait: excessive "
1071 "response from monitor: %s.", buf);
1073 while (resp_len < 0);
1075 /* Print any output characters that were preceded by ^O. */
1076 /* FIXME - This would be great as a user settabgle flag. */
1077 if (monitor_debug_p || remote_debug
1078 || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
1082 for (i = 0; i < resp_len - 1; i++)
1084 putchar_unfiltered (buf[++i]);
1090 /* Wait until the remote machine stops, then return, storing status in
1091 status just as `wait' would. */
1094 monitor_wait (struct target_ops *ops,
1095 ptid_t ptid, struct target_waitstatus *status, int options)
1097 int old_timeout = timeout;
1098 char buf[TARGET_BUF_SIZE];
1100 struct cleanup *old_chain;
1102 status->kind = TARGET_WAITKIND_EXITED;
1103 status->value.integer = 0;
1105 old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
1106 monitor_debug ("MON wait\n");
1109 /* This is somthing other than a maintenance command. */
1110 in_monitor_wait = 1;
1111 timeout = watchdog > 0 ? watchdog : -1;
1113 timeout = -1; /* Don't time out -- user program is running. */
1116 ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
1118 if (current_monitor->wait_filter)
1119 (*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status);
1121 monitor_wait_filter (buf, sizeof (buf), &resp_len, status);
1123 #if 0 /* Transferred to monitor wait filter. */
1126 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1129 fprintf_unfiltered (gdb_stderr,
1130 "monitor_wait: excessive "
1131 "response from monitor: %s.", buf);
1133 while (resp_len < 0);
1135 /* Print any output characters that were preceded by ^O. */
1136 /* FIXME - This would be great as a user settabgle flag. */
1137 if (monitor_debug_p || remote_debug
1138 || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
1142 for (i = 0; i < resp_len - 1; i++)
1144 putchar_unfiltered (buf[++i]);
1148 signal (SIGINT, ofunc);
1150 timeout = old_timeout;
1152 if (dump_reg_flag && current_monitor->dump_registers)
1155 monitor_printf (current_monitor->dump_registers);
1156 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1159 if (current_monitor->register_pattern)
1160 parse_register_dump (get_current_regcache (), buf, resp_len);
1162 monitor_debug ("Wait fetching registers after stop\n");
1163 monitor_dump_regs (get_current_regcache ());
1166 status->kind = TARGET_WAITKIND_STOPPED;
1167 status->value.sig = GDB_SIGNAL_TRAP;
1169 discard_cleanups (old_chain);
1171 in_monitor_wait = 0;
1173 return inferior_ptid;
1176 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1180 monitor_fetch_register (struct regcache *regcache, int regno)
1187 regbuf = alloca (MAX_REGISTER_SIZE * 2 + 1);
1188 zerobuf = alloca (MAX_REGISTER_SIZE);
1189 memset (zerobuf, 0, MAX_REGISTER_SIZE);
1191 if (current_monitor->regname != NULL)
1192 name = current_monitor->regname (regno);
1194 name = current_monitor->regnames[regno];
1195 monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
1197 if (!name || (*name == '\0'))
1199 monitor_debug ("No register known for %d\n", regno);
1200 regcache_raw_supply (regcache, regno, zerobuf);
1204 /* Send the register examine command. */
1206 monitor_printf (current_monitor->getreg.cmd, name);
1208 /* If RESP_DELIM is specified, we search for that as a leading
1209 delimiter for the register value. Otherwise, we just start
1210 searching from the start of the buf. */
1212 if (current_monitor->getreg.resp_delim)
1214 monitor_debug ("EXP getreg.resp_delim\n");
1215 monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1216 /* Handle case of first 32 registers listed in pairs. */
1217 if (current_monitor->flags & MO_32_REGS_PAIRED
1218 && (regno & 1) != 0 && regno < 32)
1220 monitor_debug ("EXP getreg.resp_delim\n");
1221 monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1225 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1226 if (current_monitor->flags & MO_HEX_PREFIX)
1230 c = readchar (timeout);
1232 c = readchar (timeout);
1233 if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1236 error (_("Bad value returned from monitor "
1237 "while fetching register %x."),
1241 /* Read upto the maximum number of hex digits for this register, skipping
1242 spaces, but stop reading if something else is seen. Some monitors
1243 like to drop leading zeros. */
1245 for (i = 0; i < register_size (get_regcache_arch (regcache), regno) * 2; i++)
1249 c = readchar (timeout);
1251 c = readchar (timeout);
1259 regbuf[i] = '\000'; /* Terminate the number. */
1260 monitor_debug ("REGVAL '%s'\n", regbuf);
1262 /* If TERM is present, we wait for that to show up. Also, (if TERM
1263 is present), we will send TERM_CMD if that is present. In any
1264 case, we collect all of the output into buf, and then wait for
1265 the normal prompt. */
1267 if (current_monitor->getreg.term)
1269 monitor_debug ("EXP getreg.term\n");
1270 monitor_expect (current_monitor->getreg.term, NULL, 0); /* Get
1274 if (current_monitor->getreg.term_cmd)
1276 monitor_debug ("EMIT getreg.term.cmd\n");
1277 monitor_printf (current_monitor->getreg.term_cmd);
1279 if (!current_monitor->getreg.term || /* Already expected or */
1280 current_monitor->getreg.term_cmd) /* ack expected. */
1281 monitor_expect_prompt (NULL, 0); /* Get response. */
1283 monitor_supply_register (regcache, regno, regbuf);
1286 /* Sometimes, it takes several commands to dump the registers. */
1287 /* This is a primitive for use by variations of monitor interfaces in
1288 case they need to compose the operation. */
1291 monitor_dump_reg_block (struct regcache *regcache, char *block_cmd)
1293 char buf[TARGET_BUF_SIZE];
1296 monitor_printf (block_cmd);
1297 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1298 parse_register_dump (regcache, buf, resp_len);
1303 /* Read the remote registers into the block regs. */
1304 /* Call the specific function if it has been provided. */
1307 monitor_dump_regs (struct regcache *regcache)
1309 char buf[TARGET_BUF_SIZE];
1312 if (current_monitor->dumpregs)
1313 (*(current_monitor->dumpregs)) (regcache); /* Call supplied function. */
1314 else if (current_monitor->dump_registers) /* Default version. */
1316 monitor_printf (current_monitor->dump_registers);
1317 resp_len = monitor_expect_prompt (buf, sizeof (buf));
1318 parse_register_dump (regcache, buf, resp_len);
1321 /* Need some way to read registers. */
1322 internal_error (__FILE__, __LINE__,
1323 _("failed internal consistency check"));
1327 monitor_fetch_registers (struct target_ops *ops,
1328 struct regcache *regcache, int regno)
1330 monitor_debug ("MON fetchregs\n");
1331 if (current_monitor->getreg.cmd)
1335 monitor_fetch_register (regcache, regno);
1339 for (regno = 0; regno < gdbarch_num_regs (get_regcache_arch (regcache));
1341 monitor_fetch_register (regcache, regno);
1345 monitor_dump_regs (regcache);
1349 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1352 monitor_store_register (struct regcache *regcache, int regno)
1354 int reg_size = register_size (get_regcache_arch (regcache), regno);
1358 if (current_monitor->regname != NULL)
1359 name = current_monitor->regname (regno);
1361 name = current_monitor->regnames[regno];
1363 if (!name || (*name == '\0'))
1365 monitor_debug ("MON Cannot store unknown register\n");
1369 regcache_cooked_read_unsigned (regcache, regno, &val);
1370 monitor_debug ("MON storeg %d %s\n", regno, phex (val, reg_size));
1372 /* Send the register deposit command. */
1374 if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
1375 monitor_printf (current_monitor->setreg.cmd, val, name);
1376 else if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1377 monitor_printf (current_monitor->setreg.cmd, name);
1379 monitor_printf (current_monitor->setreg.cmd, name, val);
1381 if (current_monitor->setreg.resp_delim)
1383 monitor_debug ("EXP setreg.resp_delim\n");
1384 monitor_expect_regexp (&setreg_resp_delim_pattern, NULL, 0);
1385 if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1386 monitor_printf ("%s\r", phex_nz (val, reg_size));
1388 if (current_monitor->setreg.term)
1390 monitor_debug ("EXP setreg.term\n");
1391 monitor_expect (current_monitor->setreg.term, NULL, 0);
1392 if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1393 monitor_printf ("%s\r", phex_nz (val, reg_size));
1394 monitor_expect_prompt (NULL, 0);
1397 monitor_expect_prompt (NULL, 0);
1398 if (current_monitor->setreg.term_cmd) /* Mode exit required. */
1400 monitor_debug ("EXP setreg_termcmd\n");
1401 monitor_printf ("%s", current_monitor->setreg.term_cmd);
1402 monitor_expect_prompt (NULL, 0);
1404 } /* monitor_store_register */
1406 /* Store the remote registers. */
1409 monitor_store_registers (struct target_ops *ops,
1410 struct regcache *regcache, int regno)
1414 monitor_store_register (regcache, regno);
1418 for (regno = 0; regno < gdbarch_num_regs (get_regcache_arch (regcache));
1420 monitor_store_register (regcache, regno);
1423 /* Get ready to modify the registers array. On machines which store
1424 individual registers, this doesn't need to do anything. On machines
1425 which store all the registers in one fell swoop, this makes sure
1426 that registers contains all the registers from the program being
1430 monitor_prepare_to_store (struct target_ops *self, struct regcache *regcache)
1432 /* Do nothing, since we can store individual regs. */
1436 monitor_files_info (struct target_ops *ops)
1438 printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name, baud_rate);
1442 monitor_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1444 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1445 unsigned int val, hostval;
1449 monitor_debug ("MON write %d %s\n", len, paddress (target_gdbarch (), memaddr));
1451 if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1452 memaddr = gdbarch_addr_bits_remove (target_gdbarch (), memaddr);
1454 /* Use memory fill command for leading 0 bytes. */
1456 if (current_monitor->fill)
1458 for (i = 0; i < len; i++)
1462 if (i > 4) /* More than 4 zeros is worth doing. */
1464 monitor_debug ("MON FILL %d\n", i);
1465 if (current_monitor->flags & MO_FILL_USES_ADDR)
1466 monitor_printf (current_monitor->fill, memaddr,
1467 (memaddr + i) - 1, 0);
1469 monitor_printf (current_monitor->fill, memaddr, i, 0);
1471 monitor_expect_prompt (NULL, 0);
1478 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1479 if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
1482 cmd = current_monitor->setmem.cmdll;
1486 if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
1489 cmd = current_monitor->setmem.cmdl;
1491 else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw)
1494 cmd = current_monitor->setmem.cmdw;
1499 cmd = current_monitor->setmem.cmdb;
1502 val = extract_unsigned_integer (myaddr, len, byte_order);
1506 hostval = *(unsigned int *) myaddr;
1507 monitor_debug ("Hostval(%08x) val(%08x)\n", hostval, val);
1511 if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
1512 monitor_printf_noecho (cmd, memaddr, val);
1513 else if (current_monitor->flags & MO_SETMEM_INTERACTIVE)
1515 monitor_printf_noecho (cmd, memaddr);
1517 if (current_monitor->setmem.resp_delim)
1519 monitor_debug ("EXP setmem.resp_delim");
1520 monitor_expect_regexp (&setmem_resp_delim_pattern, NULL, 0);
1521 monitor_printf ("%x\r", val);
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_memory_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1552 /* Enter the sub mode. */
1553 monitor_printf (current_monitor->setmem.cmdb, memaddr);
1554 monitor_expect_prompt (NULL, 0);
1558 monitor_printf ("%x\r", val);
1562 /* If we wanted to, here we could validate the address. */
1563 monitor_expect_prompt (NULL, 0);
1566 /* Now exit the sub mode. */
1567 monitor_printf (current_monitor->getreg.term_cmd);
1568 monitor_expect_prompt (NULL, 0);
1574 longlongendswap (unsigned char *a)
1584 *(a + i) = *(a + j);
1589 /* Format 32 chars of long long value, advance the pointer. */
1590 static char *hexlate = "0123456789abcdef";
1592 longlong_hexchars (unsigned long long value,
1602 static unsigned char disbuf[8]; /* disassembly buffer */
1603 unsigned char *scan, *limit; /* loop controls */
1604 unsigned char c, nib;
1610 unsigned long long *dp;
1612 dp = (unsigned long long *) scan;
1615 longlongendswap (disbuf); /* FIXME: ONly on big endian hosts. */
1616 while (scan < limit)
1618 c = *scan++; /* A byte of our long long value. */
1624 leadzero = 0; /* Henceforth we print even zeroes. */
1626 nib = c >> 4; /* high nibble bits */
1627 *outbuff++ = hexlate[nib];
1628 nib = c & 0x0f; /* low nibble bits */
1629 *outbuff++ = hexlate[nib];
1633 } /* longlong_hexchars */
1637 /* I am only going to call this when writing virtual byte streams.
1638 Which possably entails endian conversions. */
1641 monitor_write_memory_longlongs (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1643 static char hexstage[20]; /* At least 16 digits required, plus null. */
1649 llptr = (long long *) myaddr;
1652 monitor_printf (current_monitor->setmem.cmdll, memaddr);
1653 monitor_expect_prompt (NULL, 0);
1657 endstring = longlong_hexchars (*llptr, hexstage);
1658 *endstring = '\0'; /* NUll terminate for printf. */
1659 monitor_printf ("%s\r", hexstage);
1663 /* If we wanted to, here we could validate the address. */
1664 monitor_expect_prompt (NULL, 0);
1667 /* Now exit the sub mode. */
1668 monitor_printf (current_monitor->getreg.term_cmd);
1669 monitor_expect_prompt (NULL, 0);
1675 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1676 /* This is for the large blocks of memory which may occur in downloading.
1677 And for monitors which use interactive entry,
1678 And for monitors which do not have other downloading methods.
1679 Without this, we will end up calling monitor_write_memory many times
1680 and do the entry and exit of the sub mode many times
1681 This currently assumes...
1682 MO_SETMEM_INTERACTIVE
1683 ! MO_NO_ECHO_ON_SETMEM
1684 To use this, the you have to patch the monitor_cmds block with
1685 this function. Otherwise, its not tuned up for use by all
1686 monitor variations. */
1689 monitor_write_memory_block (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1694 /* FIXME: This would be a good place to put the zero test. */
1696 if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
1698 return monitor_write_memory_longlongs (memaddr, myaddr, len);
1701 written = monitor_write_memory_bytes (memaddr, myaddr, len);
1705 /* This is an alternate form of monitor_read_memory which is used for monitors
1706 which can only read a single byte/word/etc. at a time. */
1709 monitor_read_memory_single (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
1711 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1713 char membuf[sizeof (int) * 2 + 1];
1717 monitor_debug ("MON read single\n");
1719 /* Can't actually use long longs (nice idea, though). In fact, the
1720 call to strtoul below will fail if it tries to convert a value
1721 that's too big to fit in a long. */
1722 if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
1725 cmd = current_monitor->getmem.cmdll;
1729 if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
1732 cmd = current_monitor->getmem.cmdl;
1734 else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->getmem.cmdw)
1737 cmd = current_monitor->getmem.cmdw;
1742 cmd = current_monitor->getmem.cmdb;
1745 /* Send the examine command. */
1747 monitor_printf (cmd, memaddr);
1749 /* If RESP_DELIM is specified, we search for that as a leading
1750 delimiter for the memory value. Otherwise, we just start
1751 searching from the start of the buf. */
1753 if (current_monitor->getmem.resp_delim)
1755 monitor_debug ("EXP getmem.resp_delim\n");
1756 monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
1759 /* Now, read the appropriate number of hex digits for this loc,
1762 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1763 if (current_monitor->flags & MO_HEX_PREFIX)
1767 c = readchar (timeout);
1769 c = readchar (timeout);
1770 if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1773 monitor_error ("monitor_read_memory_single",
1774 "bad response from monitor",
1775 memaddr, 0, NULL, 0);
1781 for (i = 0; i < len * 2; i++)
1787 c = readchar (timeout);
1793 monitor_error ("monitor_read_memory_single",
1794 "bad response from monitor",
1795 memaddr, i, membuf, 0);
1799 membuf[i] = '\000'; /* Terminate the number. */
1802 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1803 present), we will send TERM_CMD if that is present. In any case, we collect
1804 all of the output into buf, and then wait for the normal prompt. */
1806 if (current_monitor->getmem.term)
1808 monitor_expect (current_monitor->getmem.term, NULL, 0); /* Get
1811 if (current_monitor->getmem.term_cmd)
1813 monitor_printf (current_monitor->getmem.term_cmd);
1814 monitor_expect_prompt (NULL, 0);
1818 monitor_expect_prompt (NULL, 0); /* Get response. */
1821 val = strtoul (membuf, &p, 16);
1823 if (val == 0 && membuf == p)
1824 monitor_error ("monitor_read_memory_single",
1825 "bad value from monitor",
1826 memaddr, 0, membuf, 0);
1828 /* supply register stores in target byte order, so swap here. */
1830 store_unsigned_integer (myaddr, len, byte_order, val);
1835 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1836 memory at MEMADDR. Returns length moved. Currently, we do no more
1837 than 16 bytes at a time. */
1840 monitor_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
1851 monitor_debug ("Zero length call to monitor_read_memory\n");
1855 monitor_debug ("MON read block ta(%s) ha(%s) %d\n",
1856 paddress (target_gdbarch (), memaddr),
1857 host_address_to_string (myaddr), len);
1859 if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1860 memaddr = gdbarch_addr_bits_remove (target_gdbarch (), memaddr);
1862 if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
1863 return monitor_read_memory_single (memaddr, myaddr, len);
1865 len = min (len, 16);
1867 /* Some dumpers align the first data with the preceding 16
1868 byte boundary. Some print blanks and start at the
1869 requested boundary. EXACT_DUMPADDR */
1871 dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
1872 ? memaddr : memaddr & ~0x0f;
1874 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1875 if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
1876 len = ((memaddr + len) & ~0xf) - memaddr;
1878 /* Send the memory examine command. */
1880 if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
1881 monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len);
1882 else if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1883 monitor_printf (current_monitor->getmem.cmdb, dumpaddr);
1885 monitor_printf (current_monitor->getmem.cmdb, memaddr, len);
1887 /* If TERM is present, we wait for that to show up. Also, (if TERM
1888 is present), we will send TERM_CMD if that is present. In any
1889 case, we collect all of the output into buf, and then wait for
1890 the normal prompt. */
1892 if (current_monitor->getmem.term)
1894 resp_len = monitor_expect (current_monitor->getmem.term,
1895 buf, sizeof buf); /* Get response. */
1898 monitor_error ("monitor_read_memory",
1899 "excessive response from monitor",
1900 memaddr, resp_len, buf, 0);
1902 if (current_monitor->getmem.term_cmd)
1904 serial_write (monitor_desc, current_monitor->getmem.term_cmd,
1905 strlen (current_monitor->getmem.term_cmd));
1906 monitor_expect_prompt (NULL, 0);
1910 resp_len = monitor_expect_prompt (buf, sizeof buf); /* Get response. */
1914 /* If RESP_DELIM is specified, we search for that as a leading
1915 delimiter for the values. Otherwise, we just start searching
1916 from the start of the buf. */
1918 if (current_monitor->getmem.resp_delim)
1921 struct re_registers resp_strings;
1923 monitor_debug ("MON getmem.resp_delim %s\n",
1924 current_monitor->getmem.resp_delim);
1926 memset (&resp_strings, 0, sizeof (struct re_registers));
1928 retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
1932 monitor_error ("monitor_read_memory",
1933 "bad response from monitor",
1934 memaddr, resp_len, buf, 0);
1936 p += resp_strings.end[0];
1938 p = strstr (p, current_monitor->getmem.resp_delim);
1940 monitor_error ("monitor_read_memory",
1941 "bad response from monitor",
1942 memaddr, resp_len, buf, 0);
1943 p += strlen (current_monitor->getmem.resp_delim);
1946 monitor_debug ("MON scanning %d ,%s '%s'\n", len,
1947 host_address_to_string (p), p);
1948 if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1956 while (!(c == '\000' || c == '\n' || c == '\r') && i > 0)
1960 if ((dumpaddr >= memaddr) && (i > 0))
1962 val = fromhex (c) * 16 + fromhex (*(p + 1));
1964 if (monitor_debug_p || remote_debug)
1965 fprintf_unfiltered (gdb_stdlog, "[%02x]", val);
1972 ++p; /* Skip a blank or other non hex char. */
1976 error (_("Failed to read via monitor"));
1977 if (monitor_debug_p || remote_debug)
1978 fprintf_unfiltered (gdb_stdlog, "\n");
1979 return fetched; /* Return the number of bytes actually
1982 monitor_debug ("MON scanning bytes\n");
1984 for (i = len; i > 0; i--)
1986 /* Skip non-hex chars, but bomb on end of string and newlines. */
1993 if (*p == '\000' || *p == '\n' || *p == '\r')
1994 monitor_error ("monitor_read_memory",
1995 "badly terminated response from monitor",
1996 memaddr, resp_len, buf, 0);
2000 val = strtoul (p, &p1, 16);
2002 if (val == 0 && p == p1)
2003 monitor_error ("monitor_read_memory",
2004 "bad value from monitor",
2005 memaddr, resp_len, buf, 0);
2018 /* Helper for monitor_xfer_partial that handles memory transfers.
2019 Arguments are like target_xfer_partial. */
2021 static enum target_xfer_status
2022 monitor_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
2023 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
2027 if (writebuf != NULL)
2029 if (current_monitor->flags & MO_HAS_BLOCKWRITES)
2030 res = monitor_write_memory_block (memaddr, writebuf, len);
2032 res = monitor_write_memory (memaddr, writebuf, len);
2036 res = monitor_read_memory (memaddr, readbuf, len);
2040 return TARGET_XFER_E_IO;
2043 *xfered_len = (ULONGEST) res;
2044 return TARGET_XFER_OK;
2048 /* Target to_xfer_partial implementation. */
2050 static enum target_xfer_status
2051 monitor_xfer_partial (struct target_ops *ops, enum target_object object,
2052 const char *annex, gdb_byte *readbuf,
2053 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
2054 ULONGEST *xfered_len)
2058 case TARGET_OBJECT_MEMORY:
2059 return monitor_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
2062 return TARGET_XFER_E_IO;
2067 monitor_kill (struct target_ops *ops)
2069 return; /* Ignore attempts to kill target system. */
2072 /* All we actually do is set the PC to the start address of exec_bfd. */
2075 monitor_create_inferior (struct target_ops *ops, char *exec_file,
2076 char *args, char **env, int from_tty)
2078 if (args && (*args != '\000'))
2079 error (_("Args are not supported by the monitor."));
2082 clear_proceed_status ();
2083 regcache_write_pc (get_current_regcache (),
2084 bfd_get_start_address (exec_bfd));
2087 /* Clean up when a program exits.
2088 The program actually lives on in the remote processor's RAM, and may be
2089 run again without a download. Don't leave it full of breakpoint
2093 monitor_mourn_inferior (struct target_ops *ops)
2095 unpush_target (targ_ops);
2096 generic_mourn_inferior (); /* Do all the proper things now. */
2097 delete_thread_silent (monitor_ptid);
2100 /* Tell the monitor to add a breakpoint. */
2103 monitor_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
2104 struct bp_target_info *bp_tgt)
2106 CORE_ADDR addr = bp_tgt->placed_address;
2110 monitor_debug ("MON inst bkpt %s\n", paddress (gdbarch, addr));
2111 if (current_monitor->set_break == NULL)
2112 error (_("No set_break defined for this monitor"));
2114 if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
2115 addr = gdbarch_addr_bits_remove (gdbarch, addr);
2117 /* Determine appropriate breakpoint size for this address. */
2118 gdbarch_breakpoint_from_pc (gdbarch, &addr, &bplen);
2119 bp_tgt->placed_address = addr;
2120 bp_tgt->placed_size = bplen;
2122 for (i = 0; i < current_monitor->num_breakpoints; i++)
2124 if (breakaddr[i] == 0)
2126 breakaddr[i] = addr;
2127 monitor_printf (current_monitor->set_break, addr);
2128 monitor_expect_prompt (NULL, 0);
2133 error (_("Too many breakpoints (> %d) for monitor."),
2134 current_monitor->num_breakpoints);
2137 /* Tell the monitor to remove a breakpoint. */
2140 monitor_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
2141 struct bp_target_info *bp_tgt)
2143 CORE_ADDR addr = bp_tgt->placed_address;
2146 monitor_debug ("MON rmbkpt %s\n", paddress (gdbarch, addr));
2147 if (current_monitor->clr_break == NULL)
2148 error (_("No clr_break defined for this monitor"));
2150 for (i = 0; i < current_monitor->num_breakpoints; i++)
2152 if (breakaddr[i] == addr)
2155 /* Some monitors remove breakpoints based on the address. */
2156 if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
2157 monitor_printf (current_monitor->clr_break, addr);
2158 else if (current_monitor->flags & MO_CLR_BREAK_1_BASED)
2159 monitor_printf (current_monitor->clr_break, i + 1);
2161 monitor_printf (current_monitor->clr_break, i);
2162 monitor_expect_prompt (NULL, 0);
2166 fprintf_unfiltered (gdb_stderr,
2167 "Can't find breakpoint associated with %s\n",
2168 paddress (gdbarch, addr));
2172 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2173 an S-record. Return non-zero if the ACK is received properly. */
2176 monitor_wait_srec_ack (void)
2180 if (current_monitor->flags & MO_SREC_ACK_PLUS)
2182 return (readchar (timeout) == '+');
2184 else if (current_monitor->flags & MO_SREC_ACK_ROTATE)
2186 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2187 if ((ch = readchar (1)) < 0)
2189 if ((ch = readchar (1)) < 0)
2191 if ((ch = readchar (1)) < 0)
2193 if ((ch = readchar (1)) < 0)
2199 /* monitor_load -- download a file. */
2202 monitor_load (char *args, int from_tty)
2204 CORE_ADDR load_offset = 0;
2206 struct cleanup *old_cleanups;
2209 monitor_debug ("MON load\n");
2212 error_no_arg (_("file to load"));
2214 argv = gdb_buildargv (args);
2215 old_cleanups = make_cleanup_freeargv (argv);
2217 filename = tilde_expand (argv[0]);
2218 make_cleanup (xfree, filename);
2220 /* Enable user to specify address for downloading as 2nd arg to load. */
2221 if (argv[1] != NULL)
2225 load_offset = strtoulst (argv[1], &endptr, 0);
2227 /* If the last word was not a valid number then
2228 treat it as a file name with spaces in. */
2229 if (argv[1] == endptr)
2230 error (_("Invalid download offset:%s."), argv[1]);
2232 if (argv[2] != NULL)
2233 error (_("Too many parameters."));
2236 monitor_printf (current_monitor->load);
2237 if (current_monitor->loadresp)
2238 monitor_expect (current_monitor->loadresp, NULL, 0);
2240 load_srec (monitor_desc, filename, load_offset,
2241 32, SREC_ALL, hashmark,
2242 current_monitor->flags & MO_SREC_ACK ?
2243 monitor_wait_srec_ack : NULL);
2245 monitor_expect_prompt (NULL, 0);
2247 do_cleanups (old_cleanups);
2249 /* Finally, make the PC point at the start address. */
2251 regcache_write_pc (get_current_regcache (),
2252 bfd_get_start_address (exec_bfd));
2254 /* There used to be code here which would clear inferior_ptid and
2255 call clear_symtab_users. None of that should be necessary:
2256 monitor targets should behave like remote protocol targets, and
2257 since generic_load does none of those things, this function
2260 Furthermore, clearing inferior_ptid is *incorrect*. After doing
2261 a load, we still have a valid connection to the monitor, with a
2262 live processor state to fiddle with. The user can type
2263 `continue' or `jump *start' and make the program run. If they do
2264 these things, however, GDB will be talking to a running program
2265 while inferior_ptid is null_ptid; this makes things like
2266 reinit_frame_cache very confused. */
2270 monitor_stop (ptid_t ptid)
2272 monitor_debug ("MON stop\n");
2273 if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
2274 serial_send_break (monitor_desc);
2275 if (current_monitor->stop)
2276 monitor_printf_noecho (current_monitor->stop);
2279 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2280 in OUTPUT until the prompt is seen. FIXME: We read the characters
2281 ourseleves here cause of a nasty echo. */
2284 monitor_rcmd (char *command,
2285 struct ui_file *outbuf)
2291 if (monitor_desc == NULL)
2292 error (_("monitor target not open."));
2294 p = current_monitor->prompt;
2296 /* Send the command. Note that if no args were supplied, then we're
2297 just sending the monitor a newline, which is sometimes useful. */
2299 monitor_printf ("%s\r", (command ? command : ""));
2301 resp_len = monitor_expect_prompt (buf, sizeof buf);
2303 fputs_unfiltered (buf, outbuf); /* Output the response. */
2306 /* Convert hex digit A to a number. */
2312 if (a >= '0' && a <= '9')
2314 if (a >= 'a' && a <= 'f')
2315 return a - 'a' + 10;
2316 if (a >= 'A' && a <= 'F')
2317 return a - 'A' + 10;
2319 error (_("Reply contains invalid hex digit 0x%x"), a);
2324 monitor_get_dev_name (void)
2329 /* Check to see if a thread is still alive. */
2332 monitor_thread_alive (struct target_ops *ops, ptid_t ptid)
2334 if (ptid_equal (ptid, monitor_ptid))
2335 /* The monitor's task is always alive. */
2341 /* Convert a thread ID to a string. Returns the string in a static
2345 monitor_pid_to_str (struct target_ops *ops, ptid_t ptid)
2347 static char buf[64];
2349 if (ptid_equal (monitor_ptid, ptid))
2351 xsnprintf (buf, sizeof buf, "Thread <main>");
2355 return normal_pid_to_str (ptid);
2358 static struct target_ops monitor_ops;
2361 init_base_monitor_ops (void)
2363 monitor_ops.to_close = monitor_close;
2364 monitor_ops.to_detach = monitor_detach;
2365 monitor_ops.to_resume = monitor_resume;
2366 monitor_ops.to_wait = monitor_wait;
2367 monitor_ops.to_fetch_registers = monitor_fetch_registers;
2368 monitor_ops.to_store_registers = monitor_store_registers;
2369 monitor_ops.to_prepare_to_store = monitor_prepare_to_store;
2370 monitor_ops.to_xfer_partial = monitor_xfer_partial;
2371 monitor_ops.to_files_info = monitor_files_info;
2372 monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
2373 monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
2374 monitor_ops.to_kill = monitor_kill;
2375 monitor_ops.to_load = monitor_load;
2376 monitor_ops.to_create_inferior = monitor_create_inferior;
2377 monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
2378 monitor_ops.to_stop = monitor_stop;
2379 monitor_ops.to_rcmd = monitor_rcmd;
2380 monitor_ops.to_log_command = serial_log_command;
2381 monitor_ops.to_thread_alive = monitor_thread_alive;
2382 monitor_ops.to_pid_to_str = monitor_pid_to_str;
2383 monitor_ops.to_stratum = process_stratum;
2384 monitor_ops.to_has_all_memory = default_child_has_all_memory;
2385 monitor_ops.to_has_memory = default_child_has_memory;
2386 monitor_ops.to_has_stack = default_child_has_stack;
2387 monitor_ops.to_has_registers = default_child_has_registers;
2388 monitor_ops.to_has_execution = default_child_has_execution;
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 (struct target_ops *ops)
2397 if (monitor_ops.to_magic != OPS_MAGIC)
2398 init_base_monitor_ops ();
2400 memcpy (ops, &monitor_ops, sizeof monitor_ops);
2403 /* Define additional commands that are usually only used by monitors. */
2405 /* -Wmissing-prototypes */
2406 extern initialize_file_ftype _initialize_remote_monitors;
2409 _initialize_remote_monitors (void)
2411 init_base_monitor_ops ();
2412 add_setshow_boolean_cmd ("hash", no_class, &hashmark, _("\
2413 Set display of activity while downloading a file."), _("\
2414 Show display of activity while downloading a file."), _("\
2415 When enabled, a hashmark \'#\' is displayed."),
2417 NULL, /* FIXME: i18n: */
2418 &setlist, &showlist);
2420 add_setshow_zuinteger_cmd ("monitor", no_class, &monitor_debug_p, _("\
2421 Set debugging of remote monitor communication."), _("\
2422 Show debugging of remote monitor communication."), _("\
2423 When enabled, communication between GDB and the remote monitor\n\
2426 NULL, /* FIXME: i18n: */
2427 &setdebuglist, &showdebuglist);
2429 /* Yes, 42000 is arbitrary. The only sense out of it, is that it
2431 monitor_ptid = ptid_build (42000, 0, 42000);