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 (0x%s): %s: %s%c"), function
, paddr_nz (memaddr
), message
, safe_string
, final_char
);
219 error (_("%s (0x%s): %s: %s"), function
, paddr_nz (memaddr
), message
, safe_string
);
222 /* Convert hex digit A to a number. */
227 if (a
>= '0' && a
<= '9')
229 else if (a
>= 'a' && a
<= 'f')
231 else if (a
>= 'A' && a
<= 'F')
234 error (_("Invalid hex digit %d"), a
);
237 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
239 This function exists to get around the problem that many host platforms
240 don't have a printf that can print 64-bit addresses. The %A format
241 specification is recognized as a special case, and causes the argument
242 to be printed as a 64-bit hexadecimal address.
244 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
245 If it is a '%s' format, the argument is a string; otherwise the
246 argument is assumed to be a long integer.
248 %% is also turned into a single %.
252 monitor_vsprintf (char *sndbuf
, char *pattern
, va_list args
)
262 for (p
= pattern
; *p
; p
++)
266 /* Copy the format specifier to a separate buffer. */
268 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
271 format
[i
] = fmt
= *p
;
272 format
[i
+ 1] = '\0';
274 /* Fetch the next argument and print it. */
278 strcpy (sndbuf
, "%");
281 arg_addr
= va_arg (args
, CORE_ADDR
);
282 strcpy (sndbuf
, paddr_nz (arg_addr
));
285 arg_string
= va_arg (args
, char *);
286 sprintf (sndbuf
, format
, arg_string
);
289 arg_int
= va_arg (args
, long);
290 sprintf (sndbuf
, format
, arg_int
);
293 sndbuf
+= strlen (sndbuf
);
302 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
303 Works just like printf. */
306 monitor_printf_noecho (char *pattern
,...)
312 va_start (args
, pattern
);
314 monitor_vsprintf (sndbuf
, pattern
, args
);
316 len
= strlen (sndbuf
);
317 if (len
+ 1 > sizeof sndbuf
)
318 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
322 char *safe_string
= (char *) alloca ((strlen (sndbuf
) * 4) + 1);
323 monitor_printable_string (safe_string
, sndbuf
, 0);
324 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
327 monitor_write (sndbuf
, len
);
330 /* monitor_printf -- Send data to monitor and check the echo. Works just like
334 monitor_printf (char *pattern
,...)
340 va_start (args
, pattern
);
342 monitor_vsprintf (sndbuf
, pattern
, args
);
344 len
= strlen (sndbuf
);
345 if (len
+ 1 > sizeof sndbuf
)
346 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
350 char *safe_string
= (char *) alloca ((len
* 4) + 1);
351 monitor_printable_string (safe_string
, sndbuf
, 0);
352 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
355 monitor_write (sndbuf
, len
);
357 /* We used to expect that the next immediate output was the characters we
358 just output, but sometimes some extra junk appeared before the characters
359 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
360 So, just start searching for what we sent, and skip anything unknown. */
361 monitor_debug ("ExpectEcho\n");
362 monitor_expect (sndbuf
, (char *) 0, 0);
366 /* Write characters to the remote system. */
369 monitor_write (char *buf
, int buflen
)
371 if (serial_write (monitor_desc
, buf
, buflen
))
372 fprintf_unfiltered (gdb_stderr
, "serial_write failed: %s\n",
373 safe_strerror (errno
));
377 /* Read a binary character from the remote system, doing all the fancy
378 timeout stuff, but without interpreting the character in any way,
379 and without printing remote debug information. */
382 monitor_readchar (void)
390 c
= serial_readchar (monitor_desc
, timeout
);
393 c
&= 0xff; /* don't lose bit 7 */
400 if (c
== SERIAL_TIMEOUT
)
401 error (_("Timeout reading from remote system."));
403 perror_with_name (_("remote-monitor"));
407 /* Read a character from the remote system, doing all the fancy
411 readchar (int timeout
)
416 last_random
, last_nl
, last_cr
, last_crnl
424 c
= serial_readchar (monitor_desc
, timeout
);
429 /* This seems to interfere with proper function of the
431 if (monitor_debug_p
|| remote_debug
)
436 puts_debug ("read -->", buf
, "<--");
441 /* Canonicialize \n\r combinations into one \r */
442 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
444 if ((c
== '\r' && state
== last_nl
)
445 || (c
== '\n' && state
== last_cr
))
466 if (c
== SERIAL_TIMEOUT
)
468 /* I fail to see how detaching here can be useful */
469 if (in_monitor_wait
) /* Watchdog went off */
471 target_mourn_inferior ();
472 error (_("GDB serial timeout has expired. Target detached."));
476 error (_("Timeout reading from remote system."));
478 perror_with_name (_("remote-monitor"));
481 /* Scan input from the remote system, until STRING is found. If BUF is non-
482 zero, then collect input until we have collected either STRING or BUFLEN-1
483 chars. In either case we terminate BUF with a 0. If input overflows BUF
484 because STRING can't be found, return -1, else return number of chars in BUF
485 (minus the terminating NUL). Note that in the non-overflow case, STRING
486 will be at the end of BUF. */
489 monitor_expect (char *string
, char *buf
, int buflen
)
492 int obuflen
= buflen
;
497 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
498 monitor_printable_string (safe_string
, string
, 0);
499 fprintf_unfiltered (gdb_stdlog
, "MON Expecting '%s'\n", safe_string
);
514 c
= readchar (timeout
);
521 c
= readchar (timeout
);
523 /* Don't expect any ^C sent to be echoed */
525 if (*p
== '\003' || c
== *p
)
535 return obuflen
- buflen
;
543 /* We got a character that doesn't match the string. We need to
544 back up p, but how far? If we're looking for "..howdy" and the
545 monitor sends "...howdy"? There's certainly a match in there,
546 but when we receive the third ".", we won't find it if we just
547 restart the matching at the beginning of the string.
549 This is a Boyer-Moore kind of situation. We want to reset P to
550 the end of the longest prefix of STRING that is a suffix of
551 what we've read so far. In the example above, that would be
552 ".." --- the longest prefix of "..howdy" that is a suffix of
553 "...". This longest prefix could be the empty string, if C
554 is nowhere to be found in STRING.
556 If this longest prefix is not the empty string, it must contain
557 C, so let's search from the end of STRING for instances of C,
558 and see if the portion of STRING before that is a suffix of
559 what we read before C. Actually, we can search backwards from
560 p, since we know no prefix can be longer than that.
562 Note that we can use STRING itself, along with C, as a record
563 of what we've received so far. :) */
566 for (i
= (p
- string
) - 1; i
>= 0; i
--)
569 /* Is this prefix a suffix of what we've read so far?
571 string[0 .. i-1] == string[p - i, p - 1]? */
572 if (! memcmp (string
, p
- i
, i
))
584 /* Search for a regexp. */
587 monitor_expect_regexp (struct re_pattern_buffer
*pat
, char *buf
, int buflen
)
591 monitor_debug ("MON Expecting regexp\n");
596 mybuf
= alloca (TARGET_BUF_SIZE
);
597 buflen
= TARGET_BUF_SIZE
;
605 if (p
- mybuf
>= buflen
)
606 { /* Buffer about to overflow */
608 /* On overflow, we copy the upper half of the buffer to the lower half. Not
609 great, but it usually works... */
611 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
612 p
= mybuf
+ buflen
/ 2;
615 *p
++ = readchar (timeout
);
617 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
623 /* Keep discarding input until we see the MONITOR prompt.
625 The convention for dealing with the prompt is that you
627 o *then* wait for the prompt.
629 Thus the last thing that a procedure does with the serial line will
630 be an monitor_expect_prompt(). Exception: monitor_resume does not
631 wait for the prompt, because the terminal is being handed over to
632 the inferior. However, the next thing which happens after that is
633 a monitor_wait which does wait for the prompt. Note that this
634 includes abnormal exit, e.g. error(). This is necessary to prevent
635 getting into states from which we can't recover. */
638 monitor_expect_prompt (char *buf
, int buflen
)
640 monitor_debug ("MON Expecting prompt\n");
641 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
644 /* Get N 32-bit words from remote, each preceded by a space, and put
645 them in registers starting at REGNO. */
656 ch
= readchar (timeout
);
657 while (isspace (ch
));
661 for (i
= 7; i
>= 1; i
--)
663 ch
= readchar (timeout
);
666 val
= (val
<< 4) | from_hex (ch
);
674 compile_pattern (char *pattern
, struct re_pattern_buffer
*compiled_pattern
,
680 compiled_pattern
->fastmap
= fastmap
;
682 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
683 val
= re_compile_pattern (pattern
,
689 error (_("compile_pattern: Can't compile pattern string `%s': %s!"), pattern
, val
);
692 re_compile_fastmap (compiled_pattern
);
695 /* Open a connection to a remote debugger. NAME is the filename used
696 for communication. */
699 monitor_open (char *args
, struct monitor_ops
*mon_ops
, int from_tty
)
704 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
705 error (_("Magic number of monitor_ops struct wrong."));
707 targ_ops
= mon_ops
->target
;
708 name
= targ_ops
->to_shortname
;
711 error (_("Use `target %s DEVICE-NAME' to use a serial port, or \n\
712 `target %s HOST-NAME:PORT-NUMBER' to use a network connection."), name
, name
);
714 target_preopen (from_tty
);
716 /* Setup pattern for register dump */
718 if (mon_ops
->register_pattern
)
719 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
722 if (mon_ops
->getmem
.resp_delim
)
723 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
724 getmem_resp_delim_fastmap
);
726 if (mon_ops
->setmem
.resp_delim
)
727 compile_pattern (mon_ops
->setmem
.resp_delim
, &setmem_resp_delim_pattern
,
728 setmem_resp_delim_fastmap
);
730 if (mon_ops
->setreg
.resp_delim
)
731 compile_pattern (mon_ops
->setreg
.resp_delim
, &setreg_resp_delim_pattern
,
732 setreg_resp_delim_fastmap
);
734 unpush_target (targ_ops
);
738 dev_name
= xstrdup (args
);
740 monitor_desc
= serial_open (dev_name
);
743 perror_with_name (dev_name
);
747 if (serial_setbaudrate (monitor_desc
, baud_rate
))
749 serial_close (monitor_desc
);
750 perror_with_name (dev_name
);
754 serial_raw (monitor_desc
);
756 serial_flush_input (monitor_desc
);
758 /* some systems only work with 2 stop bits */
760 serial_setstopbits (monitor_desc
, mon_ops
->stopbits
);
762 current_monitor
= mon_ops
;
764 /* See if we can wake up the monitor. First, try sending a stop sequence,
765 then send the init strings. Last, remove all breakpoints. */
767 if (current_monitor
->stop
)
769 monitor_stop (inferior_ptid
);
770 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
772 monitor_debug ("EXP Open echo\n");
773 monitor_expect_prompt (NULL
, 0);
777 /* wake up the monitor and see if it's alive */
778 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
780 /* Some of the characters we send may not be echoed,
781 but we hope to get a prompt at the end of it all. */
783 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
786 monitor_printf_noecho (*p
);
787 monitor_expect_prompt (NULL
, 0);
790 serial_flush_input (monitor_desc
);
792 /* Alloc breakpoints */
793 if (mon_ops
->set_break
!= NULL
)
795 if (mon_ops
->num_breakpoints
== 0)
796 mon_ops
->num_breakpoints
= 8;
798 breakaddr
= (CORE_ADDR
*) xmalloc (mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
799 memset (breakaddr
, 0, mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
802 /* Remove all breakpoints */
804 if (mon_ops
->clr_all_break
)
806 monitor_printf (mon_ops
->clr_all_break
);
807 monitor_expect_prompt (NULL
, 0);
811 printf_unfiltered (_("Remote target %s connected to %s\n"), name
, dev_name
);
813 push_target (targ_ops
);
818 /* Make run command think we are busy... */
819 inferior_ptid
= monitor_ptid
;
820 add_inferior_silent (ptid_get_pid (inferior_ptid
));
821 add_thread_silent (inferior_ptid
);
823 /* Give monitor_wait something to read */
825 monitor_printf (current_monitor
->line_term
);
827 start_remote (from_tty
);
830 /* Close out all files and local state before this target loses
834 monitor_close (int quitting
)
837 serial_close (monitor_desc
);
839 /* Free breakpoint memory */
840 if (breakaddr
!= NULL
)
848 delete_thread_silent (monitor_ptid
);
849 delete_inferior_silent (ptid_get_pid (monitor_ptid
));
852 /* Terminate the open connection to the remote debugger. Use this
853 when you want to detach and do something else with your gdb. */
856 monitor_detach (struct target_ops
*ops
, char *args
, int from_tty
)
858 pop_target (); /* calls monitor_close to do the real work */
860 printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname
);
863 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
866 monitor_supply_register (struct regcache
*regcache
, int regno
, char *valstr
)
869 unsigned char regbuf
[MAX_REGISTER_SIZE
];
874 while (p
&& *p
!= '\0')
876 if (*p
== '\r' || *p
== '\n')
887 if (!isxdigit (*p
) && *p
!= 'x')
893 val
+= fromhex (*p
++);
895 monitor_debug ("Supplying Register %d %s\n", regno
, valstr
);
897 if (val
== 0 && valstr
== p
)
898 error (_("monitor_supply_register (%d): bad value from monitor: %s."),
901 /* supply register stores in target byte order, so swap here */
903 store_unsigned_integer (regbuf
,
904 register_size (get_regcache_arch (regcache
), regno
),
907 regcache_raw_supply (regcache
, regno
, regbuf
);
912 /* Tell the remote machine to resume. */
915 monitor_resume (ptid_t ptid
, int step
, enum target_signal sig
)
917 /* Some monitors require a different command when starting a program */
918 monitor_debug ("MON resume\n");
919 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
922 monitor_printf ("run\r");
923 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
928 monitor_printf (current_monitor
->step
);
931 if (current_monitor
->continue_hook
)
932 (*current_monitor
->continue_hook
) ();
934 monitor_printf (current_monitor
->cont
);
935 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
940 /* Parse the output of a register dump command. A monitor specific
941 regexp is used to extract individual register descriptions of the
942 form REG=VAL. Each description is split up into a name and a value
943 string which are passed down to monitor specific code. */
946 parse_register_dump (struct regcache
*regcache
, char *buf
, int len
)
948 monitor_debug ("MON Parsing register dump\n");
951 int regnamelen
, vallen
;
953 /* Element 0 points to start of register name, and element 1
954 points to the start of the register value. */
955 struct re_registers register_strings
;
957 memset (®ister_strings
, 0, sizeof (struct re_registers
));
959 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
960 ®ister_strings
) == -1)
963 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
964 regname
= buf
+ register_strings
.start
[1];
965 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
966 val
= buf
+ register_strings
.start
[2];
968 current_monitor
->supply_register (regcache
, regname
, regnamelen
,
971 buf
+= register_strings
.end
[0];
972 len
-= register_strings
.end
[0];
976 /* Send ^C to target to halt it. Target will respond, and send us a
980 monitor_interrupt (int signo
)
982 /* If this doesn't work, try more severe steps. */
983 signal (signo
, monitor_interrupt_twice
);
985 if (monitor_debug_p
|| remote_debug
)
986 fprintf_unfiltered (gdb_stdlog
, "monitor_interrupt called\n");
988 target_stop (inferior_ptid
);
991 /* The user typed ^C twice. */
994 monitor_interrupt_twice (int signo
)
996 signal (signo
, ofunc
);
998 monitor_interrupt_query ();
1000 signal (signo
, monitor_interrupt
);
1003 /* Ask the user what to do when an interrupt is received. */
1006 monitor_interrupt_query (void)
1008 target_terminal_ours ();
1010 if (query ("Interrupted while waiting for the program.\n\
1011 Give up (and stop debugging it)? "))
1013 target_mourn_inferior ();
1014 deprecated_throw_reason (RETURN_QUIT
);
1017 target_terminal_inferior ();
1021 monitor_wait_cleanup (void *old_timeout
)
1023 timeout
= *(int *) old_timeout
;
1024 signal (SIGINT
, ofunc
);
1025 in_monitor_wait
= 0;
1031 monitor_wait_filter (char *buf
,
1034 struct target_waitstatus
*status
)
1039 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1040 *ext_resp_len
= resp_len
;
1043 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1045 while (resp_len
< 0);
1047 /* Print any output characters that were preceded by ^O. */
1048 /* FIXME - This would be great as a user settabgle flag */
1049 if (monitor_debug_p
|| remote_debug
1050 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1054 for (i
= 0; i
< resp_len
- 1; i
++)
1056 putchar_unfiltered (buf
[++i
]);
1062 /* Wait until the remote machine stops, then return, storing status in
1063 status just as `wait' would. */
1066 monitor_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1068 int old_timeout
= timeout
;
1069 char buf
[TARGET_BUF_SIZE
];
1071 struct cleanup
*old_chain
;
1073 status
->kind
= TARGET_WAITKIND_EXITED
;
1074 status
->value
.integer
= 0;
1076 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1077 monitor_debug ("MON wait\n");
1080 /* This is somthing other than a maintenance command */
1081 in_monitor_wait
= 1;
1082 timeout
= watchdog
> 0 ? watchdog
: -1;
1084 timeout
= -1; /* Don't time out -- user program is running. */
1087 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1089 if (current_monitor
->wait_filter
)
1090 (*current_monitor
->wait_filter
) (buf
, sizeof (buf
), &resp_len
, status
);
1092 monitor_wait_filter (buf
, sizeof (buf
), &resp_len
, status
);
1094 #if 0 /* Transferred to monitor wait filter */
1097 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1100 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1102 while (resp_len
< 0);
1104 /* Print any output characters that were preceded by ^O. */
1105 /* FIXME - This would be great as a user settabgle flag */
1106 if (monitor_debug_p
|| remote_debug
1107 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1111 for (i
= 0; i
< resp_len
- 1; i
++)
1113 putchar_unfiltered (buf
[++i
]);
1117 signal (SIGINT
, ofunc
);
1119 timeout
= old_timeout
;
1121 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1124 monitor_printf (current_monitor
->dump_registers
);
1125 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1128 if (current_monitor
->register_pattern
)
1129 parse_register_dump (get_current_regcache (), buf
, resp_len
);
1131 monitor_debug ("Wait fetching registers after stop\n");
1132 monitor_dump_regs (get_current_regcache ());
1135 status
->kind
= TARGET_WAITKIND_STOPPED
;
1136 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1138 discard_cleanups (old_chain
);
1140 in_monitor_wait
= 0;
1142 return inferior_ptid
;
1145 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1149 monitor_fetch_register (struct regcache
*regcache
, int regno
)
1156 regbuf
= alloca (MAX_REGISTER_SIZE
* 2 + 1);
1157 zerobuf
= alloca (MAX_REGISTER_SIZE
);
1158 memset (zerobuf
, 0, MAX_REGISTER_SIZE
);
1160 if (current_monitor
->regname
!= NULL
)
1161 name
= current_monitor
->regname (regno
);
1163 name
= current_monitor
->regnames
[regno
];
1164 monitor_debug ("MON fetchreg %d '%s'\n", regno
, name
? name
: "(null name)");
1166 if (!name
|| (*name
== '\0'))
1168 monitor_debug ("No register known for %d\n", regno
);
1169 regcache_raw_supply (regcache
, regno
, zerobuf
);
1173 /* send the register examine command */
1175 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1177 /* If RESP_DELIM is specified, we search for that as a leading
1178 delimiter for the register value. Otherwise, we just start
1179 searching from the start of the buf. */
1181 if (current_monitor
->getreg
.resp_delim
)
1183 monitor_debug ("EXP getreg.resp_delim\n");
1184 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1185 /* Handle case of first 32 registers listed in pairs. */
1186 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1187 && (regno
& 1) != 0 && regno
< 32)
1189 monitor_debug ("EXP getreg.resp_delim\n");
1190 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1194 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1195 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1198 c
= readchar (timeout
);
1200 c
= readchar (timeout
);
1201 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1204 error (_("Bad value returned from monitor while fetching register %x."),
1208 /* Read upto the maximum number of hex digits for this register, skipping
1209 spaces, but stop reading if something else is seen. Some monitors
1210 like to drop leading zeros. */
1212 for (i
= 0; i
< register_size (get_regcache_arch (regcache
), regno
) * 2; i
++)
1215 c
= readchar (timeout
);
1217 c
= readchar (timeout
);
1225 regbuf
[i
] = '\000'; /* terminate the number */
1226 monitor_debug ("REGVAL '%s'\n", regbuf
);
1228 /* If TERM is present, we wait for that to show up. Also, (if TERM
1229 is present), we will send TERM_CMD if that is present. In any
1230 case, we collect all of the output into buf, and then wait for
1231 the normal prompt. */
1233 if (current_monitor
->getreg
.term
)
1235 monitor_debug ("EXP getreg.term\n");
1236 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1239 if (current_monitor
->getreg
.term_cmd
)
1241 monitor_debug ("EMIT getreg.term.cmd\n");
1242 monitor_printf (current_monitor
->getreg
.term_cmd
);
1244 if (!current_monitor
->getreg
.term
|| /* Already expected or */
1245 current_monitor
->getreg
.term_cmd
) /* ack expected */
1246 monitor_expect_prompt (NULL
, 0); /* get response */
1248 monitor_supply_register (regcache
, regno
, regbuf
);
1251 /* Sometimes, it takes several commands to dump the registers */
1252 /* This is a primitive for use by variations of monitor interfaces in
1253 case they need to compose the operation.
1256 monitor_dump_reg_block (struct regcache
*regcache
, char *block_cmd
)
1258 char buf
[TARGET_BUF_SIZE
];
1260 monitor_printf (block_cmd
);
1261 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1262 parse_register_dump (regcache
, buf
, resp_len
);
1267 /* Read the remote registers into the block regs. */
1268 /* Call the specific function if it has been provided */
1271 monitor_dump_regs (struct regcache
*regcache
)
1273 char buf
[TARGET_BUF_SIZE
];
1275 if (current_monitor
->dumpregs
)
1276 (*(current_monitor
->dumpregs
)) (regcache
); /* call supplied function */
1277 else if (current_monitor
->dump_registers
) /* default version */
1279 monitor_printf (current_monitor
->dump_registers
);
1280 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1281 parse_register_dump (regcache
, buf
, resp_len
);
1284 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check")); /* Need some way to read registers */
1288 monitor_fetch_registers (struct regcache
*regcache
, int regno
)
1290 monitor_debug ("MON fetchregs\n");
1291 if (current_monitor
->getreg
.cmd
)
1295 monitor_fetch_register (regcache
, regno
);
1299 for (regno
= 0; regno
< gdbarch_num_regs (get_regcache_arch (regcache
));
1301 monitor_fetch_register (regcache
, regno
);
1305 monitor_dump_regs (regcache
);
1309 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1312 monitor_store_register (struct regcache
*regcache
, int regno
)
1317 if (current_monitor
->regname
!= NULL
)
1318 name
= current_monitor
->regname (regno
);
1320 name
= current_monitor
->regnames
[regno
];
1322 if (!name
|| (*name
== '\0'))
1324 monitor_debug ("MON Cannot store unknown register\n");
1328 regcache_cooked_read_unsigned (regcache
, regno
, &val
);
1329 monitor_debug ("MON storeg %d %s\n", regno
,
1331 register_size (get_regcache_arch (regcache
), regno
)));
1333 /* send the register deposit command */
1335 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1336 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1337 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1338 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1340 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1342 if (current_monitor
->setreg
.resp_delim
)
1344 monitor_debug ("EXP setreg.resp_delim\n");
1345 monitor_expect_regexp (&setreg_resp_delim_pattern
, NULL
, 0);
1346 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1347 monitor_printf ("%s\r", paddr_nz (val
));
1349 if (current_monitor
->setreg
.term
)
1351 monitor_debug ("EXP setreg.term\n");
1352 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1353 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1354 monitor_printf ("%s\r", paddr_nz (val
));
1355 monitor_expect_prompt (NULL
, 0);
1358 monitor_expect_prompt (NULL
, 0);
1359 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1361 monitor_debug ("EXP setreg_termcmd\n");
1362 monitor_printf ("%s", current_monitor
->setreg
.term_cmd
);
1363 monitor_expect_prompt (NULL
, 0);
1365 } /* monitor_store_register */
1367 /* Store the remote registers. */
1370 monitor_store_registers (struct regcache
*regcache
, int regno
)
1374 monitor_store_register (regcache
, regno
);
1378 for (regno
= 0; regno
< gdbarch_num_regs (get_regcache_arch (regcache
));
1380 monitor_store_register (regcache
, regno
);
1383 /* Get ready to modify the registers array. On machines which store
1384 individual registers, this doesn't need to do anything. On machines
1385 which store all the registers in one fell swoop, this makes sure
1386 that registers contains all the registers from the program being
1390 monitor_prepare_to_store (struct regcache
*regcache
)
1392 /* Do nothing, since we can store individual regs */
1396 monitor_files_info (struct target_ops
*ops
)
1398 printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name
, baud_rate
);
1402 monitor_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1404 unsigned int val
, hostval
;
1408 monitor_debug ("MON write %d %s\n", len
, paddr (memaddr
));
1410 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1411 memaddr
= gdbarch_addr_bits_remove (current_gdbarch
, memaddr
);
1413 /* Use memory fill command for leading 0 bytes. */
1415 if (current_monitor
->fill
)
1417 for (i
= 0; i
< len
; i
++)
1421 if (i
> 4) /* More than 4 zeros is worth doing */
1423 monitor_debug ("MON FILL %d\n", i
);
1424 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1425 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
) - 1, 0);
1427 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1429 monitor_expect_prompt (NULL
, 0);
1436 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1437 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1440 cmd
= current_monitor
->setmem
.cmdll
;
1444 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1447 cmd
= current_monitor
->setmem
.cmdl
;
1449 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1452 cmd
= current_monitor
->setmem
.cmdw
;
1457 cmd
= current_monitor
->setmem
.cmdb
;
1460 val
= extract_unsigned_integer (myaddr
, len
);
1464 hostval
= *(unsigned int *) myaddr
;
1465 monitor_debug ("Hostval(%08x) val(%08x)\n", hostval
, val
);
1469 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1470 monitor_printf_noecho (cmd
, memaddr
, val
);
1471 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1474 monitor_printf_noecho (cmd
, memaddr
);
1476 if (current_monitor
->setmem
.resp_delim
)
1478 monitor_debug ("EXP setmem.resp_delim");
1479 monitor_expect_regexp (&setmem_resp_delim_pattern
, NULL
, 0);
1480 monitor_printf ("%x\r", val
);
1482 if (current_monitor
->setmem
.term
)
1484 monitor_debug ("EXP setmem.term");
1485 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1486 monitor_printf ("%x\r", val
);
1488 if (current_monitor
->setmem
.term_cmd
)
1489 { /* Emit this to get out of the memory editing state */
1490 monitor_printf ("%s", current_monitor
->setmem
.term_cmd
);
1491 /* Drop through to expecting a prompt */
1495 monitor_printf (cmd
, memaddr
, val
);
1497 monitor_expect_prompt (NULL
, 0);
1504 monitor_write_memory_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
1510 /* Enter the sub mode */
1511 monitor_printf (current_monitor
->setmem
.cmdb
, memaddr
);
1512 monitor_expect_prompt (NULL
, 0);
1516 monitor_printf ("%x\r", val
);
1520 /* If we wanted to, here we could validate the address */
1521 monitor_expect_prompt (NULL
, 0);
1524 /* Now exit the sub mode */
1525 monitor_printf (current_monitor
->getreg
.term_cmd
);
1526 monitor_expect_prompt (NULL
, 0);
1532 longlongendswap (unsigned char *a
)
1541 *(a
+ i
) = *(a
+ j
);
1546 /* Format 32 chars of long long value, advance the pointer */
1547 static char *hexlate
= "0123456789abcdef";
1549 longlong_hexchars (unsigned long long value
,
1559 static unsigned char disbuf
[8]; /* disassembly buffer */
1560 unsigned char *scan
, *limit
; /* loop controls */
1561 unsigned char c
, nib
;
1566 unsigned long long *dp
;
1567 dp
= (unsigned long long *) scan
;
1570 longlongendswap (disbuf
); /* FIXME: ONly on big endian hosts */
1571 while (scan
< limit
)
1573 c
= *scan
++; /* a byte of our long long value */
1579 leadzero
= 0; /* henceforth we print even zeroes */
1581 nib
= c
>> 4; /* high nibble bits */
1582 *outbuff
++ = hexlate
[nib
];
1583 nib
= c
& 0x0f; /* low nibble bits */
1584 *outbuff
++ = hexlate
[nib
];
1588 } /* longlong_hexchars */
1592 /* I am only going to call this when writing virtual byte streams.
1593 Which possably entails endian conversions
1596 monitor_write_memory_longlongs (CORE_ADDR memaddr
, char *myaddr
, int len
)
1598 static char hexstage
[20]; /* At least 16 digits required, plus null */
1603 llptr
= (unsigned long long *) myaddr
;
1606 monitor_printf (current_monitor
->setmem
.cmdll
, memaddr
);
1607 monitor_expect_prompt (NULL
, 0);
1611 endstring
= longlong_hexchars (*llptr
, hexstage
);
1612 *endstring
= '\0'; /* NUll terminate for printf */
1613 monitor_printf ("%s\r", hexstage
);
1617 /* If we wanted to, here we could validate the address */
1618 monitor_expect_prompt (NULL
, 0);
1621 /* Now exit the sub mode */
1622 monitor_printf (current_monitor
->getreg
.term_cmd
);
1623 monitor_expect_prompt (NULL
, 0);
1629 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1630 /* This is for the large blocks of memory which may occur in downloading.
1631 And for monitors which use interactive entry,
1632 And for monitors which do not have other downloading methods.
1633 Without this, we will end up calling monitor_write_memory many times
1634 and do the entry and exit of the sub mode many times
1635 This currently assumes...
1636 MO_SETMEM_INTERACTIVE
1637 ! MO_NO_ECHO_ON_SETMEM
1638 To use this, the you have to patch the monitor_cmds block with
1639 this function. Otherwise, its not tuned up for use by all
1644 monitor_write_memory_block (CORE_ADDR memaddr
, char *myaddr
, int len
)
1648 /* FIXME: This would be a good place to put the zero test */
1650 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1652 return monitor_write_memory_longlongs (memaddr
, myaddr
, len
);
1655 written
= monitor_write_memory_bytes (memaddr
, myaddr
, len
);
1659 /* This is an alternate form of monitor_read_memory which is used for monitors
1660 which can only read a single byte/word/etc. at a time. */
1663 monitor_read_memory_single (CORE_ADDR memaddr
, char *myaddr
, int len
)
1666 char membuf
[sizeof (int) * 2 + 1];
1670 monitor_debug ("MON read single\n");
1672 /* Can't actually use long longs (nice idea, though). In fact, the
1673 call to strtoul below will fail if it tries to convert a value
1674 that's too big to fit in a long. */
1675 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1678 cmd
= current_monitor
->getmem
.cmdll
;
1682 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1685 cmd
= current_monitor
->getmem
.cmdl
;
1687 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1690 cmd
= current_monitor
->getmem
.cmdw
;
1695 cmd
= current_monitor
->getmem
.cmdb
;
1698 /* Send the examine command. */
1700 monitor_printf (cmd
, memaddr
);
1702 /* If RESP_DELIM is specified, we search for that as a leading
1703 delimiter for the memory value. Otherwise, we just start
1704 searching from the start of the buf. */
1706 if (current_monitor
->getmem
.resp_delim
)
1708 monitor_debug ("EXP getmem.resp_delim\n");
1709 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1712 /* Now, read the appropriate number of hex digits for this loc,
1715 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1716 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1720 c
= readchar (timeout
);
1722 c
= readchar (timeout
);
1723 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1726 monitor_error ("monitor_read_memory_single",
1727 "bad response from monitor",
1728 memaddr
, 0, NULL
, 0);
1733 for (i
= 0; i
< len
* 2; i
++)
1739 c
= readchar (timeout
);
1745 monitor_error ("monitor_read_memory_single",
1746 "bad response from monitor",
1747 memaddr
, i
, membuf
, 0);
1751 membuf
[i
] = '\000'; /* terminate the number */
1754 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1755 present), we will send TERM_CMD if that is present. In any case, we collect
1756 all of the output into buf, and then wait for the normal prompt. */
1758 if (current_monitor
->getmem
.term
)
1760 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1762 if (current_monitor
->getmem
.term_cmd
)
1764 monitor_printf (current_monitor
->getmem
.term_cmd
);
1765 monitor_expect_prompt (NULL
, 0);
1769 monitor_expect_prompt (NULL
, 0); /* get response */
1772 val
= strtoul (membuf
, &p
, 16);
1774 if (val
== 0 && membuf
== p
)
1775 monitor_error ("monitor_read_memory_single",
1776 "bad value from monitor",
1777 memaddr
, 0, membuf
, 0);
1779 /* supply register stores in target byte order, so swap here */
1781 store_unsigned_integer (myaddr
, len
, val
);
1786 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1787 memory at MEMADDR. Returns length moved. Currently, we do no more
1788 than 16 bytes at a time. */
1791 monitor_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1802 monitor_debug ("Zero length call to monitor_read_memory\n");
1806 monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
1807 paddr_nz (memaddr
), (long) myaddr
, len
);
1809 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1810 memaddr
= gdbarch_addr_bits_remove (current_gdbarch
, memaddr
);
1812 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1813 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1815 len
= min (len
, 16);
1817 /* Some dumpers align the first data with the preceeding 16
1818 byte boundary. Some print blanks and start at the
1819 requested boundary. EXACT_DUMPADDR
1822 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1823 ? memaddr
: memaddr
& ~0x0f;
1825 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1826 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1827 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1829 /* send the memory examine command */
1831 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1832 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
);
1833 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1834 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1836 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1838 /* If TERM is present, we wait for that to show up. Also, (if TERM
1839 is present), we will send TERM_CMD if that is present. In any
1840 case, we collect all of the output into buf, and then wait for
1841 the normal prompt. */
1843 if (current_monitor
->getmem
.term
)
1845 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1848 monitor_error ("monitor_read_memory",
1849 "excessive response from monitor",
1850 memaddr
, resp_len
, buf
, 0);
1852 if (current_monitor
->getmem
.term_cmd
)
1854 serial_write (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1855 strlen (current_monitor
->getmem
.term_cmd
));
1856 monitor_expect_prompt (NULL
, 0);
1860 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1864 /* If RESP_DELIM is specified, we search for that as a leading
1865 delimiter for the values. Otherwise, we just start searching
1866 from the start of the buf. */
1868 if (current_monitor
->getmem
.resp_delim
)
1871 struct re_registers resp_strings
;
1872 monitor_debug ("MON getmem.resp_delim %s\n", current_monitor
->getmem
.resp_delim
);
1874 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1876 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1880 monitor_error ("monitor_read_memory",
1881 "bad response from monitor",
1882 memaddr
, resp_len
, buf
, 0);
1884 p
+= resp_strings
.end
[0];
1886 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1888 monitor_error ("monitor_read_memory",
1889 "bad response from monitor",
1890 memaddr
, resp_len
, buf
, 0);
1891 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1894 monitor_debug ("MON scanning %d ,%lx '%s'\n", len
, (long) p
, p
);
1895 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1903 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1907 if ((dumpaddr
>= memaddr
) && (i
> 0))
1909 val
= fromhex (c
) * 16 + fromhex (*(p
+ 1));
1911 if (monitor_debug_p
|| remote_debug
)
1912 fprintf_unfiltered (gdb_stdlog
, "[%02x]", val
);
1919 ++p
; /* skip a blank or other non hex char */
1923 error (_("Failed to read via monitor"));
1924 if (monitor_debug_p
|| remote_debug
)
1925 fprintf_unfiltered (gdb_stdlog
, "\n");
1926 return fetched
; /* Return the number of bytes actually read */
1928 monitor_debug ("MON scanning bytes\n");
1930 for (i
= len
; i
> 0; i
--)
1932 /* Skip non-hex chars, but bomb on end of string and newlines */
1939 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1940 monitor_error ("monitor_read_memory",
1941 "badly terminated response from monitor",
1942 memaddr
, resp_len
, buf
, 0);
1946 val
= strtoul (p
, &p1
, 16);
1948 if (val
== 0 && p
== p1
)
1949 monitor_error ("monitor_read_memory",
1950 "bad value from monitor",
1951 memaddr
, resp_len
, buf
, 0);
1964 /* Transfer LEN bytes between target address MEMADDR and GDB address
1965 MYADDR. Returns 0 for success, errno code for failure. TARGET is
1969 monitor_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
1970 struct mem_attrib
*attrib
, struct target_ops
*target
)
1976 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
1977 res
= monitor_write_memory_block(memaddr
, myaddr
, len
);
1979 res
= monitor_write_memory(memaddr
, myaddr
, len
);
1983 res
= monitor_read_memory(memaddr
, myaddr
, len
);
1992 return; /* ignore attempts to kill target system */
1995 /* All we actually do is set the PC to the start address of exec_bfd. */
1998 monitor_create_inferior (struct target_ops
*ops
, char *exec_file
,
1999 char *args
, char **env
, int from_tty
)
2001 if (args
&& (*args
!= '\000'))
2002 error (_("Args are not supported by the monitor."));
2005 clear_proceed_status ();
2006 write_pc (bfd_get_start_address (exec_bfd
));
2009 /* Clean up when a program exits.
2010 The program actually lives on in the remote processor's RAM, and may be
2011 run again without a download. Don't leave it full of breakpoint
2015 monitor_mourn_inferior (struct target_ops
*ops
)
2017 unpush_target (targ_ops
);
2018 generic_mourn_inferior (); /* Do all the proper things now */
2019 delete_thread_silent (monitor_ptid
);
2022 /* Tell the monitor to add a breakpoint. */
2025 monitor_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2027 CORE_ADDR addr
= bp_tgt
->placed_address
;
2031 monitor_debug ("MON inst bkpt %s\n", paddr (addr
));
2032 if (current_monitor
->set_break
== NULL
)
2033 error (_("No set_break defined for this monitor"));
2035 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2036 addr
= gdbarch_addr_bits_remove (current_gdbarch
, addr
);
2038 /* Determine appropriate breakpoint size for this address. */
2039 gdbarch_breakpoint_from_pc (current_gdbarch
, &addr
, &bplen
);
2040 bp_tgt
->placed_address
= addr
;
2041 bp_tgt
->placed_size
= bplen
;
2043 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2045 if (breakaddr
[i
] == 0)
2047 breakaddr
[i
] = addr
;
2048 monitor_printf (current_monitor
->set_break
, addr
);
2049 monitor_expect_prompt (NULL
, 0);
2054 error (_("Too many breakpoints (> %d) for monitor."), current_monitor
->num_breakpoints
);
2057 /* Tell the monitor to remove a breakpoint. */
2060 monitor_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2062 CORE_ADDR addr
= bp_tgt
->placed_address
;
2065 monitor_debug ("MON rmbkpt %s\n", paddr (addr
));
2066 if (current_monitor
->clr_break
== NULL
)
2067 error (_("No clr_break defined for this monitor"));
2069 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2071 if (breakaddr
[i
] == addr
)
2074 /* some monitors remove breakpoints based on the address */
2075 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2076 monitor_printf (current_monitor
->clr_break
, addr
);
2077 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2078 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2080 monitor_printf (current_monitor
->clr_break
, i
);
2081 monitor_expect_prompt (NULL
, 0);
2085 fprintf_unfiltered (gdb_stderr
,
2086 "Can't find breakpoint associated with 0x%s\n",
2091 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2092 an S-record. Return non-zero if the ACK is received properly. */
2095 monitor_wait_srec_ack (void)
2099 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2101 return (readchar (timeout
) == '+');
2103 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2105 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2106 if ((ch
= readchar (1)) < 0)
2108 if ((ch
= readchar (1)) < 0)
2110 if ((ch
= readchar (1)) < 0)
2112 if ((ch
= readchar (1)) < 0)
2118 /* monitor_load -- download a file. */
2121 monitor_load (char *file
, int from_tty
)
2123 monitor_debug ("MON load\n");
2125 if (current_monitor
->load_routine
)
2126 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2128 { /* The default is ascii S-records */
2130 unsigned long load_offset
;
2133 /* enable user to specify address for downloading as 2nd arg to load */
2134 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2140 monitor_printf (current_monitor
->load
);
2141 if (current_monitor
->loadresp
)
2142 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2144 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2145 32, SREC_ALL
, hashmark
,
2146 current_monitor
->flags
& MO_SREC_ACK
?
2147 monitor_wait_srec_ack
: NULL
);
2149 monitor_expect_prompt (NULL
, 0);
2152 /* Finally, make the PC point at the start address */
2154 write_pc (bfd_get_start_address (exec_bfd
));
2156 /* There used to be code here which would clear inferior_ptid and
2157 call clear_symtab_users. None of that should be necessary:
2158 monitor targets should behave like remote protocol targets, and
2159 since generic_load does none of those things, this function
2162 Furthermore, clearing inferior_ptid is *incorrect*. After doing
2163 a load, we still have a valid connection to the monitor, with a
2164 live processor state to fiddle with. The user can type
2165 `continue' or `jump *start' and make the program run. If they do
2166 these things, however, GDB will be talking to a running program
2167 while inferior_ptid is null_ptid; this makes things like
2168 reinit_frame_cache very confused. */
2172 monitor_stop (ptid_t ptid
)
2174 monitor_debug ("MON stop\n");
2175 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2176 serial_send_break (monitor_desc
);
2177 if (current_monitor
->stop
)
2178 monitor_printf_noecho (current_monitor
->stop
);
2181 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2182 in OUTPUT until the prompt is seen. FIXME: We read the characters
2183 ourseleves here cause of a nasty echo. */
2186 monitor_rcmd (char *command
,
2187 struct ui_file
*outbuf
)
2193 if (monitor_desc
== NULL
)
2194 error (_("monitor target not open."));
2196 p
= current_monitor
->prompt
;
2198 /* Send the command. Note that if no args were supplied, then we're
2199 just sending the monitor a newline, which is sometimes useful. */
2201 monitor_printf ("%s\r", (command
? command
: ""));
2203 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2205 fputs_unfiltered (buf
, outbuf
); /* Output the response */
2208 /* Convert hex digit A to a number. */
2214 if (a
>= '0' && a
<= '9')
2216 if (a
>= 'a' && a
<= 'f')
2217 return a
- 'a' + 10;
2218 if (a
>= 'A' && a
<= 'F')
2219 return a
- 'A' + 10;
2221 error (_("Reply contains invalid hex digit 0x%x"), a
);
2226 monitor_get_dev_name (void)
2231 /* Check to see if a thread is still alive. */
2234 monitor_thread_alive (ptid_t ptid
)
2236 if (ptid_equal (ptid
, monitor_ptid
))
2237 /* The monitor's task is always alive. */
2243 /* Convert a thread ID to a string. Returns the string in a static
2247 monitor_pid_to_str (ptid_t ptid
)
2249 static char buf
[64];
2251 if (ptid_equal (monitor_ptid
, ptid
))
2253 xsnprintf (buf
, sizeof buf
, "Thread <main>");
2257 return normal_pid_to_str (ptid
);
2260 static struct target_ops monitor_ops
;
2263 init_base_monitor_ops (void)
2265 monitor_ops
.to_close
= monitor_close
;
2266 monitor_ops
.to_detach
= monitor_detach
;
2267 monitor_ops
.to_resume
= monitor_resume
;
2268 monitor_ops
.to_wait
= monitor_wait
;
2269 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2270 monitor_ops
.to_store_registers
= monitor_store_registers
;
2271 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2272 monitor_ops
.deprecated_xfer_memory
= monitor_xfer_memory
;
2273 monitor_ops
.to_files_info
= monitor_files_info
;
2274 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2275 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2276 monitor_ops
.to_kill
= monitor_kill
;
2277 monitor_ops
.to_load
= monitor_load
;
2278 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2279 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2280 monitor_ops
.to_stop
= monitor_stop
;
2281 monitor_ops
.to_rcmd
= monitor_rcmd
;
2282 monitor_ops
.to_log_command
= serial_log_command
;
2283 monitor_ops
.to_thread_alive
= monitor_thread_alive
;
2284 monitor_ops
.to_pid_to_str
= monitor_pid_to_str
;
2285 monitor_ops
.to_stratum
= process_stratum
;
2286 monitor_ops
.to_has_all_memory
= 1;
2287 monitor_ops
.to_has_memory
= 1;
2288 monitor_ops
.to_has_stack
= 1;
2289 monitor_ops
.to_has_registers
= 1;
2290 monitor_ops
.to_has_execution
= 1;
2291 monitor_ops
.to_magic
= OPS_MAGIC
;
2292 } /* init_base_monitor_ops */
2294 /* Init the target_ops structure pointed at by OPS */
2297 init_monitor_ops (struct target_ops
*ops
)
2299 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2300 init_base_monitor_ops ();
2302 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2305 /* Define additional commands that are usually only used by monitors. */
2307 extern initialize_file_ftype _initialize_remote_monitors
; /* -Wmissing-prototypes */
2310 _initialize_remote_monitors (void)
2312 init_base_monitor_ops ();
2313 add_setshow_boolean_cmd ("hash", no_class
, &hashmark
, _("\
2314 Set display of activity while downloading a file."), _("\
2315 Show display of activity while downloading a file."), _("\
2316 When enabled, a hashmark \'#\' is displayed."),
2318 NULL
, /* FIXME: i18n: */
2319 &setlist
, &showlist
);
2321 add_setshow_zinteger_cmd ("monitor", no_class
, &monitor_debug_p
, _("\
2322 Set debugging of remote monitor communication."), _("\
2323 Show debugging of remote monitor communication."), _("\
2324 When enabled, communication between GDB and the remote monitor\n\
2327 NULL
, /* FIXME: i18n: */
2328 &setdebuglist
, &showdebuglist
);
2330 /* Yes, 42000 is arbitrary. The only sense out of it, is that it
2332 monitor_ptid
= ptid_build (42000, 0, 42000);