1 /* Remote debugging interface for boot monitors, for GDB.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 2000, 2001, 2002, 2006, 2007 Free Software Foundation, Inc.
6 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
7 Resurrected from the ashes by Stu Grossman.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 Boston, MA 02110-1301, USA. */
26 /* This file was derived from various remote-* modules. It is a collection
27 of generic support functions so GDB can talk directly to a ROM based
28 monitor. This saves use from having to hack an exception based handler
29 into existence, and makes for quick porting.
31 This module talks to a debug monitor called 'MONITOR', which
32 We communicate with MONITOR via either a direct serial line, or a TCP
33 (or possibly TELNET) stream to a terminal multiplexor,
34 which in turn talks to the target board. */
36 /* FIXME 32x64: This code assumes that registers and addresses are at
37 most 32 bits long. If they can be larger, you will need to declare
38 values as LONGEST and use %llx or some such to print values when
39 building commands to send to the monitor. Since we don't know of
40 any actual 64-bit targets with ROM monitors that use this code,
41 it's not an issue right now. -sts 4/18/96 */
46 #include "exceptions.h"
49 #include "gdb_string.h"
50 #include <sys/types.h>
56 #include "gdb_regex.h"
60 static char *dev_name
;
61 static struct target_ops
*targ_ops
;
63 static void monitor_interrupt_query (void);
64 static void monitor_interrupt_twice (int);
65 static void monitor_stop (void);
66 static void monitor_dump_regs (struct regcache
*regcache
);
69 static int from_hex (int a
);
72 static struct monitor_ops
*current_monitor
;
74 static int hashmark
; /* flag set by "set hash" */
76 static int timeout
= 30;
78 static int in_monitor_wait
= 0; /* Non-zero means we are in monitor_wait() */
80 static void (*ofunc
) (); /* Old SIGINT signal handler */
82 static CORE_ADDR
*breakaddr
;
84 /* Descriptor for I/O to remote machine. Initialize it to NULL so
85 that monitor_open knows that we don't have a file open when the
88 static struct serial
*monitor_desc
= NULL
;
90 /* Pointer to regexp pattern matching data */
92 static struct re_pattern_buffer register_pattern
;
93 static char register_fastmap
[256];
95 static struct re_pattern_buffer getmem_resp_delim_pattern
;
96 static char getmem_resp_delim_fastmap
[256];
98 static struct re_pattern_buffer setmem_resp_delim_pattern
;
99 static char setmem_resp_delim_fastmap
[256];
101 static struct re_pattern_buffer setreg_resp_delim_pattern
;
102 static char setreg_resp_delim_fastmap
[256];
104 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
105 monitor_wait wakes up. */
107 static int first_time
= 0; /* is this the first time we're executing after
108 gaving created the child proccess? */
110 #define TARGET_BUF_SIZE 2048
112 /* Monitor specific debugging information. Typically only useful to
113 the developer of a new monitor interface. */
115 static void monitor_debug (const char *fmt
, ...) ATTR_FORMAT(printf
, 1, 2);
117 static int monitor_debug_p
= 0;
119 /* NOTE: This file alternates between monitor_debug_p and remote_debug
120 when determining if debug information is printed. Perhaps this
121 could be simplified. */
124 monitor_debug (const char *fmt
, ...)
129 va_start (args
, fmt
);
130 vfprintf_filtered (gdb_stdlog
, fmt
, args
);
136 /* Convert a string into a printable representation, Return # byte in
137 the new string. When LEN is >0 it specifies the size of the
138 string. Otherwize strlen(oldstr) is used. */
141 monitor_printable_string (char *newstr
, char *oldstr
, int len
)
147 len
= strlen (oldstr
);
149 for (i
= 0; i
< len
; i
++)
160 sprintf (newstr
, "\\x%02x", ch
& 0xff);
199 /* Print monitor errors with a string, converting the string to printable
203 monitor_error (char *function
, char *message
,
204 CORE_ADDR memaddr
, int len
, char *string
, int final_char
)
206 int real_len
= (len
== 0 && string
!= (char *) 0) ? strlen (string
) : len
;
207 char *safe_string
= alloca ((real_len
* 4) + 1);
208 monitor_printable_string (safe_string
, string
, real_len
);
211 error (_("%s (0x%s): %s: %s%c"), function
, paddr_nz (memaddr
), message
, safe_string
, final_char
);
213 error (_("%s (0x%s): %s: %s"), function
, paddr_nz (memaddr
), message
, safe_string
);
216 /* Convert hex digit A to a number. */
221 if (a
>= '0' && a
<= '9')
223 else if (a
>= 'a' && a
<= 'f')
225 else if (a
>= 'A' && a
<= 'F')
228 error (_("Invalid hex digit %d"), a
);
231 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
233 This function exists to get around the problem that many host platforms
234 don't have a printf that can print 64-bit addresses. The %A format
235 specification is recognized as a special case, and causes the argument
236 to be printed as a 64-bit hexadecimal address.
238 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
239 If it is a '%s' format, the argument is a string; otherwise the
240 argument is assumed to be a long integer.
242 %% is also turned into a single %.
246 monitor_vsprintf (char *sndbuf
, char *pattern
, va_list args
)
256 for (p
= pattern
; *p
; p
++)
260 /* Copy the format specifier to a separate buffer. */
262 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
265 format
[i
] = fmt
= *p
;
266 format
[i
+ 1] = '\0';
268 /* Fetch the next argument and print it. */
272 strcpy (sndbuf
, "%");
275 arg_addr
= va_arg (args
, CORE_ADDR
);
276 strcpy (sndbuf
, paddr_nz (arg_addr
));
279 arg_string
= va_arg (args
, char *);
280 sprintf (sndbuf
, format
, arg_string
);
283 arg_int
= va_arg (args
, long);
284 sprintf (sndbuf
, format
, arg_int
);
287 sndbuf
+= strlen (sndbuf
);
296 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
297 Works just like printf. */
300 monitor_printf_noecho (char *pattern
,...)
306 va_start (args
, pattern
);
308 monitor_vsprintf (sndbuf
, pattern
, args
);
310 len
= strlen (sndbuf
);
311 if (len
+ 1 > sizeof sndbuf
)
312 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
316 char *safe_string
= (char *) alloca ((strlen (sndbuf
) * 4) + 1);
317 monitor_printable_string (safe_string
, sndbuf
, 0);
318 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
321 monitor_write (sndbuf
, len
);
324 /* monitor_printf -- Send data to monitor and check the echo. Works just like
328 monitor_printf (char *pattern
,...)
334 va_start (args
, pattern
);
336 monitor_vsprintf (sndbuf
, pattern
, args
);
338 len
= strlen (sndbuf
);
339 if (len
+ 1 > sizeof sndbuf
)
340 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
344 char *safe_string
= (char *) alloca ((len
* 4) + 1);
345 monitor_printable_string (safe_string
, sndbuf
, 0);
346 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
349 monitor_write (sndbuf
, len
);
351 /* We used to expect that the next immediate output was the characters we
352 just output, but sometimes some extra junk appeared before the characters
353 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
354 So, just start searching for what we sent, and skip anything unknown. */
355 monitor_debug ("ExpectEcho\n");
356 monitor_expect (sndbuf
, (char *) 0, 0);
360 /* Write characters to the remote system. */
363 monitor_write (char *buf
, int buflen
)
365 if (serial_write (monitor_desc
, buf
, buflen
))
366 fprintf_unfiltered (gdb_stderr
, "serial_write failed: %s\n",
367 safe_strerror (errno
));
371 /* Read a binary character from the remote system, doing all the fancy
372 timeout stuff, but without interpreting the character in any way,
373 and without printing remote debug information. */
376 monitor_readchar (void)
384 c
= serial_readchar (monitor_desc
, timeout
);
387 c
&= 0xff; /* don't lose bit 7 */
394 if (c
== SERIAL_TIMEOUT
)
395 error (_("Timeout reading from remote system."));
397 perror_with_name (_("remote-monitor"));
401 /* Read a character from the remote system, doing all the fancy
405 readchar (int timeout
)
410 last_random
, last_nl
, last_cr
, last_crnl
418 c
= serial_readchar (monitor_desc
, timeout
);
423 /* This seems to interfere with proper function of the
425 if (monitor_debug_p
|| remote_debug
)
430 puts_debug ("read -->", buf
, "<--");
435 /* Canonicialize \n\r combinations into one \r */
436 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
438 if ((c
== '\r' && state
== last_nl
)
439 || (c
== '\n' && state
== last_cr
))
460 if (c
== SERIAL_TIMEOUT
)
462 /* I fail to see how detaching here can be useful */
463 if (in_monitor_wait
) /* Watchdog went off */
465 target_mourn_inferior ();
466 error (_("GDB serial timeout has expired. Target detached."));
470 error (_("Timeout reading from remote system."));
472 perror_with_name (_("remote-monitor"));
475 /* Scan input from the remote system, until STRING is found. If BUF is non-
476 zero, then collect input until we have collected either STRING or BUFLEN-1
477 chars. In either case we terminate BUF with a 0. If input overflows BUF
478 because STRING can't be found, return -1, else return number of chars in BUF
479 (minus the terminating NUL). Note that in the non-overflow case, STRING
480 will be at the end of BUF. */
483 monitor_expect (char *string
, char *buf
, int buflen
)
486 int obuflen
= buflen
;
491 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
492 monitor_printable_string (safe_string
, string
, 0);
493 fprintf_unfiltered (gdb_stdlog
, "MON Expecting '%s'\n", safe_string
);
508 c
= readchar (timeout
);
515 c
= readchar (timeout
);
517 /* Don't expect any ^C sent to be echoed */
519 if (*p
== '\003' || c
== *p
)
529 return obuflen
- buflen
;
537 /* We got a character that doesn't match the string. We need to
538 back up p, but how far? If we're looking for "..howdy" and the
539 monitor sends "...howdy"? There's certainly a match in there,
540 but when we receive the third ".", we won't find it if we just
541 restart the matching at the beginning of the string.
543 This is a Boyer-Moore kind of situation. We want to reset P to
544 the end of the longest prefix of STRING that is a suffix of
545 what we've read so far. In the example above, that would be
546 ".." --- the longest prefix of "..howdy" that is a suffix of
547 "...". This longest prefix could be the empty string, if C
548 is nowhere to be found in STRING.
550 If this longest prefix is not the empty string, it must contain
551 C, so let's search from the end of STRING for instances of C,
552 and see if the portion of STRING before that is a suffix of
553 what we read before C. Actually, we can search backwards from
554 p, since we know no prefix can be longer than that.
556 Note that we can use STRING itself, along with C, as a record
557 of what we've received so far. :) */
560 for (i
= (p
- string
) - 1; i
>= 0; i
--)
563 /* Is this prefix a suffix of what we've read so far?
565 string[0 .. i-1] == string[p - i, p - 1]? */
566 if (! memcmp (string
, p
- i
, i
))
578 /* Search for a regexp. */
581 monitor_expect_regexp (struct re_pattern_buffer
*pat
, char *buf
, int buflen
)
585 monitor_debug ("MON Expecting regexp\n");
590 mybuf
= alloca (TARGET_BUF_SIZE
);
591 buflen
= TARGET_BUF_SIZE
;
599 if (p
- mybuf
>= buflen
)
600 { /* Buffer about to overflow */
602 /* On overflow, we copy the upper half of the buffer to the lower half. Not
603 great, but it usually works... */
605 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
606 p
= mybuf
+ buflen
/ 2;
609 *p
++ = readchar (timeout
);
611 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
617 /* Keep discarding input until we see the MONITOR prompt.
619 The convention for dealing with the prompt is that you
621 o *then* wait for the prompt.
623 Thus the last thing that a procedure does with the serial line will
624 be an monitor_expect_prompt(). Exception: monitor_resume does not
625 wait for the prompt, because the terminal is being handed over to
626 the inferior. However, the next thing which happens after that is
627 a monitor_wait which does wait for the prompt. Note that this
628 includes abnormal exit, e.g. error(). This is necessary to prevent
629 getting into states from which we can't recover. */
632 monitor_expect_prompt (char *buf
, int buflen
)
634 monitor_debug ("MON Expecting prompt\n");
635 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
638 /* Get N 32-bit words from remote, each preceded by a space, and put
639 them in registers starting at REGNO. */
650 ch
= readchar (timeout
);
651 while (isspace (ch
));
655 for (i
= 7; i
>= 1; i
--)
657 ch
= readchar (timeout
);
660 val
= (val
<< 4) | from_hex (ch
);
668 compile_pattern (char *pattern
, struct re_pattern_buffer
*compiled_pattern
,
674 compiled_pattern
->fastmap
= fastmap
;
676 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
677 val
= re_compile_pattern (pattern
,
683 error (_("compile_pattern: Can't compile pattern string `%s': %s!"), pattern
, val
);
686 re_compile_fastmap (compiled_pattern
);
689 /* Open a connection to a remote debugger. NAME is the filename used
690 for communication. */
693 monitor_open (char *args
, struct monitor_ops
*mon_ops
, int from_tty
)
698 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
699 error (_("Magic number of monitor_ops struct wrong."));
701 targ_ops
= mon_ops
->target
;
702 name
= targ_ops
->to_shortname
;
705 error (_("Use `target %s DEVICE-NAME' to use a serial port, or \n\
706 `target %s HOST-NAME:PORT-NUMBER' to use a network connection."), name
, name
);
708 target_preopen (from_tty
);
710 /* Setup pattern for register dump */
712 if (mon_ops
->register_pattern
)
713 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
716 if (mon_ops
->getmem
.resp_delim
)
717 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
718 getmem_resp_delim_fastmap
);
720 if (mon_ops
->setmem
.resp_delim
)
721 compile_pattern (mon_ops
->setmem
.resp_delim
, &setmem_resp_delim_pattern
,
722 setmem_resp_delim_fastmap
);
724 if (mon_ops
->setreg
.resp_delim
)
725 compile_pattern (mon_ops
->setreg
.resp_delim
, &setreg_resp_delim_pattern
,
726 setreg_resp_delim_fastmap
);
728 unpush_target (targ_ops
);
732 dev_name
= xstrdup (args
);
734 monitor_desc
= serial_open (dev_name
);
737 perror_with_name (dev_name
);
741 if (serial_setbaudrate (monitor_desc
, baud_rate
))
743 serial_close (monitor_desc
);
744 perror_with_name (dev_name
);
748 serial_raw (monitor_desc
);
750 serial_flush_input (monitor_desc
);
752 /* some systems only work with 2 stop bits */
754 serial_setstopbits (monitor_desc
, mon_ops
->stopbits
);
756 current_monitor
= mon_ops
;
758 /* See if we can wake up the monitor. First, try sending a stop sequence,
759 then send the init strings. Last, remove all breakpoints. */
761 if (current_monitor
->stop
)
764 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
766 monitor_debug ("EXP Open echo\n");
767 monitor_expect_prompt (NULL
, 0);
771 /* wake up the monitor and see if it's alive */
772 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
774 /* Some of the characters we send may not be echoed,
775 but we hope to get a prompt at the end of it all. */
777 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
780 monitor_printf_noecho (*p
);
781 monitor_expect_prompt (NULL
, 0);
784 serial_flush_input (monitor_desc
);
786 /* Alloc breakpoints */
787 if (mon_ops
->set_break
!= NULL
)
789 if (mon_ops
->num_breakpoints
== 0)
790 mon_ops
->num_breakpoints
= 8;
792 breakaddr
= (CORE_ADDR
*) xmalloc (mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
793 memset (breakaddr
, 0, mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
796 /* Remove all breakpoints */
798 if (mon_ops
->clr_all_break
)
800 monitor_printf (mon_ops
->clr_all_break
);
801 monitor_expect_prompt (NULL
, 0);
805 printf_unfiltered (_("Remote target %s connected to %s\n"), name
, dev_name
);
807 push_target (targ_ops
);
809 inferior_ptid
= pid_to_ptid (42000); /* Make run command think we are busy... */
811 /* Give monitor_wait something to read */
813 monitor_printf (current_monitor
->line_term
);
815 start_remote (from_tty
);
818 /* Close out all files and local state before this target loses
822 monitor_close (int quitting
)
825 serial_close (monitor_desc
);
827 /* Free breakpoint memory */
828 if (breakaddr
!= NULL
)
837 /* Terminate the open connection to the remote debugger. Use this
838 when you want to detach and do something else with your gdb. */
841 monitor_detach (char *args
, int from_tty
)
843 pop_target (); /* calls monitor_close to do the real work */
845 printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname
);
848 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
851 monitor_supply_register (struct regcache
*regcache
, int regno
, char *valstr
)
854 unsigned char regbuf
[MAX_REGISTER_SIZE
];
859 while (p
&& *p
!= '\0')
861 if (*p
== '\r' || *p
== '\n')
872 if (!isxdigit (*p
) && *p
!= 'x')
878 val
+= fromhex (*p
++);
880 monitor_debug ("Supplying Register %d %s\n", regno
, valstr
);
882 if (val
== 0 && valstr
== p
)
883 error (_("monitor_supply_register (%d): bad value from monitor: %s."),
886 /* supply register stores in target byte order, so swap here */
888 store_unsigned_integer (regbuf
, register_size (current_gdbarch
, regno
), val
);
890 regcache_raw_supply (regcache
, regno
, regbuf
);
895 /* Tell the remote machine to resume. */
898 monitor_resume (ptid_t ptid
, int step
, enum target_signal sig
)
900 /* Some monitors require a different command when starting a program */
901 monitor_debug ("MON resume\n");
902 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
905 monitor_printf ("run\r");
906 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
911 monitor_printf (current_monitor
->step
);
914 if (current_monitor
->continue_hook
)
915 (*current_monitor
->continue_hook
) ();
917 monitor_printf (current_monitor
->cont
);
918 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
923 /* Parse the output of a register dump command. A monitor specific
924 regexp is used to extract individual register descriptions of the
925 form REG=VAL. Each description is split up into a name and a value
926 string which are passed down to monitor specific code. */
929 parse_register_dump (struct regcache
*regcache
, char *buf
, int len
)
931 monitor_debug ("MON Parsing register dump\n");
934 int regnamelen
, vallen
;
936 /* Element 0 points to start of register name, and element 1
937 points to the start of the register value. */
938 struct re_registers register_strings
;
940 memset (®ister_strings
, 0, sizeof (struct re_registers
));
942 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
943 ®ister_strings
) == -1)
946 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
947 regname
= buf
+ register_strings
.start
[1];
948 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
949 val
= buf
+ register_strings
.start
[2];
951 current_monitor
->supply_register (regcache
, regname
, regnamelen
,
954 buf
+= register_strings
.end
[0];
955 len
-= register_strings
.end
[0];
959 /* Send ^C to target to halt it. Target will respond, and send us a
963 monitor_interrupt (int signo
)
965 /* If this doesn't work, try more severe steps. */
966 signal (signo
, monitor_interrupt_twice
);
968 if (monitor_debug_p
|| remote_debug
)
969 fprintf_unfiltered (gdb_stdlog
, "monitor_interrupt called\n");
974 /* The user typed ^C twice. */
977 monitor_interrupt_twice (int signo
)
979 signal (signo
, ofunc
);
981 monitor_interrupt_query ();
983 signal (signo
, monitor_interrupt
);
986 /* Ask the user what to do when an interrupt is received. */
989 monitor_interrupt_query (void)
991 target_terminal_ours ();
993 if (query ("Interrupted while waiting for the program.\n\
994 Give up (and stop debugging it)? "))
996 target_mourn_inferior ();
997 deprecated_throw_reason (RETURN_QUIT
);
1000 target_terminal_inferior ();
1004 monitor_wait_cleanup (void *old_timeout
)
1006 timeout
= *(int *) old_timeout
;
1007 signal (SIGINT
, ofunc
);
1008 in_monitor_wait
= 0;
1014 monitor_wait_filter (char *buf
,
1017 struct target_waitstatus
*status
)
1022 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1023 *ext_resp_len
= resp_len
;
1026 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1028 while (resp_len
< 0);
1030 /* Print any output characters that were preceded by ^O. */
1031 /* FIXME - This would be great as a user settabgle flag */
1032 if (monitor_debug_p
|| remote_debug
1033 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1037 for (i
= 0; i
< resp_len
- 1; i
++)
1039 putchar_unfiltered (buf
[++i
]);
1045 /* Wait until the remote machine stops, then return, storing status in
1046 status just as `wait' would. */
1049 monitor_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1051 int old_timeout
= timeout
;
1052 char buf
[TARGET_BUF_SIZE
];
1054 struct cleanup
*old_chain
;
1056 status
->kind
= TARGET_WAITKIND_EXITED
;
1057 status
->value
.integer
= 0;
1059 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1060 monitor_debug ("MON wait\n");
1063 /* This is somthing other than a maintenance command */
1064 in_monitor_wait
= 1;
1065 timeout
= watchdog
> 0 ? watchdog
: -1;
1067 timeout
= -1; /* Don't time out -- user program is running. */
1070 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1072 if (current_monitor
->wait_filter
)
1073 (*current_monitor
->wait_filter
) (buf
, sizeof (buf
), &resp_len
, status
);
1075 monitor_wait_filter (buf
, sizeof (buf
), &resp_len
, status
);
1077 #if 0 /* Transferred to monitor wait filter */
1080 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1083 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1085 while (resp_len
< 0);
1087 /* Print any output characters that were preceded by ^O. */
1088 /* FIXME - This would be great as a user settabgle flag */
1089 if (monitor_debug_p
|| remote_debug
1090 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1094 for (i
= 0; i
< resp_len
- 1; i
++)
1096 putchar_unfiltered (buf
[++i
]);
1100 signal (SIGINT
, ofunc
);
1102 timeout
= old_timeout
;
1104 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1107 monitor_printf (current_monitor
->dump_registers
);
1108 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1111 if (current_monitor
->register_pattern
)
1112 parse_register_dump (current_regcache
, buf
, resp_len
);
1114 monitor_debug ("Wait fetching registers after stop\n");
1115 monitor_dump_regs (current_regcache
);
1118 status
->kind
= TARGET_WAITKIND_STOPPED
;
1119 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1121 discard_cleanups (old_chain
);
1123 in_monitor_wait
= 0;
1125 return inferior_ptid
;
1128 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1132 monitor_fetch_register (struct regcache
*regcache
, int regno
)
1139 regbuf
= alloca (MAX_REGISTER_SIZE
* 2 + 1);
1140 zerobuf
= alloca (MAX_REGISTER_SIZE
);
1141 memset (zerobuf
, 0, MAX_REGISTER_SIZE
);
1143 if (current_monitor
->regname
!= NULL
)
1144 name
= current_monitor
->regname (regno
);
1146 name
= current_monitor
->regnames
[regno
];
1147 monitor_debug ("MON fetchreg %d '%s'\n", regno
, name
? name
: "(null name)");
1149 if (!name
|| (*name
== '\0'))
1151 monitor_debug ("No register known for %d\n", regno
);
1152 regcache_raw_supply (regcache
, regno
, zerobuf
);
1156 /* send the register examine command */
1158 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1160 /* If RESP_DELIM is specified, we search for that as a leading
1161 delimiter for the register value. Otherwise, we just start
1162 searching from the start of the buf. */
1164 if (current_monitor
->getreg
.resp_delim
)
1166 monitor_debug ("EXP getreg.resp_delim\n");
1167 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1168 /* Handle case of first 32 registers listed in pairs. */
1169 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1170 && (regno
& 1) != 0 && regno
< 32)
1172 monitor_debug ("EXP getreg.resp_delim\n");
1173 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1177 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1178 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1181 c
= readchar (timeout
);
1183 c
= readchar (timeout
);
1184 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1187 error (_("Bad value returned from monitor while fetching register %x."),
1191 /* Read upto the maximum number of hex digits for this register, skipping
1192 spaces, but stop reading if something else is seen. Some monitors
1193 like to drop leading zeros. */
1195 for (i
= 0; i
< register_size (current_gdbarch
, regno
) * 2; i
++)
1198 c
= readchar (timeout
);
1200 c
= readchar (timeout
);
1208 regbuf
[i
] = '\000'; /* terminate the number */
1209 monitor_debug ("REGVAL '%s'\n", regbuf
);
1211 /* If TERM is present, we wait for that to show up. Also, (if TERM
1212 is present), we will send TERM_CMD if that is present. In any
1213 case, we collect all of the output into buf, and then wait for
1214 the normal prompt. */
1216 if (current_monitor
->getreg
.term
)
1218 monitor_debug ("EXP getreg.term\n");
1219 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1222 if (current_monitor
->getreg
.term_cmd
)
1224 monitor_debug ("EMIT getreg.term.cmd\n");
1225 monitor_printf (current_monitor
->getreg
.term_cmd
);
1227 if (!current_monitor
->getreg
.term
|| /* Already expected or */
1228 current_monitor
->getreg
.term_cmd
) /* ack expected */
1229 monitor_expect_prompt (NULL
, 0); /* get response */
1231 monitor_supply_register (regcache
, regno
, regbuf
);
1234 /* Sometimes, it takes several commands to dump the registers */
1235 /* This is a primitive for use by variations of monitor interfaces in
1236 case they need to compose the operation.
1239 monitor_dump_reg_block (struct regcache
*regcache
, char *block_cmd
)
1241 char buf
[TARGET_BUF_SIZE
];
1243 monitor_printf (block_cmd
);
1244 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1245 parse_register_dump (regcache
, buf
, resp_len
);
1250 /* Read the remote registers into the block regs. */
1251 /* Call the specific function if it has been provided */
1254 monitor_dump_regs (struct regcache
*regcache
)
1256 char buf
[TARGET_BUF_SIZE
];
1258 if (current_monitor
->dumpregs
)
1259 (*(current_monitor
->dumpregs
)) (regcache
); /* call supplied function */
1260 else if (current_monitor
->dump_registers
) /* default version */
1262 monitor_printf (current_monitor
->dump_registers
);
1263 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1264 parse_register_dump (regcache
, buf
, resp_len
);
1267 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check")); /* Need some way to read registers */
1271 monitor_fetch_registers (struct regcache
*regcache
, int regno
)
1273 monitor_debug ("MON fetchregs\n");
1274 if (current_monitor
->getreg
.cmd
)
1278 monitor_fetch_register (regcache
, regno
);
1282 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1283 monitor_fetch_register (regcache
, regno
);
1287 monitor_dump_regs (regcache
);
1291 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1294 monitor_store_register (struct regcache
*regcache
, int regno
)
1299 if (current_monitor
->regname
!= NULL
)
1300 name
= current_monitor
->regname (regno
);
1302 name
= current_monitor
->regnames
[regno
];
1304 if (!name
|| (*name
== '\0'))
1306 monitor_debug ("MON Cannot store unknown register\n");
1310 regcache_cooked_read_unsigned (regcache
, regno
, &val
);
1311 monitor_debug ("MON storeg %d %s\n", regno
,
1312 phex (val
, register_size (current_gdbarch
, regno
)));
1314 /* send the register deposit command */
1316 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1317 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1318 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1319 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1321 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1323 if (current_monitor
->setreg
.resp_delim
)
1325 monitor_debug ("EXP setreg.resp_delim\n");
1326 monitor_expect_regexp (&setreg_resp_delim_pattern
, NULL
, 0);
1327 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1328 monitor_printf ("%s\r", paddr_nz (val
));
1330 if (current_monitor
->setreg
.term
)
1332 monitor_debug ("EXP setreg.term\n");
1333 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1334 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1335 monitor_printf ("%s\r", paddr_nz (val
));
1336 monitor_expect_prompt (NULL
, 0);
1339 monitor_expect_prompt (NULL
, 0);
1340 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1342 monitor_debug ("EXP setreg_termcmd\n");
1343 monitor_printf ("%s", current_monitor
->setreg
.term_cmd
);
1344 monitor_expect_prompt (NULL
, 0);
1346 } /* monitor_store_register */
1348 /* Store the remote registers. */
1351 monitor_store_registers (struct regcache
*regcache
, int regno
)
1355 monitor_store_register (regcache
, regno
);
1359 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1360 monitor_store_register (regcache
, regno
);
1363 /* Get ready to modify the registers array. On machines which store
1364 individual registers, this doesn't need to do anything. On machines
1365 which store all the registers in one fell swoop, this makes sure
1366 that registers contains all the registers from the program being
1370 monitor_prepare_to_store (struct regcache
*regcache
)
1372 /* Do nothing, since we can store individual regs */
1376 monitor_files_info (struct target_ops
*ops
)
1378 printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name
, baud_rate
);
1382 monitor_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1384 unsigned int val
, hostval
;
1388 monitor_debug ("MON write %d %s\n", len
, paddr (memaddr
));
1390 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1391 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1393 /* Use memory fill command for leading 0 bytes. */
1395 if (current_monitor
->fill
)
1397 for (i
= 0; i
< len
; i
++)
1401 if (i
> 4) /* More than 4 zeros is worth doing */
1403 monitor_debug ("MON FILL %d\n", i
);
1404 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1405 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
) - 1, 0);
1407 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1409 monitor_expect_prompt (NULL
, 0);
1416 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1417 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1420 cmd
= current_monitor
->setmem
.cmdll
;
1424 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1427 cmd
= current_monitor
->setmem
.cmdl
;
1429 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1432 cmd
= current_monitor
->setmem
.cmdw
;
1437 cmd
= current_monitor
->setmem
.cmdb
;
1440 val
= extract_unsigned_integer (myaddr
, len
);
1444 hostval
= *(unsigned int *) myaddr
;
1445 monitor_debug ("Hostval(%08x) val(%08x)\n", hostval
, val
);
1449 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1450 monitor_printf_noecho (cmd
, memaddr
, val
);
1451 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1454 monitor_printf_noecho (cmd
, memaddr
);
1456 if (current_monitor
->setmem
.resp_delim
)
1458 monitor_debug ("EXP setmem.resp_delim");
1459 monitor_expect_regexp (&setmem_resp_delim_pattern
, NULL
, 0);
1460 monitor_printf ("%x\r", val
);
1462 if (current_monitor
->setmem
.term
)
1464 monitor_debug ("EXP setmem.term");
1465 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1466 monitor_printf ("%x\r", val
);
1468 if (current_monitor
->setmem
.term_cmd
)
1469 { /* Emit this to get out of the memory editing state */
1470 monitor_printf ("%s", current_monitor
->setmem
.term_cmd
);
1471 /* Drop through to expecting a prompt */
1475 monitor_printf (cmd
, memaddr
, val
);
1477 monitor_expect_prompt (NULL
, 0);
1484 monitor_write_memory_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
1490 /* Enter the sub mode */
1491 monitor_printf (current_monitor
->setmem
.cmdb
, memaddr
);
1492 monitor_expect_prompt (NULL
, 0);
1496 monitor_printf ("%x\r", val
);
1500 /* If we wanted to, here we could validate the address */
1501 monitor_expect_prompt (NULL
, 0);
1504 /* Now exit the sub mode */
1505 monitor_printf (current_monitor
->getreg
.term_cmd
);
1506 monitor_expect_prompt (NULL
, 0);
1512 longlongendswap (unsigned char *a
)
1521 *(a
+ i
) = *(a
+ j
);
1526 /* Format 32 chars of long long value, advance the pointer */
1527 static char *hexlate
= "0123456789abcdef";
1529 longlong_hexchars (unsigned long long value
,
1539 static unsigned char disbuf
[8]; /* disassembly buffer */
1540 unsigned char *scan
, *limit
; /* loop controls */
1541 unsigned char c
, nib
;
1546 unsigned long long *dp
;
1547 dp
= (unsigned long long *) scan
;
1550 longlongendswap (disbuf
); /* FIXME: ONly on big endian hosts */
1551 while (scan
< limit
)
1553 c
= *scan
++; /* a byte of our long long value */
1559 leadzero
= 0; /* henceforth we print even zeroes */
1561 nib
= c
>> 4; /* high nibble bits */
1562 *outbuff
++ = hexlate
[nib
];
1563 nib
= c
& 0x0f; /* low nibble bits */
1564 *outbuff
++ = hexlate
[nib
];
1568 } /* longlong_hexchars */
1572 /* I am only going to call this when writing virtual byte streams.
1573 Which possably entails endian conversions
1576 monitor_write_memory_longlongs (CORE_ADDR memaddr
, char *myaddr
, int len
)
1578 static char hexstage
[20]; /* At least 16 digits required, plus null */
1583 llptr
= (unsigned long long *) myaddr
;
1586 monitor_printf (current_monitor
->setmem
.cmdll
, memaddr
);
1587 monitor_expect_prompt (NULL
, 0);
1591 endstring
= longlong_hexchars (*llptr
, hexstage
);
1592 *endstring
= '\0'; /* NUll terminate for printf */
1593 monitor_printf ("%s\r", hexstage
);
1597 /* If we wanted to, here we could validate the address */
1598 monitor_expect_prompt (NULL
, 0);
1601 /* Now exit the sub mode */
1602 monitor_printf (current_monitor
->getreg
.term_cmd
);
1603 monitor_expect_prompt (NULL
, 0);
1609 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1610 /* This is for the large blocks of memory which may occur in downloading.
1611 And for monitors which use interactive entry,
1612 And for monitors which do not have other downloading methods.
1613 Without this, we will end up calling monitor_write_memory many times
1614 and do the entry and exit of the sub mode many times
1615 This currently assumes...
1616 MO_SETMEM_INTERACTIVE
1617 ! MO_NO_ECHO_ON_SETMEM
1618 To use this, the you have to patch the monitor_cmds block with
1619 this function. Otherwise, its not tuned up for use by all
1624 monitor_write_memory_block (CORE_ADDR memaddr
, char *myaddr
, int len
)
1628 /* FIXME: This would be a good place to put the zero test */
1630 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1632 return monitor_write_memory_longlongs (memaddr
, myaddr
, len
);
1635 written
= monitor_write_memory_bytes (memaddr
, myaddr
, len
);
1639 /* This is an alternate form of monitor_read_memory which is used for monitors
1640 which can only read a single byte/word/etc. at a time. */
1643 monitor_read_memory_single (CORE_ADDR memaddr
, char *myaddr
, int len
)
1646 char membuf
[sizeof (int) * 2 + 1];
1650 monitor_debug ("MON read single\n");
1652 /* Can't actually use long longs (nice idea, though). In fact, the
1653 call to strtoul below will fail if it tries to convert a value
1654 that's too big to fit in a long. */
1655 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1658 cmd
= current_monitor
->getmem
.cmdll
;
1662 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1665 cmd
= current_monitor
->getmem
.cmdl
;
1667 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1670 cmd
= current_monitor
->getmem
.cmdw
;
1675 cmd
= current_monitor
->getmem
.cmdb
;
1678 /* Send the examine command. */
1680 monitor_printf (cmd
, memaddr
);
1682 /* If RESP_DELIM is specified, we search for that as a leading
1683 delimiter for the memory value. Otherwise, we just start
1684 searching from the start of the buf. */
1686 if (current_monitor
->getmem
.resp_delim
)
1688 monitor_debug ("EXP getmem.resp_delim\n");
1689 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1692 /* Now, read the appropriate number of hex digits for this loc,
1695 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1696 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1700 c
= readchar (timeout
);
1702 c
= readchar (timeout
);
1703 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1706 monitor_error ("monitor_read_memory_single",
1707 "bad response from monitor",
1708 memaddr
, 0, NULL
, 0);
1713 for (i
= 0; i
< len
* 2; i
++)
1719 c
= readchar (timeout
);
1725 monitor_error ("monitor_read_memory_single",
1726 "bad response from monitor",
1727 memaddr
, i
, membuf
, 0);
1731 membuf
[i
] = '\000'; /* terminate the number */
1734 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1735 present), we will send TERM_CMD if that is present. In any case, we collect
1736 all of the output into buf, and then wait for the normal prompt. */
1738 if (current_monitor
->getmem
.term
)
1740 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1742 if (current_monitor
->getmem
.term_cmd
)
1744 monitor_printf (current_monitor
->getmem
.term_cmd
);
1745 monitor_expect_prompt (NULL
, 0);
1749 monitor_expect_prompt (NULL
, 0); /* get response */
1752 val
= strtoul (membuf
, &p
, 16);
1754 if (val
== 0 && membuf
== p
)
1755 monitor_error ("monitor_read_memory_single",
1756 "bad value from monitor",
1757 memaddr
, 0, membuf
, 0);
1759 /* supply register stores in target byte order, so swap here */
1761 store_unsigned_integer (myaddr
, len
, val
);
1766 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1767 memory at MEMADDR. Returns length moved. Currently, we do no more
1768 than 16 bytes at a time. */
1771 monitor_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1782 monitor_debug ("Zero length call to monitor_read_memory\n");
1786 monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
1787 paddr_nz (memaddr
), (long) myaddr
, len
);
1789 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1790 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1792 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1793 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1795 len
= min (len
, 16);
1797 /* Some dumpers align the first data with the preceeding 16
1798 byte boundary. Some print blanks and start at the
1799 requested boundary. EXACT_DUMPADDR
1802 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1803 ? memaddr
: memaddr
& ~0x0f;
1805 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1806 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1807 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1809 /* send the memory examine command */
1811 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1812 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
);
1813 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1814 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1816 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1818 /* If TERM is present, we wait for that to show up. Also, (if TERM
1819 is present), we will send TERM_CMD if that is present. In any
1820 case, we collect all of the output into buf, and then wait for
1821 the normal prompt. */
1823 if (current_monitor
->getmem
.term
)
1825 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1828 monitor_error ("monitor_read_memory",
1829 "excessive response from monitor",
1830 memaddr
, resp_len
, buf
, 0);
1832 if (current_monitor
->getmem
.term_cmd
)
1834 serial_write (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1835 strlen (current_monitor
->getmem
.term_cmd
));
1836 monitor_expect_prompt (NULL
, 0);
1840 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1844 /* If RESP_DELIM is specified, we search for that as a leading
1845 delimiter for the values. Otherwise, we just start searching
1846 from the start of the buf. */
1848 if (current_monitor
->getmem
.resp_delim
)
1851 struct re_registers resp_strings
;
1852 monitor_debug ("MON getmem.resp_delim %s\n", current_monitor
->getmem
.resp_delim
);
1854 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1856 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1860 monitor_error ("monitor_read_memory",
1861 "bad response from monitor",
1862 memaddr
, resp_len
, buf
, 0);
1864 p
+= resp_strings
.end
[0];
1866 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1868 monitor_error ("monitor_read_memory",
1869 "bad response from monitor",
1870 memaddr
, resp_len
, buf
, 0);
1871 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1874 monitor_debug ("MON scanning %d ,%lx '%s'\n", len
, (long) p
, p
);
1875 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1883 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1887 if ((dumpaddr
>= memaddr
) && (i
> 0))
1889 val
= fromhex (c
) * 16 + fromhex (*(p
+ 1));
1891 if (monitor_debug_p
|| remote_debug
)
1892 fprintf_unfiltered (gdb_stdlog
, "[%02x]", val
);
1899 ++p
; /* skip a blank or other non hex char */
1903 error (_("Failed to read via monitor"));
1904 if (monitor_debug_p
|| remote_debug
)
1905 fprintf_unfiltered (gdb_stdlog
, "\n");
1906 return fetched
; /* Return the number of bytes actually read */
1908 monitor_debug ("MON scanning bytes\n");
1910 for (i
= len
; i
> 0; i
--)
1912 /* Skip non-hex chars, but bomb on end of string and newlines */
1919 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1920 monitor_error ("monitor_read_memory",
1921 "badly terminated response from monitor",
1922 memaddr
, resp_len
, buf
, 0);
1926 val
= strtoul (p
, &p1
, 16);
1928 if (val
== 0 && p
== p1
)
1929 monitor_error ("monitor_read_memory",
1930 "bad value from monitor",
1931 memaddr
, resp_len
, buf
, 0);
1944 /* Transfer LEN bytes between target address MEMADDR and GDB address
1945 MYADDR. Returns 0 for success, errno code for failure. TARGET is
1949 monitor_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
1950 struct mem_attrib
*attrib
, struct target_ops
*target
)
1956 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
1957 res
= monitor_write_memory_block(memaddr
, myaddr
, len
);
1959 res
= monitor_write_memory(memaddr
, myaddr
, len
);
1963 res
= monitor_read_memory(memaddr
, myaddr
, len
);
1972 return; /* ignore attempts to kill target system */
1975 /* All we actually do is set the PC to the start address of exec_bfd. */
1978 monitor_create_inferior (char *exec_file
, char *args
, char **env
,
1981 if (args
&& (*args
!= '\000'))
1982 error (_("Args are not supported by the monitor."));
1985 clear_proceed_status ();
1986 write_pc (bfd_get_start_address (exec_bfd
));
1989 /* Clean up when a program exits.
1990 The program actually lives on in the remote processor's RAM, and may be
1991 run again without a download. Don't leave it full of breakpoint
1995 monitor_mourn_inferior (void)
1997 unpush_target (targ_ops
);
1998 generic_mourn_inferior (); /* Do all the proper things now */
2001 /* Tell the monitor to add a breakpoint. */
2004 monitor_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2006 CORE_ADDR addr
= bp_tgt
->placed_address
;
2008 const unsigned char *bp
;
2011 monitor_debug ("MON inst bkpt %s\n", paddr (addr
));
2012 if (current_monitor
->set_break
== NULL
)
2013 error (_("No set_break defined for this monitor"));
2015 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2016 addr
= ADDR_BITS_REMOVE (addr
);
2018 /* Determine appropriate breakpoint size for this address. */
2019 bp
= gdbarch_breakpoint_from_pc (current_gdbarch
, &addr
, &bplen
);
2020 bp_tgt
->placed_address
= addr
;
2021 bp_tgt
->placed_size
= bplen
;
2023 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2025 if (breakaddr
[i
] == 0)
2027 breakaddr
[i
] = addr
;
2028 monitor_printf (current_monitor
->set_break
, addr
);
2029 monitor_expect_prompt (NULL
, 0);
2034 error (_("Too many breakpoints (> %d) for monitor."), current_monitor
->num_breakpoints
);
2037 /* Tell the monitor to remove a breakpoint. */
2040 monitor_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2042 CORE_ADDR addr
= bp_tgt
->placed_address
;
2045 monitor_debug ("MON rmbkpt %s\n", paddr (addr
));
2046 if (current_monitor
->clr_break
== NULL
)
2047 error (_("No clr_break defined for this monitor"));
2049 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2051 if (breakaddr
[i
] == addr
)
2054 /* some monitors remove breakpoints based on the address */
2055 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2056 monitor_printf (current_monitor
->clr_break
, addr
);
2057 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2058 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2060 monitor_printf (current_monitor
->clr_break
, i
);
2061 monitor_expect_prompt (NULL
, 0);
2065 fprintf_unfiltered (gdb_stderr
,
2066 "Can't find breakpoint associated with 0x%s\n",
2071 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2072 an S-record. Return non-zero if the ACK is received properly. */
2075 monitor_wait_srec_ack (void)
2079 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2081 return (readchar (timeout
) == '+');
2083 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2085 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2086 if ((ch
= readchar (1)) < 0)
2088 if ((ch
= readchar (1)) < 0)
2090 if ((ch
= readchar (1)) < 0)
2092 if ((ch
= readchar (1)) < 0)
2098 /* monitor_load -- download a file. */
2101 monitor_load (char *file
, int from_tty
)
2103 monitor_debug ("MON load\n");
2105 if (current_monitor
->load_routine
)
2106 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2108 { /* The default is ascii S-records */
2110 unsigned long load_offset
;
2113 /* enable user to specify address for downloading as 2nd arg to load */
2114 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2120 monitor_printf (current_monitor
->load
);
2121 if (current_monitor
->loadresp
)
2122 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2124 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2125 32, SREC_ALL
, hashmark
,
2126 current_monitor
->flags
& MO_SREC_ACK
?
2127 monitor_wait_srec_ack
: NULL
);
2129 monitor_expect_prompt (NULL
, 0);
2132 /* Finally, make the PC point at the start address */
2134 write_pc (bfd_get_start_address (exec_bfd
));
2136 /* There used to be code here which would clear inferior_ptid and
2137 call clear_symtab_users. None of that should be necessary:
2138 monitor targets should behave like remote protocol targets, and
2139 since generic_load does none of those things, this function
2142 Furthermore, clearing inferior_ptid is *incorrect*. After doing
2143 a load, we still have a valid connection to the monitor, with a
2144 live processor state to fiddle with. The user can type
2145 `continue' or `jump *start' and make the program run. If they do
2146 these things, however, GDB will be talking to a running program
2147 while inferior_ptid is null_ptid; this makes things like
2148 reinit_frame_cache very confused. */
2154 monitor_debug ("MON stop\n");
2155 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2156 serial_send_break (monitor_desc
);
2157 if (current_monitor
->stop
)
2158 monitor_printf_noecho (current_monitor
->stop
);
2161 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2162 in OUTPUT until the prompt is seen. FIXME: We read the characters
2163 ourseleves here cause of a nasty echo. */
2166 monitor_rcmd (char *command
,
2167 struct ui_file
*outbuf
)
2173 if (monitor_desc
== NULL
)
2174 error (_("monitor target not open."));
2176 p
= current_monitor
->prompt
;
2178 /* Send the command. Note that if no args were supplied, then we're
2179 just sending the monitor a newline, which is sometimes useful. */
2181 monitor_printf ("%s\r", (command
? command
: ""));
2183 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2185 fputs_unfiltered (buf
, outbuf
); /* Output the response */
2188 /* Convert hex digit A to a number. */
2194 if (a
>= '0' && a
<= '9')
2196 if (a
>= 'a' && a
<= 'f')
2197 return a
- 'a' + 10;
2198 if (a
>= 'A' && a
<= 'F')
2199 return a
- 'A' + 10;
2201 error (_("Reply contains invalid hex digit 0x%x"), a
);
2206 monitor_get_dev_name (void)
2211 static struct target_ops monitor_ops
;
2214 init_base_monitor_ops (void)
2216 monitor_ops
.to_close
= monitor_close
;
2217 monitor_ops
.to_detach
= monitor_detach
;
2218 monitor_ops
.to_resume
= monitor_resume
;
2219 monitor_ops
.to_wait
= monitor_wait
;
2220 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2221 monitor_ops
.to_store_registers
= monitor_store_registers
;
2222 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2223 monitor_ops
.deprecated_xfer_memory
= monitor_xfer_memory
;
2224 monitor_ops
.to_files_info
= monitor_files_info
;
2225 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2226 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2227 monitor_ops
.to_kill
= monitor_kill
;
2228 monitor_ops
.to_load
= monitor_load
;
2229 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2230 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2231 monitor_ops
.to_stop
= monitor_stop
;
2232 monitor_ops
.to_rcmd
= monitor_rcmd
;
2233 monitor_ops
.to_stratum
= process_stratum
;
2234 monitor_ops
.to_has_all_memory
= 1;
2235 monitor_ops
.to_has_memory
= 1;
2236 monitor_ops
.to_has_stack
= 1;
2237 monitor_ops
.to_has_registers
= 1;
2238 monitor_ops
.to_has_execution
= 1;
2239 monitor_ops
.to_magic
= OPS_MAGIC
;
2240 } /* init_base_monitor_ops */
2242 /* Init the target_ops structure pointed at by OPS */
2245 init_monitor_ops (struct target_ops
*ops
)
2247 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2248 init_base_monitor_ops ();
2250 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2253 /* Define additional commands that are usually only used by monitors. */
2255 extern initialize_file_ftype _initialize_remote_monitors
; /* -Wmissing-prototypes */
2258 _initialize_remote_monitors (void)
2260 init_base_monitor_ops ();
2261 add_setshow_boolean_cmd ("hash", no_class
, &hashmark
, _("\
2262 Set display of activity while downloading a file."), _("\
2263 Show display of activity while downloading a file."), _("\
2264 When enabled, a hashmark \'#\' is displayed."),
2266 NULL
, /* FIXME: i18n: */
2267 &setlist
, &showlist
);
2269 add_setshow_zinteger_cmd ("monitor", no_class
, &monitor_debug_p
, _("\
2270 Set debugging of remote monitor communication."), _("\
2271 Show debugging of remote monitor communication."), _("\
2272 When enabled, communication between GDB and the remote monitor\n\
2275 NULL
, /* FIXME: i18n: */
2276 &setdebuglist
, &showdebuglist
);