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, 2008, 2009 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"
57 #include "gdbthread.h"
59 static char *dev_name
;
60 static struct target_ops
*targ_ops
;
62 static void monitor_interrupt_query (void);
63 static void monitor_interrupt_twice (int);
64 static void monitor_stop (ptid_t
);
65 static void monitor_dump_regs (struct regcache
*regcache
);
68 static int from_hex (int a
);
71 static struct monitor_ops
*current_monitor
;
73 static int hashmark
; /* flag set by "set hash" */
75 static int timeout
= 30;
77 static int in_monitor_wait
= 0; /* Non-zero means we are in monitor_wait() */
79 static void (*ofunc
) (); /* Old SIGINT signal handler */
81 static CORE_ADDR
*breakaddr
;
83 /* Descriptor for I/O to remote machine. Initialize it to NULL so
84 that monitor_open knows that we don't have a file open when the
87 static struct serial
*monitor_desc
= NULL
;
89 /* Pointer to regexp pattern matching data */
91 static struct re_pattern_buffer register_pattern
;
92 static char register_fastmap
[256];
94 static struct re_pattern_buffer getmem_resp_delim_pattern
;
95 static char getmem_resp_delim_fastmap
[256];
97 static struct re_pattern_buffer setmem_resp_delim_pattern
;
98 static char setmem_resp_delim_fastmap
[256];
100 static struct re_pattern_buffer setreg_resp_delim_pattern
;
101 static char setreg_resp_delim_fastmap
[256];
103 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
104 monitor_wait wakes up. */
106 static int first_time
= 0; /* is this the first time we're executing after
107 gaving created the child proccess? */
110 /* This is the ptid we use while we're connected to a monitor. Its
111 value is arbitrary, as monitor targets don't have a notion of
112 processes or threads, but we need something non-null to place in
114 static ptid_t monitor_ptid
;
116 #define TARGET_BUF_SIZE 2048
118 /* Monitor specific debugging information. Typically only useful to
119 the developer of a new monitor interface. */
121 static void monitor_debug (const char *fmt
, ...) ATTR_FORMAT(printf
, 1, 2);
123 static int monitor_debug_p
= 0;
125 /* NOTE: This file alternates between monitor_debug_p and remote_debug
126 when determining if debug information is printed. Perhaps this
127 could be simplified. */
130 monitor_debug (const char *fmt
, ...)
135 va_start (args
, fmt
);
136 vfprintf_filtered (gdb_stdlog
, fmt
, args
);
142 /* Convert a string into a printable representation, Return # byte in
143 the new string. When LEN is >0 it specifies the size of the
144 string. Otherwize strlen(oldstr) is used. */
147 monitor_printable_string (char *newstr
, char *oldstr
, int len
)
153 len
= strlen (oldstr
);
155 for (i
= 0; i
< len
; i
++)
166 sprintf (newstr
, "\\x%02x", ch
& 0xff);
205 /* Print monitor errors with a string, converting the string to printable
209 monitor_error (char *function
, char *message
,
210 CORE_ADDR memaddr
, int len
, char *string
, int final_char
)
212 int real_len
= (len
== 0 && string
!= (char *) 0) ? strlen (string
) : len
;
213 char *safe_string
= alloca ((real_len
* 4) + 1);
214 monitor_printable_string (safe_string
, string
, real_len
);
217 error (_("%s (%s): %s: %s%c"),
218 function
, paddress (target_gdbarch
, memaddr
),
219 message
, safe_string
, final_char
);
221 error (_("%s (%s): %s: %s"),
222 function
, paddress (target_gdbarch
, memaddr
),
223 message
, safe_string
);
226 /* Convert hex digit A to a number. */
231 if (a
>= '0' && a
<= '9')
233 else if (a
>= 'a' && a
<= 'f')
235 else if (a
>= 'A' && a
<= 'F')
238 error (_("Invalid hex digit %d"), a
);
241 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
243 This function exists to get around the problem that many host platforms
244 don't have a printf that can print 64-bit addresses. The %A format
245 specification is recognized as a special case, and causes the argument
246 to be printed as a 64-bit hexadecimal address.
248 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
249 If it is a '%s' format, the argument is a string; otherwise the
250 argument is assumed to be a long integer.
252 %% is also turned into a single %.
256 monitor_vsprintf (char *sndbuf
, char *pattern
, va_list args
)
258 int addr_bit
= gdbarch_addr_bit (target_gdbarch
);
267 for (p
= pattern
; *p
; p
++)
271 /* Copy the format specifier to a separate buffer. */
273 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
276 format
[i
] = fmt
= *p
;
277 format
[i
+ 1] = '\0';
279 /* Fetch the next argument and print it. */
283 strcpy (sndbuf
, "%");
286 arg_addr
= va_arg (args
, CORE_ADDR
);
287 strcpy (sndbuf
, phex_nz (arg_addr
, addr_bit
/ 8));
290 arg_string
= va_arg (args
, char *);
291 sprintf (sndbuf
, format
, arg_string
);
294 arg_int
= va_arg (args
, long);
295 sprintf (sndbuf
, format
, arg_int
);
298 sndbuf
+= strlen (sndbuf
);
307 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
308 Works just like printf. */
311 monitor_printf_noecho (char *pattern
,...)
317 va_start (args
, pattern
);
319 monitor_vsprintf (sndbuf
, pattern
, args
);
321 len
= strlen (sndbuf
);
322 if (len
+ 1 > sizeof sndbuf
)
323 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
327 char *safe_string
= (char *) alloca ((strlen (sndbuf
) * 4) + 1);
328 monitor_printable_string (safe_string
, sndbuf
, 0);
329 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
332 monitor_write (sndbuf
, len
);
335 /* monitor_printf -- Send data to monitor and check the echo. Works just like
339 monitor_printf (char *pattern
,...)
345 va_start (args
, pattern
);
347 monitor_vsprintf (sndbuf
, pattern
, args
);
349 len
= strlen (sndbuf
);
350 if (len
+ 1 > sizeof sndbuf
)
351 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
355 char *safe_string
= (char *) alloca ((len
* 4) + 1);
356 monitor_printable_string (safe_string
, sndbuf
, 0);
357 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
360 monitor_write (sndbuf
, len
);
362 /* We used to expect that the next immediate output was the characters we
363 just output, but sometimes some extra junk appeared before the characters
364 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
365 So, just start searching for what we sent, and skip anything unknown. */
366 monitor_debug ("ExpectEcho\n");
367 monitor_expect (sndbuf
, (char *) 0, 0);
371 /* Write characters to the remote system. */
374 monitor_write (char *buf
, int buflen
)
376 if (serial_write (monitor_desc
, buf
, buflen
))
377 fprintf_unfiltered (gdb_stderr
, "serial_write failed: %s\n",
378 safe_strerror (errno
));
382 /* Read a binary character from the remote system, doing all the fancy
383 timeout stuff, but without interpreting the character in any way,
384 and without printing remote debug information. */
387 monitor_readchar (void)
395 c
= serial_readchar (monitor_desc
, timeout
);
398 c
&= 0xff; /* don't lose bit 7 */
405 if (c
== SERIAL_TIMEOUT
)
406 error (_("Timeout reading from remote system."));
408 perror_with_name (_("remote-monitor"));
412 /* Read a character from the remote system, doing all the fancy
416 readchar (int timeout
)
421 last_random
, last_nl
, last_cr
, last_crnl
429 c
= serial_readchar (monitor_desc
, timeout
);
434 /* This seems to interfere with proper function of the
436 if (monitor_debug_p
|| remote_debug
)
441 puts_debug ("read -->", buf
, "<--");
446 /* Canonicialize \n\r combinations into one \r */
447 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
449 if ((c
== '\r' && state
== last_nl
)
450 || (c
== '\n' && state
== last_cr
))
471 if (c
== SERIAL_TIMEOUT
)
473 /* I fail to see how detaching here can be useful */
474 if (in_monitor_wait
) /* Watchdog went off */
476 target_mourn_inferior ();
477 error (_("GDB serial timeout has expired. Target detached."));
481 error (_("Timeout reading from remote system."));
483 perror_with_name (_("remote-monitor"));
486 /* Scan input from the remote system, until STRING is found. If BUF is non-
487 zero, then collect input until we have collected either STRING or BUFLEN-1
488 chars. In either case we terminate BUF with a 0. If input overflows BUF
489 because STRING can't be found, return -1, else return number of chars in BUF
490 (minus the terminating NUL). Note that in the non-overflow case, STRING
491 will be at the end of BUF. */
494 monitor_expect (char *string
, char *buf
, int buflen
)
497 int obuflen
= buflen
;
502 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
503 monitor_printable_string (safe_string
, string
, 0);
504 fprintf_unfiltered (gdb_stdlog
, "MON Expecting '%s'\n", safe_string
);
519 c
= readchar (timeout
);
526 c
= readchar (timeout
);
528 /* Don't expect any ^C sent to be echoed */
530 if (*p
== '\003' || c
== *p
)
540 return obuflen
- buflen
;
548 /* We got a character that doesn't match the string. We need to
549 back up p, but how far? If we're looking for "..howdy" and the
550 monitor sends "...howdy"? There's certainly a match in there,
551 but when we receive the third ".", we won't find it if we just
552 restart the matching at the beginning of the string.
554 This is a Boyer-Moore kind of situation. We want to reset P to
555 the end of the longest prefix of STRING that is a suffix of
556 what we've read so far. In the example above, that would be
557 ".." --- the longest prefix of "..howdy" that is a suffix of
558 "...". This longest prefix could be the empty string, if C
559 is nowhere to be found in STRING.
561 If this longest prefix is not the empty string, it must contain
562 C, so let's search from the end of STRING for instances of C,
563 and see if the portion of STRING before that is a suffix of
564 what we read before C. Actually, we can search backwards from
565 p, since we know no prefix can be longer than that.
567 Note that we can use STRING itself, along with C, as a record
568 of what we've received so far. :) */
571 for (i
= (p
- string
) - 1; i
>= 0; i
--)
574 /* Is this prefix a suffix of what we've read so far?
576 string[0 .. i-1] == string[p - i, p - 1]? */
577 if (! memcmp (string
, p
- i
, i
))
589 /* Search for a regexp. */
592 monitor_expect_regexp (struct re_pattern_buffer
*pat
, char *buf
, int buflen
)
596 monitor_debug ("MON Expecting regexp\n");
601 mybuf
= alloca (TARGET_BUF_SIZE
);
602 buflen
= TARGET_BUF_SIZE
;
610 if (p
- mybuf
>= buflen
)
611 { /* Buffer about to overflow */
613 /* On overflow, we copy the upper half of the buffer to the lower half. Not
614 great, but it usually works... */
616 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
617 p
= mybuf
+ buflen
/ 2;
620 *p
++ = readchar (timeout
);
622 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
628 /* Keep discarding input until we see the MONITOR prompt.
630 The convention for dealing with the prompt is that you
632 o *then* wait for the prompt.
634 Thus the last thing that a procedure does with the serial line will
635 be an monitor_expect_prompt(). Exception: monitor_resume does not
636 wait for the prompt, because the terminal is being handed over to
637 the inferior. However, the next thing which happens after that is
638 a monitor_wait which does wait for the prompt. Note that this
639 includes abnormal exit, e.g. error(). This is necessary to prevent
640 getting into states from which we can't recover. */
643 monitor_expect_prompt (char *buf
, int buflen
)
645 monitor_debug ("MON Expecting prompt\n");
646 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
649 /* Get N 32-bit words from remote, each preceded by a space, and put
650 them in registers starting at REGNO. */
661 ch
= readchar (timeout
);
662 while (isspace (ch
));
666 for (i
= 7; i
>= 1; i
--)
668 ch
= readchar (timeout
);
671 val
= (val
<< 4) | from_hex (ch
);
679 compile_pattern (char *pattern
, struct re_pattern_buffer
*compiled_pattern
,
685 compiled_pattern
->fastmap
= fastmap
;
687 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
688 val
= re_compile_pattern (pattern
,
694 error (_("compile_pattern: Can't compile pattern string `%s': %s!"), pattern
, val
);
697 re_compile_fastmap (compiled_pattern
);
700 /* Open a connection to a remote debugger. NAME is the filename used
701 for communication. */
704 monitor_open (char *args
, struct monitor_ops
*mon_ops
, int from_tty
)
708 struct inferior
*inf
;
710 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
711 error (_("Magic number of monitor_ops struct wrong."));
713 targ_ops
= mon_ops
->target
;
714 name
= targ_ops
->to_shortname
;
717 error (_("Use `target %s DEVICE-NAME' to use a serial port, or \n\
718 `target %s HOST-NAME:PORT-NUMBER' to use a network connection."), name
, name
);
720 target_preopen (from_tty
);
722 /* Setup pattern for register dump */
724 if (mon_ops
->register_pattern
)
725 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
728 if (mon_ops
->getmem
.resp_delim
)
729 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
730 getmem_resp_delim_fastmap
);
732 if (mon_ops
->setmem
.resp_delim
)
733 compile_pattern (mon_ops
->setmem
.resp_delim
, &setmem_resp_delim_pattern
,
734 setmem_resp_delim_fastmap
);
736 if (mon_ops
->setreg
.resp_delim
)
737 compile_pattern (mon_ops
->setreg
.resp_delim
, &setreg_resp_delim_pattern
,
738 setreg_resp_delim_fastmap
);
740 unpush_target (targ_ops
);
744 dev_name
= xstrdup (args
);
746 monitor_desc
= serial_open (dev_name
);
749 perror_with_name (dev_name
);
753 if (serial_setbaudrate (monitor_desc
, baud_rate
))
755 serial_close (monitor_desc
);
756 perror_with_name (dev_name
);
760 serial_raw (monitor_desc
);
762 serial_flush_input (monitor_desc
);
764 /* some systems only work with 2 stop bits */
766 serial_setstopbits (monitor_desc
, mon_ops
->stopbits
);
768 current_monitor
= mon_ops
;
770 /* See if we can wake up the monitor. First, try sending a stop sequence,
771 then send the init strings. Last, remove all breakpoints. */
773 if (current_monitor
->stop
)
775 monitor_stop (inferior_ptid
);
776 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
778 monitor_debug ("EXP Open echo\n");
779 monitor_expect_prompt (NULL
, 0);
783 /* wake up the monitor and see if it's alive */
784 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
786 /* Some of the characters we send may not be echoed,
787 but we hope to get a prompt at the end of it all. */
789 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
792 monitor_printf_noecho (*p
);
793 monitor_expect_prompt (NULL
, 0);
796 serial_flush_input (monitor_desc
);
798 /* Alloc breakpoints */
799 if (mon_ops
->set_break
!= NULL
)
801 if (mon_ops
->num_breakpoints
== 0)
802 mon_ops
->num_breakpoints
= 8;
804 breakaddr
= (CORE_ADDR
*) xmalloc (mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
805 memset (breakaddr
, 0, mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
808 /* Remove all breakpoints */
810 if (mon_ops
->clr_all_break
)
812 monitor_printf (mon_ops
->clr_all_break
);
813 monitor_expect_prompt (NULL
, 0);
817 printf_unfiltered (_("Remote target %s connected to %s\n"), name
, dev_name
);
819 push_target (targ_ops
);
824 /* Make run command think we are busy... */
825 inferior_ptid
= monitor_ptid
;
826 inf
= current_inferior ();
827 inferior_appeared (inf
, ptid_get_pid (inferior_ptid
));
828 add_thread_silent (inferior_ptid
);
830 /* Give monitor_wait something to read */
832 monitor_printf (current_monitor
->line_term
);
834 start_remote (from_tty
);
837 /* Close out all files and local state before this target loses
841 monitor_close (int quitting
)
844 serial_close (monitor_desc
);
846 /* Free breakpoint memory */
847 if (breakaddr
!= NULL
)
855 delete_thread_silent (monitor_ptid
);
856 delete_inferior_silent (ptid_get_pid (monitor_ptid
));
859 /* Terminate the open connection to the remote debugger. Use this
860 when you want to detach and do something else with your gdb. */
863 monitor_detach (struct target_ops
*ops
, char *args
, int from_tty
)
865 pop_target (); /* calls monitor_close to do the real work */
867 printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname
);
870 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
873 monitor_supply_register (struct regcache
*regcache
, int regno
, char *valstr
)
875 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
876 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
878 unsigned char regbuf
[MAX_REGISTER_SIZE
];
883 while (p
&& *p
!= '\0')
885 if (*p
== '\r' || *p
== '\n')
896 if (!isxdigit (*p
) && *p
!= 'x')
902 val
+= fromhex (*p
++);
904 monitor_debug ("Supplying Register %d %s\n", regno
, valstr
);
906 if (val
== 0 && valstr
== p
)
907 error (_("monitor_supply_register (%d): bad value from monitor: %s."),
910 /* supply register stores in target byte order, so swap here */
912 store_unsigned_integer (regbuf
, register_size (gdbarch
, regno
), byte_order
,
915 regcache_raw_supply (regcache
, regno
, regbuf
);
920 /* Tell the remote machine to resume. */
923 monitor_resume (struct target_ops
*ops
,
924 ptid_t ptid
, int step
, enum target_signal sig
)
926 /* Some monitors require a different command when starting a program */
927 monitor_debug ("MON resume\n");
928 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
931 monitor_printf ("run\r");
932 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
937 monitor_printf (current_monitor
->step
);
940 if (current_monitor
->continue_hook
)
941 (*current_monitor
->continue_hook
) ();
943 monitor_printf (current_monitor
->cont
);
944 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
949 /* Parse the output of a register dump command. A monitor specific
950 regexp is used to extract individual register descriptions of the
951 form REG=VAL. Each description is split up into a name and a value
952 string which are passed down to monitor specific code. */
955 parse_register_dump (struct regcache
*regcache
, char *buf
, int len
)
957 monitor_debug ("MON Parsing register dump\n");
960 int regnamelen
, vallen
;
962 /* Element 0 points to start of register name, and element 1
963 points to the start of the register value. */
964 struct re_registers register_strings
;
966 memset (®ister_strings
, 0, sizeof (struct re_registers
));
968 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
969 ®ister_strings
) == -1)
972 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
973 regname
= buf
+ register_strings
.start
[1];
974 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
975 val
= buf
+ register_strings
.start
[2];
977 current_monitor
->supply_register (regcache
, regname
, regnamelen
,
980 buf
+= register_strings
.end
[0];
981 len
-= register_strings
.end
[0];
985 /* Send ^C to target to halt it. Target will respond, and send us a
989 monitor_interrupt (int signo
)
991 /* If this doesn't work, try more severe steps. */
992 signal (signo
, monitor_interrupt_twice
);
994 if (monitor_debug_p
|| remote_debug
)
995 fprintf_unfiltered (gdb_stdlog
, "monitor_interrupt called\n");
997 target_stop (inferior_ptid
);
1000 /* The user typed ^C twice. */
1003 monitor_interrupt_twice (int signo
)
1005 signal (signo
, ofunc
);
1007 monitor_interrupt_query ();
1009 signal (signo
, monitor_interrupt
);
1012 /* Ask the user what to do when an interrupt is received. */
1015 monitor_interrupt_query (void)
1017 target_terminal_ours ();
1019 if (query (_("Interrupted while waiting for the program.\n\
1020 Give up (and stop debugging it)? ")))
1022 target_mourn_inferior ();
1023 deprecated_throw_reason (RETURN_QUIT
);
1026 target_terminal_inferior ();
1030 monitor_wait_cleanup (void *old_timeout
)
1032 timeout
= *(int *) old_timeout
;
1033 signal (SIGINT
, ofunc
);
1034 in_monitor_wait
= 0;
1040 monitor_wait_filter (char *buf
,
1043 struct target_waitstatus
*status
)
1048 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1049 *ext_resp_len
= resp_len
;
1052 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1054 while (resp_len
< 0);
1056 /* Print any output characters that were preceded by ^O. */
1057 /* FIXME - This would be great as a user settabgle flag */
1058 if (monitor_debug_p
|| remote_debug
1059 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1063 for (i
= 0; i
< resp_len
- 1; i
++)
1065 putchar_unfiltered (buf
[++i
]);
1071 /* Wait until the remote machine stops, then return, storing status in
1072 status just as `wait' would. */
1075 monitor_wait (struct target_ops
*ops
,
1076 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1078 int old_timeout
= timeout
;
1079 char buf
[TARGET_BUF_SIZE
];
1081 struct cleanup
*old_chain
;
1083 status
->kind
= TARGET_WAITKIND_EXITED
;
1084 status
->value
.integer
= 0;
1086 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1087 monitor_debug ("MON wait\n");
1090 /* This is somthing other than a maintenance command */
1091 in_monitor_wait
= 1;
1092 timeout
= watchdog
> 0 ? watchdog
: -1;
1094 timeout
= -1; /* Don't time out -- user program is running. */
1097 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1099 if (current_monitor
->wait_filter
)
1100 (*current_monitor
->wait_filter
) (buf
, sizeof (buf
), &resp_len
, status
);
1102 monitor_wait_filter (buf
, sizeof (buf
), &resp_len
, status
);
1104 #if 0 /* Transferred to monitor wait filter */
1107 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1110 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1112 while (resp_len
< 0);
1114 /* Print any output characters that were preceded by ^O. */
1115 /* FIXME - This would be great as a user settabgle flag */
1116 if (monitor_debug_p
|| remote_debug
1117 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1121 for (i
= 0; i
< resp_len
- 1; i
++)
1123 putchar_unfiltered (buf
[++i
]);
1127 signal (SIGINT
, ofunc
);
1129 timeout
= old_timeout
;
1131 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1134 monitor_printf (current_monitor
->dump_registers
);
1135 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1138 if (current_monitor
->register_pattern
)
1139 parse_register_dump (get_current_regcache (), buf
, resp_len
);
1141 monitor_debug ("Wait fetching registers after stop\n");
1142 monitor_dump_regs (get_current_regcache ());
1145 status
->kind
= TARGET_WAITKIND_STOPPED
;
1146 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1148 discard_cleanups (old_chain
);
1150 in_monitor_wait
= 0;
1152 return inferior_ptid
;
1155 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1159 monitor_fetch_register (struct regcache
*regcache
, int regno
)
1166 regbuf
= alloca (MAX_REGISTER_SIZE
* 2 + 1);
1167 zerobuf
= alloca (MAX_REGISTER_SIZE
);
1168 memset (zerobuf
, 0, MAX_REGISTER_SIZE
);
1170 if (current_monitor
->regname
!= NULL
)
1171 name
= current_monitor
->regname (regno
);
1173 name
= current_monitor
->regnames
[regno
];
1174 monitor_debug ("MON fetchreg %d '%s'\n", regno
, name
? name
: "(null name)");
1176 if (!name
|| (*name
== '\0'))
1178 monitor_debug ("No register known for %d\n", regno
);
1179 regcache_raw_supply (regcache
, regno
, zerobuf
);
1183 /* send the register examine command */
1185 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1187 /* If RESP_DELIM is specified, we search for that as a leading
1188 delimiter for the register value. Otherwise, we just start
1189 searching from the start of the buf. */
1191 if (current_monitor
->getreg
.resp_delim
)
1193 monitor_debug ("EXP getreg.resp_delim\n");
1194 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1195 /* Handle case of first 32 registers listed in pairs. */
1196 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1197 && (regno
& 1) != 0 && regno
< 32)
1199 monitor_debug ("EXP getreg.resp_delim\n");
1200 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1204 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1205 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1208 c
= readchar (timeout
);
1210 c
= readchar (timeout
);
1211 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1214 error (_("Bad value returned from monitor while fetching register %x."),
1218 /* Read upto the maximum number of hex digits for this register, skipping
1219 spaces, but stop reading if something else is seen. Some monitors
1220 like to drop leading zeros. */
1222 for (i
= 0; i
< register_size (get_regcache_arch (regcache
), regno
) * 2; i
++)
1225 c
= readchar (timeout
);
1227 c
= readchar (timeout
);
1235 regbuf
[i
] = '\000'; /* terminate the number */
1236 monitor_debug ("REGVAL '%s'\n", regbuf
);
1238 /* If TERM is present, we wait for that to show up. Also, (if TERM
1239 is present), we will send TERM_CMD if that is present. In any
1240 case, we collect all of the output into buf, and then wait for
1241 the normal prompt. */
1243 if (current_monitor
->getreg
.term
)
1245 monitor_debug ("EXP getreg.term\n");
1246 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1249 if (current_monitor
->getreg
.term_cmd
)
1251 monitor_debug ("EMIT getreg.term.cmd\n");
1252 monitor_printf (current_monitor
->getreg
.term_cmd
);
1254 if (!current_monitor
->getreg
.term
|| /* Already expected or */
1255 current_monitor
->getreg
.term_cmd
) /* ack expected */
1256 monitor_expect_prompt (NULL
, 0); /* get response */
1258 monitor_supply_register (regcache
, regno
, regbuf
);
1261 /* Sometimes, it takes several commands to dump the registers */
1262 /* This is a primitive for use by variations of monitor interfaces in
1263 case they need to compose the operation.
1266 monitor_dump_reg_block (struct regcache
*regcache
, char *block_cmd
)
1268 char buf
[TARGET_BUF_SIZE
];
1270 monitor_printf (block_cmd
);
1271 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1272 parse_register_dump (regcache
, buf
, resp_len
);
1277 /* Read the remote registers into the block regs. */
1278 /* Call the specific function if it has been provided */
1281 monitor_dump_regs (struct regcache
*regcache
)
1283 char buf
[TARGET_BUF_SIZE
];
1285 if (current_monitor
->dumpregs
)
1286 (*(current_monitor
->dumpregs
)) (regcache
); /* call supplied function */
1287 else if (current_monitor
->dump_registers
) /* default version */
1289 monitor_printf (current_monitor
->dump_registers
);
1290 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1291 parse_register_dump (regcache
, buf
, resp_len
);
1294 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check")); /* Need some way to read registers */
1298 monitor_fetch_registers (struct target_ops
*ops
,
1299 struct regcache
*regcache
, int regno
)
1301 monitor_debug ("MON fetchregs\n");
1302 if (current_monitor
->getreg
.cmd
)
1306 monitor_fetch_register (regcache
, regno
);
1310 for (regno
= 0; regno
< gdbarch_num_regs (get_regcache_arch (regcache
));
1312 monitor_fetch_register (regcache
, regno
);
1316 monitor_dump_regs (regcache
);
1320 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1323 monitor_store_register (struct regcache
*regcache
, int regno
)
1325 int reg_size
= register_size (get_regcache_arch (regcache
), regno
);
1329 if (current_monitor
->regname
!= NULL
)
1330 name
= current_monitor
->regname (regno
);
1332 name
= current_monitor
->regnames
[regno
];
1334 if (!name
|| (*name
== '\0'))
1336 monitor_debug ("MON Cannot store unknown register\n");
1340 regcache_cooked_read_unsigned (regcache
, regno
, &val
);
1341 monitor_debug ("MON storeg %d %s\n", regno
, phex (val
, reg_size
));
1343 /* send the register deposit command */
1345 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1346 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1347 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1348 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1350 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1352 if (current_monitor
->setreg
.resp_delim
)
1354 monitor_debug ("EXP setreg.resp_delim\n");
1355 monitor_expect_regexp (&setreg_resp_delim_pattern
, NULL
, 0);
1356 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1357 monitor_printf ("%s\r", phex_nz (val
, reg_size
));
1359 if (current_monitor
->setreg
.term
)
1361 monitor_debug ("EXP setreg.term\n");
1362 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1363 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1364 monitor_printf ("%s\r", phex_nz (val
, reg_size
));
1365 monitor_expect_prompt (NULL
, 0);
1368 monitor_expect_prompt (NULL
, 0);
1369 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1371 monitor_debug ("EXP setreg_termcmd\n");
1372 monitor_printf ("%s", current_monitor
->setreg
.term_cmd
);
1373 monitor_expect_prompt (NULL
, 0);
1375 } /* monitor_store_register */
1377 /* Store the remote registers. */
1380 monitor_store_registers (struct target_ops
*ops
,
1381 struct regcache
*regcache
, int regno
)
1385 monitor_store_register (regcache
, regno
);
1389 for (regno
= 0; regno
< gdbarch_num_regs (get_regcache_arch (regcache
));
1391 monitor_store_register (regcache
, regno
);
1394 /* Get ready to modify the registers array. On machines which store
1395 individual registers, this doesn't need to do anything. On machines
1396 which store all the registers in one fell swoop, this makes sure
1397 that registers contains all the registers from the program being
1401 monitor_prepare_to_store (struct regcache
*regcache
)
1403 /* Do nothing, since we can store individual regs */
1407 monitor_files_info (struct target_ops
*ops
)
1409 printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name
, baud_rate
);
1413 monitor_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1415 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
1416 unsigned int val
, hostval
;
1420 monitor_debug ("MON write %d %s\n", len
, paddress (target_gdbarch
, memaddr
));
1422 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1423 memaddr
= gdbarch_addr_bits_remove (target_gdbarch
, memaddr
);
1425 /* Use memory fill command for leading 0 bytes. */
1427 if (current_monitor
->fill
)
1429 for (i
= 0; i
< len
; i
++)
1433 if (i
> 4) /* More than 4 zeros is worth doing */
1435 monitor_debug ("MON FILL %d\n", i
);
1436 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1437 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
) - 1, 0);
1439 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1441 monitor_expect_prompt (NULL
, 0);
1448 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1449 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1452 cmd
= current_monitor
->setmem
.cmdll
;
1456 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1459 cmd
= current_monitor
->setmem
.cmdl
;
1461 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1464 cmd
= current_monitor
->setmem
.cmdw
;
1469 cmd
= current_monitor
->setmem
.cmdb
;
1472 val
= extract_unsigned_integer (myaddr
, len
, byte_order
);
1476 hostval
= *(unsigned int *) myaddr
;
1477 monitor_debug ("Hostval(%08x) val(%08x)\n", hostval
, val
);
1481 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1482 monitor_printf_noecho (cmd
, memaddr
, val
);
1483 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1486 monitor_printf_noecho (cmd
, memaddr
);
1488 if (current_monitor
->setmem
.resp_delim
)
1490 monitor_debug ("EXP setmem.resp_delim");
1491 monitor_expect_regexp (&setmem_resp_delim_pattern
, NULL
, 0);
1492 monitor_printf ("%x\r", val
);
1494 if (current_monitor
->setmem
.term
)
1496 monitor_debug ("EXP setmem.term");
1497 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1498 monitor_printf ("%x\r", val
);
1500 if (current_monitor
->setmem
.term_cmd
)
1501 { /* Emit this to get out of the memory editing state */
1502 monitor_printf ("%s", current_monitor
->setmem
.term_cmd
);
1503 /* Drop through to expecting a prompt */
1507 monitor_printf (cmd
, memaddr
, val
);
1509 monitor_expect_prompt (NULL
, 0);
1516 monitor_write_memory_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
1522 /* Enter the sub mode */
1523 monitor_printf (current_monitor
->setmem
.cmdb
, memaddr
);
1524 monitor_expect_prompt (NULL
, 0);
1528 monitor_printf ("%x\r", val
);
1532 /* If we wanted to, here we could validate the address */
1533 monitor_expect_prompt (NULL
, 0);
1536 /* Now exit the sub mode */
1537 monitor_printf (current_monitor
->getreg
.term_cmd
);
1538 monitor_expect_prompt (NULL
, 0);
1544 longlongendswap (unsigned char *a
)
1553 *(a
+ i
) = *(a
+ j
);
1558 /* Format 32 chars of long long value, advance the pointer */
1559 static char *hexlate
= "0123456789abcdef";
1561 longlong_hexchars (unsigned long long value
,
1571 static unsigned char disbuf
[8]; /* disassembly buffer */
1572 unsigned char *scan
, *limit
; /* loop controls */
1573 unsigned char c
, nib
;
1578 unsigned long long *dp
;
1579 dp
= (unsigned long long *) scan
;
1582 longlongendswap (disbuf
); /* FIXME: ONly on big endian hosts */
1583 while (scan
< limit
)
1585 c
= *scan
++; /* a byte of our long long value */
1591 leadzero
= 0; /* henceforth we print even zeroes */
1593 nib
= c
>> 4; /* high nibble bits */
1594 *outbuff
++ = hexlate
[nib
];
1595 nib
= c
& 0x0f; /* low nibble bits */
1596 *outbuff
++ = hexlate
[nib
];
1600 } /* longlong_hexchars */
1604 /* I am only going to call this when writing virtual byte streams.
1605 Which possably entails endian conversions
1608 monitor_write_memory_longlongs (CORE_ADDR memaddr
, char *myaddr
, int len
)
1610 static char hexstage
[20]; /* At least 16 digits required, plus null */
1615 llptr
= (unsigned long long *) myaddr
;
1618 monitor_printf (current_monitor
->setmem
.cmdll
, memaddr
);
1619 monitor_expect_prompt (NULL
, 0);
1623 endstring
= longlong_hexchars (*llptr
, hexstage
);
1624 *endstring
= '\0'; /* NUll terminate for printf */
1625 monitor_printf ("%s\r", hexstage
);
1629 /* If we wanted to, here we could validate the address */
1630 monitor_expect_prompt (NULL
, 0);
1633 /* Now exit the sub mode */
1634 monitor_printf (current_monitor
->getreg
.term_cmd
);
1635 monitor_expect_prompt (NULL
, 0);
1641 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1642 /* This is for the large blocks of memory which may occur in downloading.
1643 And for monitors which use interactive entry,
1644 And for monitors which do not have other downloading methods.
1645 Without this, we will end up calling monitor_write_memory many times
1646 and do the entry and exit of the sub mode many times
1647 This currently assumes...
1648 MO_SETMEM_INTERACTIVE
1649 ! MO_NO_ECHO_ON_SETMEM
1650 To use this, the you have to patch the monitor_cmds block with
1651 this function. Otherwise, its not tuned up for use by all
1656 monitor_write_memory_block (CORE_ADDR memaddr
, char *myaddr
, int len
)
1660 /* FIXME: This would be a good place to put the zero test */
1662 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1664 return monitor_write_memory_longlongs (memaddr
, myaddr
, len
);
1667 written
= monitor_write_memory_bytes (memaddr
, myaddr
, len
);
1671 /* This is an alternate form of monitor_read_memory which is used for monitors
1672 which can only read a single byte/word/etc. at a time. */
1675 monitor_read_memory_single (CORE_ADDR memaddr
, char *myaddr
, int len
)
1677 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
1679 char membuf
[sizeof (int) * 2 + 1];
1683 monitor_debug ("MON read single\n");
1685 /* Can't actually use long longs (nice idea, though). In fact, the
1686 call to strtoul below will fail if it tries to convert a value
1687 that's too big to fit in a long. */
1688 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1691 cmd
= current_monitor
->getmem
.cmdll
;
1695 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1698 cmd
= current_monitor
->getmem
.cmdl
;
1700 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1703 cmd
= current_monitor
->getmem
.cmdw
;
1708 cmd
= current_monitor
->getmem
.cmdb
;
1711 /* Send the examine command. */
1713 monitor_printf (cmd
, memaddr
);
1715 /* If RESP_DELIM is specified, we search for that as a leading
1716 delimiter for the memory value. Otherwise, we just start
1717 searching from the start of the buf. */
1719 if (current_monitor
->getmem
.resp_delim
)
1721 monitor_debug ("EXP getmem.resp_delim\n");
1722 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1725 /* Now, read the appropriate number of hex digits for this loc,
1728 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1729 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1733 c
= readchar (timeout
);
1735 c
= readchar (timeout
);
1736 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1739 monitor_error ("monitor_read_memory_single",
1740 "bad response from monitor",
1741 memaddr
, 0, NULL
, 0);
1746 for (i
= 0; i
< len
* 2; i
++)
1752 c
= readchar (timeout
);
1758 monitor_error ("monitor_read_memory_single",
1759 "bad response from monitor",
1760 memaddr
, i
, membuf
, 0);
1764 membuf
[i
] = '\000'; /* terminate the number */
1767 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1768 present), we will send TERM_CMD if that is present. In any case, we collect
1769 all of the output into buf, and then wait for the normal prompt. */
1771 if (current_monitor
->getmem
.term
)
1773 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1775 if (current_monitor
->getmem
.term_cmd
)
1777 monitor_printf (current_monitor
->getmem
.term_cmd
);
1778 monitor_expect_prompt (NULL
, 0);
1782 monitor_expect_prompt (NULL
, 0); /* get response */
1785 val
= strtoul (membuf
, &p
, 16);
1787 if (val
== 0 && membuf
== p
)
1788 monitor_error ("monitor_read_memory_single",
1789 "bad value from monitor",
1790 memaddr
, 0, membuf
, 0);
1792 /* supply register stores in target byte order, so swap here */
1794 store_unsigned_integer (myaddr
, len
, byte_order
, val
);
1799 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1800 memory at MEMADDR. Returns length moved. Currently, we do no more
1801 than 16 bytes at a time. */
1804 monitor_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1815 monitor_debug ("Zero length call to monitor_read_memory\n");
1819 monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
1820 paddress (target_gdbarch
, memaddr
), (long) myaddr
, len
);
1822 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1823 memaddr
= gdbarch_addr_bits_remove (target_gdbarch
, memaddr
);
1825 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1826 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1828 len
= min (len
, 16);
1830 /* Some dumpers align the first data with the preceeding 16
1831 byte boundary. Some print blanks and start at the
1832 requested boundary. EXACT_DUMPADDR
1835 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1836 ? memaddr
: memaddr
& ~0x0f;
1838 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1839 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1840 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1842 /* send the memory examine command */
1844 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1845 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
);
1846 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1847 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1849 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1851 /* If TERM is present, we wait for that to show up. Also, (if TERM
1852 is present), we will send TERM_CMD if that is present. In any
1853 case, we collect all of the output into buf, and then wait for
1854 the normal prompt. */
1856 if (current_monitor
->getmem
.term
)
1858 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1861 monitor_error ("monitor_read_memory",
1862 "excessive response from monitor",
1863 memaddr
, resp_len
, buf
, 0);
1865 if (current_monitor
->getmem
.term_cmd
)
1867 serial_write (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1868 strlen (current_monitor
->getmem
.term_cmd
));
1869 monitor_expect_prompt (NULL
, 0);
1873 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1877 /* If RESP_DELIM is specified, we search for that as a leading
1878 delimiter for the values. Otherwise, we just start searching
1879 from the start of the buf. */
1881 if (current_monitor
->getmem
.resp_delim
)
1884 struct re_registers resp_strings
;
1885 monitor_debug ("MON getmem.resp_delim %s\n", current_monitor
->getmem
.resp_delim
);
1887 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1889 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1893 monitor_error ("monitor_read_memory",
1894 "bad response from monitor",
1895 memaddr
, resp_len
, buf
, 0);
1897 p
+= resp_strings
.end
[0];
1899 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1901 monitor_error ("monitor_read_memory",
1902 "bad response from monitor",
1903 memaddr
, resp_len
, buf
, 0);
1904 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1907 monitor_debug ("MON scanning %d ,%lx '%s'\n", len
, (long) p
, p
);
1908 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1916 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1920 if ((dumpaddr
>= memaddr
) && (i
> 0))
1922 val
= fromhex (c
) * 16 + fromhex (*(p
+ 1));
1924 if (monitor_debug_p
|| remote_debug
)
1925 fprintf_unfiltered (gdb_stdlog
, "[%02x]", val
);
1932 ++p
; /* skip a blank or other non hex char */
1936 error (_("Failed to read via monitor"));
1937 if (monitor_debug_p
|| remote_debug
)
1938 fprintf_unfiltered (gdb_stdlog
, "\n");
1939 return fetched
; /* Return the number of bytes actually read */
1941 monitor_debug ("MON scanning bytes\n");
1943 for (i
= len
; i
> 0; i
--)
1945 /* Skip non-hex chars, but bomb on end of string and newlines */
1952 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1953 monitor_error ("monitor_read_memory",
1954 "badly terminated response from monitor",
1955 memaddr
, resp_len
, buf
, 0);
1959 val
= strtoul (p
, &p1
, 16);
1961 if (val
== 0 && p
== p1
)
1962 monitor_error ("monitor_read_memory",
1963 "bad value from monitor",
1964 memaddr
, resp_len
, buf
, 0);
1977 /* Transfer LEN bytes between target address MEMADDR and GDB address
1978 MYADDR. Returns 0 for success, errno code for failure. TARGET is
1982 monitor_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
1983 struct mem_attrib
*attrib
, struct target_ops
*target
)
1989 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
1990 res
= monitor_write_memory_block(memaddr
, myaddr
, len
);
1992 res
= monitor_write_memory(memaddr
, myaddr
, len
);
1996 res
= monitor_read_memory(memaddr
, myaddr
, len
);
2003 monitor_kill (struct target_ops
*ops
)
2005 return; /* ignore attempts to kill target system */
2008 /* All we actually do is set the PC to the start address of exec_bfd. */
2011 monitor_create_inferior (struct target_ops
*ops
, char *exec_file
,
2012 char *args
, char **env
, int from_tty
)
2014 if (args
&& (*args
!= '\000'))
2015 error (_("Args are not supported by the monitor."));
2018 clear_proceed_status ();
2019 regcache_write_pc (get_current_regcache (),
2020 bfd_get_start_address (exec_bfd
));
2023 /* Clean up when a program exits.
2024 The program actually lives on in the remote processor's RAM, and may be
2025 run again without a download. Don't leave it full of breakpoint
2029 monitor_mourn_inferior (struct target_ops
*ops
)
2031 unpush_target (targ_ops
);
2032 generic_mourn_inferior (); /* Do all the proper things now */
2033 delete_thread_silent (monitor_ptid
);
2036 /* Tell the monitor to add a breakpoint. */
2039 monitor_insert_breakpoint (struct gdbarch
*gdbarch
,
2040 struct bp_target_info
*bp_tgt
)
2042 CORE_ADDR addr
= bp_tgt
->placed_address
;
2046 monitor_debug ("MON inst bkpt %s\n", paddress (gdbarch
, addr
));
2047 if (current_monitor
->set_break
== NULL
)
2048 error (_("No set_break defined for this monitor"));
2050 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2051 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
2053 /* Determine appropriate breakpoint size for this address. */
2054 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bplen
);
2055 bp_tgt
->placed_address
= addr
;
2056 bp_tgt
->placed_size
= bplen
;
2058 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2060 if (breakaddr
[i
] == 0)
2062 breakaddr
[i
] = addr
;
2063 monitor_printf (current_monitor
->set_break
, addr
);
2064 monitor_expect_prompt (NULL
, 0);
2069 error (_("Too many breakpoints (> %d) for monitor."), current_monitor
->num_breakpoints
);
2072 /* Tell the monitor to remove a breakpoint. */
2075 monitor_remove_breakpoint (struct gdbarch
*gdbarch
,
2076 struct bp_target_info
*bp_tgt
)
2078 CORE_ADDR addr
= bp_tgt
->placed_address
;
2081 monitor_debug ("MON rmbkpt %s\n", paddress (gdbarch
, addr
));
2082 if (current_monitor
->clr_break
== NULL
)
2083 error (_("No clr_break defined for this monitor"));
2085 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2087 if (breakaddr
[i
] == addr
)
2090 /* some monitors remove breakpoints based on the address */
2091 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2092 monitor_printf (current_monitor
->clr_break
, addr
);
2093 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2094 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2096 monitor_printf (current_monitor
->clr_break
, i
);
2097 monitor_expect_prompt (NULL
, 0);
2101 fprintf_unfiltered (gdb_stderr
,
2102 "Can't find breakpoint associated with %s\n",
2103 paddress (gdbarch
, addr
));
2107 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2108 an S-record. Return non-zero if the ACK is received properly. */
2111 monitor_wait_srec_ack (void)
2115 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2117 return (readchar (timeout
) == '+');
2119 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2121 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2122 if ((ch
= readchar (1)) < 0)
2124 if ((ch
= readchar (1)) < 0)
2126 if ((ch
= readchar (1)) < 0)
2128 if ((ch
= readchar (1)) < 0)
2134 /* monitor_load -- download a file. */
2137 monitor_load (char *file
, int from_tty
)
2139 monitor_debug ("MON load\n");
2141 if (current_monitor
->load_routine
)
2142 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2144 { /* The default is ascii S-records */
2146 unsigned long load_offset
;
2149 /* enable user to specify address for downloading as 2nd arg to load */
2150 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2156 monitor_printf (current_monitor
->load
);
2157 if (current_monitor
->loadresp
)
2158 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2160 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2161 32, SREC_ALL
, hashmark
,
2162 current_monitor
->flags
& MO_SREC_ACK
?
2163 monitor_wait_srec_ack
: NULL
);
2165 monitor_expect_prompt (NULL
, 0);
2168 /* Finally, make the PC point at the start address */
2170 regcache_write_pc (get_current_regcache (),
2171 bfd_get_start_address (exec_bfd
));
2173 /* There used to be code here which would clear inferior_ptid and
2174 call clear_symtab_users. None of that should be necessary:
2175 monitor targets should behave like remote protocol targets, and
2176 since generic_load does none of those things, this function
2179 Furthermore, clearing inferior_ptid is *incorrect*. After doing
2180 a load, we still have a valid connection to the monitor, with a
2181 live processor state to fiddle with. The user can type
2182 `continue' or `jump *start' and make the program run. If they do
2183 these things, however, GDB will be talking to a running program
2184 while inferior_ptid is null_ptid; this makes things like
2185 reinit_frame_cache very confused. */
2189 monitor_stop (ptid_t ptid
)
2191 monitor_debug ("MON stop\n");
2192 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2193 serial_send_break (monitor_desc
);
2194 if (current_monitor
->stop
)
2195 monitor_printf_noecho (current_monitor
->stop
);
2198 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2199 in OUTPUT until the prompt is seen. FIXME: We read the characters
2200 ourseleves here cause of a nasty echo. */
2203 monitor_rcmd (char *command
,
2204 struct ui_file
*outbuf
)
2210 if (monitor_desc
== NULL
)
2211 error (_("monitor target not open."));
2213 p
= current_monitor
->prompt
;
2215 /* Send the command. Note that if no args were supplied, then we're
2216 just sending the monitor a newline, which is sometimes useful. */
2218 monitor_printf ("%s\r", (command
? command
: ""));
2220 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2222 fputs_unfiltered (buf
, outbuf
); /* Output the response */
2225 /* Convert hex digit A to a number. */
2231 if (a
>= '0' && a
<= '9')
2233 if (a
>= 'a' && a
<= 'f')
2234 return a
- 'a' + 10;
2235 if (a
>= 'A' && a
<= 'F')
2236 return a
- 'A' + 10;
2238 error (_("Reply contains invalid hex digit 0x%x"), a
);
2243 monitor_get_dev_name (void)
2248 /* Check to see if a thread is still alive. */
2251 monitor_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2253 if (ptid_equal (ptid
, monitor_ptid
))
2254 /* The monitor's task is always alive. */
2260 /* Convert a thread ID to a string. Returns the string in a static
2264 monitor_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2266 static char buf
[64];
2268 if (ptid_equal (monitor_ptid
, ptid
))
2270 xsnprintf (buf
, sizeof buf
, "Thread <main>");
2274 return normal_pid_to_str (ptid
);
2277 static struct target_ops monitor_ops
;
2280 init_base_monitor_ops (void)
2282 monitor_ops
.to_close
= monitor_close
;
2283 monitor_ops
.to_detach
= monitor_detach
;
2284 monitor_ops
.to_resume
= monitor_resume
;
2285 monitor_ops
.to_wait
= monitor_wait
;
2286 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2287 monitor_ops
.to_store_registers
= monitor_store_registers
;
2288 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2289 monitor_ops
.deprecated_xfer_memory
= monitor_xfer_memory
;
2290 monitor_ops
.to_files_info
= monitor_files_info
;
2291 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2292 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2293 monitor_ops
.to_kill
= monitor_kill
;
2294 monitor_ops
.to_load
= monitor_load
;
2295 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2296 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2297 monitor_ops
.to_stop
= monitor_stop
;
2298 monitor_ops
.to_rcmd
= monitor_rcmd
;
2299 monitor_ops
.to_log_command
= serial_log_command
;
2300 monitor_ops
.to_thread_alive
= monitor_thread_alive
;
2301 monitor_ops
.to_pid_to_str
= monitor_pid_to_str
;
2302 monitor_ops
.to_stratum
= process_stratum
;
2303 monitor_ops
.to_has_all_memory
= default_child_has_all_memory
;
2304 monitor_ops
.to_has_memory
= default_child_has_memory
;
2305 monitor_ops
.to_has_stack
= default_child_has_stack
;
2306 monitor_ops
.to_has_registers
= default_child_has_registers
;
2307 monitor_ops
.to_has_execution
= default_child_has_execution
;
2308 monitor_ops
.to_magic
= OPS_MAGIC
;
2309 } /* init_base_monitor_ops */
2311 /* Init the target_ops structure pointed at by OPS */
2314 init_monitor_ops (struct target_ops
*ops
)
2316 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2317 init_base_monitor_ops ();
2319 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2322 /* Define additional commands that are usually only used by monitors. */
2324 extern initialize_file_ftype _initialize_remote_monitors
; /* -Wmissing-prototypes */
2327 _initialize_remote_monitors (void)
2329 init_base_monitor_ops ();
2330 add_setshow_boolean_cmd ("hash", no_class
, &hashmark
, _("\
2331 Set display of activity while downloading a file."), _("\
2332 Show display of activity while downloading a file."), _("\
2333 When enabled, a hashmark \'#\' is displayed."),
2335 NULL
, /* FIXME: i18n: */
2336 &setlist
, &showlist
);
2338 add_setshow_zinteger_cmd ("monitor", no_class
, &monitor_debug_p
, _("\
2339 Set debugging of remote monitor communication."), _("\
2340 Show debugging of remote monitor communication."), _("\
2341 When enabled, communication between GDB and the remote monitor\n\
2344 NULL
, /* FIXME: i18n: */
2345 &setdebuglist
, &showdebuglist
);
2347 /* Yes, 42000 is arbitrary. The only sense out of it, is that it
2349 monitor_ptid
= ptid_build (42000, 0, 42000);