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 3 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, see <http://www.gnu.org/licenses/>. */
24 /* This file was derived from various remote-* modules. It is a collection
25 of generic support functions so GDB can talk directly to a ROM based
26 monitor. This saves use from having to hack an exception based handler
27 into existence, and makes for quick porting.
29 This module talks to a debug monitor called 'MONITOR', which
30 We communicate with MONITOR via either a direct serial line, or a TCP
31 (or possibly TELNET) stream to a terminal multiplexor,
32 which in turn talks to the target board. */
34 /* FIXME 32x64: This code assumes that registers and addresses are at
35 most 32 bits long. If they can be larger, you will need to declare
36 values as LONGEST and use %llx or some such to print values when
37 building commands to send to the monitor. Since we don't know of
38 any actual 64-bit targets with ROM monitors that use this code,
39 it's not an issue right now. -sts 4/18/96 */
44 #include "exceptions.h"
47 #include "gdb_string.h"
48 #include <sys/types.h>
54 #include "gdb_regex.h"
58 static char *dev_name
;
59 static struct target_ops
*targ_ops
;
61 static void monitor_interrupt_query (void);
62 static void monitor_interrupt_twice (int);
63 static void monitor_stop (void);
64 static void monitor_dump_regs (struct regcache
*regcache
);
67 static int from_hex (int a
);
70 static struct monitor_ops
*current_monitor
;
72 static int hashmark
; /* flag set by "set hash" */
74 static int timeout
= 30;
76 static int in_monitor_wait
= 0; /* Non-zero means we are in monitor_wait() */
78 static void (*ofunc
) (); /* Old SIGINT signal handler */
80 static CORE_ADDR
*breakaddr
;
82 /* Descriptor for I/O to remote machine. Initialize it to NULL so
83 that monitor_open knows that we don't have a file open when the
86 static struct serial
*monitor_desc
= NULL
;
88 /* Pointer to regexp pattern matching data */
90 static struct re_pattern_buffer register_pattern
;
91 static char register_fastmap
[256];
93 static struct re_pattern_buffer getmem_resp_delim_pattern
;
94 static char getmem_resp_delim_fastmap
[256];
96 static struct re_pattern_buffer setmem_resp_delim_pattern
;
97 static char setmem_resp_delim_fastmap
[256];
99 static struct re_pattern_buffer setreg_resp_delim_pattern
;
100 static char setreg_resp_delim_fastmap
[256];
102 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
103 monitor_wait wakes up. */
105 static int first_time
= 0; /* is this the first time we're executing after
106 gaving created the child proccess? */
108 #define TARGET_BUF_SIZE 2048
110 /* Monitor specific debugging information. Typically only useful to
111 the developer of a new monitor interface. */
113 static void monitor_debug (const char *fmt
, ...) ATTR_FORMAT(printf
, 1, 2);
115 static int monitor_debug_p
= 0;
117 /* NOTE: This file alternates between monitor_debug_p and remote_debug
118 when determining if debug information is printed. Perhaps this
119 could be simplified. */
122 monitor_debug (const char *fmt
, ...)
127 va_start (args
, fmt
);
128 vfprintf_filtered (gdb_stdlog
, fmt
, args
);
134 /* Convert a string into a printable representation, Return # byte in
135 the new string. When LEN is >0 it specifies the size of the
136 string. Otherwize strlen(oldstr) is used. */
139 monitor_printable_string (char *newstr
, char *oldstr
, int len
)
145 len
= strlen (oldstr
);
147 for (i
= 0; i
< len
; i
++)
158 sprintf (newstr
, "\\x%02x", ch
& 0xff);
197 /* Print monitor errors with a string, converting the string to printable
201 monitor_error (char *function
, char *message
,
202 CORE_ADDR memaddr
, int len
, char *string
, int final_char
)
204 int real_len
= (len
== 0 && string
!= (char *) 0) ? strlen (string
) : len
;
205 char *safe_string
= alloca ((real_len
* 4) + 1);
206 monitor_printable_string (safe_string
, string
, real_len
);
209 error (_("%s (0x%s): %s: %s%c"), function
, paddr_nz (memaddr
), message
, safe_string
, final_char
);
211 error (_("%s (0x%s): %s: %s"), function
, paddr_nz (memaddr
), message
, safe_string
);
214 /* Convert hex digit A to a number. */
219 if (a
>= '0' && a
<= '9')
221 else if (a
>= 'a' && a
<= 'f')
223 else if (a
>= 'A' && a
<= 'F')
226 error (_("Invalid hex digit %d"), a
);
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 %.
244 monitor_vsprintf (char *sndbuf
, char *pattern
, va_list args
)
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
, paddr_nz (arg_addr
));
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__
, _("failed internal consistency check"));
314 char *safe_string
= (char *) alloca ((strlen (sndbuf
) * 4) + 1);
315 monitor_printable_string (safe_string
, sndbuf
, 0);
316 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
319 monitor_write (sndbuf
, len
);
322 /* monitor_printf -- Send data to monitor and check the echo. Works just like
326 monitor_printf (char *pattern
,...)
332 va_start (args
, pattern
);
334 monitor_vsprintf (sndbuf
, pattern
, args
);
336 len
= strlen (sndbuf
);
337 if (len
+ 1 > sizeof sndbuf
)
338 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
342 char *safe_string
= (char *) alloca ((len
* 4) + 1);
343 monitor_printable_string (safe_string
, sndbuf
, 0);
344 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
347 monitor_write (sndbuf
, len
);
349 /* We used to expect that the next immediate output was the characters we
350 just output, but sometimes some extra junk appeared before the characters
351 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
352 So, just start searching for what we sent, and skip anything unknown. */
353 monitor_debug ("ExpectEcho\n");
354 monitor_expect (sndbuf
, (char *) 0, 0);
358 /* Write characters to the remote system. */
361 monitor_write (char *buf
, int buflen
)
363 if (serial_write (monitor_desc
, buf
, buflen
))
364 fprintf_unfiltered (gdb_stderr
, "serial_write failed: %s\n",
365 safe_strerror (errno
));
369 /* Read a binary character from the remote system, doing all the fancy
370 timeout stuff, but without interpreting the character in any way,
371 and without printing remote debug information. */
374 monitor_readchar (void)
382 c
= serial_readchar (monitor_desc
, timeout
);
385 c
&= 0xff; /* don't lose bit 7 */
392 if (c
== SERIAL_TIMEOUT
)
393 error (_("Timeout reading from remote system."));
395 perror_with_name (_("remote-monitor"));
399 /* Read a character from the remote system, doing all the fancy
403 readchar (int timeout
)
408 last_random
, last_nl
, last_cr
, last_crnl
416 c
= serial_readchar (monitor_desc
, timeout
);
421 /* This seems to interfere with proper function of the
423 if (monitor_debug_p
|| remote_debug
)
428 puts_debug ("read -->", buf
, "<--");
433 /* Canonicialize \n\r combinations into one \r */
434 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
436 if ((c
== '\r' && state
== last_nl
)
437 || (c
== '\n' && state
== last_cr
))
458 if (c
== SERIAL_TIMEOUT
)
460 /* I fail to see how detaching here can be useful */
461 if (in_monitor_wait
) /* Watchdog went off */
463 target_mourn_inferior ();
464 error (_("GDB serial timeout has expired. Target detached."));
468 error (_("Timeout reading from remote system."));
470 perror_with_name (_("remote-monitor"));
473 /* Scan input from the remote system, until STRING is found. If BUF is non-
474 zero, then collect input until we have collected either STRING or BUFLEN-1
475 chars. In either case we terminate BUF with a 0. If input overflows BUF
476 because STRING can't be found, return -1, else return number of chars in BUF
477 (minus the terminating NUL). Note that in the non-overflow case, STRING
478 will be at the end of BUF. */
481 monitor_expect (char *string
, char *buf
, int buflen
)
484 int obuflen
= buflen
;
489 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
490 monitor_printable_string (safe_string
, string
, 0);
491 fprintf_unfiltered (gdb_stdlog
, "MON Expecting '%s'\n", safe_string
);
506 c
= readchar (timeout
);
513 c
= readchar (timeout
);
515 /* Don't expect any ^C sent to be echoed */
517 if (*p
== '\003' || c
== *p
)
527 return obuflen
- buflen
;
535 /* We got a character that doesn't match the string. We need to
536 back up p, but how far? If we're looking for "..howdy" and the
537 monitor sends "...howdy"? There's certainly a match in there,
538 but when we receive the third ".", we won't find it if we just
539 restart the matching at the beginning of the string.
541 This is a Boyer-Moore kind of situation. We want to reset P to
542 the end of the longest prefix of STRING that is a suffix of
543 what we've read so far. In the example above, that would be
544 ".." --- the longest prefix of "..howdy" that is a suffix of
545 "...". This longest prefix could be the empty string, if C
546 is nowhere to be found in STRING.
548 If this longest prefix is not the empty string, it must contain
549 C, so let's search from the end of STRING for instances of C,
550 and see if the portion of STRING before that is a suffix of
551 what we read before C. Actually, we can search backwards from
552 p, since we know no prefix can be longer than that.
554 Note that we can use STRING itself, along with C, as a record
555 of what we've received so far. :) */
558 for (i
= (p
- string
) - 1; i
>= 0; i
--)
561 /* Is this prefix a suffix of what we've read so far?
563 string[0 .. i-1] == string[p - i, p - 1]? */
564 if (! memcmp (string
, p
- i
, i
))
576 /* Search for a regexp. */
579 monitor_expect_regexp (struct re_pattern_buffer
*pat
, char *buf
, int buflen
)
583 monitor_debug ("MON Expecting regexp\n");
588 mybuf
= alloca (TARGET_BUF_SIZE
);
589 buflen
= TARGET_BUF_SIZE
;
597 if (p
- mybuf
>= buflen
)
598 { /* Buffer about to overflow */
600 /* On overflow, we copy the upper half of the buffer to the lower half. Not
601 great, but it usually works... */
603 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
604 p
= mybuf
+ buflen
/ 2;
607 *p
++ = readchar (timeout
);
609 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
615 /* Keep discarding input until we see the MONITOR prompt.
617 The convention for dealing with the prompt is that you
619 o *then* wait for the prompt.
621 Thus the last thing that a procedure does with the serial line will
622 be an monitor_expect_prompt(). Exception: monitor_resume does not
623 wait for the prompt, because the terminal is being handed over to
624 the inferior. However, the next thing which happens after that is
625 a monitor_wait which does wait for the prompt. Note that this
626 includes abnormal exit, e.g. error(). This is necessary to prevent
627 getting into states from which we can't recover. */
630 monitor_expect_prompt (char *buf
, int buflen
)
632 monitor_debug ("MON Expecting prompt\n");
633 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
636 /* Get N 32-bit words from remote, each preceded by a space, and put
637 them in registers starting at REGNO. */
648 ch
= readchar (timeout
);
649 while (isspace (ch
));
653 for (i
= 7; i
>= 1; i
--)
655 ch
= readchar (timeout
);
658 val
= (val
<< 4) | from_hex (ch
);
666 compile_pattern (char *pattern
, struct re_pattern_buffer
*compiled_pattern
,
672 compiled_pattern
->fastmap
= fastmap
;
674 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
675 val
= re_compile_pattern (pattern
,
681 error (_("compile_pattern: Can't compile pattern string `%s': %s!"), pattern
, val
);
684 re_compile_fastmap (compiled_pattern
);
687 /* Open a connection to a remote debugger. NAME is the filename used
688 for communication. */
691 monitor_open (char *args
, struct monitor_ops
*mon_ops
, int from_tty
)
696 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
697 error (_("Magic number of monitor_ops struct wrong."));
699 targ_ops
= mon_ops
->target
;
700 name
= targ_ops
->to_shortname
;
703 error (_("Use `target %s DEVICE-NAME' to use a serial port, or \n\
704 `target %s HOST-NAME:PORT-NUMBER' to use a network connection."), name
, name
);
706 target_preopen (from_tty
);
708 /* Setup pattern for register dump */
710 if (mon_ops
->register_pattern
)
711 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
714 if (mon_ops
->getmem
.resp_delim
)
715 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
716 getmem_resp_delim_fastmap
);
718 if (mon_ops
->setmem
.resp_delim
)
719 compile_pattern (mon_ops
->setmem
.resp_delim
, &setmem_resp_delim_pattern
,
720 setmem_resp_delim_fastmap
);
722 if (mon_ops
->setreg
.resp_delim
)
723 compile_pattern (mon_ops
->setreg
.resp_delim
, &setreg_resp_delim_pattern
,
724 setreg_resp_delim_fastmap
);
726 unpush_target (targ_ops
);
730 dev_name
= xstrdup (args
);
732 monitor_desc
= serial_open (dev_name
);
735 perror_with_name (dev_name
);
739 if (serial_setbaudrate (monitor_desc
, baud_rate
))
741 serial_close (monitor_desc
);
742 perror_with_name (dev_name
);
746 serial_raw (monitor_desc
);
748 serial_flush_input (monitor_desc
);
750 /* some systems only work with 2 stop bits */
752 serial_setstopbits (monitor_desc
, mon_ops
->stopbits
);
754 current_monitor
= mon_ops
;
756 /* See if we can wake up the monitor. First, try sending a stop sequence,
757 then send the init strings. Last, remove all breakpoints. */
759 if (current_monitor
->stop
)
762 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
764 monitor_debug ("EXP Open echo\n");
765 monitor_expect_prompt (NULL
, 0);
769 /* wake up the monitor and see if it's alive */
770 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
772 /* Some of the characters we send may not be echoed,
773 but we hope to get a prompt at the end of it all. */
775 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
778 monitor_printf_noecho (*p
);
779 monitor_expect_prompt (NULL
, 0);
782 serial_flush_input (monitor_desc
);
784 /* Alloc breakpoints */
785 if (mon_ops
->set_break
!= NULL
)
787 if (mon_ops
->num_breakpoints
== 0)
788 mon_ops
->num_breakpoints
= 8;
790 breakaddr
= (CORE_ADDR
*) xmalloc (mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
791 memset (breakaddr
, 0, mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
794 /* Remove all breakpoints */
796 if (mon_ops
->clr_all_break
)
798 monitor_printf (mon_ops
->clr_all_break
);
799 monitor_expect_prompt (NULL
, 0);
803 printf_unfiltered (_("Remote target %s connected to %s\n"), name
, dev_name
);
805 push_target (targ_ops
);
807 inferior_ptid
= pid_to_ptid (42000); /* Make run command think we are busy... */
809 /* Give monitor_wait something to read */
811 monitor_printf (current_monitor
->line_term
);
813 start_remote (from_tty
);
816 /* Close out all files and local state before this target loses
820 monitor_close (int quitting
)
823 serial_close (monitor_desc
);
825 /* Free breakpoint memory */
826 if (breakaddr
!= NULL
)
835 /* Terminate the open connection to the remote debugger. Use this
836 when you want to detach and do something else with your gdb. */
839 monitor_detach (char *args
, int from_tty
)
841 pop_target (); /* calls monitor_close to do the real work */
843 printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname
);
846 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
849 monitor_supply_register (struct regcache
*regcache
, int regno
, char *valstr
)
852 unsigned char regbuf
[MAX_REGISTER_SIZE
];
857 while (p
&& *p
!= '\0')
859 if (*p
== '\r' || *p
== '\n')
870 if (!isxdigit (*p
) && *p
!= 'x')
876 val
+= fromhex (*p
++);
878 monitor_debug ("Supplying Register %d %s\n", regno
, valstr
);
880 if (val
== 0 && valstr
== p
)
881 error (_("monitor_supply_register (%d): bad value from monitor: %s."),
884 /* supply register stores in target byte order, so swap here */
886 store_unsigned_integer (regbuf
, register_size (current_gdbarch
, regno
), val
);
888 regcache_raw_supply (regcache
, regno
, regbuf
);
893 /* Tell the remote machine to resume. */
896 monitor_resume (ptid_t ptid
, int step
, enum target_signal sig
)
898 /* Some monitors require a different command when starting a program */
899 monitor_debug ("MON resume\n");
900 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
903 monitor_printf ("run\r");
904 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
909 monitor_printf (current_monitor
->step
);
912 if (current_monitor
->continue_hook
)
913 (*current_monitor
->continue_hook
) ();
915 monitor_printf (current_monitor
->cont
);
916 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
921 /* Parse the output of a register dump command. A monitor specific
922 regexp is used to extract individual register descriptions of the
923 form REG=VAL. Each description is split up into a name and a value
924 string which are passed down to monitor specific code. */
927 parse_register_dump (struct regcache
*regcache
, char *buf
, int len
)
929 monitor_debug ("MON Parsing register dump\n");
932 int regnamelen
, vallen
;
934 /* Element 0 points to start of register name, and element 1
935 points to the start of the register value. */
936 struct re_registers register_strings
;
938 memset (®ister_strings
, 0, sizeof (struct re_registers
));
940 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
941 ®ister_strings
) == -1)
944 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
945 regname
= buf
+ register_strings
.start
[1];
946 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
947 val
= buf
+ register_strings
.start
[2];
949 current_monitor
->supply_register (regcache
, regname
, regnamelen
,
952 buf
+= register_strings
.end
[0];
953 len
-= register_strings
.end
[0];
957 /* Send ^C to target to halt it. Target will respond, and send us a
961 monitor_interrupt (int signo
)
963 /* If this doesn't work, try more severe steps. */
964 signal (signo
, monitor_interrupt_twice
);
966 if (monitor_debug_p
|| remote_debug
)
967 fprintf_unfiltered (gdb_stdlog
, "monitor_interrupt called\n");
972 /* The user typed ^C twice. */
975 monitor_interrupt_twice (int signo
)
977 signal (signo
, ofunc
);
979 monitor_interrupt_query ();
981 signal (signo
, monitor_interrupt
);
984 /* Ask the user what to do when an interrupt is received. */
987 monitor_interrupt_query (void)
989 target_terminal_ours ();
991 if (query ("Interrupted while waiting for the program.\n\
992 Give up (and stop debugging it)? "))
994 target_mourn_inferior ();
995 deprecated_throw_reason (RETURN_QUIT
);
998 target_terminal_inferior ();
1002 monitor_wait_cleanup (void *old_timeout
)
1004 timeout
= *(int *) old_timeout
;
1005 signal (SIGINT
, ofunc
);
1006 in_monitor_wait
= 0;
1012 monitor_wait_filter (char *buf
,
1015 struct target_waitstatus
*status
)
1020 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1021 *ext_resp_len
= resp_len
;
1024 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1026 while (resp_len
< 0);
1028 /* Print any output characters that were preceded by ^O. */
1029 /* FIXME - This would be great as a user settabgle flag */
1030 if (monitor_debug_p
|| remote_debug
1031 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1035 for (i
= 0; i
< resp_len
- 1; i
++)
1037 putchar_unfiltered (buf
[++i
]);
1043 /* Wait until the remote machine stops, then return, storing status in
1044 status just as `wait' would. */
1047 monitor_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1049 int old_timeout
= timeout
;
1050 char buf
[TARGET_BUF_SIZE
];
1052 struct cleanup
*old_chain
;
1054 status
->kind
= TARGET_WAITKIND_EXITED
;
1055 status
->value
.integer
= 0;
1057 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1058 monitor_debug ("MON wait\n");
1061 /* This is somthing other than a maintenance command */
1062 in_monitor_wait
= 1;
1063 timeout
= watchdog
> 0 ? watchdog
: -1;
1065 timeout
= -1; /* Don't time out -- user program is running. */
1068 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1070 if (current_monitor
->wait_filter
)
1071 (*current_monitor
->wait_filter
) (buf
, sizeof (buf
), &resp_len
, status
);
1073 monitor_wait_filter (buf
, sizeof (buf
), &resp_len
, status
);
1075 #if 0 /* Transferred to monitor wait filter */
1078 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1081 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1083 while (resp_len
< 0);
1085 /* Print any output characters that were preceded by ^O. */
1086 /* FIXME - This would be great as a user settabgle flag */
1087 if (monitor_debug_p
|| remote_debug
1088 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1092 for (i
= 0; i
< resp_len
- 1; i
++)
1094 putchar_unfiltered (buf
[++i
]);
1098 signal (SIGINT
, ofunc
);
1100 timeout
= old_timeout
;
1102 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1105 monitor_printf (current_monitor
->dump_registers
);
1106 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1109 if (current_monitor
->register_pattern
)
1110 parse_register_dump (get_current_regcache (), buf
, resp_len
);
1112 monitor_debug ("Wait fetching registers after stop\n");
1113 monitor_dump_regs (get_current_regcache ());
1116 status
->kind
= TARGET_WAITKIND_STOPPED
;
1117 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1119 discard_cleanups (old_chain
);
1121 in_monitor_wait
= 0;
1123 return inferior_ptid
;
1126 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1130 monitor_fetch_register (struct regcache
*regcache
, int regno
)
1137 regbuf
= alloca (MAX_REGISTER_SIZE
* 2 + 1);
1138 zerobuf
= alloca (MAX_REGISTER_SIZE
);
1139 memset (zerobuf
, 0, MAX_REGISTER_SIZE
);
1141 if (current_monitor
->regname
!= NULL
)
1142 name
= current_monitor
->regname (regno
);
1144 name
= current_monitor
->regnames
[regno
];
1145 monitor_debug ("MON fetchreg %d '%s'\n", regno
, name
? name
: "(null name)");
1147 if (!name
|| (*name
== '\0'))
1149 monitor_debug ("No register known for %d\n", regno
);
1150 regcache_raw_supply (regcache
, regno
, zerobuf
);
1154 /* send the register examine command */
1156 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1158 /* If RESP_DELIM is specified, we search for that as a leading
1159 delimiter for the register value. Otherwise, we just start
1160 searching from the start of the buf. */
1162 if (current_monitor
->getreg
.resp_delim
)
1164 monitor_debug ("EXP getreg.resp_delim\n");
1165 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1166 /* Handle case of first 32 registers listed in pairs. */
1167 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1168 && (regno
& 1) != 0 && regno
< 32)
1170 monitor_debug ("EXP getreg.resp_delim\n");
1171 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1175 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1176 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1179 c
= readchar (timeout
);
1181 c
= readchar (timeout
);
1182 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1185 error (_("Bad value returned from monitor while fetching register %x."),
1189 /* Read upto the maximum number of hex digits for this register, skipping
1190 spaces, but stop reading if something else is seen. Some monitors
1191 like to drop leading zeros. */
1193 for (i
= 0; i
< register_size (current_gdbarch
, regno
) * 2; i
++)
1196 c
= readchar (timeout
);
1198 c
= readchar (timeout
);
1206 regbuf
[i
] = '\000'; /* terminate the number */
1207 monitor_debug ("REGVAL '%s'\n", regbuf
);
1209 /* If TERM is present, we wait for that to show up. Also, (if TERM
1210 is present), we will send TERM_CMD if that is present. In any
1211 case, we collect all of the output into buf, and then wait for
1212 the normal prompt. */
1214 if (current_monitor
->getreg
.term
)
1216 monitor_debug ("EXP getreg.term\n");
1217 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1220 if (current_monitor
->getreg
.term_cmd
)
1222 monitor_debug ("EMIT getreg.term.cmd\n");
1223 monitor_printf (current_monitor
->getreg
.term_cmd
);
1225 if (!current_monitor
->getreg
.term
|| /* Already expected or */
1226 current_monitor
->getreg
.term_cmd
) /* ack expected */
1227 monitor_expect_prompt (NULL
, 0); /* get response */
1229 monitor_supply_register (regcache
, regno
, regbuf
);
1232 /* Sometimes, it takes several commands to dump the registers */
1233 /* This is a primitive for use by variations of monitor interfaces in
1234 case they need to compose the operation.
1237 monitor_dump_reg_block (struct regcache
*regcache
, char *block_cmd
)
1239 char buf
[TARGET_BUF_SIZE
];
1241 monitor_printf (block_cmd
);
1242 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1243 parse_register_dump (regcache
, buf
, resp_len
);
1248 /* Read the remote registers into the block regs. */
1249 /* Call the specific function if it has been provided */
1252 monitor_dump_regs (struct regcache
*regcache
)
1254 char buf
[TARGET_BUF_SIZE
];
1256 if (current_monitor
->dumpregs
)
1257 (*(current_monitor
->dumpregs
)) (regcache
); /* call supplied function */
1258 else if (current_monitor
->dump_registers
) /* default version */
1260 monitor_printf (current_monitor
->dump_registers
);
1261 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1262 parse_register_dump (regcache
, buf
, resp_len
);
1265 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check")); /* Need some way to read registers */
1269 monitor_fetch_registers (struct regcache
*regcache
, int regno
)
1271 monitor_debug ("MON fetchregs\n");
1272 if (current_monitor
->getreg
.cmd
)
1276 monitor_fetch_register (regcache
, regno
);
1280 for (regno
= 0; regno
< gdbarch_num_regs (current_gdbarch
); regno
++)
1281 monitor_fetch_register (regcache
, regno
);
1285 monitor_dump_regs (regcache
);
1289 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1292 monitor_store_register (struct regcache
*regcache
, int regno
)
1297 if (current_monitor
->regname
!= NULL
)
1298 name
= current_monitor
->regname (regno
);
1300 name
= current_monitor
->regnames
[regno
];
1302 if (!name
|| (*name
== '\0'))
1304 monitor_debug ("MON Cannot store unknown register\n");
1308 regcache_cooked_read_unsigned (regcache
, regno
, &val
);
1309 monitor_debug ("MON storeg %d %s\n", regno
,
1310 phex (val
, register_size (current_gdbarch
, regno
)));
1312 /* send the register deposit command */
1314 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1315 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1316 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1317 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1319 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1321 if (current_monitor
->setreg
.resp_delim
)
1323 monitor_debug ("EXP setreg.resp_delim\n");
1324 monitor_expect_regexp (&setreg_resp_delim_pattern
, NULL
, 0);
1325 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1326 monitor_printf ("%s\r", paddr_nz (val
));
1328 if (current_monitor
->setreg
.term
)
1330 monitor_debug ("EXP setreg.term\n");
1331 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1332 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1333 monitor_printf ("%s\r", paddr_nz (val
));
1334 monitor_expect_prompt (NULL
, 0);
1337 monitor_expect_prompt (NULL
, 0);
1338 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1340 monitor_debug ("EXP setreg_termcmd\n");
1341 monitor_printf ("%s", current_monitor
->setreg
.term_cmd
);
1342 monitor_expect_prompt (NULL
, 0);
1344 } /* monitor_store_register */
1346 /* Store the remote registers. */
1349 monitor_store_registers (struct regcache
*regcache
, int regno
)
1353 monitor_store_register (regcache
, regno
);
1357 for (regno
= 0; regno
< gdbarch_num_regs (current_gdbarch
); regno
++)
1358 monitor_store_register (regcache
, regno
);
1361 /* Get ready to modify the registers array. On machines which store
1362 individual registers, this doesn't need to do anything. On machines
1363 which store all the registers in one fell swoop, this makes sure
1364 that registers contains all the registers from the program being
1368 monitor_prepare_to_store (struct regcache
*regcache
)
1370 /* Do nothing, since we can store individual regs */
1374 monitor_files_info (struct target_ops
*ops
)
1376 printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name
, baud_rate
);
1380 monitor_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1382 unsigned int val
, hostval
;
1386 monitor_debug ("MON write %d %s\n", len
, paddr (memaddr
));
1388 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1389 memaddr
= gdbarch_addr_bits_remove (current_gdbarch
, memaddr
);
1391 /* Use memory fill command for leading 0 bytes. */
1393 if (current_monitor
->fill
)
1395 for (i
= 0; i
< len
; i
++)
1399 if (i
> 4) /* More than 4 zeros is worth doing */
1401 monitor_debug ("MON FILL %d\n", i
);
1402 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1403 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
) - 1, 0);
1405 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1407 monitor_expect_prompt (NULL
, 0);
1414 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1415 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1418 cmd
= current_monitor
->setmem
.cmdll
;
1422 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1425 cmd
= current_monitor
->setmem
.cmdl
;
1427 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1430 cmd
= current_monitor
->setmem
.cmdw
;
1435 cmd
= current_monitor
->setmem
.cmdb
;
1438 val
= extract_unsigned_integer (myaddr
, len
);
1442 hostval
= *(unsigned int *) myaddr
;
1443 monitor_debug ("Hostval(%08x) val(%08x)\n", hostval
, val
);
1447 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1448 monitor_printf_noecho (cmd
, memaddr
, val
);
1449 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1452 monitor_printf_noecho (cmd
, memaddr
);
1454 if (current_monitor
->setmem
.resp_delim
)
1456 monitor_debug ("EXP setmem.resp_delim");
1457 monitor_expect_regexp (&setmem_resp_delim_pattern
, NULL
, 0);
1458 monitor_printf ("%x\r", val
);
1460 if (current_monitor
->setmem
.term
)
1462 monitor_debug ("EXP setmem.term");
1463 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1464 monitor_printf ("%x\r", val
);
1466 if (current_monitor
->setmem
.term_cmd
)
1467 { /* Emit this to get out of the memory editing state */
1468 monitor_printf ("%s", current_monitor
->setmem
.term_cmd
);
1469 /* Drop through to expecting a prompt */
1473 monitor_printf (cmd
, memaddr
, val
);
1475 monitor_expect_prompt (NULL
, 0);
1482 monitor_write_memory_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
1488 /* Enter the sub mode */
1489 monitor_printf (current_monitor
->setmem
.cmdb
, memaddr
);
1490 monitor_expect_prompt (NULL
, 0);
1494 monitor_printf ("%x\r", val
);
1498 /* If we wanted to, here we could validate the address */
1499 monitor_expect_prompt (NULL
, 0);
1502 /* Now exit the sub mode */
1503 monitor_printf (current_monitor
->getreg
.term_cmd
);
1504 monitor_expect_prompt (NULL
, 0);
1510 longlongendswap (unsigned char *a
)
1519 *(a
+ i
) = *(a
+ j
);
1524 /* Format 32 chars of long long value, advance the pointer */
1525 static char *hexlate
= "0123456789abcdef";
1527 longlong_hexchars (unsigned long long value
,
1537 static unsigned char disbuf
[8]; /* disassembly buffer */
1538 unsigned char *scan
, *limit
; /* loop controls */
1539 unsigned char c
, nib
;
1544 unsigned long long *dp
;
1545 dp
= (unsigned long long *) scan
;
1548 longlongendswap (disbuf
); /* FIXME: ONly on big endian hosts */
1549 while (scan
< limit
)
1551 c
= *scan
++; /* a byte of our long long value */
1557 leadzero
= 0; /* henceforth we print even zeroes */
1559 nib
= c
>> 4; /* high nibble bits */
1560 *outbuff
++ = hexlate
[nib
];
1561 nib
= c
& 0x0f; /* low nibble bits */
1562 *outbuff
++ = hexlate
[nib
];
1566 } /* longlong_hexchars */
1570 /* I am only going to call this when writing virtual byte streams.
1571 Which possably entails endian conversions
1574 monitor_write_memory_longlongs (CORE_ADDR memaddr
, char *myaddr
, int len
)
1576 static char hexstage
[20]; /* At least 16 digits required, plus null */
1581 llptr
= (unsigned long long *) myaddr
;
1584 monitor_printf (current_monitor
->setmem
.cmdll
, memaddr
);
1585 monitor_expect_prompt (NULL
, 0);
1589 endstring
= longlong_hexchars (*llptr
, hexstage
);
1590 *endstring
= '\0'; /* NUll terminate for printf */
1591 monitor_printf ("%s\r", hexstage
);
1595 /* If we wanted to, here we could validate the address */
1596 monitor_expect_prompt (NULL
, 0);
1599 /* Now exit the sub mode */
1600 monitor_printf (current_monitor
->getreg
.term_cmd
);
1601 monitor_expect_prompt (NULL
, 0);
1607 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1608 /* This is for the large blocks of memory which may occur in downloading.
1609 And for monitors which use interactive entry,
1610 And for monitors which do not have other downloading methods.
1611 Without this, we will end up calling monitor_write_memory many times
1612 and do the entry and exit of the sub mode many times
1613 This currently assumes...
1614 MO_SETMEM_INTERACTIVE
1615 ! MO_NO_ECHO_ON_SETMEM
1616 To use this, the you have to patch the monitor_cmds block with
1617 this function. Otherwise, its not tuned up for use by all
1622 monitor_write_memory_block (CORE_ADDR memaddr
, char *myaddr
, int len
)
1626 /* FIXME: This would be a good place to put the zero test */
1628 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1630 return monitor_write_memory_longlongs (memaddr
, myaddr
, len
);
1633 written
= monitor_write_memory_bytes (memaddr
, myaddr
, len
);
1637 /* This is an alternate form of monitor_read_memory which is used for monitors
1638 which can only read a single byte/word/etc. at a time. */
1641 monitor_read_memory_single (CORE_ADDR memaddr
, char *myaddr
, int len
)
1644 char membuf
[sizeof (int) * 2 + 1];
1648 monitor_debug ("MON read single\n");
1650 /* Can't actually use long longs (nice idea, though). In fact, the
1651 call to strtoul below will fail if it tries to convert a value
1652 that's too big to fit in a long. */
1653 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1656 cmd
= current_monitor
->getmem
.cmdll
;
1660 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1663 cmd
= current_monitor
->getmem
.cmdl
;
1665 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1668 cmd
= current_monitor
->getmem
.cmdw
;
1673 cmd
= current_monitor
->getmem
.cmdb
;
1676 /* Send the examine command. */
1678 monitor_printf (cmd
, memaddr
);
1680 /* If RESP_DELIM is specified, we search for that as a leading
1681 delimiter for the memory value. Otherwise, we just start
1682 searching from the start of the buf. */
1684 if (current_monitor
->getmem
.resp_delim
)
1686 monitor_debug ("EXP getmem.resp_delim\n");
1687 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1690 /* Now, read the appropriate number of hex digits for this loc,
1693 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1694 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1698 c
= readchar (timeout
);
1700 c
= readchar (timeout
);
1701 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1704 monitor_error ("monitor_read_memory_single",
1705 "bad response from monitor",
1706 memaddr
, 0, NULL
, 0);
1711 for (i
= 0; i
< len
* 2; i
++)
1717 c
= readchar (timeout
);
1723 monitor_error ("monitor_read_memory_single",
1724 "bad response from monitor",
1725 memaddr
, i
, membuf
, 0);
1729 membuf
[i
] = '\000'; /* terminate the number */
1732 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1733 present), we will send TERM_CMD if that is present. In any case, we collect
1734 all of the output into buf, and then wait for the normal prompt. */
1736 if (current_monitor
->getmem
.term
)
1738 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1740 if (current_monitor
->getmem
.term_cmd
)
1742 monitor_printf (current_monitor
->getmem
.term_cmd
);
1743 monitor_expect_prompt (NULL
, 0);
1747 monitor_expect_prompt (NULL
, 0); /* get response */
1750 val
= strtoul (membuf
, &p
, 16);
1752 if (val
== 0 && membuf
== p
)
1753 monitor_error ("monitor_read_memory_single",
1754 "bad value from monitor",
1755 memaddr
, 0, membuf
, 0);
1757 /* supply register stores in target byte order, so swap here */
1759 store_unsigned_integer (myaddr
, len
, val
);
1764 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1765 memory at MEMADDR. Returns length moved. Currently, we do no more
1766 than 16 bytes at a time. */
1769 monitor_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1780 monitor_debug ("Zero length call to monitor_read_memory\n");
1784 monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
1785 paddr_nz (memaddr
), (long) myaddr
, len
);
1787 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1788 memaddr
= gdbarch_addr_bits_remove (current_gdbarch
, memaddr
);
1790 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1791 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1793 len
= min (len
, 16);
1795 /* Some dumpers align the first data with the preceeding 16
1796 byte boundary. Some print blanks and start at the
1797 requested boundary. EXACT_DUMPADDR
1800 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1801 ? memaddr
: memaddr
& ~0x0f;
1803 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1804 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1805 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1807 /* send the memory examine command */
1809 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1810 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
);
1811 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1812 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1814 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1816 /* If TERM is present, we wait for that to show up. Also, (if TERM
1817 is present), we will send TERM_CMD if that is present. In any
1818 case, we collect all of the output into buf, and then wait for
1819 the normal prompt. */
1821 if (current_monitor
->getmem
.term
)
1823 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1826 monitor_error ("monitor_read_memory",
1827 "excessive response from monitor",
1828 memaddr
, resp_len
, buf
, 0);
1830 if (current_monitor
->getmem
.term_cmd
)
1832 serial_write (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1833 strlen (current_monitor
->getmem
.term_cmd
));
1834 monitor_expect_prompt (NULL
, 0);
1838 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1842 /* If RESP_DELIM is specified, we search for that as a leading
1843 delimiter for the values. Otherwise, we just start searching
1844 from the start of the buf. */
1846 if (current_monitor
->getmem
.resp_delim
)
1849 struct re_registers resp_strings
;
1850 monitor_debug ("MON getmem.resp_delim %s\n", current_monitor
->getmem
.resp_delim
);
1852 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1854 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1858 monitor_error ("monitor_read_memory",
1859 "bad response from monitor",
1860 memaddr
, resp_len
, buf
, 0);
1862 p
+= resp_strings
.end
[0];
1864 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1866 monitor_error ("monitor_read_memory",
1867 "bad response from monitor",
1868 memaddr
, resp_len
, buf
, 0);
1869 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1872 monitor_debug ("MON scanning %d ,%lx '%s'\n", len
, (long) p
, p
);
1873 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1881 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1885 if ((dumpaddr
>= memaddr
) && (i
> 0))
1887 val
= fromhex (c
) * 16 + fromhex (*(p
+ 1));
1889 if (monitor_debug_p
|| remote_debug
)
1890 fprintf_unfiltered (gdb_stdlog
, "[%02x]", val
);
1897 ++p
; /* skip a blank or other non hex char */
1901 error (_("Failed to read via monitor"));
1902 if (monitor_debug_p
|| remote_debug
)
1903 fprintf_unfiltered (gdb_stdlog
, "\n");
1904 return fetched
; /* Return the number of bytes actually read */
1906 monitor_debug ("MON scanning bytes\n");
1908 for (i
= len
; i
> 0; i
--)
1910 /* Skip non-hex chars, but bomb on end of string and newlines */
1917 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1918 monitor_error ("monitor_read_memory",
1919 "badly terminated response from monitor",
1920 memaddr
, resp_len
, buf
, 0);
1924 val
= strtoul (p
, &p1
, 16);
1926 if (val
== 0 && p
== p1
)
1927 monitor_error ("monitor_read_memory",
1928 "bad value from monitor",
1929 memaddr
, resp_len
, buf
, 0);
1942 /* Transfer LEN bytes between target address MEMADDR and GDB address
1943 MYADDR. Returns 0 for success, errno code for failure. TARGET is
1947 monitor_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
1948 struct mem_attrib
*attrib
, struct target_ops
*target
)
1954 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
1955 res
= monitor_write_memory_block(memaddr
, myaddr
, len
);
1957 res
= monitor_write_memory(memaddr
, myaddr
, len
);
1961 res
= monitor_read_memory(memaddr
, myaddr
, len
);
1970 return; /* ignore attempts to kill target system */
1973 /* All we actually do is set the PC to the start address of exec_bfd. */
1976 monitor_create_inferior (char *exec_file
, char *args
, char **env
,
1979 if (args
&& (*args
!= '\000'))
1980 error (_("Args are not supported by the monitor."));
1983 clear_proceed_status ();
1984 write_pc (bfd_get_start_address (exec_bfd
));
1987 /* Clean up when a program exits.
1988 The program actually lives on in the remote processor's RAM, and may be
1989 run again without a download. Don't leave it full of breakpoint
1993 monitor_mourn_inferior (void)
1995 unpush_target (targ_ops
);
1996 generic_mourn_inferior (); /* Do all the proper things now */
1999 /* Tell the monitor to add a breakpoint. */
2002 monitor_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2004 CORE_ADDR addr
= bp_tgt
->placed_address
;
2006 const unsigned char *bp
;
2009 monitor_debug ("MON inst bkpt %s\n", paddr (addr
));
2010 if (current_monitor
->set_break
== NULL
)
2011 error (_("No set_break defined for this monitor"));
2013 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2014 addr
= gdbarch_addr_bits_remove (current_gdbarch
, addr
);
2016 /* Determine appropriate breakpoint size for this address. */
2017 bp
= gdbarch_breakpoint_from_pc (current_gdbarch
, &addr
, &bplen
);
2018 bp_tgt
->placed_address
= addr
;
2019 bp_tgt
->placed_size
= bplen
;
2021 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2023 if (breakaddr
[i
] == 0)
2025 breakaddr
[i
] = addr
;
2026 monitor_printf (current_monitor
->set_break
, addr
);
2027 monitor_expect_prompt (NULL
, 0);
2032 error (_("Too many breakpoints (> %d) for monitor."), current_monitor
->num_breakpoints
);
2035 /* Tell the monitor to remove a breakpoint. */
2038 monitor_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2040 CORE_ADDR addr
= bp_tgt
->placed_address
;
2043 monitor_debug ("MON rmbkpt %s\n", paddr (addr
));
2044 if (current_monitor
->clr_break
== NULL
)
2045 error (_("No clr_break defined for this monitor"));
2047 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2049 if (breakaddr
[i
] == addr
)
2052 /* some monitors remove breakpoints based on the address */
2053 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2054 monitor_printf (current_monitor
->clr_break
, addr
);
2055 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2056 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2058 monitor_printf (current_monitor
->clr_break
, i
);
2059 monitor_expect_prompt (NULL
, 0);
2063 fprintf_unfiltered (gdb_stderr
,
2064 "Can't find breakpoint associated with 0x%s\n",
2069 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2070 an S-record. Return non-zero if the ACK is received properly. */
2073 monitor_wait_srec_ack (void)
2077 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2079 return (readchar (timeout
) == '+');
2081 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2083 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2084 if ((ch
= readchar (1)) < 0)
2086 if ((ch
= readchar (1)) < 0)
2088 if ((ch
= readchar (1)) < 0)
2090 if ((ch
= readchar (1)) < 0)
2096 /* monitor_load -- download a file. */
2099 monitor_load (char *file
, int from_tty
)
2101 monitor_debug ("MON load\n");
2103 if (current_monitor
->load_routine
)
2104 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2106 { /* The default is ascii S-records */
2108 unsigned long load_offset
;
2111 /* enable user to specify address for downloading as 2nd arg to load */
2112 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2118 monitor_printf (current_monitor
->load
);
2119 if (current_monitor
->loadresp
)
2120 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2122 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2123 32, SREC_ALL
, hashmark
,
2124 current_monitor
->flags
& MO_SREC_ACK
?
2125 monitor_wait_srec_ack
: NULL
);
2127 monitor_expect_prompt (NULL
, 0);
2130 /* Finally, make the PC point at the start address */
2132 write_pc (bfd_get_start_address (exec_bfd
));
2134 /* There used to be code here which would clear inferior_ptid and
2135 call clear_symtab_users. None of that should be necessary:
2136 monitor targets should behave like remote protocol targets, and
2137 since generic_load does none of those things, this function
2140 Furthermore, clearing inferior_ptid is *incorrect*. After doing
2141 a load, we still have a valid connection to the monitor, with a
2142 live processor state to fiddle with. The user can type
2143 `continue' or `jump *start' and make the program run. If they do
2144 these things, however, GDB will be talking to a running program
2145 while inferior_ptid is null_ptid; this makes things like
2146 reinit_frame_cache very confused. */
2152 monitor_debug ("MON stop\n");
2153 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2154 serial_send_break (monitor_desc
);
2155 if (current_monitor
->stop
)
2156 monitor_printf_noecho (current_monitor
->stop
);
2159 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2160 in OUTPUT until the prompt is seen. FIXME: We read the characters
2161 ourseleves here cause of a nasty echo. */
2164 monitor_rcmd (char *command
,
2165 struct ui_file
*outbuf
)
2171 if (monitor_desc
== NULL
)
2172 error (_("monitor target not open."));
2174 p
= current_monitor
->prompt
;
2176 /* Send the command. Note that if no args were supplied, then we're
2177 just sending the monitor a newline, which is sometimes useful. */
2179 monitor_printf ("%s\r", (command
? command
: ""));
2181 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2183 fputs_unfiltered (buf
, outbuf
); /* Output the response */
2186 /* Convert hex digit A to a number. */
2192 if (a
>= '0' && a
<= '9')
2194 if (a
>= 'a' && a
<= 'f')
2195 return a
- 'a' + 10;
2196 if (a
>= 'A' && a
<= 'F')
2197 return a
- 'A' + 10;
2199 error (_("Reply contains invalid hex digit 0x%x"), a
);
2204 monitor_get_dev_name (void)
2209 static struct target_ops monitor_ops
;
2212 init_base_monitor_ops (void)
2214 monitor_ops
.to_close
= monitor_close
;
2215 monitor_ops
.to_detach
= monitor_detach
;
2216 monitor_ops
.to_resume
= monitor_resume
;
2217 monitor_ops
.to_wait
= monitor_wait
;
2218 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2219 monitor_ops
.to_store_registers
= monitor_store_registers
;
2220 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2221 monitor_ops
.deprecated_xfer_memory
= monitor_xfer_memory
;
2222 monitor_ops
.to_files_info
= monitor_files_info
;
2223 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2224 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2225 monitor_ops
.to_kill
= monitor_kill
;
2226 monitor_ops
.to_load
= monitor_load
;
2227 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2228 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2229 monitor_ops
.to_stop
= monitor_stop
;
2230 monitor_ops
.to_rcmd
= monitor_rcmd
;
2231 monitor_ops
.to_stratum
= process_stratum
;
2232 monitor_ops
.to_has_all_memory
= 1;
2233 monitor_ops
.to_has_memory
= 1;
2234 monitor_ops
.to_has_stack
= 1;
2235 monitor_ops
.to_has_registers
= 1;
2236 monitor_ops
.to_has_execution
= 1;
2237 monitor_ops
.to_magic
= OPS_MAGIC
;
2238 } /* init_base_monitor_ops */
2240 /* Init the target_ops structure pointed at by OPS */
2243 init_monitor_ops (struct target_ops
*ops
)
2245 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2246 init_base_monitor_ops ();
2248 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2251 /* Define additional commands that are usually only used by monitors. */
2253 extern initialize_file_ftype _initialize_remote_monitors
; /* -Wmissing-prototypes */
2256 _initialize_remote_monitors (void)
2258 init_base_monitor_ops ();
2259 add_setshow_boolean_cmd ("hash", no_class
, &hashmark
, _("\
2260 Set display of activity while downloading a file."), _("\
2261 Show display of activity while downloading a file."), _("\
2262 When enabled, a hashmark \'#\' is displayed."),
2264 NULL
, /* FIXME: i18n: */
2265 &setlist
, &showlist
);
2267 add_setshow_zinteger_cmd ("monitor", no_class
, &monitor_debug_p
, _("\
2268 Set debugging of remote monitor communication."), _("\
2269 Show debugging of remote monitor communication."), _("\
2270 When enabled, communication between GDB and the remote monitor\n\
2273 NULL
, /* FIXME: i18n: */
2274 &setdebuglist
, &showdebuglist
);