1 /* Remote debugging interface for boot monitors, for GDB.
3 Copyright (C) 1990-2015 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 */
45 #include <sys/types.h>
52 #include "gdb_regex.h"
55 #include "gdbthread.h"
56 #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 (struct target_ops
*self
, 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 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
231 This function exists to get around the problem that many host platforms
232 don't have a printf that can print 64-bit addresses. The %A format
233 specification is recognized as a special case, and causes the argument
234 to be printed as a 64-bit hexadecimal address.
236 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
237 If it is a '%s' format, the argument is a string; otherwise the
238 argument is assumed to be a long integer.
240 %% is also turned into a single %. */
243 monitor_vsprintf (char *sndbuf
, char *pattern
, va_list args
)
245 int addr_bit
= gdbarch_addr_bit (target_gdbarch ());
254 for (p
= pattern
; *p
; p
++)
258 /* Copy the format specifier to a separate buffer. */
260 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
263 format
[i
] = fmt
= *p
;
264 format
[i
+ 1] = '\0';
266 /* Fetch the next argument and print it. */
270 strcpy (sndbuf
, "%");
273 arg_addr
= va_arg (args
, CORE_ADDR
);
274 strcpy (sndbuf
, phex_nz (arg_addr
, addr_bit
/ 8));
277 arg_string
= va_arg (args
, char *);
278 sprintf (sndbuf
, format
, arg_string
);
281 arg_int
= va_arg (args
, long);
282 sprintf (sndbuf
, format
, arg_int
);
285 sndbuf
+= strlen (sndbuf
);
294 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
295 Works just like printf. */
298 monitor_printf_noecho (char *pattern
,...)
304 va_start (args
, pattern
);
306 monitor_vsprintf (sndbuf
, pattern
, args
);
308 len
= strlen (sndbuf
);
309 if (len
+ 1 > sizeof sndbuf
)
310 internal_error (__FILE__
, __LINE__
,
311 _("failed internal consistency check"));
315 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__
,
341 _("failed internal consistency check"));
345 char *safe_string
= (char *) alloca ((len
* 4) + 1);
347 monitor_printable_string (safe_string
, sndbuf
, 0);
348 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
351 monitor_write (sndbuf
, len
);
353 /* We used to expect that the next immediate output was the
354 characters we just output, but sometimes some extra junk appeared
355 before the characters we expected, like an extra prompt, or a
356 portmaster sending telnet negotiations. So, just start searching
357 for what we sent, and skip anything unknown. */
358 monitor_debug ("ExpectEcho\n");
359 monitor_expect (sndbuf
, (char *) 0, 0);
363 /* Write characters to the remote system. */
366 monitor_write (char *buf
, int buflen
)
368 if (serial_write (monitor_desc
, buf
, buflen
))
369 fprintf_unfiltered (gdb_stderr
, "serial_write failed: %s\n",
370 safe_strerror (errno
));
374 /* Read a binary character from the remote system, doing all the fancy
375 timeout stuff, but without interpreting the character in any way,
376 and without printing remote debug information. */
379 monitor_readchar (void)
387 c
= serial_readchar (monitor_desc
, timeout
);
390 c
&= 0xff; /* don't lose bit 7 */
397 if (c
== SERIAL_TIMEOUT
)
398 error (_("Timeout reading from remote system."));
400 perror_with_name (_("remote-monitor"));
404 /* Read a character from the remote system, doing all the fancy
408 readchar (int timeout
)
413 last_random
, last_nl
, last_cr
, last_crnl
421 c
= serial_readchar (monitor_desc
, timeout
);
426 /* This seems to interfere with proper function of the
428 if (monitor_debug_p
|| remote_debug
)
434 puts_debug ("read -->", buf
, "<--");
439 /* Canonicialize \n\r combinations into one \r. */
440 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
442 if ((c
== '\r' && state
== last_nl
)
443 || (c
== '\n' && state
== last_cr
))
464 if (c
== SERIAL_TIMEOUT
)
466 /* I fail to see how detaching here can be useful. */
467 if (in_monitor_wait
) /* Watchdog went off. */
469 target_mourn_inferior ();
470 error (_("GDB serial timeout has expired. Target detached."));
474 error (_("Timeout reading from remote system."));
476 perror_with_name (_("remote-monitor"));
479 /* Scan input from the remote system, until STRING is found. If BUF is non-
480 zero, then collect input until we have collected either STRING or BUFLEN-1
481 chars. In either case we terminate BUF with a 0. If input overflows BUF
482 because STRING can't be found, return -1, else return number of chars in BUF
483 (minus the terminating NUL). Note that in the non-overflow case, STRING
484 will be at the end of BUF. */
487 monitor_expect (char *string
, char *buf
, int buflen
)
490 int obuflen
= buflen
;
495 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
496 monitor_printable_string (safe_string
, string
, 0);
497 fprintf_unfiltered (gdb_stdlog
, "MON Expecting '%s'\n", safe_string
);
513 c
= readchar (timeout
);
520 c
= readchar (timeout
);
522 /* Don't expect any ^C sent to be echoed. */
524 if (*p
== '\003' || c
== *p
)
534 return obuflen
- buflen
;
542 /* We got a character that doesn't match the string. We need to
543 back up p, but how far? If we're looking for "..howdy" and the
544 monitor sends "...howdy"? There's certainly a match in there,
545 but when we receive the third ".", we won't find it if we just
546 restart the matching at the beginning of the string.
548 This is a Boyer-Moore kind of situation. We want to reset P to
549 the end of the longest prefix of STRING that is a suffix of
550 what we've read so far. In the example above, that would be
551 ".." --- the longest prefix of "..howdy" that is a suffix of
552 "...". This longest prefix could be the empty string, if C
553 is nowhere to be found in STRING.
555 If this longest prefix is not the empty string, it must contain
556 C, so let's search from the end of STRING for instances of C,
557 and see if the portion of STRING before that is a suffix of
558 what we read before C. Actually, we can search backwards from
559 p, since we know no prefix can be longer than that.
561 Note that we can use STRING itself, along with C, as a record
562 of what we've received so far. :) */
565 for (i
= (p
- string
) - 1; i
>= 0; i
--)
568 /* Is this prefix a suffix of what we've read so far?
570 string[0 .. i-1] == string[p - i, p - 1]? */
571 if (! memcmp (string
, p
- i
, i
))
583 /* Search for a regexp. */
586 monitor_expect_regexp (struct re_pattern_buffer
*pat
, char *buf
, int buflen
)
591 monitor_debug ("MON Expecting regexp\n");
596 mybuf
= alloca (TARGET_BUF_SIZE
);
597 buflen
= TARGET_BUF_SIZE
;
605 if (p
- mybuf
>= buflen
)
606 { /* Buffer about to overflow. */
608 /* On overflow, we copy the upper half of the buffer to the lower half. Not
609 great, but it usually works... */
611 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
612 p
= mybuf
+ buflen
/ 2;
615 *p
++ = readchar (timeout
);
617 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
623 /* Keep discarding input until we see the MONITOR prompt.
625 The convention for dealing with the prompt is that you
627 o *then* wait for the prompt.
629 Thus the last thing that a procedure does with the serial line will
630 be an monitor_expect_prompt(). Exception: monitor_resume does not
631 wait for the prompt, because the terminal is being handed over to
632 the inferior. However, the next thing which happens after that is
633 a monitor_wait which does wait for the prompt. Note that this
634 includes abnormal exit, e.g. error(). This is necessary to prevent
635 getting into states from which we can't recover. */
638 monitor_expect_prompt (char *buf
, int buflen
)
640 monitor_debug ("MON Expecting prompt\n");
641 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
644 /* Get N 32-bit words from remote, each preceded by a space, and put
645 them in registers starting at REGNO. */
656 ch
= readchar (timeout
);
657 while (isspace (ch
));
661 for (i
= 7; i
>= 1; i
--)
663 ch
= readchar (timeout
);
666 val
= (val
<< 4) | from_hex (ch
);
674 compile_pattern (char *pattern
, struct re_pattern_buffer
*compiled_pattern
,
680 compiled_pattern
->fastmap
= fastmap
;
682 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
683 val
= re_compile_pattern (pattern
,
689 error (_("compile_pattern: Can't compile pattern string `%s': %s!"),
693 re_compile_fastmap (compiled_pattern
);
696 /* Open a connection to a remote debugger. NAME is the filename used
697 for communication. */
700 monitor_open (const char *args
, struct monitor_ops
*mon_ops
, int from_tty
)
704 struct inferior
*inf
;
706 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
707 error (_("Magic number of monitor_ops struct wrong."));
709 targ_ops
= mon_ops
->target
;
710 name
= targ_ops
->to_shortname
;
713 error (_("Use `target %s DEVICE-NAME' to use a serial port, or\n\
714 `target %s HOST-NAME:PORT-NUMBER' to use a network connection."), name
, name
);
716 target_preopen (from_tty
);
718 /* Setup pattern for register dump. */
720 if (mon_ops
->register_pattern
)
721 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
724 if (mon_ops
->getmem
.resp_delim
)
725 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
726 getmem_resp_delim_fastmap
);
728 if (mon_ops
->setmem
.resp_delim
)
729 compile_pattern (mon_ops
->setmem
.resp_delim
, &setmem_resp_delim_pattern
,
730 setmem_resp_delim_fastmap
);
732 if (mon_ops
->setreg
.resp_delim
)
733 compile_pattern (mon_ops
->setreg
.resp_delim
, &setreg_resp_delim_pattern
,
734 setreg_resp_delim_fastmap
);
736 unpush_target (targ_ops
);
740 dev_name
= xstrdup (args
);
742 monitor_desc
= serial_open (dev_name
);
745 perror_with_name (dev_name
);
749 if (serial_setbaudrate (monitor_desc
, baud_rate
))
751 serial_close (monitor_desc
);
752 perror_with_name (dev_name
);
756 serial_setparity (monitor_desc
, serial_parity
);
757 serial_raw (monitor_desc
);
759 serial_flush_input (monitor_desc
);
761 /* some systems only work with 2 stop bits. */
763 serial_setstopbits (monitor_desc
, mon_ops
->stopbits
);
765 current_monitor
= mon_ops
;
767 /* See if we can wake up the monitor. First, try sending a stop sequence,
768 then send the init strings. Last, remove all breakpoints. */
770 if (current_monitor
->stop
)
772 monitor_stop (targ_ops
, inferior_ptid
);
773 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
775 monitor_debug ("EXP Open echo\n");
776 monitor_expect_prompt (NULL
, 0);
780 /* wake up the monitor and see if it's alive. */
781 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
783 /* Some of the characters we send may not be echoed,
784 but we hope to get a prompt at the end of it all. */
786 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
789 monitor_printf_noecho (*p
);
790 monitor_expect_prompt (NULL
, 0);
793 serial_flush_input (monitor_desc
);
795 /* Alloc breakpoints */
796 if (mon_ops
->set_break
!= NULL
)
798 if (mon_ops
->num_breakpoints
== 0)
799 mon_ops
->num_breakpoints
= 8;
801 breakaddr
= (CORE_ADDR
*)
802 xmalloc (mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
803 memset (breakaddr
, 0, mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
806 /* Remove all breakpoints. */
808 if (mon_ops
->clr_all_break
)
810 monitor_printf (mon_ops
->clr_all_break
);
811 monitor_expect_prompt (NULL
, 0);
815 printf_unfiltered (_("Remote target %s connected to %s\n"),
818 push_target (targ_ops
);
823 /* Make run command think we are busy... */
824 inferior_ptid
= monitor_ptid
;
825 inf
= current_inferior ();
826 inferior_appeared (inf
, ptid_get_pid (inferior_ptid
));
827 add_thread_silent (inferior_ptid
);
829 /* Give monitor_wait something to read. */
831 monitor_printf (current_monitor
->line_term
);
833 init_wait_for_inferior ();
835 start_remote (from_tty
);
838 /* Close out all files and local state before this target loses
842 monitor_close (struct target_ops
*self
)
845 serial_close (monitor_desc
);
847 /* Free breakpoint memory. */
848 if (breakaddr
!= NULL
)
856 delete_thread_silent (monitor_ptid
);
857 delete_inferior_silent (ptid_get_pid (monitor_ptid
));
860 /* Terminate the open connection to the remote debugger. Use this
861 when you want to detach and do something else with your gdb. */
864 monitor_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
866 unpush_target (ops
); /* calls monitor_close to do the real work. */
868 printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname
);
871 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
874 monitor_supply_register (struct regcache
*regcache
, int regno
, char *valstr
)
876 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
877 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
879 unsigned char regbuf
[MAX_REGISTER_SIZE
];
884 while (p
&& *p
!= '\0')
886 if (*p
== '\r' || *p
== '\n')
897 if (!isxdigit (*p
) && *p
!= 'x')
903 val
+= fromhex (*p
++);
905 monitor_debug ("Supplying Register %d %s\n", regno
, valstr
);
907 if (val
== 0 && valstr
== p
)
908 error (_("monitor_supply_register (%d): bad value from monitor: %s."),
911 /* supply register stores in target byte order, so swap here. */
913 store_unsigned_integer (regbuf
, register_size (gdbarch
, regno
), byte_order
,
916 regcache_raw_supply (regcache
, regno
, regbuf
);
921 /* Tell the remote machine to resume. */
924 monitor_resume (struct target_ops
*ops
,
925 ptid_t ptid
, int step
, enum gdb_signal sig
)
927 /* Some monitors require a different command when starting a program. */
928 monitor_debug ("MON resume\n");
929 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
932 monitor_printf ("run\r");
933 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
938 monitor_printf (current_monitor
->step
);
941 if (current_monitor
->continue_hook
)
942 (*current_monitor
->continue_hook
) ();
944 monitor_printf (current_monitor
->cont
);
945 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
950 /* Parse the output of a register dump command. A monitor specific
951 regexp is used to extract individual register descriptions of the
952 form REG=VAL. Each description is split up into a name and a value
953 string which are passed down to monitor specific code. */
956 parse_register_dump (struct regcache
*regcache
, char *buf
, int len
)
958 monitor_debug ("MON Parsing register dump\n");
961 int regnamelen
, vallen
;
964 /* Element 0 points to start of register name, and element 1
965 points to the start of the register value. */
966 struct re_registers register_strings
;
968 memset (®ister_strings
, 0, sizeof (struct re_registers
));
970 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
971 ®ister_strings
) == -1)
974 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
975 regname
= buf
+ register_strings
.start
[1];
976 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
977 val
= buf
+ register_strings
.start
[2];
979 current_monitor
->supply_register (regcache
, regname
, regnamelen
,
982 buf
+= register_strings
.end
[0];
983 len
-= register_strings
.end
[0];
987 /* Send ^C to target to halt it. Target will respond, and send us a
991 monitor_interrupt (int signo
)
993 /* If this doesn't work, try more severe steps. */
994 signal (signo
, monitor_interrupt_twice
);
996 if (monitor_debug_p
|| remote_debug
)
997 fprintf_unfiltered (gdb_stdlog
, "monitor_interrupt called\n");
999 target_stop (inferior_ptid
);
1002 /* The user typed ^C twice. */
1005 monitor_interrupt_twice (int signo
)
1007 signal (signo
, ofunc
);
1009 monitor_interrupt_query ();
1011 signal (signo
, monitor_interrupt
);
1014 /* Ask the user what to do when an interrupt is received. */
1017 monitor_interrupt_query (void)
1019 target_terminal_ours ();
1021 if (query (_("Interrupted while waiting for the program.\n\
1022 Give up (and stop debugging it)? ")))
1024 target_mourn_inferior ();
1028 target_terminal_inferior ();
1032 monitor_wait_cleanup (void *old_timeout
)
1034 timeout
= *(int *) old_timeout
;
1035 signal (SIGINT
, ofunc
);
1036 in_monitor_wait
= 0;
1042 monitor_wait_filter (char *buf
,
1045 struct target_waitstatus
*status
)
1051 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1052 *ext_resp_len
= resp_len
;
1055 fprintf_unfiltered (gdb_stderr
,
1056 "monitor_wait: excessive "
1057 "response from monitor: %s.", buf
);
1059 while (resp_len
< 0);
1061 /* Print any output characters that were preceded by ^O. */
1062 /* FIXME - This would be great as a user settabgle flag. */
1063 if (monitor_debug_p
|| remote_debug
1064 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1068 for (i
= 0; i
< resp_len
- 1; i
++)
1070 putchar_unfiltered (buf
[++i
]);
1076 /* Wait until the remote machine stops, then return, storing status in
1077 status just as `wait' would. */
1080 monitor_wait (struct target_ops
*ops
,
1081 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1083 int old_timeout
= timeout
;
1084 char buf
[TARGET_BUF_SIZE
];
1086 struct cleanup
*old_chain
;
1088 status
->kind
= TARGET_WAITKIND_EXITED
;
1089 status
->value
.integer
= 0;
1091 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1092 monitor_debug ("MON wait\n");
1095 /* This is somthing other than a maintenance command. */
1096 in_monitor_wait
= 1;
1097 timeout
= watchdog
> 0 ? watchdog
: -1;
1099 timeout
= -1; /* Don't time out -- user program is running. */
1102 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1104 if (current_monitor
->wait_filter
)
1105 (*current_monitor
->wait_filter
) (buf
, sizeof (buf
), &resp_len
, status
);
1107 monitor_wait_filter (buf
, sizeof (buf
), &resp_len
, status
);
1109 #if 0 /* Transferred to monitor wait filter. */
1112 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1115 fprintf_unfiltered (gdb_stderr
,
1116 "monitor_wait: excessive "
1117 "response from monitor: %s.", buf
);
1119 while (resp_len
< 0);
1121 /* Print any output characters that were preceded by ^O. */
1122 /* FIXME - This would be great as a user settabgle flag. */
1123 if (monitor_debug_p
|| remote_debug
1124 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1128 for (i
= 0; i
< resp_len
- 1; i
++)
1130 putchar_unfiltered (buf
[++i
]);
1134 signal (SIGINT
, ofunc
);
1136 timeout
= old_timeout
;
1138 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1141 monitor_printf (current_monitor
->dump_registers
);
1142 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1145 if (current_monitor
->register_pattern
)
1146 parse_register_dump (get_current_regcache (), buf
, resp_len
);
1148 monitor_debug ("Wait fetching registers after stop\n");
1149 monitor_dump_regs (get_current_regcache ());
1152 status
->kind
= TARGET_WAITKIND_STOPPED
;
1153 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1155 discard_cleanups (old_chain
);
1157 in_monitor_wait
= 0;
1159 return inferior_ptid
;
1162 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1166 monitor_fetch_register (struct regcache
*regcache
, int regno
)
1173 regbuf
= alloca (MAX_REGISTER_SIZE
* 2 + 1);
1174 zerobuf
= alloca (MAX_REGISTER_SIZE
);
1175 memset (zerobuf
, 0, MAX_REGISTER_SIZE
);
1177 if (current_monitor
->regname
!= NULL
)
1178 name
= current_monitor
->regname (regno
);
1180 name
= current_monitor
->regnames
[regno
];
1181 monitor_debug ("MON fetchreg %d '%s'\n", regno
, name
? name
: "(null name)");
1183 if (!name
|| (*name
== '\0'))
1185 monitor_debug ("No register known for %d\n", regno
);
1186 regcache_raw_supply (regcache
, regno
, zerobuf
);
1190 /* Send the register examine command. */
1192 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1194 /* If RESP_DELIM is specified, we search for that as a leading
1195 delimiter for the register value. Otherwise, we just start
1196 searching from the start of the buf. */
1198 if (current_monitor
->getreg
.resp_delim
)
1200 monitor_debug ("EXP getreg.resp_delim\n");
1201 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1202 /* Handle case of first 32 registers listed in pairs. */
1203 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1204 && (regno
& 1) != 0 && regno
< 32)
1206 monitor_debug ("EXP getreg.resp_delim\n");
1207 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1211 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1212 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1216 c
= readchar (timeout
);
1218 c
= readchar (timeout
);
1219 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1222 error (_("Bad value returned from monitor "
1223 "while fetching register %x."),
1227 /* Read upto the maximum number of hex digits for this register, skipping
1228 spaces, but stop reading if something else is seen. Some monitors
1229 like to drop leading zeros. */
1231 for (i
= 0; i
< register_size (get_regcache_arch (regcache
), regno
) * 2; i
++)
1235 c
= readchar (timeout
);
1237 c
= readchar (timeout
);
1245 regbuf
[i
] = '\000'; /* Terminate the number. */
1246 monitor_debug ("REGVAL '%s'\n", regbuf
);
1248 /* If TERM is present, we wait for that to show up. Also, (if TERM
1249 is present), we will send TERM_CMD if that is present. In any
1250 case, we collect all of the output into buf, and then wait for
1251 the normal prompt. */
1253 if (current_monitor
->getreg
.term
)
1255 monitor_debug ("EXP getreg.term\n");
1256 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* Get
1260 if (current_monitor
->getreg
.term_cmd
)
1262 monitor_debug ("EMIT getreg.term.cmd\n");
1263 monitor_printf (current_monitor
->getreg
.term_cmd
);
1265 if (!current_monitor
->getreg
.term
|| /* Already expected or */
1266 current_monitor
->getreg
.term_cmd
) /* ack expected. */
1267 monitor_expect_prompt (NULL
, 0); /* Get response. */
1269 monitor_supply_register (regcache
, regno
, regbuf
);
1272 /* Sometimes, it takes several commands to dump the registers. */
1273 /* This is a primitive for use by variations of monitor interfaces in
1274 case they need to compose the operation. */
1277 monitor_dump_reg_block (struct regcache
*regcache
, char *block_cmd
)
1279 char buf
[TARGET_BUF_SIZE
];
1282 monitor_printf (block_cmd
);
1283 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1284 parse_register_dump (regcache
, buf
, resp_len
);
1289 /* Read the remote registers into the block regs. */
1290 /* Call the specific function if it has been provided. */
1293 monitor_dump_regs (struct regcache
*regcache
)
1295 char buf
[TARGET_BUF_SIZE
];
1298 if (current_monitor
->dumpregs
)
1299 (*(current_monitor
->dumpregs
)) (regcache
); /* Call supplied function. */
1300 else if (current_monitor
->dump_registers
) /* Default version. */
1302 monitor_printf (current_monitor
->dump_registers
);
1303 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1304 parse_register_dump (regcache
, buf
, resp_len
);
1307 /* Need some way to read registers. */
1308 internal_error (__FILE__
, __LINE__
,
1309 _("failed internal consistency check"));
1313 monitor_fetch_registers (struct target_ops
*ops
,
1314 struct regcache
*regcache
, int regno
)
1316 monitor_debug ("MON fetchregs\n");
1317 if (current_monitor
->getreg
.cmd
)
1321 monitor_fetch_register (regcache
, regno
);
1325 for (regno
= 0; regno
< gdbarch_num_regs (get_regcache_arch (regcache
));
1327 monitor_fetch_register (regcache
, regno
);
1331 monitor_dump_regs (regcache
);
1335 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1338 monitor_store_register (struct regcache
*regcache
, int regno
)
1340 int reg_size
= register_size (get_regcache_arch (regcache
), regno
);
1344 if (current_monitor
->regname
!= NULL
)
1345 name
= current_monitor
->regname (regno
);
1347 name
= current_monitor
->regnames
[regno
];
1349 if (!name
|| (*name
== '\0'))
1351 monitor_debug ("MON Cannot store unknown register\n");
1355 regcache_cooked_read_unsigned (regcache
, regno
, &val
);
1356 monitor_debug ("MON storeg %d %s\n", regno
, phex (val
, reg_size
));
1358 /* Send the register deposit command. */
1360 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1361 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1362 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1363 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1365 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1367 if (current_monitor
->setreg
.resp_delim
)
1369 monitor_debug ("EXP setreg.resp_delim\n");
1370 monitor_expect_regexp (&setreg_resp_delim_pattern
, NULL
, 0);
1371 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1372 monitor_printf ("%s\r", phex_nz (val
, reg_size
));
1374 if (current_monitor
->setreg
.term
)
1376 monitor_debug ("EXP setreg.term\n");
1377 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1378 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1379 monitor_printf ("%s\r", phex_nz (val
, reg_size
));
1380 monitor_expect_prompt (NULL
, 0);
1383 monitor_expect_prompt (NULL
, 0);
1384 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required. */
1386 monitor_debug ("EXP setreg_termcmd\n");
1387 monitor_printf ("%s", current_monitor
->setreg
.term_cmd
);
1388 monitor_expect_prompt (NULL
, 0);
1390 } /* monitor_store_register */
1392 /* Store the remote registers. */
1395 monitor_store_registers (struct target_ops
*ops
,
1396 struct regcache
*regcache
, int regno
)
1400 monitor_store_register (regcache
, regno
);
1404 for (regno
= 0; regno
< gdbarch_num_regs (get_regcache_arch (regcache
));
1406 monitor_store_register (regcache
, regno
);
1409 /* Get ready to modify the registers array. On machines which store
1410 individual registers, this doesn't need to do anything. On machines
1411 which store all the registers in one fell swoop, this makes sure
1412 that registers contains all the registers from the program being
1416 monitor_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
1418 /* Do nothing, since we can store individual regs. */
1422 monitor_files_info (struct target_ops
*ops
)
1424 printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name
, baud_rate
);
1428 monitor_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1430 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
1431 unsigned int val
, hostval
;
1435 monitor_debug ("MON write %d %s\n", len
, paddress (target_gdbarch (), memaddr
));
1437 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1438 memaddr
= gdbarch_addr_bits_remove (target_gdbarch (), memaddr
);
1440 /* Use memory fill command for leading 0 bytes. */
1442 if (current_monitor
->fill
)
1444 for (i
= 0; i
< len
; i
++)
1448 if (i
> 4) /* More than 4 zeros is worth doing. */
1450 monitor_debug ("MON FILL %d\n", i
);
1451 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1452 monitor_printf (current_monitor
->fill
, memaddr
,
1453 (memaddr
+ i
) - 1, 0);
1455 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1457 monitor_expect_prompt (NULL
, 0);
1464 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1465 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1468 cmd
= current_monitor
->setmem
.cmdll
;
1472 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1475 cmd
= current_monitor
->setmem
.cmdl
;
1477 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1480 cmd
= current_monitor
->setmem
.cmdw
;
1485 cmd
= current_monitor
->setmem
.cmdb
;
1488 val
= extract_unsigned_integer (myaddr
, len
, byte_order
);
1492 hostval
= *(unsigned int *) myaddr
;
1493 monitor_debug ("Hostval(%08x) val(%08x)\n", hostval
, val
);
1497 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1498 monitor_printf_noecho (cmd
, memaddr
, val
);
1499 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1501 monitor_printf_noecho (cmd
, memaddr
);
1503 if (current_monitor
->setmem
.resp_delim
)
1505 monitor_debug ("EXP setmem.resp_delim");
1506 monitor_expect_regexp (&setmem_resp_delim_pattern
, NULL
, 0);
1507 monitor_printf ("%x\r", val
);
1509 if (current_monitor
->setmem
.term
)
1511 monitor_debug ("EXP setmem.term");
1512 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1513 monitor_printf ("%x\r", val
);
1515 if (current_monitor
->setmem
.term_cmd
)
1516 { /* Emit this to get out of the memory editing state. */
1517 monitor_printf ("%s", current_monitor
->setmem
.term_cmd
);
1518 /* Drop through to expecting a prompt. */
1522 monitor_printf (cmd
, memaddr
, val
);
1524 monitor_expect_prompt (NULL
, 0);
1531 monitor_write_memory_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1538 /* Enter the sub mode. */
1539 monitor_printf (current_monitor
->setmem
.cmdb
, memaddr
);
1540 monitor_expect_prompt (NULL
, 0);
1544 monitor_printf ("%x\r", val
);
1548 /* If we wanted to, here we could validate the address. */
1549 monitor_expect_prompt (NULL
, 0);
1552 /* Now exit the sub mode. */
1553 monitor_printf (current_monitor
->getreg
.term_cmd
);
1554 monitor_expect_prompt (NULL
, 0);
1560 longlongendswap (unsigned char *a
)
1570 *(a
+ i
) = *(a
+ j
);
1575 /* Format 32 chars of long long value, advance the pointer. */
1576 static char *hexlate
= "0123456789abcdef";
1578 longlong_hexchars (unsigned long long value
,
1588 static unsigned char disbuf
[8]; /* disassembly buffer */
1589 unsigned char *scan
, *limit
; /* loop controls */
1590 unsigned char c
, nib
;
1596 unsigned long long *dp
;
1598 dp
= (unsigned long long *) scan
;
1601 longlongendswap (disbuf
); /* FIXME: ONly on big endian hosts. */
1602 while (scan
< limit
)
1604 c
= *scan
++; /* A byte of our long long value. */
1610 leadzero
= 0; /* Henceforth we print even zeroes. */
1612 nib
= c
>> 4; /* high nibble bits */
1613 *outbuff
++ = hexlate
[nib
];
1614 nib
= c
& 0x0f; /* low nibble bits */
1615 *outbuff
++ = hexlate
[nib
];
1619 } /* longlong_hexchars */
1623 /* I am only going to call this when writing virtual byte streams.
1624 Which possably entails endian conversions. */
1627 monitor_write_memory_longlongs (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1629 static char hexstage
[20]; /* At least 16 digits required, plus null. */
1635 llptr
= (long long *) myaddr
;
1638 monitor_printf (current_monitor
->setmem
.cmdll
, memaddr
);
1639 monitor_expect_prompt (NULL
, 0);
1643 endstring
= longlong_hexchars (*llptr
, hexstage
);
1644 *endstring
= '\0'; /* NUll terminate for printf. */
1645 monitor_printf ("%s\r", hexstage
);
1649 /* If we wanted to, here we could validate the address. */
1650 monitor_expect_prompt (NULL
, 0);
1653 /* Now exit the sub mode. */
1654 monitor_printf (current_monitor
->getreg
.term_cmd
);
1655 monitor_expect_prompt (NULL
, 0);
1661 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1662 /* This is for the large blocks of memory which may occur in downloading.
1663 And for monitors which use interactive entry,
1664 And for monitors which do not have other downloading methods.
1665 Without this, we will end up calling monitor_write_memory many times
1666 and do the entry and exit of the sub mode many times
1667 This currently assumes...
1668 MO_SETMEM_INTERACTIVE
1669 ! MO_NO_ECHO_ON_SETMEM
1670 To use this, the you have to patch the monitor_cmds block with
1671 this function. Otherwise, its not tuned up for use by all
1672 monitor variations. */
1675 monitor_write_memory_block (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1680 /* FIXME: This would be a good place to put the zero test. */
1682 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1684 return monitor_write_memory_longlongs (memaddr
, myaddr
, len
);
1687 written
= monitor_write_memory_bytes (memaddr
, myaddr
, len
);
1691 /* This is an alternate form of monitor_read_memory which is used for monitors
1692 which can only read a single byte/word/etc. at a time. */
1695 monitor_read_memory_single (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1697 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
1699 char membuf
[sizeof (int) * 2 + 1];
1703 monitor_debug ("MON read single\n");
1705 /* Can't actually use long longs (nice idea, though). In fact, the
1706 call to strtoul below will fail if it tries to convert a value
1707 that's too big to fit in a long. */
1708 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1711 cmd
= current_monitor
->getmem
.cmdll
;
1715 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1718 cmd
= current_monitor
->getmem
.cmdl
;
1720 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1723 cmd
= current_monitor
->getmem
.cmdw
;
1728 cmd
= current_monitor
->getmem
.cmdb
;
1731 /* Send the examine command. */
1733 monitor_printf (cmd
, memaddr
);
1735 /* If RESP_DELIM is specified, we search for that as a leading
1736 delimiter for the memory value. Otherwise, we just start
1737 searching from the start of the buf. */
1739 if (current_monitor
->getmem
.resp_delim
)
1741 monitor_debug ("EXP getmem.resp_delim\n");
1742 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1745 /* Now, read the appropriate number of hex digits for this loc,
1748 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1749 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1753 c
= readchar (timeout
);
1755 c
= readchar (timeout
);
1756 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1759 monitor_error ("monitor_read_memory_single",
1760 "bad response from monitor",
1761 memaddr
, 0, NULL
, 0);
1767 for (i
= 0; i
< len
* 2; i
++)
1773 c
= readchar (timeout
);
1779 monitor_error ("monitor_read_memory_single",
1780 "bad response from monitor",
1781 memaddr
, i
, membuf
, 0);
1785 membuf
[i
] = '\000'; /* Terminate the number. */
1788 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1789 present), we will send TERM_CMD if that is present. In any case, we collect
1790 all of the output into buf, and then wait for the normal prompt. */
1792 if (current_monitor
->getmem
.term
)
1794 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* Get
1797 if (current_monitor
->getmem
.term_cmd
)
1799 monitor_printf (current_monitor
->getmem
.term_cmd
);
1800 monitor_expect_prompt (NULL
, 0);
1804 monitor_expect_prompt (NULL
, 0); /* Get response. */
1807 val
= strtoul (membuf
, &p
, 16);
1809 if (val
== 0 && membuf
== p
)
1810 monitor_error ("monitor_read_memory_single",
1811 "bad value from monitor",
1812 memaddr
, 0, membuf
, 0);
1814 /* supply register stores in target byte order, so swap here. */
1816 store_unsigned_integer (myaddr
, len
, byte_order
, val
);
1821 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1822 memory at MEMADDR. Returns length moved. Currently, we do no more
1823 than 16 bytes at a time. */
1826 monitor_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1837 monitor_debug ("Zero length call to monitor_read_memory\n");
1841 monitor_debug ("MON read block ta(%s) ha(%s) %d\n",
1842 paddress (target_gdbarch (), memaddr
),
1843 host_address_to_string (myaddr
), len
);
1845 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1846 memaddr
= gdbarch_addr_bits_remove (target_gdbarch (), memaddr
);
1848 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1849 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1851 len
= min (len
, 16);
1853 /* Some dumpers align the first data with the preceding 16
1854 byte boundary. Some print blanks and start at the
1855 requested boundary. EXACT_DUMPADDR */
1857 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1858 ? memaddr
: memaddr
& ~0x0f;
1860 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1861 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1862 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1864 /* Send the memory examine command. */
1866 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1867 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
);
1868 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1869 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1871 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1873 /* If TERM is present, we wait for that to show up. Also, (if TERM
1874 is present), we will send TERM_CMD if that is present. In any
1875 case, we collect all of the output into buf, and then wait for
1876 the normal prompt. */
1878 if (current_monitor
->getmem
.term
)
1880 resp_len
= monitor_expect (current_monitor
->getmem
.term
,
1881 buf
, sizeof buf
); /* Get response. */
1884 monitor_error ("monitor_read_memory",
1885 "excessive response from monitor",
1886 memaddr
, resp_len
, buf
, 0);
1888 if (current_monitor
->getmem
.term_cmd
)
1890 serial_write (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1891 strlen (current_monitor
->getmem
.term_cmd
));
1892 monitor_expect_prompt (NULL
, 0);
1896 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* Get response. */
1900 /* If RESP_DELIM is specified, we search for that as a leading
1901 delimiter for the values. Otherwise, we just start searching
1902 from the start of the buf. */
1904 if (current_monitor
->getmem
.resp_delim
)
1907 struct re_registers resp_strings
;
1909 monitor_debug ("MON getmem.resp_delim %s\n",
1910 current_monitor
->getmem
.resp_delim
);
1912 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1914 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1918 monitor_error ("monitor_read_memory",
1919 "bad response from monitor",
1920 memaddr
, resp_len
, buf
, 0);
1922 p
+= resp_strings
.end
[0];
1924 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1926 monitor_error ("monitor_read_memory",
1927 "bad response from monitor",
1928 memaddr
, resp_len
, buf
, 0);
1929 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1932 monitor_debug ("MON scanning %d ,%s '%s'\n", len
,
1933 host_address_to_string (p
), p
);
1934 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1942 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1946 if ((dumpaddr
>= memaddr
) && (i
> 0))
1948 val
= fromhex (c
) * 16 + fromhex (*(p
+ 1));
1950 if (monitor_debug_p
|| remote_debug
)
1951 fprintf_unfiltered (gdb_stdlog
, "[%02x]", val
);
1958 ++p
; /* Skip a blank or other non hex char. */
1962 error (_("Failed to read via monitor"));
1963 if (monitor_debug_p
|| remote_debug
)
1964 fprintf_unfiltered (gdb_stdlog
, "\n");
1965 return fetched
; /* Return the number of bytes actually
1968 monitor_debug ("MON scanning bytes\n");
1970 for (i
= len
; i
> 0; i
--)
1972 /* Skip non-hex chars, but bomb on end of string and newlines. */
1979 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1980 monitor_error ("monitor_read_memory",
1981 "badly terminated response from monitor",
1982 memaddr
, resp_len
, buf
, 0);
1986 val
= strtoul (p
, &p1
, 16);
1988 if (val
== 0 && p
== p1
)
1989 monitor_error ("monitor_read_memory",
1990 "bad value from monitor",
1991 memaddr
, resp_len
, buf
, 0);
2004 /* Helper for monitor_xfer_partial that handles memory transfers.
2005 Arguments are like target_xfer_partial. */
2007 static enum target_xfer_status
2008 monitor_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2009 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2013 if (writebuf
!= NULL
)
2015 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
2016 res
= monitor_write_memory_block (memaddr
, writebuf
, len
);
2018 res
= monitor_write_memory (memaddr
, writebuf
, len
);
2022 res
= monitor_read_memory (memaddr
, readbuf
, len
);
2026 return TARGET_XFER_E_IO
;
2029 *xfered_len
= (ULONGEST
) res
;
2030 return TARGET_XFER_OK
;
2034 /* Target to_xfer_partial implementation. */
2036 static enum target_xfer_status
2037 monitor_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2038 const char *annex
, gdb_byte
*readbuf
,
2039 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2040 ULONGEST
*xfered_len
)
2044 case TARGET_OBJECT_MEMORY
:
2045 return monitor_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2048 return TARGET_XFER_E_IO
;
2053 monitor_kill (struct target_ops
*ops
)
2055 return; /* Ignore attempts to kill target system. */
2058 /* All we actually do is set the PC to the start address of exec_bfd. */
2061 monitor_create_inferior (struct target_ops
*ops
, char *exec_file
,
2062 char *args
, char **env
, int from_tty
)
2064 if (args
&& (*args
!= '\000'))
2065 error (_("Args are not supported by the monitor."));
2068 clear_proceed_status (0);
2069 regcache_write_pc (get_current_regcache (),
2070 bfd_get_start_address (exec_bfd
));
2073 /* Clean up when a program exits.
2074 The program actually lives on in the remote processor's RAM, and may be
2075 run again without a download. Don't leave it full of breakpoint
2079 monitor_mourn_inferior (struct target_ops
*ops
)
2081 unpush_target (targ_ops
);
2082 generic_mourn_inferior (); /* Do all the proper things now. */
2083 delete_thread_silent (monitor_ptid
);
2086 /* Tell the monitor to add a breakpoint. */
2089 monitor_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
2090 struct bp_target_info
*bp_tgt
)
2092 CORE_ADDR addr
= bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
2096 monitor_debug ("MON inst bkpt %s\n", paddress (gdbarch
, addr
));
2097 if (current_monitor
->set_break
== NULL
)
2098 error (_("No set_break defined for this monitor"));
2100 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2101 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
2103 /* Determine appropriate breakpoint size for this address. */
2104 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bplen
);
2105 bp_tgt
->placed_address
= addr
;
2106 bp_tgt
->placed_size
= bplen
;
2108 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2110 if (breakaddr
[i
] == 0)
2112 breakaddr
[i
] = addr
;
2113 monitor_printf (current_monitor
->set_break
, addr
);
2114 monitor_expect_prompt (NULL
, 0);
2119 error (_("Too many breakpoints (> %d) for monitor."),
2120 current_monitor
->num_breakpoints
);
2123 /* Tell the monitor to remove a breakpoint. */
2126 monitor_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
2127 struct bp_target_info
*bp_tgt
)
2129 CORE_ADDR addr
= bp_tgt
->placed_address
;
2132 monitor_debug ("MON rmbkpt %s\n", paddress (gdbarch
, addr
));
2133 if (current_monitor
->clr_break
== NULL
)
2134 error (_("No clr_break defined for this monitor"));
2136 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2138 if (breakaddr
[i
] == addr
)
2141 /* Some monitors remove breakpoints based on the address. */
2142 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2143 monitor_printf (current_monitor
->clr_break
, addr
);
2144 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2145 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2147 monitor_printf (current_monitor
->clr_break
, i
);
2148 monitor_expect_prompt (NULL
, 0);
2152 fprintf_unfiltered (gdb_stderr
,
2153 "Can't find breakpoint associated with %s\n",
2154 paddress (gdbarch
, addr
));
2158 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2159 an S-record. Return non-zero if the ACK is received properly. */
2162 monitor_wait_srec_ack (void)
2166 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2168 return (readchar (timeout
) == '+');
2170 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2172 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2173 if ((ch
= readchar (1)) < 0)
2175 if ((ch
= readchar (1)) < 0)
2177 if ((ch
= readchar (1)) < 0)
2179 if ((ch
= readchar (1)) < 0)
2185 /* monitor_load -- download a file. */
2188 monitor_load (struct target_ops
*self
, const char *args
, int from_tty
)
2190 CORE_ADDR load_offset
= 0;
2192 struct cleanup
*old_cleanups
;
2195 monitor_debug ("MON load\n");
2198 error_no_arg (_("file to load"));
2200 argv
= gdb_buildargv (args
);
2201 old_cleanups
= make_cleanup_freeargv (argv
);
2203 filename
= tilde_expand (argv
[0]);
2204 make_cleanup (xfree
, filename
);
2206 /* Enable user to specify address for downloading as 2nd arg to load. */
2207 if (argv
[1] != NULL
)
2211 load_offset
= strtoulst (argv
[1], &endptr
, 0);
2213 /* If the last word was not a valid number then
2214 treat it as a file name with spaces in. */
2215 if (argv
[1] == endptr
)
2216 error (_("Invalid download offset:%s."), argv
[1]);
2218 if (argv
[2] != NULL
)
2219 error (_("Too many parameters."));
2222 monitor_printf (current_monitor
->load
);
2223 if (current_monitor
->loadresp
)
2224 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2226 load_srec (monitor_desc
, filename
, load_offset
,
2227 32, SREC_ALL
, hashmark
,
2228 current_monitor
->flags
& MO_SREC_ACK
?
2229 monitor_wait_srec_ack
: NULL
);
2231 monitor_expect_prompt (NULL
, 0);
2233 do_cleanups (old_cleanups
);
2235 /* Finally, make the PC point at the start address. */
2237 regcache_write_pc (get_current_regcache (),
2238 bfd_get_start_address (exec_bfd
));
2240 /* There used to be code here which would clear inferior_ptid and
2241 call clear_symtab_users. None of that should be necessary:
2242 monitor targets should behave like remote protocol targets, and
2243 since generic_load does none of those things, this function
2246 Furthermore, clearing inferior_ptid is *incorrect*. After doing
2247 a load, we still have a valid connection to the monitor, with a
2248 live processor state to fiddle with. The user can type
2249 `continue' or `jump *start' and make the program run. If they do
2250 these things, however, GDB will be talking to a running program
2251 while inferior_ptid is null_ptid; this makes things like
2252 reinit_frame_cache very confused. */
2256 monitor_stop (struct target_ops
*self
, ptid_t ptid
)
2258 monitor_debug ("MON stop\n");
2259 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2260 serial_send_break (monitor_desc
);
2261 if (current_monitor
->stop
)
2262 monitor_printf_noecho (current_monitor
->stop
);
2265 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2266 in OUTPUT until the prompt is seen. FIXME: We read the characters
2267 ourseleves here cause of a nasty echo. */
2270 monitor_rcmd (struct target_ops
*self
, const char *command
,
2271 struct ui_file
*outbuf
)
2277 if (monitor_desc
== NULL
)
2278 error (_("monitor target not open."));
2280 p
= current_monitor
->prompt
;
2282 /* Send the command. Note that if no args were supplied, then we're
2283 just sending the monitor a newline, which is sometimes useful. */
2285 monitor_printf ("%s\r", (command
? command
: ""));
2287 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2289 fputs_unfiltered (buf
, outbuf
); /* Output the response. */
2292 /* Convert hex digit A to a number. */
2298 if (a
>= '0' && a
<= '9')
2300 if (a
>= 'a' && a
<= 'f')
2301 return a
- 'a' + 10;
2302 if (a
>= 'A' && a
<= 'F')
2303 return a
- 'A' + 10;
2305 error (_("Reply contains invalid hex digit 0x%x"), a
);
2310 monitor_get_dev_name (void)
2315 /* Check to see if a thread is still alive. */
2318 monitor_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2320 if (ptid_equal (ptid
, monitor_ptid
))
2321 /* The monitor's task is always alive. */
2327 /* Convert a thread ID to a string. Returns the string in a static
2331 monitor_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2333 static char buf
[64];
2335 if (ptid_equal (monitor_ptid
, ptid
))
2337 xsnprintf (buf
, sizeof buf
, "Thread <main>");
2341 return normal_pid_to_str (ptid
);
2344 static struct target_ops monitor_ops
;
2347 init_base_monitor_ops (void)
2349 monitor_ops
.to_close
= monitor_close
;
2350 monitor_ops
.to_detach
= monitor_detach
;
2351 monitor_ops
.to_resume
= monitor_resume
;
2352 monitor_ops
.to_wait
= monitor_wait
;
2353 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2354 monitor_ops
.to_store_registers
= monitor_store_registers
;
2355 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2356 monitor_ops
.to_xfer_partial
= monitor_xfer_partial
;
2357 monitor_ops
.to_files_info
= monitor_files_info
;
2358 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2359 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2360 monitor_ops
.to_kill
= monitor_kill
;
2361 monitor_ops
.to_load
= monitor_load
;
2362 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2363 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2364 monitor_ops
.to_stop
= monitor_stop
;
2365 monitor_ops
.to_rcmd
= monitor_rcmd
;
2366 monitor_ops
.to_log_command
= serial_log_command
;
2367 monitor_ops
.to_thread_alive
= monitor_thread_alive
;
2368 monitor_ops
.to_pid_to_str
= monitor_pid_to_str
;
2369 monitor_ops
.to_stratum
= process_stratum
;
2370 monitor_ops
.to_has_all_memory
= default_child_has_all_memory
;
2371 monitor_ops
.to_has_memory
= default_child_has_memory
;
2372 monitor_ops
.to_has_stack
= default_child_has_stack
;
2373 monitor_ops
.to_has_registers
= default_child_has_registers
;
2374 monitor_ops
.to_has_execution
= default_child_has_execution
;
2375 monitor_ops
.to_magic
= OPS_MAGIC
;
2376 } /* init_base_monitor_ops */
2378 /* Init the target_ops structure pointed at by OPS. */
2381 init_monitor_ops (struct target_ops
*ops
)
2383 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2384 init_base_monitor_ops ();
2386 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2389 /* Define additional commands that are usually only used by monitors. */
2391 /* -Wmissing-prototypes */
2392 extern initialize_file_ftype _initialize_remote_monitors
;
2395 _initialize_remote_monitors (void)
2397 init_base_monitor_ops ();
2398 add_setshow_boolean_cmd ("hash", no_class
, &hashmark
, _("\
2399 Set display of activity while downloading a file."), _("\
2400 Show display of activity while downloading a file."), _("\
2401 When enabled, a hashmark \'#\' is displayed."),
2403 NULL
, /* FIXME: i18n: */
2404 &setlist
, &showlist
);
2406 add_setshow_zuinteger_cmd ("monitor", no_class
, &monitor_debug_p
, _("\
2407 Set debugging of remote monitor communication."), _("\
2408 Show debugging of remote monitor communication."), _("\
2409 When enabled, communication between GDB and the remote monitor\n\
2412 NULL
, /* FIXME: i18n: */
2413 &setdebuglist
, &showdebuglist
);
2415 /* Yes, 42000 is arbitrary. The only sense out of it, is that it
2417 monitor_ptid
= ptid_build (42000, 0, 42000);