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, 2010, 2011
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
8 Resurrected from the ashes by Stu Grossman.
10 This file is part of GDB.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 /* This file was derived from various remote-* modules. It is a collection
26 of generic support functions so GDB can talk directly to a ROM based
27 monitor. This saves use from having to hack an exception based handler
28 into existence, and makes for quick porting.
30 This module talks to a debug monitor called 'MONITOR', which
31 We communicate with MONITOR via either a direct serial line, or a TCP
32 (or possibly TELNET) stream to a terminal multiplexor,
33 which in turn talks to the target board. */
35 /* FIXME 32x64: This code assumes that registers and addresses are at
36 most 32 bits long. If they can be larger, you will need to declare
37 values as LONGEST and use %llx or some such to print values when
38 building commands to send to the monitor. Since we don't know of
39 any actual 64-bit targets with ROM monitors that use this code,
40 it's not an issue right now. -sts 4/18/96 */
45 #include "exceptions.h"
48 #include "gdb_string.h"
49 #include <sys/types.h>
55 #include "gdb_regex.h"
58 #include "gdbthread.h"
60 static char *dev_name
;
61 static struct target_ops
*targ_ops
;
63 static void monitor_interrupt_query (void);
64 static void monitor_interrupt_twice (int);
65 static void monitor_stop (ptid_t
);
66 static void monitor_dump_regs (struct regcache
*regcache
);
69 static int from_hex (int a
);
72 static struct monitor_ops
*current_monitor
;
74 static int hashmark
; /* flag set by "set hash" */
76 static int timeout
= 30;
78 static int in_monitor_wait
= 0; /* Non-zero means we are in monitor_wait() */
80 static void (*ofunc
) (); /* Old SIGINT signal handler */
82 static CORE_ADDR
*breakaddr
;
84 /* Descriptor for I/O to remote machine. Initialize it to NULL so
85 that monitor_open knows that we don't have a file open when the
88 static struct serial
*monitor_desc
= NULL
;
90 /* Pointer to regexp pattern matching data */
92 static struct re_pattern_buffer register_pattern
;
93 static char register_fastmap
[256];
95 static struct re_pattern_buffer getmem_resp_delim_pattern
;
96 static char getmem_resp_delim_fastmap
[256];
98 static struct re_pattern_buffer setmem_resp_delim_pattern
;
99 static char setmem_resp_delim_fastmap
[256];
101 static struct re_pattern_buffer setreg_resp_delim_pattern
;
102 static char setreg_resp_delim_fastmap
[256];
104 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
105 monitor_wait wakes up. */
107 static int first_time
= 0; /* Is this the first time we're
108 executing after gaving created the
112 /* This is the ptid we use while we're connected to a monitor. Its
113 value is arbitrary, as monitor targets don't have a notion of
114 processes or threads, but we need something non-null to place in
116 static ptid_t monitor_ptid
;
118 #define TARGET_BUF_SIZE 2048
120 /* Monitor specific debugging information. Typically only useful to
121 the developer of a new monitor interface. */
123 static void monitor_debug (const char *fmt
, ...) ATTRIBUTE_PRINTF (1, 2);
125 static int monitor_debug_p
= 0;
127 /* NOTE: This file alternates between monitor_debug_p and remote_debug
128 when determining if debug information is printed. Perhaps this
129 could be simplified. */
132 monitor_debug (const char *fmt
, ...)
138 va_start (args
, fmt
);
139 vfprintf_filtered (gdb_stdlog
, fmt
, args
);
145 /* Convert a string into a printable representation, Return # byte in
146 the new string. When LEN is >0 it specifies the size of the
147 string. Otherwize strlen(oldstr) is used. */
150 monitor_printable_string (char *newstr
, char *oldstr
, int len
)
156 len
= strlen (oldstr
);
158 for (i
= 0; i
< len
; i
++)
169 sprintf (newstr
, "\\x%02x", ch
& 0xff);
208 /* Print monitor errors with a string, converting the string to printable
212 monitor_error (char *function
, char *message
,
213 CORE_ADDR memaddr
, int len
, char *string
, int final_char
)
215 int real_len
= (len
== 0 && string
!= (char *) 0) ? strlen (string
) : len
;
216 char *safe_string
= alloca ((real_len
* 4) + 1);
218 monitor_printable_string (safe_string
, string
, real_len
);
221 error (_("%s (%s): %s: %s%c"),
222 function
, paddress (target_gdbarch
, memaddr
),
223 message
, safe_string
, final_char
);
225 error (_("%s (%s): %s: %s"),
226 function
, paddress (target_gdbarch
, memaddr
),
227 message
, safe_string
);
230 /* Convert hex digit A to a number. */
235 if (a
>= '0' && a
<= '9')
237 else if (a
>= 'a' && a
<= 'f')
239 else if (a
>= 'A' && a
<= 'F')
242 error (_("Invalid hex digit %d"), a
);
245 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
247 This function exists to get around the problem that many host platforms
248 don't have a printf that can print 64-bit addresses. The %A format
249 specification is recognized as a special case, and causes the argument
250 to be printed as a 64-bit hexadecimal address.
252 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
253 If it is a '%s' format, the argument is a string; otherwise the
254 argument is assumed to be a long integer.
256 %% is also turned into a single %.
260 monitor_vsprintf (char *sndbuf
, char *pattern
, va_list args
)
262 int addr_bit
= gdbarch_addr_bit (target_gdbarch
);
271 for (p
= pattern
; *p
; p
++)
275 /* Copy the format specifier to a separate buffer. */
277 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
280 format
[i
] = fmt
= *p
;
281 format
[i
+ 1] = '\0';
283 /* Fetch the next argument and print it. */
287 strcpy (sndbuf
, "%");
290 arg_addr
= va_arg (args
, CORE_ADDR
);
291 strcpy (sndbuf
, phex_nz (arg_addr
, addr_bit
/ 8));
294 arg_string
= va_arg (args
, char *);
295 sprintf (sndbuf
, format
, arg_string
);
298 arg_int
= va_arg (args
, long);
299 sprintf (sndbuf
, format
, arg_int
);
302 sndbuf
+= strlen (sndbuf
);
311 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
312 Works just like printf. */
315 monitor_printf_noecho (char *pattern
,...)
321 va_start (args
, pattern
);
323 monitor_vsprintf (sndbuf
, pattern
, args
);
325 len
= strlen (sndbuf
);
326 if (len
+ 1 > sizeof sndbuf
)
327 internal_error (__FILE__
, __LINE__
,
328 _("failed internal consistency check"));
332 char *safe_string
= (char *) alloca ((strlen (sndbuf
) * 4) + 1);
334 monitor_printable_string (safe_string
, sndbuf
, 0);
335 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
338 monitor_write (sndbuf
, len
);
341 /* monitor_printf -- Send data to monitor and check the echo. Works just like
345 monitor_printf (char *pattern
,...)
351 va_start (args
, pattern
);
353 monitor_vsprintf (sndbuf
, pattern
, args
);
355 len
= strlen (sndbuf
);
356 if (len
+ 1 > sizeof sndbuf
)
357 internal_error (__FILE__
, __LINE__
,
358 _("failed internal consistency check"));
362 char *safe_string
= (char *) alloca ((len
* 4) + 1);
364 monitor_printable_string (safe_string
, sndbuf
, 0);
365 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
368 monitor_write (sndbuf
, len
);
370 /* We used to expect that the next immediate output was the
371 characters we just output, but sometimes some extra junk appeared
372 before the characters we expected, like an extra prompt, or a
373 portmaster sending telnet negotiations. So, just start searching
374 for what we sent, and skip anything unknown. */
375 monitor_debug ("ExpectEcho\n");
376 monitor_expect (sndbuf
, (char *) 0, 0);
380 /* Write characters to the remote system. */
383 monitor_write (char *buf
, int buflen
)
385 if (serial_write (monitor_desc
, buf
, buflen
))
386 fprintf_unfiltered (gdb_stderr
, "serial_write failed: %s\n",
387 safe_strerror (errno
));
391 /* Read a binary character from the remote system, doing all the fancy
392 timeout stuff, but without interpreting the character in any way,
393 and without printing remote debug information. */
396 monitor_readchar (void)
404 c
= serial_readchar (monitor_desc
, timeout
);
407 c
&= 0xff; /* don't lose bit 7 */
414 if (c
== SERIAL_TIMEOUT
)
415 error (_("Timeout reading from remote system."));
417 perror_with_name (_("remote-monitor"));
421 /* Read a character from the remote system, doing all the fancy
425 readchar (int timeout
)
430 last_random
, last_nl
, last_cr
, last_crnl
438 c
= serial_readchar (monitor_desc
, timeout
);
443 /* This seems to interfere with proper function of the
445 if (monitor_debug_p
|| remote_debug
)
451 puts_debug ("read -->", buf
, "<--");
456 /* Canonicialize \n\r combinations into one \r */
457 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
459 if ((c
== '\r' && state
== last_nl
)
460 || (c
== '\n' && state
== last_cr
))
481 if (c
== SERIAL_TIMEOUT
)
483 /* I fail to see how detaching here can be useful */
484 if (in_monitor_wait
) /* Watchdog went off */
486 target_mourn_inferior ();
487 error (_("GDB serial timeout has expired. Target detached."));
491 error (_("Timeout reading from remote system."));
493 perror_with_name (_("remote-monitor"));
496 /* Scan input from the remote system, until STRING is found. If BUF is non-
497 zero, then collect input until we have collected either STRING or BUFLEN-1
498 chars. In either case we terminate BUF with a 0. If input overflows BUF
499 because STRING can't be found, return -1, else return number of chars in BUF
500 (minus the terminating NUL). Note that in the non-overflow case, STRING
501 will be at the end of BUF. */
504 monitor_expect (char *string
, char *buf
, int buflen
)
507 int obuflen
= buflen
;
512 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
513 monitor_printable_string (safe_string
, string
, 0);
514 fprintf_unfiltered (gdb_stdlog
, "MON Expecting '%s'\n", safe_string
);
529 c
= readchar (timeout
);
536 c
= readchar (timeout
);
538 /* Don't expect any ^C sent to be echoed */
540 if (*p
== '\003' || c
== *p
)
550 return obuflen
- buflen
;
558 /* We got a character that doesn't match the string. We need to
559 back up p, but how far? If we're looking for "..howdy" and the
560 monitor sends "...howdy"? There's certainly a match in there,
561 but when we receive the third ".", we won't find it if we just
562 restart the matching at the beginning of the string.
564 This is a Boyer-Moore kind of situation. We want to reset P to
565 the end of the longest prefix of STRING that is a suffix of
566 what we've read so far. In the example above, that would be
567 ".." --- the longest prefix of "..howdy" that is a suffix of
568 "...". This longest prefix could be the empty string, if C
569 is nowhere to be found in STRING.
571 If this longest prefix is not the empty string, it must contain
572 C, so let's search from the end of STRING for instances of C,
573 and see if the portion of STRING before that is a suffix of
574 what we read before C. Actually, we can search backwards from
575 p, since we know no prefix can be longer than that.
577 Note that we can use STRING itself, along with C, as a record
578 of what we've received so far. :) */
581 for (i
= (p
- string
) - 1; i
>= 0; i
--)
584 /* Is this prefix a suffix of what we've read so far?
586 string[0 .. i-1] == string[p - i, p - 1]? */
587 if (! memcmp (string
, p
- i
, i
))
599 /* Search for a regexp. */
602 monitor_expect_regexp (struct re_pattern_buffer
*pat
, char *buf
, int buflen
)
607 monitor_debug ("MON Expecting regexp\n");
612 mybuf
= alloca (TARGET_BUF_SIZE
);
613 buflen
= TARGET_BUF_SIZE
;
621 if (p
- mybuf
>= buflen
)
622 { /* Buffer about to overflow */
624 /* On overflow, we copy the upper half of the buffer to the lower half. Not
625 great, but it usually works... */
627 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
628 p
= mybuf
+ buflen
/ 2;
631 *p
++ = readchar (timeout
);
633 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
639 /* Keep discarding input until we see the MONITOR prompt.
641 The convention for dealing with the prompt is that you
643 o *then* wait for the prompt.
645 Thus the last thing that a procedure does with the serial line will
646 be an monitor_expect_prompt(). Exception: monitor_resume does not
647 wait for the prompt, because the terminal is being handed over to
648 the inferior. However, the next thing which happens after that is
649 a monitor_wait which does wait for the prompt. Note that this
650 includes abnormal exit, e.g. error(). This is necessary to prevent
651 getting into states from which we can't recover. */
654 monitor_expect_prompt (char *buf
, int buflen
)
656 monitor_debug ("MON Expecting prompt\n");
657 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
660 /* Get N 32-bit words from remote, each preceded by a space, and put
661 them in registers starting at REGNO. */
672 ch
= readchar (timeout
);
673 while (isspace (ch
));
677 for (i
= 7; i
>= 1; i
--)
679 ch
= readchar (timeout
);
682 val
= (val
<< 4) | from_hex (ch
);
690 compile_pattern (char *pattern
, struct re_pattern_buffer
*compiled_pattern
,
696 compiled_pattern
->fastmap
= fastmap
;
698 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
699 val
= re_compile_pattern (pattern
,
705 error (_("compile_pattern: Can't compile pattern string `%s': %s!"),
709 re_compile_fastmap (compiled_pattern
);
712 /* Open a connection to a remote debugger. NAME is the filename used
713 for communication. */
716 monitor_open (char *args
, struct monitor_ops
*mon_ops
, int from_tty
)
720 struct inferior
*inf
;
722 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
723 error (_("Magic number of monitor_ops struct wrong."));
725 targ_ops
= mon_ops
->target
;
726 name
= targ_ops
->to_shortname
;
729 error (_("Use `target %s DEVICE-NAME' to use a serial port, or\n\
730 `target %s HOST-NAME:PORT-NUMBER' to use a network connection."), name
, name
);
732 target_preopen (from_tty
);
734 /* Setup pattern for register dump */
736 if (mon_ops
->register_pattern
)
737 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
740 if (mon_ops
->getmem
.resp_delim
)
741 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
742 getmem_resp_delim_fastmap
);
744 if (mon_ops
->setmem
.resp_delim
)
745 compile_pattern (mon_ops
->setmem
.resp_delim
, &setmem_resp_delim_pattern
,
746 setmem_resp_delim_fastmap
);
748 if (mon_ops
->setreg
.resp_delim
)
749 compile_pattern (mon_ops
->setreg
.resp_delim
, &setreg_resp_delim_pattern
,
750 setreg_resp_delim_fastmap
);
752 unpush_target (targ_ops
);
756 dev_name
= xstrdup (args
);
758 monitor_desc
= serial_open (dev_name
);
761 perror_with_name (dev_name
);
765 if (serial_setbaudrate (monitor_desc
, baud_rate
))
767 serial_close (monitor_desc
);
768 perror_with_name (dev_name
);
772 serial_raw (monitor_desc
);
774 serial_flush_input (monitor_desc
);
776 /* some systems only work with 2 stop bits */
778 serial_setstopbits (monitor_desc
, mon_ops
->stopbits
);
780 current_monitor
= mon_ops
;
782 /* See if we can wake up the monitor. First, try sending a stop sequence,
783 then send the init strings. Last, remove all breakpoints. */
785 if (current_monitor
->stop
)
787 monitor_stop (inferior_ptid
);
788 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
790 monitor_debug ("EXP Open echo\n");
791 monitor_expect_prompt (NULL
, 0);
795 /* wake up the monitor and see if it's alive */
796 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
798 /* Some of the characters we send may not be echoed,
799 but we hope to get a prompt at the end of it all. */
801 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
804 monitor_printf_noecho (*p
);
805 monitor_expect_prompt (NULL
, 0);
808 serial_flush_input (monitor_desc
);
810 /* Alloc breakpoints */
811 if (mon_ops
->set_break
!= NULL
)
813 if (mon_ops
->num_breakpoints
== 0)
814 mon_ops
->num_breakpoints
= 8;
816 breakaddr
= (CORE_ADDR
*)
817 xmalloc (mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
818 memset (breakaddr
, 0, mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
821 /* Remove all breakpoints */
823 if (mon_ops
->clr_all_break
)
825 monitor_printf (mon_ops
->clr_all_break
);
826 monitor_expect_prompt (NULL
, 0);
830 printf_unfiltered (_("Remote target %s connected to %s\n"),
833 push_target (targ_ops
);
838 /* Make run command think we are busy... */
839 inferior_ptid
= monitor_ptid
;
840 inf
= current_inferior ();
841 inferior_appeared (inf
, ptid_get_pid (inferior_ptid
));
842 add_thread_silent (inferior_ptid
);
844 /* Give monitor_wait something to read */
846 monitor_printf (current_monitor
->line_term
);
848 start_remote (from_tty
);
851 /* Close out all files and local state before this target loses
855 monitor_close (int quitting
)
858 serial_close (monitor_desc
);
860 /* Free breakpoint memory */
861 if (breakaddr
!= NULL
)
869 delete_thread_silent (monitor_ptid
);
870 delete_inferior_silent (ptid_get_pid (monitor_ptid
));
873 /* Terminate the open connection to the remote debugger. Use this
874 when you want to detach and do something else with your gdb. */
877 monitor_detach (struct target_ops
*ops
, char *args
, int from_tty
)
879 pop_target (); /* calls monitor_close to do the real work */
881 printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname
);
884 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
887 monitor_supply_register (struct regcache
*regcache
, int regno
, char *valstr
)
889 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
890 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
892 unsigned char regbuf
[MAX_REGISTER_SIZE
];
897 while (p
&& *p
!= '\0')
899 if (*p
== '\r' || *p
== '\n')
910 if (!isxdigit (*p
) && *p
!= 'x')
916 val
+= fromhex (*p
++);
918 monitor_debug ("Supplying Register %d %s\n", regno
, valstr
);
920 if (val
== 0 && valstr
== p
)
921 error (_("monitor_supply_register (%d): bad value from monitor: %s."),
924 /* supply register stores in target byte order, so swap here */
926 store_unsigned_integer (regbuf
, register_size (gdbarch
, regno
), byte_order
,
929 regcache_raw_supply (regcache
, regno
, regbuf
);
934 /* Tell the remote machine to resume. */
937 monitor_resume (struct target_ops
*ops
,
938 ptid_t ptid
, int step
, enum target_signal sig
)
940 /* Some monitors require a different command when starting a program */
941 monitor_debug ("MON resume\n");
942 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
945 monitor_printf ("run\r");
946 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
951 monitor_printf (current_monitor
->step
);
954 if (current_monitor
->continue_hook
)
955 (*current_monitor
->continue_hook
) ();
957 monitor_printf (current_monitor
->cont
);
958 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
963 /* Parse the output of a register dump command. A monitor specific
964 regexp is used to extract individual register descriptions of the
965 form REG=VAL. Each description is split up into a name and a value
966 string which are passed down to monitor specific code. */
969 parse_register_dump (struct regcache
*regcache
, char *buf
, int len
)
971 monitor_debug ("MON Parsing register dump\n");
974 int regnamelen
, vallen
;
977 /* Element 0 points to start of register name, and element 1
978 points to the start of the register value. */
979 struct re_registers register_strings
;
981 memset (®ister_strings
, 0, sizeof (struct re_registers
));
983 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
984 ®ister_strings
) == -1)
987 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
988 regname
= buf
+ register_strings
.start
[1];
989 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
990 val
= buf
+ register_strings
.start
[2];
992 current_monitor
->supply_register (regcache
, regname
, regnamelen
,
995 buf
+= register_strings
.end
[0];
996 len
-= register_strings
.end
[0];
1000 /* Send ^C to target to halt it. Target will respond, and send us a
1004 monitor_interrupt (int signo
)
1006 /* If this doesn't work, try more severe steps. */
1007 signal (signo
, monitor_interrupt_twice
);
1009 if (monitor_debug_p
|| remote_debug
)
1010 fprintf_unfiltered (gdb_stdlog
, "monitor_interrupt called\n");
1012 target_stop (inferior_ptid
);
1015 /* The user typed ^C twice. */
1018 monitor_interrupt_twice (int signo
)
1020 signal (signo
, ofunc
);
1022 monitor_interrupt_query ();
1024 signal (signo
, monitor_interrupt
);
1027 /* Ask the user what to do when an interrupt is received. */
1030 monitor_interrupt_query (void)
1032 target_terminal_ours ();
1034 if (query (_("Interrupted while waiting for the program.\n\
1035 Give up (and stop debugging it)? ")))
1037 target_mourn_inferior ();
1038 deprecated_throw_reason (RETURN_QUIT
);
1041 target_terminal_inferior ();
1045 monitor_wait_cleanup (void *old_timeout
)
1047 timeout
= *(int *) old_timeout
;
1048 signal (SIGINT
, ofunc
);
1049 in_monitor_wait
= 0;
1055 monitor_wait_filter (char *buf
,
1058 struct target_waitstatus
*status
)
1064 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1065 *ext_resp_len
= resp_len
;
1068 fprintf_unfiltered (gdb_stderr
,
1069 "monitor_wait: excessive "
1070 "response from monitor: %s.", buf
);
1072 while (resp_len
< 0);
1074 /* Print any output characters that were preceded by ^O. */
1075 /* FIXME - This would be great as a user settabgle flag */
1076 if (monitor_debug_p
|| remote_debug
1077 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1081 for (i
= 0; i
< resp_len
- 1; i
++)
1083 putchar_unfiltered (buf
[++i
]);
1089 /* Wait until the remote machine stops, then return, storing status in
1090 status just as `wait' would. */
1093 monitor_wait (struct target_ops
*ops
,
1094 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1096 int old_timeout
= timeout
;
1097 char buf
[TARGET_BUF_SIZE
];
1099 struct cleanup
*old_chain
;
1101 status
->kind
= TARGET_WAITKIND_EXITED
;
1102 status
->value
.integer
= 0;
1104 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1105 monitor_debug ("MON wait\n");
1108 /* This is somthing other than a maintenance command */
1109 in_monitor_wait
= 1;
1110 timeout
= watchdog
> 0 ? watchdog
: -1;
1112 timeout
= -1; /* Don't time out -- user program is running. */
1115 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1117 if (current_monitor
->wait_filter
)
1118 (*current_monitor
->wait_filter
) (buf
, sizeof (buf
), &resp_len
, status
);
1120 monitor_wait_filter (buf
, sizeof (buf
), &resp_len
, status
);
1122 #if 0 /* Transferred to monitor wait filter */
1125 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1128 fprintf_unfiltered (gdb_stderr
,
1129 "monitor_wait: excessive "
1130 "response from monitor: %s.", buf
);
1132 while (resp_len
< 0);
1134 /* Print any output characters that were preceded by ^O. */
1135 /* FIXME - This would be great as a user settabgle flag */
1136 if (monitor_debug_p
|| remote_debug
1137 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1141 for (i
= 0; i
< resp_len
- 1; i
++)
1143 putchar_unfiltered (buf
[++i
]);
1147 signal (SIGINT
, ofunc
);
1149 timeout
= old_timeout
;
1151 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1154 monitor_printf (current_monitor
->dump_registers
);
1155 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1158 if (current_monitor
->register_pattern
)
1159 parse_register_dump (get_current_regcache (), buf
, resp_len
);
1161 monitor_debug ("Wait fetching registers after stop\n");
1162 monitor_dump_regs (get_current_regcache ());
1165 status
->kind
= TARGET_WAITKIND_STOPPED
;
1166 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1168 discard_cleanups (old_chain
);
1170 in_monitor_wait
= 0;
1172 return inferior_ptid
;
1175 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1179 monitor_fetch_register (struct regcache
*regcache
, int regno
)
1186 regbuf
= alloca (MAX_REGISTER_SIZE
* 2 + 1);
1187 zerobuf
= alloca (MAX_REGISTER_SIZE
);
1188 memset (zerobuf
, 0, MAX_REGISTER_SIZE
);
1190 if (current_monitor
->regname
!= NULL
)
1191 name
= current_monitor
->regname (regno
);
1193 name
= current_monitor
->regnames
[regno
];
1194 monitor_debug ("MON fetchreg %d '%s'\n", regno
, name
? name
: "(null name)");
1196 if (!name
|| (*name
== '\0'))
1198 monitor_debug ("No register known for %d\n", regno
);
1199 regcache_raw_supply (regcache
, regno
, zerobuf
);
1203 /* send the register examine command */
1205 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1207 /* If RESP_DELIM is specified, we search for that as a leading
1208 delimiter for the register value. Otherwise, we just start
1209 searching from the start of the buf. */
1211 if (current_monitor
->getreg
.resp_delim
)
1213 monitor_debug ("EXP getreg.resp_delim\n");
1214 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1215 /* Handle case of first 32 registers listed in pairs. */
1216 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1217 && (regno
& 1) != 0 && regno
< 32)
1219 monitor_debug ("EXP getreg.resp_delim\n");
1220 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1224 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1225 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1229 c
= readchar (timeout
);
1231 c
= readchar (timeout
);
1232 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1235 error (_("Bad value returned from monitor "
1236 "while fetching register %x."),
1240 /* Read upto the maximum number of hex digits for this register, skipping
1241 spaces, but stop reading if something else is seen. Some monitors
1242 like to drop leading zeros. */
1244 for (i
= 0; i
< register_size (get_regcache_arch (regcache
), regno
) * 2; i
++)
1248 c
= readchar (timeout
);
1250 c
= readchar (timeout
);
1258 regbuf
[i
] = '\000'; /* terminate the number */
1259 monitor_debug ("REGVAL '%s'\n", regbuf
);
1261 /* If TERM is present, we wait for that to show up. Also, (if TERM
1262 is present), we will send TERM_CMD if that is present. In any
1263 case, we collect all of the output into buf, and then wait for
1264 the normal prompt. */
1266 if (current_monitor
->getreg
.term
)
1268 monitor_debug ("EXP getreg.term\n");
1269 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get
1273 if (current_monitor
->getreg
.term_cmd
)
1275 monitor_debug ("EMIT getreg.term.cmd\n");
1276 monitor_printf (current_monitor
->getreg
.term_cmd
);
1278 if (!current_monitor
->getreg
.term
|| /* Already expected or */
1279 current_monitor
->getreg
.term_cmd
) /* ack expected */
1280 monitor_expect_prompt (NULL
, 0); /* get response */
1282 monitor_supply_register (regcache
, regno
, regbuf
);
1285 /* Sometimes, it takes several commands to dump the registers */
1286 /* This is a primitive for use by variations of monitor interfaces in
1287 case they need to compose the operation.
1290 monitor_dump_reg_block (struct regcache
*regcache
, char *block_cmd
)
1292 char buf
[TARGET_BUF_SIZE
];
1295 monitor_printf (block_cmd
);
1296 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1297 parse_register_dump (regcache
, buf
, resp_len
);
1302 /* Read the remote registers into the block regs. */
1303 /* Call the specific function if it has been provided */
1306 monitor_dump_regs (struct regcache
*regcache
)
1308 char buf
[TARGET_BUF_SIZE
];
1311 if (current_monitor
->dumpregs
)
1312 (*(current_monitor
->dumpregs
)) (regcache
); /* call supplied function */
1313 else if (current_monitor
->dump_registers
) /* default version */
1315 monitor_printf (current_monitor
->dump_registers
);
1316 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1317 parse_register_dump (regcache
, buf
, resp_len
);
1320 /* Need some way to read registers */
1321 internal_error (__FILE__
, __LINE__
,
1322 _("failed internal consistency check"));
1326 monitor_fetch_registers (struct target_ops
*ops
,
1327 struct regcache
*regcache
, int regno
)
1329 monitor_debug ("MON fetchregs\n");
1330 if (current_monitor
->getreg
.cmd
)
1334 monitor_fetch_register (regcache
, regno
);
1338 for (regno
= 0; regno
< gdbarch_num_regs (get_regcache_arch (regcache
));
1340 monitor_fetch_register (regcache
, regno
);
1344 monitor_dump_regs (regcache
);
1348 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1351 monitor_store_register (struct regcache
*regcache
, int regno
)
1353 int reg_size
= register_size (get_regcache_arch (regcache
), regno
);
1357 if (current_monitor
->regname
!= NULL
)
1358 name
= current_monitor
->regname (regno
);
1360 name
= current_monitor
->regnames
[regno
];
1362 if (!name
|| (*name
== '\0'))
1364 monitor_debug ("MON Cannot store unknown register\n");
1368 regcache_cooked_read_unsigned (regcache
, regno
, &val
);
1369 monitor_debug ("MON storeg %d %s\n", regno
, phex (val
, reg_size
));
1371 /* send the register deposit command */
1373 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1374 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1375 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1376 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1378 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1380 if (current_monitor
->setreg
.resp_delim
)
1382 monitor_debug ("EXP setreg.resp_delim\n");
1383 monitor_expect_regexp (&setreg_resp_delim_pattern
, NULL
, 0);
1384 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1385 monitor_printf ("%s\r", phex_nz (val
, reg_size
));
1387 if (current_monitor
->setreg
.term
)
1389 monitor_debug ("EXP setreg.term\n");
1390 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1391 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1392 monitor_printf ("%s\r", phex_nz (val
, reg_size
));
1393 monitor_expect_prompt (NULL
, 0);
1396 monitor_expect_prompt (NULL
, 0);
1397 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1399 monitor_debug ("EXP setreg_termcmd\n");
1400 monitor_printf ("%s", current_monitor
->setreg
.term_cmd
);
1401 monitor_expect_prompt (NULL
, 0);
1403 } /* monitor_store_register */
1405 /* Store the remote registers. */
1408 monitor_store_registers (struct target_ops
*ops
,
1409 struct regcache
*regcache
, int regno
)
1413 monitor_store_register (regcache
, regno
);
1417 for (regno
= 0; regno
< gdbarch_num_regs (get_regcache_arch (regcache
));
1419 monitor_store_register (regcache
, regno
);
1422 /* Get ready to modify the registers array. On machines which store
1423 individual registers, this doesn't need to do anything. On machines
1424 which store all the registers in one fell swoop, this makes sure
1425 that registers contains all the registers from the program being
1429 monitor_prepare_to_store (struct regcache
*regcache
)
1431 /* Do nothing, since we can store individual regs */
1435 monitor_files_info (struct target_ops
*ops
)
1437 printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name
, baud_rate
);
1441 monitor_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1443 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
1444 unsigned int val
, hostval
;
1448 monitor_debug ("MON write %d %s\n", len
, paddress (target_gdbarch
, memaddr
));
1450 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1451 memaddr
= gdbarch_addr_bits_remove (target_gdbarch
, memaddr
);
1453 /* Use memory fill command for leading 0 bytes. */
1455 if (current_monitor
->fill
)
1457 for (i
= 0; i
< len
; i
++)
1461 if (i
> 4) /* More than 4 zeros is worth doing */
1463 monitor_debug ("MON FILL %d\n", i
);
1464 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1465 monitor_printf (current_monitor
->fill
, memaddr
,
1466 (memaddr
+ i
) - 1, 0);
1468 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1470 monitor_expect_prompt (NULL
, 0);
1477 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1478 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1481 cmd
= current_monitor
->setmem
.cmdll
;
1485 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1488 cmd
= current_monitor
->setmem
.cmdl
;
1490 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1493 cmd
= current_monitor
->setmem
.cmdw
;
1498 cmd
= current_monitor
->setmem
.cmdb
;
1501 val
= extract_unsigned_integer (myaddr
, len
, byte_order
);
1505 hostval
= *(unsigned int *) myaddr
;
1506 monitor_debug ("Hostval(%08x) val(%08x)\n", hostval
, val
);
1510 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1511 monitor_printf_noecho (cmd
, memaddr
, val
);
1512 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1514 monitor_printf_noecho (cmd
, memaddr
);
1516 if (current_monitor
->setmem
.resp_delim
)
1518 monitor_debug ("EXP setmem.resp_delim");
1519 monitor_expect_regexp (&setmem_resp_delim_pattern
, NULL
, 0);
1520 monitor_printf ("%x\r", val
);
1522 if (current_monitor
->setmem
.term
)
1524 monitor_debug ("EXP setmem.term");
1525 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1526 monitor_printf ("%x\r", val
);
1528 if (current_monitor
->setmem
.term_cmd
)
1529 { /* Emit this to get out of the memory editing state */
1530 monitor_printf ("%s", current_monitor
->setmem
.term_cmd
);
1531 /* Drop through to expecting a prompt */
1535 monitor_printf (cmd
, memaddr
, val
);
1537 monitor_expect_prompt (NULL
, 0);
1544 monitor_write_memory_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
1551 /* Enter the sub mode */
1552 monitor_printf (current_monitor
->setmem
.cmdb
, memaddr
);
1553 monitor_expect_prompt (NULL
, 0);
1557 monitor_printf ("%x\r", val
);
1561 /* If we wanted to, here we could validate the address */
1562 monitor_expect_prompt (NULL
, 0);
1565 /* Now exit the sub mode */
1566 monitor_printf (current_monitor
->getreg
.term_cmd
);
1567 monitor_expect_prompt (NULL
, 0);
1573 longlongendswap (unsigned char *a
)
1583 *(a
+ i
) = *(a
+ j
);
1588 /* Format 32 chars of long long value, advance the pointer */
1589 static char *hexlate
= "0123456789abcdef";
1591 longlong_hexchars (unsigned long long value
,
1601 static unsigned char disbuf
[8]; /* disassembly buffer */
1602 unsigned char *scan
, *limit
; /* loop controls */
1603 unsigned char c
, nib
;
1609 unsigned long long *dp
;
1611 dp
= (unsigned long long *) scan
;
1614 longlongendswap (disbuf
); /* FIXME: ONly on big endian hosts */
1615 while (scan
< limit
)
1617 c
= *scan
++; /* a byte of our long long value */
1623 leadzero
= 0; /* henceforth we print even zeroes */
1625 nib
= c
>> 4; /* high nibble bits */
1626 *outbuff
++ = hexlate
[nib
];
1627 nib
= c
& 0x0f; /* low nibble bits */
1628 *outbuff
++ = hexlate
[nib
];
1632 } /* longlong_hexchars */
1636 /* I am only going to call this when writing virtual byte streams.
1637 Which possably entails endian conversions
1640 monitor_write_memory_longlongs (CORE_ADDR memaddr
, char *myaddr
, int len
)
1642 static char hexstage
[20]; /* At least 16 digits required, plus null */
1648 llptr
= (unsigned long long *) myaddr
;
1651 monitor_printf (current_monitor
->setmem
.cmdll
, memaddr
);
1652 monitor_expect_prompt (NULL
, 0);
1656 endstring
= longlong_hexchars (*llptr
, hexstage
);
1657 *endstring
= '\0'; /* NUll terminate for printf */
1658 monitor_printf ("%s\r", hexstage
);
1662 /* If we wanted to, here we could validate the address */
1663 monitor_expect_prompt (NULL
, 0);
1666 /* Now exit the sub mode */
1667 monitor_printf (current_monitor
->getreg
.term_cmd
);
1668 monitor_expect_prompt (NULL
, 0);
1674 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1675 /* This is for the large blocks of memory which may occur in downloading.
1676 And for monitors which use interactive entry,
1677 And for monitors which do not have other downloading methods.
1678 Without this, we will end up calling monitor_write_memory many times
1679 and do the entry and exit of the sub mode many times
1680 This currently assumes...
1681 MO_SETMEM_INTERACTIVE
1682 ! MO_NO_ECHO_ON_SETMEM
1683 To use this, the you have to patch the monitor_cmds block with
1684 this function. Otherwise, its not tuned up for use by all
1689 monitor_write_memory_block (CORE_ADDR memaddr
, char *myaddr
, int len
)
1694 /* FIXME: This would be a good place to put the zero test */
1696 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1698 return monitor_write_memory_longlongs (memaddr
, myaddr
, len
);
1701 written
= monitor_write_memory_bytes (memaddr
, myaddr
, len
);
1705 /* This is an alternate form of monitor_read_memory which is used for monitors
1706 which can only read a single byte/word/etc. at a time. */
1709 monitor_read_memory_single (CORE_ADDR memaddr
, char *myaddr
, int len
)
1711 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
1713 char membuf
[sizeof (int) * 2 + 1];
1717 monitor_debug ("MON read single\n");
1719 /* Can't actually use long longs (nice idea, though). In fact, the
1720 call to strtoul below will fail if it tries to convert a value
1721 that's too big to fit in a long. */
1722 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1725 cmd
= current_monitor
->getmem
.cmdll
;
1729 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1732 cmd
= current_monitor
->getmem
.cmdl
;
1734 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1737 cmd
= current_monitor
->getmem
.cmdw
;
1742 cmd
= current_monitor
->getmem
.cmdb
;
1745 /* Send the examine command. */
1747 monitor_printf (cmd
, memaddr
);
1749 /* If RESP_DELIM is specified, we search for that as a leading
1750 delimiter for the memory value. Otherwise, we just start
1751 searching from the start of the buf. */
1753 if (current_monitor
->getmem
.resp_delim
)
1755 monitor_debug ("EXP getmem.resp_delim\n");
1756 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1759 /* Now, read the appropriate number of hex digits for this loc,
1762 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1763 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1767 c
= readchar (timeout
);
1769 c
= readchar (timeout
);
1770 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1773 monitor_error ("monitor_read_memory_single",
1774 "bad response from monitor",
1775 memaddr
, 0, NULL
, 0);
1781 for (i
= 0; i
< len
* 2; i
++)
1787 c
= readchar (timeout
);
1793 monitor_error ("monitor_read_memory_single",
1794 "bad response from monitor",
1795 memaddr
, i
, membuf
, 0);
1799 membuf
[i
] = '\000'; /* terminate the number */
1802 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1803 present), we will send TERM_CMD if that is present. In any case, we collect
1804 all of the output into buf, and then wait for the normal prompt. */
1806 if (current_monitor
->getmem
.term
)
1808 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get
1811 if (current_monitor
->getmem
.term_cmd
)
1813 monitor_printf (current_monitor
->getmem
.term_cmd
);
1814 monitor_expect_prompt (NULL
, 0);
1818 monitor_expect_prompt (NULL
, 0); /* get response */
1821 val
= strtoul (membuf
, &p
, 16);
1823 if (val
== 0 && membuf
== p
)
1824 monitor_error ("monitor_read_memory_single",
1825 "bad value from monitor",
1826 memaddr
, 0, membuf
, 0);
1828 /* supply register stores in target byte order, so swap here */
1830 store_unsigned_integer (myaddr
, len
, byte_order
, val
);
1835 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1836 memory at MEMADDR. Returns length moved. Currently, we do no more
1837 than 16 bytes at a time. */
1840 monitor_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1851 monitor_debug ("Zero length call to monitor_read_memory\n");
1855 monitor_debug ("MON read block ta(%s) ha(%s) %d\n",
1856 paddress (target_gdbarch
, memaddr
),
1857 host_address_to_string (myaddr
), len
);
1859 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1860 memaddr
= gdbarch_addr_bits_remove (target_gdbarch
, memaddr
);
1862 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1863 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1865 len
= min (len
, 16);
1867 /* Some dumpers align the first data with the preceeding 16
1868 byte boundary. Some print blanks and start at the
1869 requested boundary. EXACT_DUMPADDR
1872 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1873 ? memaddr
: memaddr
& ~0x0f;
1875 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1876 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1877 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1879 /* send the memory examine command */
1881 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1882 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
);
1883 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1884 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1886 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1888 /* If TERM is present, we wait for that to show up. Also, (if TERM
1889 is present), we will send TERM_CMD if that is present. In any
1890 case, we collect all of the output into buf, and then wait for
1891 the normal prompt. */
1893 if (current_monitor
->getmem
.term
)
1895 resp_len
= monitor_expect (current_monitor
->getmem
.term
,
1896 buf
, sizeof buf
); /* get response */
1899 monitor_error ("monitor_read_memory",
1900 "excessive response from monitor",
1901 memaddr
, resp_len
, buf
, 0);
1903 if (current_monitor
->getmem
.term_cmd
)
1905 serial_write (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1906 strlen (current_monitor
->getmem
.term_cmd
));
1907 monitor_expect_prompt (NULL
, 0);
1911 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1915 /* If RESP_DELIM is specified, we search for that as a leading
1916 delimiter for the values. Otherwise, we just start searching
1917 from the start of the buf. */
1919 if (current_monitor
->getmem
.resp_delim
)
1922 struct re_registers resp_strings
;
1924 monitor_debug ("MON getmem.resp_delim %s\n",
1925 current_monitor
->getmem
.resp_delim
);
1927 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1929 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1933 monitor_error ("monitor_read_memory",
1934 "bad response from monitor",
1935 memaddr
, resp_len
, buf
, 0);
1937 p
+= resp_strings
.end
[0];
1939 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1941 monitor_error ("monitor_read_memory",
1942 "bad response from monitor",
1943 memaddr
, resp_len
, buf
, 0);
1944 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1947 monitor_debug ("MON scanning %d ,%s '%s'\n", len
,
1948 host_address_to_string (p
), p
);
1949 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1957 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1961 if ((dumpaddr
>= memaddr
) && (i
> 0))
1963 val
= fromhex (c
) * 16 + fromhex (*(p
+ 1));
1965 if (monitor_debug_p
|| remote_debug
)
1966 fprintf_unfiltered (gdb_stdlog
, "[%02x]", val
);
1973 ++p
; /* skip a blank or other non hex char */
1977 error (_("Failed to read via monitor"));
1978 if (monitor_debug_p
|| remote_debug
)
1979 fprintf_unfiltered (gdb_stdlog
, "\n");
1980 return fetched
; /* Return the number of bytes actually read */
1982 monitor_debug ("MON scanning bytes\n");
1984 for (i
= len
; i
> 0; i
--)
1986 /* Skip non-hex chars, but bomb on end of string and newlines */
1993 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1994 monitor_error ("monitor_read_memory",
1995 "badly terminated response from monitor",
1996 memaddr
, resp_len
, buf
, 0);
2000 val
= strtoul (p
, &p1
, 16);
2002 if (val
== 0 && p
== p1
)
2003 monitor_error ("monitor_read_memory",
2004 "bad value from monitor",
2005 memaddr
, resp_len
, buf
, 0);
2018 /* Transfer LEN bytes between target address MEMADDR and GDB address
2019 MYADDR. Returns 0 for success, errno code for failure. TARGET is
2023 monitor_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
2024 struct mem_attrib
*attrib
, struct target_ops
*target
)
2030 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
2031 res
= monitor_write_memory_block(memaddr
, myaddr
, len
);
2033 res
= monitor_write_memory(memaddr
, myaddr
, len
);
2037 res
= monitor_read_memory(memaddr
, myaddr
, len
);
2044 monitor_kill (struct target_ops
*ops
)
2046 return; /* ignore attempts to kill target system */
2049 /* All we actually do is set the PC to the start address of exec_bfd. */
2052 monitor_create_inferior (struct target_ops
*ops
, char *exec_file
,
2053 char *args
, char **env
, int from_tty
)
2055 if (args
&& (*args
!= '\000'))
2056 error (_("Args are not supported by the monitor."));
2059 clear_proceed_status ();
2060 regcache_write_pc (get_current_regcache (),
2061 bfd_get_start_address (exec_bfd
));
2064 /* Clean up when a program exits.
2065 The program actually lives on in the remote processor's RAM, and may be
2066 run again without a download. Don't leave it full of breakpoint
2070 monitor_mourn_inferior (struct target_ops
*ops
)
2072 unpush_target (targ_ops
);
2073 generic_mourn_inferior (); /* Do all the proper things now */
2074 delete_thread_silent (monitor_ptid
);
2077 /* Tell the monitor to add a breakpoint. */
2080 monitor_insert_breakpoint (struct gdbarch
*gdbarch
,
2081 struct bp_target_info
*bp_tgt
)
2083 CORE_ADDR addr
= bp_tgt
->placed_address
;
2087 monitor_debug ("MON inst bkpt %s\n", paddress (gdbarch
, addr
));
2088 if (current_monitor
->set_break
== NULL
)
2089 error (_("No set_break defined for this monitor"));
2091 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2092 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
2094 /* Determine appropriate breakpoint size for this address. */
2095 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bplen
);
2096 bp_tgt
->placed_address
= addr
;
2097 bp_tgt
->placed_size
= bplen
;
2099 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2101 if (breakaddr
[i
] == 0)
2103 breakaddr
[i
] = addr
;
2104 monitor_printf (current_monitor
->set_break
, addr
);
2105 monitor_expect_prompt (NULL
, 0);
2110 error (_("Too many breakpoints (> %d) for monitor."),
2111 current_monitor
->num_breakpoints
);
2114 /* Tell the monitor to remove a breakpoint. */
2117 monitor_remove_breakpoint (struct gdbarch
*gdbarch
,
2118 struct bp_target_info
*bp_tgt
)
2120 CORE_ADDR addr
= bp_tgt
->placed_address
;
2123 monitor_debug ("MON rmbkpt %s\n", paddress (gdbarch
, addr
));
2124 if (current_monitor
->clr_break
== NULL
)
2125 error (_("No clr_break defined for this monitor"));
2127 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2129 if (breakaddr
[i
] == addr
)
2132 /* some monitors remove breakpoints based on the address */
2133 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2134 monitor_printf (current_monitor
->clr_break
, addr
);
2135 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2136 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2138 monitor_printf (current_monitor
->clr_break
, i
);
2139 monitor_expect_prompt (NULL
, 0);
2143 fprintf_unfiltered (gdb_stderr
,
2144 "Can't find breakpoint associated with %s\n",
2145 paddress (gdbarch
, addr
));
2149 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2150 an S-record. Return non-zero if the ACK is received properly. */
2153 monitor_wait_srec_ack (void)
2157 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2159 return (readchar (timeout
) == '+');
2161 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2163 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2164 if ((ch
= readchar (1)) < 0)
2166 if ((ch
= readchar (1)) < 0)
2168 if ((ch
= readchar (1)) < 0)
2170 if ((ch
= readchar (1)) < 0)
2176 /* monitor_load -- download a file. */
2179 monitor_load (char *file
, int from_tty
)
2181 monitor_debug ("MON load\n");
2183 if (current_monitor
->load_routine
)
2184 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2186 { /* The default is ascii S-records */
2188 unsigned long load_offset
;
2191 /* enable user to specify address for downloading as 2nd arg to load */
2192 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2198 monitor_printf (current_monitor
->load
);
2199 if (current_monitor
->loadresp
)
2200 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2202 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2203 32, SREC_ALL
, hashmark
,
2204 current_monitor
->flags
& MO_SREC_ACK
?
2205 monitor_wait_srec_ack
: NULL
);
2207 monitor_expect_prompt (NULL
, 0);
2210 /* Finally, make the PC point at the start address */
2212 regcache_write_pc (get_current_regcache (),
2213 bfd_get_start_address (exec_bfd
));
2215 /* There used to be code here which would clear inferior_ptid and
2216 call clear_symtab_users. None of that should be necessary:
2217 monitor targets should behave like remote protocol targets, and
2218 since generic_load does none of those things, this function
2221 Furthermore, clearing inferior_ptid is *incorrect*. After doing
2222 a load, we still have a valid connection to the monitor, with a
2223 live processor state to fiddle with. The user can type
2224 `continue' or `jump *start' and make the program run. If they do
2225 these things, however, GDB will be talking to a running program
2226 while inferior_ptid is null_ptid; this makes things like
2227 reinit_frame_cache very confused. */
2231 monitor_stop (ptid_t ptid
)
2233 monitor_debug ("MON stop\n");
2234 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2235 serial_send_break (monitor_desc
);
2236 if (current_monitor
->stop
)
2237 monitor_printf_noecho (current_monitor
->stop
);
2240 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2241 in OUTPUT until the prompt is seen. FIXME: We read the characters
2242 ourseleves here cause of a nasty echo. */
2245 monitor_rcmd (char *command
,
2246 struct ui_file
*outbuf
)
2252 if (monitor_desc
== NULL
)
2253 error (_("monitor target not open."));
2255 p
= current_monitor
->prompt
;
2257 /* Send the command. Note that if no args were supplied, then we're
2258 just sending the monitor a newline, which is sometimes useful. */
2260 monitor_printf ("%s\r", (command
? command
: ""));
2262 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2264 fputs_unfiltered (buf
, outbuf
); /* Output the response */
2267 /* Convert hex digit A to a number. */
2273 if (a
>= '0' && a
<= '9')
2275 if (a
>= 'a' && a
<= 'f')
2276 return a
- 'a' + 10;
2277 if (a
>= 'A' && a
<= 'F')
2278 return a
- 'A' + 10;
2280 error (_("Reply contains invalid hex digit 0x%x"), a
);
2285 monitor_get_dev_name (void)
2290 /* Check to see if a thread is still alive. */
2293 monitor_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2295 if (ptid_equal (ptid
, monitor_ptid
))
2296 /* The monitor's task is always alive. */
2302 /* Convert a thread ID to a string. Returns the string in a static
2306 monitor_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2308 static char buf
[64];
2310 if (ptid_equal (monitor_ptid
, ptid
))
2312 xsnprintf (buf
, sizeof buf
, "Thread <main>");
2316 return normal_pid_to_str (ptid
);
2319 static struct target_ops monitor_ops
;
2322 init_base_monitor_ops (void)
2324 monitor_ops
.to_close
= monitor_close
;
2325 monitor_ops
.to_detach
= monitor_detach
;
2326 monitor_ops
.to_resume
= monitor_resume
;
2327 monitor_ops
.to_wait
= monitor_wait
;
2328 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2329 monitor_ops
.to_store_registers
= monitor_store_registers
;
2330 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2331 monitor_ops
.deprecated_xfer_memory
= monitor_xfer_memory
;
2332 monitor_ops
.to_files_info
= monitor_files_info
;
2333 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2334 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2335 monitor_ops
.to_kill
= monitor_kill
;
2336 monitor_ops
.to_load
= monitor_load
;
2337 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2338 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2339 monitor_ops
.to_stop
= monitor_stop
;
2340 monitor_ops
.to_rcmd
= monitor_rcmd
;
2341 monitor_ops
.to_log_command
= serial_log_command
;
2342 monitor_ops
.to_thread_alive
= monitor_thread_alive
;
2343 monitor_ops
.to_pid_to_str
= monitor_pid_to_str
;
2344 monitor_ops
.to_stratum
= process_stratum
;
2345 monitor_ops
.to_has_all_memory
= default_child_has_all_memory
;
2346 monitor_ops
.to_has_memory
= default_child_has_memory
;
2347 monitor_ops
.to_has_stack
= default_child_has_stack
;
2348 monitor_ops
.to_has_registers
= default_child_has_registers
;
2349 monitor_ops
.to_has_execution
= default_child_has_execution
;
2350 monitor_ops
.to_magic
= OPS_MAGIC
;
2351 } /* init_base_monitor_ops */
2353 /* Init the target_ops structure pointed at by OPS */
2356 init_monitor_ops (struct target_ops
*ops
)
2358 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2359 init_base_monitor_ops ();
2361 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2364 /* Define additional commands that are usually only used by monitors. */
2366 /* -Wmissing-prototypes */
2367 extern initialize_file_ftype _initialize_remote_monitors
;
2370 _initialize_remote_monitors (void)
2372 init_base_monitor_ops ();
2373 add_setshow_boolean_cmd ("hash", no_class
, &hashmark
, _("\
2374 Set display of activity while downloading a file."), _("\
2375 Show display of activity while downloading a file."), _("\
2376 When enabled, a hashmark \'#\' is displayed."),
2378 NULL
, /* FIXME: i18n: */
2379 &setlist
, &showlist
);
2381 add_setshow_zinteger_cmd ("monitor", no_class
, &monitor_debug_p
, _("\
2382 Set debugging of remote monitor communication."), _("\
2383 Show debugging of remote monitor communication."), _("\
2384 When enabled, communication between GDB and the remote monitor\n\
2387 NULL
, /* FIXME: i18n: */
2388 &setdebuglist
, &showdebuglist
);
2390 /* Yes, 42000 is arbitrary. The only sense out of it, is that it
2392 monitor_ptid
= ptid_build (42000, 0, 42000);