1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990-1993, 1995-1997, 1999-2000 Free Software Foundation, Inc.
3 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
4 Resurrected from the ashes by Stu Grossman.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* This file was derived from various remote-* modules. It is a collection
24 of generic support functions so GDB can talk directly to a ROM based
25 monitor. This saves use from having to hack an exception based handler
26 into existance, and makes for quick porting.
28 This module talks to a debug monitor called 'MONITOR', which
29 We communicate with MONITOR via either a direct serial line, or a TCP
30 (or possibly TELNET) stream to a terminal multiplexor,
31 which in turn talks to the target board. */
33 /* FIXME 32x64: This code assumes that registers and addresses are at
34 most 32 bits long. If they can be larger, you will need to declare
35 values as LONGEST and use %llx or some such to print values when
36 building commands to send to the monitor. Since we don't know of
37 any actual 64-bit targets with ROM monitors that use this code,
38 it's not an issue right now. -sts 4/18/96 */
46 #include "gdb_string.h"
47 #include <sys/types.h>
53 #include "gnu-regex.h"
57 static char *dev_name
;
58 static struct target_ops
*targ_ops
;
60 static void monitor_vsprintf
PARAMS ((char *sndbuf
, char *pattern
, va_list args
));
62 static int readchar
PARAMS ((int timeout
));
64 static void monitor_fetch_register
PARAMS ((int regno
));
65 static void monitor_store_register
PARAMS ((int regno
));
67 static void monitor_printable_string (char *newstr
, char *oldstr
, int len
);
68 static void monitor_error (char *function
, char *message
, CORE_ADDR memaddr
, int len
, char *string
, int final_char
);
69 static void monitor_detach
PARAMS ((char *args
, int from_tty
));
70 static void monitor_resume
PARAMS ((int pid
, int step
, enum target_signal sig
));
71 static void monitor_interrupt
PARAMS ((int signo
));
72 static void monitor_interrupt_twice
PARAMS ((int signo
));
73 static void monitor_interrupt_query
PARAMS ((void));
74 static void monitor_wait_cleanup
PARAMS ((void *old_timeout
));
76 static int monitor_wait
PARAMS ((int pid
, struct target_waitstatus
* status
));
77 static void monitor_fetch_registers
PARAMS ((int regno
));
78 static void monitor_store_registers
PARAMS ((int regno
));
79 static void monitor_prepare_to_store
PARAMS ((void));
80 static int monitor_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
, int len
, int write
, struct target_ops
* target
));
81 static void monitor_files_info
PARAMS ((struct target_ops
* ops
));
82 static int monitor_insert_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
83 static int monitor_remove_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
84 static void monitor_kill
PARAMS ((void));
85 static void monitor_load
PARAMS ((char *file
, int from_tty
));
86 static void monitor_mourn_inferior
PARAMS ((void));
87 static void monitor_stop
PARAMS ((void));
89 static int monitor_read_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
, int len
));
90 static int monitor_write_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
, int len
));
91 static int monitor_write_memory_bytes
PARAMS ((CORE_ADDR addr
,
92 char *myaddr
, int len
));
93 static int monitor_write_memory_block
PARAMS ((
97 static int monitor_expect_regexp
PARAMS ((struct re_pattern_buffer
* pat
,
98 char *buf
, int buflen
));
99 static void monitor_dump_regs
PARAMS ((void));
101 static int from_hex
PARAMS ((int a
));
102 static unsigned long get_hex_word
PARAMS ((void));
104 static void parse_register_dump
PARAMS ((char *, int));
106 static struct monitor_ops
*current_monitor
;
108 static int hashmark
; /* flag set by "set hash" */
110 static int timeout
= 30;
112 static int in_monitor_wait
= 0; /* Non-zero means we are in monitor_wait() */
114 static void (*ofunc
) (); /* Old SIGINT signal handler */
116 static CORE_ADDR
*breakaddr
;
118 /* Descriptor for I/O to remote machine. Initialize it to NULL so
119 that monitor_open knows that we don't have a file open when the
122 static serial_t monitor_desc
= NULL
;
124 /* Pointer to regexp pattern matching data */
126 static struct re_pattern_buffer register_pattern
;
127 static char register_fastmap
[256];
129 static struct re_pattern_buffer getmem_resp_delim_pattern
;
130 static char getmem_resp_delim_fastmap
[256];
132 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
133 monitor_wait wakes up. */
135 static DCACHE
*remote_dcache
;
136 static int first_time
= 0; /* is this the first time we're executing after
137 gaving created the child proccess? */
139 #define TARGET_BUF_SIZE 2048
141 /* Monitor specific debugging information. Typically only useful to
142 the developer of a new monitor interface. */
144 static void monitor_debug (const char *fmt
, ...) ATTR_FORMAT(printf
, 1, 2);
146 static int monitor_debug_p
= 0;
148 /* NOTE: This file alternates between monitor_debug_p and remote_debug
149 when determining if debug information is printed. Perhaphs this
150 could be simplified. */
153 monitor_debug (const char *fmt
, ...)
158 va_start (args
, fmt
);
159 vfprintf_filtered (gdb_stdlog
, fmt
, args
);
165 /* Convert a string into a printable representation, Return # byte in
166 the new string. When LEN is >0 it specifies the size of the
167 string. Otherwize strlen(oldstr) is used. */
170 monitor_printable_string (char *newstr
, char *oldstr
, int len
)
176 len
= strlen (oldstr
);
178 for (i
= 0; i
< len
; i
++)
189 sprintf (newstr
, "\\x%02x", ch
& 0xff);
228 /* Print monitor errors with a string, converting the string to printable
232 monitor_error (char *function
, char *message
,
233 CORE_ADDR memaddr
, int len
, char *string
, int final_char
)
235 int real_len
= (len
== 0 && string
!= (char *) 0) ? strlen (string
) : len
;
236 char *safe_string
= alloca ((real_len
* 4) + 1);
237 monitor_printable_string (safe_string
, string
, real_len
);
240 error ("%s (0x%s): %s: %s%c", function
, paddr_nz (memaddr
), message
, safe_string
, final_char
);
242 error ("%s (0x%s): %s: %s", function
, paddr_nz (memaddr
), message
, safe_string
);
245 /* Convert hex digit A to a number. */
251 if (a
>= '0' && a
<= '9')
253 else if (a
>= 'a' && a
<= 'f')
255 else if (a
>= 'A' && a
<= 'F')
258 error ("Invalid hex digit %d", a
);
261 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
263 This function exists to get around the problem that many host platforms
264 don't have a printf that can print 64-bit addresses. The %A format
265 specification is recognized as a special case, and causes the argument
266 to be printed as a 64-bit hexadecimal address.
268 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
269 If it is a '%s' format, the argument is a string; otherwise the
270 argument is assumed to be a long integer.
272 %% is also turned into a single %.
276 monitor_vsprintf (sndbuf
, pattern
, args
)
289 for (p
= pattern
; *p
; p
++)
293 /* Copy the format specifier to a separate buffer. */
295 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
298 format
[i
] = fmt
= *p
;
299 format
[i
+ 1] = '\0';
301 /* Fetch the next argument and print it. */
305 strcpy (sndbuf
, "%");
308 arg_addr
= va_arg (args
, CORE_ADDR
);
309 strcpy (sndbuf
, paddr_nz (arg_addr
));
312 arg_string
= va_arg (args
, char *);
313 sprintf (sndbuf
, format
, arg_string
);
316 arg_int
= va_arg (args
, long);
317 sprintf (sndbuf
, format
, arg_int
);
320 sndbuf
+= strlen (sndbuf
);
329 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
330 Works just like printf. */
333 monitor_printf_noecho (char *pattern
,...)
339 va_start (args
, pattern
);
341 monitor_vsprintf (sndbuf
, pattern
, args
);
343 len
= strlen (sndbuf
);
344 if (len
+ 1 > sizeof sndbuf
)
349 char *safe_string
= (char *) alloca ((strlen (sndbuf
) * 4) + 1);
350 monitor_printable_string (safe_string
, sndbuf
, 0);
351 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
354 monitor_write (sndbuf
, len
);
357 /* monitor_printf -- Send data to monitor and check the echo. Works just like
361 monitor_printf (char *pattern
,...)
367 va_start (args
, pattern
);
369 monitor_vsprintf (sndbuf
, pattern
, args
);
371 len
= strlen (sndbuf
);
372 if (len
+ 1 > sizeof sndbuf
)
377 char *safe_string
= (char *) alloca ((len
* 4) + 1);
378 monitor_printable_string (safe_string
, sndbuf
, 0);
379 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
382 monitor_write (sndbuf
, len
);
384 /* We used to expect that the next immediate output was the characters we
385 just output, but sometimes some extra junk appeared before the characters
386 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
387 So, just start searching for what we sent, and skip anything unknown. */
388 monitor_debug ("ExpectEcho\n");
389 monitor_expect (sndbuf
, (char *) 0, 0);
393 /* Write characters to the remote system. */
396 monitor_write (buf
, buflen
)
400 if (SERIAL_WRITE (monitor_desc
, buf
, buflen
))
401 fprintf_unfiltered (gdb_stderr
, "SERIAL_WRITE failed: %s\n",
402 safe_strerror (errno
));
406 /* Read a binary character from the remote system, doing all the fancy
407 timeout stuff, but without interpreting the character in any way,
408 and without printing remote debug information. */
419 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
422 c
&= 0xff; /* don't lose bit 7 */
429 if (c
== SERIAL_TIMEOUT
)
430 error ("Timeout reading from remote system.");
432 perror_with_name ("remote-monitor");
436 /* Read a character from the remote system, doing all the fancy
446 last_random
, last_nl
, last_cr
, last_crnl
454 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
459 /* This seems to interfere with proper function of the
461 if (monitor_debug_p
|| remote_debug
)
466 puts_debug ("read -->", buf
, "<--");
471 /* Canonicialize \n\r combinations into one \r */
472 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
474 if ((c
== '\r' && state
== last_nl
)
475 || (c
== '\n' && state
== last_cr
))
496 if (c
== SERIAL_TIMEOUT
)
498 /* I fail to see how detaching here can be useful */
499 if (in_monitor_wait
) /* Watchdog went off */
501 target_mourn_inferior ();
502 error ("GDB serial timeout has expired. Target detached.\n");
506 error ("Timeout reading from remote system.");
508 perror_with_name ("remote-monitor");
511 /* Scan input from the remote system, until STRING is found. If BUF is non-
512 zero, then collect input until we have collected either STRING or BUFLEN-1
513 chars. In either case we terminate BUF with a 0. If input overflows BUF
514 because STRING can't be found, return -1, else return number of chars in BUF
515 (minus the terminating NUL). Note that in the non-overflow case, STRING
516 will be at the end of BUF. */
519 monitor_expect (string
, buf
, buflen
)
525 int obuflen
= buflen
;
527 extern struct target_ops
*targ_ops
;
531 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
532 monitor_printable_string (safe_string
, string
, 0);
533 fprintf_unfiltered (gdb_stdlog
, "MON Expecting '%s'\n", safe_string
);
548 c
= readchar (timeout
);
555 c
= readchar (timeout
);
557 /* Don't expect any ^C sent to be echoed */
559 if (*p
== '\003' || c
== *p
)
569 return obuflen
- buflen
;
575 else if ((c
== '\021' || c
== '\023') &&
576 (STREQ (targ_ops
->to_shortname
, "m32r")
577 || STREQ (targ_ops
->to_shortname
, "mon2000")))
578 { /* m32r monitor emits random DC1/DC3 chars */
583 /* We got a character that doesn't match the string. We need to
584 back up p, but how far? If we're looking for "..howdy" and the
585 monitor sends "...howdy"? There's certainly a match in there,
586 but when we receive the third ".", we won't find it if we just
587 restart the matching at the beginning of the string.
589 This is a Boyer-Moore kind of situation. We want to reset P to
590 the end of the longest prefix of STRING that is a suffix of
591 what we've read so far. In the example above, that would be
592 ".." --- the longest prefix of "..howdy" that is a suffix of
593 "...". This longest prefix could be the empty string, if C
594 is nowhere to be found in STRING.
596 If this longest prefix is not the empty string, it must contain
597 C, so let's search from the end of STRING for instances of C,
598 and see if the portion of STRING before that is a suffix of
599 what we read before C. Actually, we can search backwards from
600 p, since we know no prefix can be longer than that.
602 Note that we can use STRING itself, along with C, as a record
603 of what we've received so far. :) */
606 for (i
= (p
- string
) - 1; i
>= 0; i
--)
609 /* Is this prefix a suffix of what we've read so far?
611 string[0 .. i-1] == string[p - i, p - 1]? */
612 if (! memcmp (string
, p
- i
, i
))
624 /* Search for a regexp. */
627 monitor_expect_regexp (pat
, buf
, buflen
)
628 struct re_pattern_buffer
*pat
;
634 monitor_debug ("MON Expecting regexp\n");
639 mybuf
= alloca (TARGET_BUF_SIZE
);
640 buflen
= TARGET_BUF_SIZE
;
648 if (p
- mybuf
>= buflen
)
649 { /* Buffer about to overflow */
651 /* On overflow, we copy the upper half of the buffer to the lower half. Not
652 great, but it usually works... */
654 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
655 p
= mybuf
+ buflen
/ 2;
658 *p
++ = readchar (timeout
);
660 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
666 /* Keep discarding input until we see the MONITOR prompt.
668 The convention for dealing with the prompt is that you
670 o *then* wait for the prompt.
672 Thus the last thing that a procedure does with the serial line will
673 be an monitor_expect_prompt(). Exception: monitor_resume does not
674 wait for the prompt, because the terminal is being handed over to
675 the inferior. However, the next thing which happens after that is
676 a monitor_wait which does wait for the prompt. Note that this
677 includes abnormal exit, e.g. error(). This is necessary to prevent
678 getting into states from which we can't recover. */
681 monitor_expect_prompt (buf
, buflen
)
685 monitor_debug ("MON Expecting prompt\n");
686 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
689 /* Get N 32-bit words from remote, each preceded by a space, and put
690 them in registers starting at REGNO. */
701 ch
= readchar (timeout
);
702 while (isspace (ch
));
706 for (i
= 7; i
>= 1; i
--)
708 ch
= readchar (timeout
);
711 val
= (val
<< 4) | from_hex (ch
);
719 compile_pattern (pattern
, compiled_pattern
, fastmap
)
721 struct re_pattern_buffer
*compiled_pattern
;
727 compiled_pattern
->fastmap
= fastmap
;
729 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
730 val
= re_compile_pattern (pattern
,
736 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern
, val
);
739 re_compile_fastmap (compiled_pattern
);
742 /* Open a connection to a remote debugger. NAME is the filename used
743 for communication. */
746 monitor_open (args
, mon_ops
, from_tty
)
748 struct monitor_ops
*mon_ops
;
754 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
755 error ("Magic number of monitor_ops struct wrong.");
757 targ_ops
= mon_ops
->target
;
758 name
= targ_ops
->to_shortname
;
761 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
762 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
764 target_preopen (from_tty
);
766 /* Setup pattern for register dump */
768 if (mon_ops
->register_pattern
)
769 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
772 if (mon_ops
->getmem
.resp_delim
)
773 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
774 getmem_resp_delim_fastmap
);
776 unpush_target (targ_ops
);
780 dev_name
= strsave (args
);
782 monitor_desc
= SERIAL_OPEN (dev_name
);
785 perror_with_name (dev_name
);
789 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
791 SERIAL_CLOSE (monitor_desc
);
792 perror_with_name (dev_name
);
796 SERIAL_RAW (monitor_desc
);
798 SERIAL_FLUSH_INPUT (monitor_desc
);
800 /* some systems only work with 2 stop bits */
802 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
804 current_monitor
= mon_ops
;
806 /* See if we can wake up the monitor. First, try sending a stop sequence,
807 then send the init strings. Last, remove all breakpoints. */
809 if (current_monitor
->stop
)
812 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
814 monitor_debug ("EXP Open echo\n");
815 monitor_expect_prompt (NULL
, 0);
819 /* wake up the monitor and see if it's alive */
820 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
822 /* Some of the characters we send may not be echoed,
823 but we hope to get a prompt at the end of it all. */
825 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
828 monitor_printf_noecho (*p
);
829 monitor_expect_prompt (NULL
, 0);
832 SERIAL_FLUSH_INPUT (monitor_desc
);
834 /* Alloc breakpoints */
835 if (mon_ops
->set_break
!= NULL
)
837 if (mon_ops
->num_breakpoints
== 0)
838 mon_ops
->num_breakpoints
= 8;
840 breakaddr
= (CORE_ADDR
*) xmalloc (mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
841 memset (breakaddr
, 0, mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
844 /* Remove all breakpoints */
846 if (mon_ops
->clr_all_break
)
848 monitor_printf (mon_ops
->clr_all_break
);
849 monitor_expect_prompt (NULL
, 0);
853 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
855 push_target (targ_ops
);
857 inferior_pid
= 42000; /* Make run command think we are busy... */
859 /* Give monitor_wait something to read */
861 monitor_printf (current_monitor
->line_term
);
863 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
864 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory_block
);
866 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory
);
870 /* Close out all files and local state before this target loses
874 monitor_close (quitting
)
878 SERIAL_CLOSE (monitor_desc
);
880 /* Free breakpoint memory */
881 if (breakaddr
!= NULL
)
890 /* Terminate the open connection to the remote debugger. Use this
891 when you want to detach and do something else with your gdb. */
894 monitor_detach (args
, from_tty
)
898 pop_target (); /* calls monitor_close to do the real work */
900 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
903 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
906 monitor_supply_register (regno
, valstr
)
911 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
916 while (p
&& *p
!= '\0')
918 if (*p
== '\r' || *p
== '\n')
929 if (!isxdigit (*p
) && *p
!= 'x')
935 val
+= fromhex (*p
++);
937 monitor_debug ("Supplying Register %d %s\n", regno
, valstr
);
940 error ("monitor_supply_register (%d): bad value from monitor: %s.",
943 /* supply register stores in target byte order, so swap here */
945 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
947 supply_register (regno
, regbuf
);
952 /* Tell the remote machine to resume. */
955 flush_monitor_dcache ()
957 dcache_flush (remote_dcache
);
961 monitor_resume (pid
, step
, sig
)
963 enum target_signal sig
;
965 /* Some monitors require a different command when starting a program */
966 monitor_debug ("MON resume\n");
967 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
970 monitor_printf ("run\r");
971 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
975 dcache_flush (remote_dcache
);
977 monitor_printf (current_monitor
->step
);
980 if (current_monitor
->continue_hook
)
981 (*current_monitor
->continue_hook
) ();
983 monitor_printf (current_monitor
->cont
);
984 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
989 /* Parse the output of a register dump command. A monitor specific
990 regexp is used to extract individual register descriptions of the
991 form REG=VAL. Each description is split up into a name and a value
992 string which are passed down to monitor specific code. */
995 parse_register_dump (buf
, len
)
999 monitor_debug ("MON Parsing register dump\n");
1002 int regnamelen
, vallen
;
1003 char *regname
, *val
;
1004 /* Element 0 points to start of register name, and element 1
1005 points to the start of the register value. */
1006 struct re_registers register_strings
;
1008 memset (®ister_strings
, 0, sizeof (struct re_registers
));
1010 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
1011 ®ister_strings
) == -1)
1014 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
1015 regname
= buf
+ register_strings
.start
[1];
1016 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
1017 val
= buf
+ register_strings
.start
[2];
1019 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
1021 buf
+= register_strings
.end
[0];
1022 len
-= register_strings
.end
[0];
1026 /* Send ^C to target to halt it. Target will respond, and send us a
1030 monitor_interrupt (signo
)
1033 /* If this doesn't work, try more severe steps. */
1034 signal (signo
, monitor_interrupt_twice
);
1036 if (monitor_debug_p
|| remote_debug
)
1037 fprintf_unfiltered (gdb_stdlog
, "monitor_interrupt called\n");
1042 /* The user typed ^C twice. */
1045 monitor_interrupt_twice (signo
)
1048 signal (signo
, ofunc
);
1050 monitor_interrupt_query ();
1052 signal (signo
, monitor_interrupt
);
1055 /* Ask the user what to do when an interrupt is received. */
1058 monitor_interrupt_query ()
1060 target_terminal_ours ();
1062 if (query ("Interrupted while waiting for the program.\n\
1063 Give up (and stop debugging it)? "))
1065 target_mourn_inferior ();
1066 return_to_top_level (RETURN_QUIT
);
1069 target_terminal_inferior ();
1073 monitor_wait_cleanup (old_timeout
)
1076 timeout
= *(int *) old_timeout
;
1077 signal (SIGINT
, ofunc
);
1078 in_monitor_wait
= 0;
1084 monitor_wait_filter (char *buf
,
1087 struct target_waitstatus
*status
1093 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1094 *ext_resp_len
= resp_len
;
1097 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1099 while (resp_len
< 0);
1101 /* Print any output characters that were preceded by ^O. */
1102 /* FIXME - This would be great as a user settabgle flag */
1103 if (monitor_debug_p
|| remote_debug
1104 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1108 for (i
= 0; i
< resp_len
- 1; i
++)
1110 putchar_unfiltered (buf
[++i
]);
1116 /* Wait until the remote machine stops, then return, storing status in
1117 status just as `wait' would. */
1120 monitor_wait (pid
, status
)
1122 struct target_waitstatus
*status
;
1124 int old_timeout
= timeout
;
1125 char buf
[TARGET_BUF_SIZE
];
1127 struct cleanup
*old_chain
;
1129 status
->kind
= TARGET_WAITKIND_EXITED
;
1130 status
->value
.integer
= 0;
1132 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1133 monitor_debug ("MON wait\n");
1136 /* This is somthing other than a maintenance command */
1137 in_monitor_wait
= 1;
1138 timeout
= watchdog
> 0 ? watchdog
: -1;
1140 timeout
= -1; /* Don't time out -- user program is running. */
1143 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1145 if (current_monitor
->wait_filter
)
1146 (*current_monitor
->wait_filter
) (buf
, sizeof (buf
), &resp_len
, status
);
1148 monitor_wait_filter (buf
, sizeof (buf
), &resp_len
, status
);
1150 #if 0 /* Transferred to monitor wait filter */
1153 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1156 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1158 while (resp_len
< 0);
1160 /* Print any output characters that were preceded by ^O. */
1161 /* FIXME - This would be great as a user settabgle flag */
1162 if (monitor_debug_p
|| remote_debug
1163 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1167 for (i
= 0; i
< resp_len
- 1; i
++)
1169 putchar_unfiltered (buf
[++i
]);
1173 signal (SIGINT
, ofunc
);
1175 timeout
= old_timeout
;
1177 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1180 monitor_printf (current_monitor
->dump_registers
);
1181 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1184 if (current_monitor
->register_pattern
)
1185 parse_register_dump (buf
, resp_len
);
1187 monitor_debug ("Wait fetching registers after stop\n");
1188 monitor_dump_regs ();
1191 status
->kind
= TARGET_WAITKIND_STOPPED
;
1192 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1194 discard_cleanups (old_chain
);
1196 in_monitor_wait
= 0;
1198 return inferior_pid
;
1201 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1205 monitor_fetch_register (regno
)
1209 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] =
1211 char regbuf
[MAX_REGISTER_RAW_SIZE
* 2 + 1];
1214 name
= current_monitor
->regnames
[regno
];
1215 monitor_debug ("MON fetchreg %d '%s'\n", regno
, name
? name
: "(null name)");
1217 if (!name
|| (*name
== '\0'))
1219 monitor_debug ("No register known for %d\n", regno
);
1220 supply_register (regno
, zerobuf
);
1224 /* send the register examine command */
1226 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1228 /* If RESP_DELIM is specified, we search for that as a leading
1229 delimiter for the register value. Otherwise, we just start
1230 searching from the start of the buf. */
1232 if (current_monitor
->getreg
.resp_delim
)
1234 monitor_debug ("EXP getreg.resp_delim\n");
1235 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1236 /* Handle case of first 32 registers listed in pairs. */
1237 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1238 && (regno
& 1) != 0 && regno
< 32)
1240 monitor_debug ("EXP getreg.resp_delim\n");
1241 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1245 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1246 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1249 c
= readchar (timeout
);
1251 c
= readchar (timeout
);
1252 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1255 error ("Bad value returned from monitor while fetching register %x.",
1259 /* Read upto the maximum number of hex digits for this register, skipping
1260 spaces, but stop reading if something else is seen. Some monitors
1261 like to drop leading zeros. */
1263 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
1266 c
= readchar (timeout
);
1268 c
= readchar (timeout
);
1276 regbuf
[i
] = '\000'; /* terminate the number */
1277 monitor_debug ("REGVAL '%s'\n", regbuf
);
1279 /* If TERM is present, we wait for that to show up. Also, (if TERM
1280 is present), we will send TERM_CMD if that is present. In any
1281 case, we collect all of the output into buf, and then wait for
1282 the normal prompt. */
1284 if (current_monitor
->getreg
.term
)
1286 monitor_debug ("EXP getreg.term\n");
1287 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1290 if (current_monitor
->getreg
.term_cmd
)
1292 monitor_debug ("EMIT getreg.term.cmd\n");
1293 monitor_printf (current_monitor
->getreg
.term_cmd
);
1295 if (!current_monitor
->getreg
.term
|| /* Already expected or */
1296 current_monitor
->getreg
.term_cmd
) /* ack expected */
1297 monitor_expect_prompt (NULL
, 0); /* get response */
1299 monitor_supply_register (regno
, regbuf
);
1302 /* Sometimes, it takes several commands to dump the registers */
1303 /* This is a primitive for use by variations of monitor interfaces in
1304 case they need to compose the operation.
1307 monitor_dump_reg_block (char *block_cmd
)
1309 char buf
[TARGET_BUF_SIZE
];
1311 monitor_printf (block_cmd
);
1312 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1313 parse_register_dump (buf
, resp_len
);
1318 /* Read the remote registers into the block regs. */
1319 /* Call the specific function if it has been provided */
1322 monitor_dump_regs ()
1324 char buf
[TARGET_BUF_SIZE
];
1326 if (current_monitor
->dumpregs
)
1327 (*(current_monitor
->dumpregs
)) (); /* call supplied function */
1328 else if (current_monitor
->dump_registers
) /* default version */
1330 monitor_printf (current_monitor
->dump_registers
);
1331 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1332 parse_register_dump (buf
, resp_len
);
1335 abort (); /* Need some way to read registers */
1339 monitor_fetch_registers (regno
)
1342 monitor_debug ("MON fetchregs\n");
1343 if (current_monitor
->getreg
.cmd
)
1347 monitor_fetch_register (regno
);
1351 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1352 monitor_fetch_register (regno
);
1356 monitor_dump_regs ();
1360 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1363 monitor_store_register (regno
)
1369 name
= current_monitor
->regnames
[regno
];
1370 if (!name
|| (*name
== '\0'))
1372 monitor_debug ("MON Cannot store unknown register\n");
1376 val
= read_register (regno
);
1377 monitor_debug ("MON storeg %d %s\n", regno
, preg (val
));
1379 /* send the register deposit command */
1381 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1382 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1383 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1384 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1386 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1388 if (current_monitor
->setreg
.term
)
1390 monitor_debug ("EXP setreg.term\n");
1391 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1392 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1393 monitor_printf ("%s\r", paddr_nz (val
));
1394 monitor_expect_prompt (NULL
, 0);
1397 monitor_expect_prompt (NULL
, 0);
1398 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1400 monitor_debug ("EXP setreg_termcmd\n");
1401 monitor_printf ("%s", current_monitor
->setreg
.term_cmd
);
1402 monitor_expect_prompt (NULL
, 0);
1404 } /* monitor_store_register */
1406 /* Store the remote registers. */
1409 monitor_store_registers (regno
)
1414 monitor_store_register (regno
);
1418 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1419 monitor_store_register (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 ()
1431 /* Do nothing, since we can store individual regs */
1435 monitor_files_info (ops
)
1436 struct target_ops
*ops
;
1438 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1442 monitor_write_memory (memaddr
, myaddr
, len
)
1447 unsigned int val
, hostval
;
1451 monitor_debug ("MON write %d %s\n", len
, paddr (memaddr
));
1453 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1454 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1456 /* Use memory fill command for leading 0 bytes. */
1458 if (current_monitor
->fill
)
1460 for (i
= 0; i
< len
; i
++)
1464 if (i
> 4) /* More than 4 zeros is worth doing */
1466 monitor_debug ("MON FILL %d\n", i
);
1467 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1468 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
) - 1, 0);
1470 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1472 monitor_expect_prompt (NULL
, 0);
1479 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1480 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1483 cmd
= current_monitor
->setmem
.cmdll
;
1487 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1490 cmd
= current_monitor
->setmem
.cmdl
;
1492 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1495 cmd
= current_monitor
->setmem
.cmdw
;
1500 cmd
= current_monitor
->setmem
.cmdb
;
1503 val
= extract_unsigned_integer (myaddr
, len
);
1507 hostval
= *(unsigned int *) myaddr
;
1508 monitor_debug ("Hostval(%08x) val(%08x)\n", hostval
, val
);
1512 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1513 monitor_printf_noecho (cmd
, memaddr
, val
);
1514 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1517 monitor_printf_noecho (cmd
, memaddr
);
1519 if (current_monitor
->setmem
.term
)
1521 monitor_debug ("EXP setmem.term");
1522 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1523 monitor_printf ("%x\r", val
);
1525 if (current_monitor
->setmem
.term_cmd
)
1526 { /* Emit this to get out of the memory editing state */
1527 monitor_printf ("%s", current_monitor
->setmem
.term_cmd
);
1528 /* Drop through to expecting a prompt */
1532 monitor_printf (cmd
, memaddr
, val
);
1534 monitor_expect_prompt (NULL
, 0);
1541 monitor_write_even_block (memaddr
, myaddr
, len
)
1548 /* Enter the sub mode */
1549 monitor_printf (current_monitor
->setmem
.cmdl
, memaddr
);
1550 monitor_expect_prompt (NULL
, 0);
1554 val
= extract_unsigned_integer (myaddr
, 4); /* REALLY */
1555 monitor_printf ("%x\r", val
);
1559 monitor_debug (" @ %s\n", paddr (memaddr
));
1560 /* If we wanted to, here we could validate the address */
1561 monitor_expect_prompt (NULL
, 0);
1563 /* Now exit the sub mode */
1564 monitor_printf (current_monitor
->getreg
.term_cmd
);
1565 monitor_expect_prompt (NULL
, 0);
1571 monitor_write_memory_bytes (memaddr
, myaddr
, len
)
1580 /* Enter the sub mode */
1581 monitor_printf (current_monitor
->setmem
.cmdb
, memaddr
);
1582 monitor_expect_prompt (NULL
, 0);
1586 monitor_printf ("%x\r", val
);
1590 /* If we wanted to, here we could validate the address */
1591 monitor_expect_prompt (NULL
, 0);
1594 /* Now exit the sub mode */
1595 monitor_printf (current_monitor
->getreg
.term_cmd
);
1596 monitor_expect_prompt (NULL
, 0);
1602 longlongendswap (unsigned char *a
)
1611 *(a
+ i
) = *(a
+ j
);
1616 /* Format 32 chars of long long value, advance the pointer */
1617 static char *hexlate
= "0123456789abcdef";
1619 longlong_hexchars (unsigned long long value
,
1629 static unsigned char disbuf
[8]; /* disassembly buffer */
1630 unsigned char *scan
, *limit
; /* loop controls */
1631 unsigned char c
, nib
;
1636 unsigned long long *dp
;
1637 dp
= (unsigned long long *) scan
;
1640 longlongendswap (disbuf
); /* FIXME: ONly on big endian hosts */
1641 while (scan
< limit
)
1643 c
= *scan
++; /* a byte of our long long value */
1649 leadzero
= 0; /* henceforth we print even zeroes */
1651 nib
= c
>> 4; /* high nibble bits */
1652 *outbuff
++ = hexlate
[nib
];
1653 nib
= c
& 0x0f; /* low nibble bits */
1654 *outbuff
++ = hexlate
[nib
];
1658 } /* longlong_hexchars */
1662 /* I am only going to call this when writing virtual byte streams.
1663 Which possably entails endian conversions
1666 monitor_write_memory_longlongs (memaddr
, myaddr
, len
)
1671 static char hexstage
[20]; /* At least 16 digits required, plus null */
1676 llptr
= (unsigned long long *) myaddr
;
1679 monitor_printf (current_monitor
->setmem
.cmdll
, memaddr
);
1680 monitor_expect_prompt (NULL
, 0);
1684 endstring
= longlong_hexchars (*llptr
, hexstage
);
1685 *endstring
= '\0'; /* NUll terminate for printf */
1686 monitor_printf ("%s\r", hexstage
);
1690 /* If we wanted to, here we could validate the address */
1691 monitor_expect_prompt (NULL
, 0);
1694 /* Now exit the sub mode */
1695 monitor_printf (current_monitor
->getreg
.term_cmd
);
1696 monitor_expect_prompt (NULL
, 0);
1702 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1703 /* This is for the large blocks of memory which may occur in downloading.
1704 And for monitors which use interactive entry,
1705 And for monitors which do not have other downloading methods.
1706 Without this, we will end up calling monitor_write_memory many times
1707 and do the entry and exit of the sub mode many times
1708 This currently assumes...
1709 MO_SETMEM_INTERACTIVE
1710 ! MO_NO_ECHO_ON_SETMEM
1711 To use this, the you have to patch the monitor_cmds block with
1712 this function. Otherwise, its not tuned up for use by all
1717 monitor_write_memory_block (memaddr
, myaddr
, len
)
1724 /* FIXME: This would be a good place to put the zero test */
1726 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1728 return monitor_write_memory_longlongs (memaddr
, myaddr
, len
);
1735 written
= monitor_write_even_block (memaddr
, myaddr
, len
);
1736 /* Adjust calling parameters by written amount */
1742 written
= monitor_write_memory_bytes (memaddr
, myaddr
, len
);
1746 /* This is an alternate form of monitor_read_memory which is used for monitors
1747 which can only read a single byte/word/etc. at a time. */
1750 monitor_read_memory_single (memaddr
, myaddr
, len
)
1756 char membuf
[sizeof (int) * 2 + 1];
1761 monitor_debug ("MON read single\n");
1763 /* Can't actually use long longs (nice idea, though). In fact, the
1764 call to strtoul below will fail if it tries to convert a value
1765 that's too big to fit in a long. */
1766 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1769 cmd
= current_monitor
->getmem
.cmdll
;
1773 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1776 cmd
= current_monitor
->getmem
.cmdl
;
1778 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1781 cmd
= current_monitor
->getmem
.cmdw
;
1786 cmd
= current_monitor
->getmem
.cmdb
;
1789 /* Send the examine command. */
1791 monitor_printf (cmd
, memaddr
);
1793 /* If RESP_DELIM is specified, we search for that as a leading
1794 delimiter for the memory value. Otherwise, we just start
1795 searching from the start of the buf. */
1797 if (current_monitor
->getmem
.resp_delim
)
1799 monitor_debug ("EXP getmem.resp_delim\n");
1800 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1803 /* Now, read the appropriate number of hex digits for this loc,
1806 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1807 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1811 c
= readchar (timeout
);
1813 c
= readchar (timeout
);
1814 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1817 monitor_error ("monitor_read_memory_single",
1818 "bad response from monitor",
1819 memaddr
, i
, membuf
, c
);
1821 for (i
= 0; i
< len
* 2; i
++)
1827 c
= readchar (timeout
);
1833 monitor_error ("monitor_read_memory_single",
1834 "bad response from monitor",
1835 memaddr
, i
, membuf
, c
);
1841 membuf
[i
] = '\000'; /* terminate the number */
1843 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1844 present), we will send TERM_CMD if that is present. In any case, we collect
1845 all of the output into buf, and then wait for the normal prompt. */
1847 if (current_monitor
->getmem
.term
)
1849 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1851 if (current_monitor
->getmem
.term_cmd
)
1853 monitor_printf (current_monitor
->getmem
.term_cmd
);
1854 monitor_expect_prompt (NULL
, 0);
1858 monitor_expect_prompt (NULL
, 0); /* get response */
1861 val
= strtoul (membuf
, &p
, 16);
1863 if (val
== 0 && membuf
== p
)
1864 monitor_error ("monitor_read_memory_single",
1865 "bad value from monitor",
1866 memaddr
, 0, membuf
, 0);
1868 /* supply register stores in target byte order, so swap here */
1870 store_unsigned_integer (myaddr
, len
, val
);
1875 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1876 memory at MEMADDR. Returns length moved. Currently, we do no more
1877 than 16 bytes at a time. */
1880 monitor_read_memory (memaddr
, myaddr
, len
)
1894 monitor_debug ("Zero length call to monitor_read_memory\n");
1898 monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
1899 paddr_nz (memaddr
), (long) myaddr
, len
);
1901 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1902 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1904 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1905 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1907 len
= min (len
, 16);
1909 /* Some dumpers align the first data with the preceeding 16
1910 byte boundary. Some print blanks and start at the
1911 requested boundary. EXACT_DUMPADDR
1914 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1915 ? memaddr
: memaddr
& ~0x0f;
1917 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1918 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1919 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1921 /* send the memory examine command */
1923 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1924 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
);
1925 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1926 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1928 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1930 /* If TERM is present, we wait for that to show up. Also, (if TERM
1931 is present), we will send TERM_CMD if that is present. In any
1932 case, we collect all of the output into buf, and then wait for
1933 the normal prompt. */
1935 if (current_monitor
->getmem
.term
)
1937 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1940 monitor_error ("monitor_read_memory",
1941 "excessive response from monitor",
1942 memaddr
, resp_len
, buf
, 0);
1944 if (current_monitor
->getmem
.term_cmd
)
1946 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1947 strlen (current_monitor
->getmem
.term_cmd
));
1948 monitor_expect_prompt (NULL
, 0);
1952 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1956 /* If RESP_DELIM is specified, we search for that as a leading
1957 delimiter for the values. Otherwise, we just start searching
1958 from the start of the buf. */
1960 if (current_monitor
->getmem
.resp_delim
)
1963 struct re_registers resp_strings
;
1964 monitor_debug ("MON getmem.resp_delim %s\n", current_monitor
->getmem
.resp_delim
);
1966 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1968 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1972 monitor_error ("monitor_read_memory",
1973 "bad response from monitor",
1974 memaddr
, resp_len
, buf
, 0);
1976 p
+= resp_strings
.end
[0];
1978 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1980 monitor_error ("monitor_read_memory",
1981 "bad response from monitor",
1982 memaddr
, resp_len
, buf
, 0);
1983 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1986 monitor_debug ("MON scanning %d ,%lx '%s'\n", len
, (long) p
, p
);
1987 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1995 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1999 if ((dumpaddr
>= memaddr
) && (i
> 0))
2001 val
= fromhex (c
) * 16 + fromhex (*(p
+ 1));
2003 if (monitor_debug_p
|| remote_debug
)
2004 fprintf_unfiltered (gdb_stdlog
, "[%02x]", val
);
2011 ++p
; /* skip a blank or other non hex char */
2015 error ("Failed to read via monitor");
2016 if (monitor_debug_p
|| remote_debug
)
2017 fprintf_unfiltered (gdb_stdlog
, "\n");
2018 return fetched
; /* Return the number of bytes actually read */
2020 monitor_debug ("MON scanning bytes\n");
2022 for (i
= len
; i
> 0; i
--)
2024 /* Skip non-hex chars, but bomb on end of string and newlines */
2031 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
2032 monitor_error ("monitor_read_memory",
2033 "badly terminated response from monitor",
2034 memaddr
, resp_len
, buf
, 0);
2038 val
= strtoul (p
, &p1
, 16);
2040 if (val
== 0 && p
== p1
)
2041 monitor_error ("monitor_read_memory",
2042 "bad value from monitor",
2043 memaddr
, resp_len
, buf
, 0);
2057 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
2062 struct target_ops
*target
; /* ignored */
2064 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, write
);
2070 return; /* ignore attempts to kill target system */
2073 /* All we actually do is set the PC to the start address of exec_bfd, and start
2074 the program at that point. */
2077 monitor_create_inferior (exec_file
, args
, env
)
2082 if (args
&& (*args
!= '\000'))
2083 error ("Args are not supported by the monitor.");
2086 clear_proceed_status ();
2087 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
2090 /* Clean up when a program exits.
2091 The program actually lives on in the remote processor's RAM, and may be
2092 run again without a download. Don't leave it full of breakpoint
2096 monitor_mourn_inferior ()
2098 unpush_target (targ_ops
);
2099 generic_mourn_inferior (); /* Do all the proper things now */
2102 /* Tell the monitor to add a breakpoint. */
2105 monitor_insert_breakpoint (addr
, shadow
)
2113 monitor_debug ("MON inst bkpt %s\n", paddr (addr
));
2114 if (current_monitor
->set_break
== NULL
)
2115 error ("No set_break defined for this monitor");
2117 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2118 addr
= ADDR_BITS_REMOVE (addr
);
2120 /* Determine appropriate breakpoint size for this address. */
2121 bp
= memory_breakpoint_from_pc (&addr
, &bplen
);
2123 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2125 if (breakaddr
[i
] == 0)
2127 breakaddr
[i
] = addr
;
2128 monitor_read_memory (addr
, shadow
, bplen
);
2129 monitor_printf (current_monitor
->set_break
, addr
);
2130 monitor_expect_prompt (NULL
, 0);
2135 error ("Too many breakpoints (> %d) for monitor.", current_monitor
->num_breakpoints
);
2138 /* Tell the monitor to remove a breakpoint. */
2141 monitor_remove_breakpoint (addr
, shadow
)
2147 monitor_debug ("MON rmbkpt %s\n", paddr (addr
));
2148 if (current_monitor
->clr_break
== NULL
)
2149 error ("No clr_break defined for this monitor");
2151 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2152 addr
= ADDR_BITS_REMOVE (addr
);
2154 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2156 if (breakaddr
[i
] == addr
)
2159 /* some monitors remove breakpoints based on the address */
2160 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2161 monitor_printf (current_monitor
->clr_break
, addr
);
2162 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2163 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2165 monitor_printf (current_monitor
->clr_break
, i
);
2166 monitor_expect_prompt (NULL
, 0);
2170 fprintf_unfiltered (gdb_stderr
,
2171 "Can't find breakpoint associated with 0x%s\n",
2176 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2177 an S-record. Return non-zero if the ACK is received properly. */
2180 monitor_wait_srec_ack ()
2184 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2186 return (readchar (timeout
) == '+');
2188 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2190 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2191 if ((ch
= readchar (1)) < 0)
2193 if ((ch
= readchar (1)) < 0)
2195 if ((ch
= readchar (1)) < 0)
2197 if ((ch
= readchar (1)) < 0)
2203 /* monitor_load -- download a file. */
2206 monitor_load (file
, from_tty
)
2210 dcache_flush (remote_dcache
);
2211 monitor_debug ("MON load\n");
2213 if (current_monitor
->load_routine
)
2214 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2216 { /* The default is ascii S-records */
2218 unsigned long load_offset
;
2221 /* enable user to specify address for downloading as 2nd arg to load */
2222 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2228 monitor_printf (current_monitor
->load
);
2229 if (current_monitor
->loadresp
)
2230 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2232 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2233 32, SREC_ALL
, hashmark
,
2234 current_monitor
->flags
& MO_SREC_ACK
?
2235 monitor_wait_srec_ack
: NULL
);
2237 monitor_expect_prompt (NULL
, 0);
2240 /* Finally, make the PC point at the start address */
2243 write_pc (bfd_get_start_address (exec_bfd
));
2245 inferior_pid
= 0; /* No process now */
2247 /* This is necessary because many things were based on the PC at the time that
2248 we attached to the monitor, which is no longer valid now that we have loaded
2249 new code (and just changed the PC). Another way to do this might be to call
2250 normal_stop, except that the stack may not be valid, and things would get
2251 horribly confused... */
2253 clear_symtab_users ();
2259 monitor_debug ("MON stop\n");
2260 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2261 SERIAL_SEND_BREAK (monitor_desc
);
2262 if (current_monitor
->stop
)
2263 monitor_printf_noecho (current_monitor
->stop
);
2266 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2267 in OUTPUT until the prompt is seen. FIXME: We read the characters
2268 ourseleves here cause of a nasty echo. */
2271 monitor_rcmd (char *command
,
2272 struct ui_file
*outbuf
)
2278 if (monitor_desc
== NULL
)
2279 error ("monitor target not open.");
2281 p
= current_monitor
->prompt
;
2283 /* Send the command. Note that if no args were supplied, then we're
2284 just sending the monitor a newline, which is sometimes useful. */
2286 monitor_printf ("%s\r", (command
? command
: ""));
2288 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2290 fputs_unfiltered (buf
, outbuf
); /* Output the response */
2293 /* Convert hex digit A to a number. */
2300 if (a
>= '0' && a
<= '9')
2302 if (a
>= 'a' && a
<= 'f')
2303 return a
- 'a' + 10;
2304 if (a
>= 'A' && a
<= 'F')
2305 return a
- 'A' + 10;
2307 error ("Reply contains invalid hex digit 0x%x", a
);
2312 monitor_get_dev_name ()
2317 static struct target_ops monitor_ops
;
2320 init_base_monitor_ops (void)
2322 monitor_ops
.to_shortname
= NULL
;
2323 monitor_ops
.to_longname
= NULL
;
2324 monitor_ops
.to_doc
= NULL
;
2325 monitor_ops
.to_open
= NULL
;
2326 monitor_ops
.to_close
= monitor_close
;
2327 monitor_ops
.to_attach
= NULL
;
2328 monitor_ops
.to_post_attach
= NULL
;
2329 monitor_ops
.to_require_attach
= NULL
;
2330 monitor_ops
.to_detach
= monitor_detach
;
2331 monitor_ops
.to_require_detach
= NULL
;
2332 monitor_ops
.to_resume
= monitor_resume
;
2333 monitor_ops
.to_wait
= monitor_wait
;
2334 monitor_ops
.to_post_wait
= NULL
;
2335 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2336 monitor_ops
.to_store_registers
= monitor_store_registers
;
2337 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2338 monitor_ops
.to_xfer_memory
= monitor_xfer_memory
;
2339 monitor_ops
.to_files_info
= monitor_files_info
;
2340 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2341 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2342 monitor_ops
.to_terminal_init
= 0;
2343 monitor_ops
.to_terminal_inferior
= 0;
2344 monitor_ops
.to_terminal_ours_for_output
= 0;
2345 monitor_ops
.to_terminal_ours
= 0;
2346 monitor_ops
.to_terminal_info
= 0;
2347 monitor_ops
.to_kill
= monitor_kill
;
2348 monitor_ops
.to_load
= monitor_load
;
2349 monitor_ops
.to_lookup_symbol
= 0;
2350 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2351 monitor_ops
.to_post_startup_inferior
= NULL
;
2352 monitor_ops
.to_acknowledge_created_inferior
= NULL
;
2353 monitor_ops
.to_clone_and_follow_inferior
= NULL
;
2354 monitor_ops
.to_post_follow_inferior_by_clone
= NULL
;
2355 monitor_ops
.to_insert_fork_catchpoint
= NULL
;
2356 monitor_ops
.to_remove_fork_catchpoint
= NULL
;
2357 monitor_ops
.to_insert_vfork_catchpoint
= NULL
;
2358 monitor_ops
.to_remove_vfork_catchpoint
= NULL
;
2359 monitor_ops
.to_has_forked
= NULL
;
2360 monitor_ops
.to_has_vforked
= NULL
;
2361 monitor_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2362 monitor_ops
.to_post_follow_vfork
= NULL
;
2363 monitor_ops
.to_insert_exec_catchpoint
= NULL
;
2364 monitor_ops
.to_remove_exec_catchpoint
= NULL
;
2365 monitor_ops
.to_has_execd
= NULL
;
2366 monitor_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2367 monitor_ops
.to_has_exited
= NULL
;
2368 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2369 monitor_ops
.to_can_run
= 0;
2370 monitor_ops
.to_notice_signals
= 0;
2371 monitor_ops
.to_thread_alive
= 0;
2372 monitor_ops
.to_stop
= monitor_stop
;
2373 monitor_ops
.to_rcmd
= monitor_rcmd
;
2374 monitor_ops
.to_pid_to_exec_file
= NULL
;
2375 monitor_ops
.to_core_file_to_sym_file
= NULL
;
2376 monitor_ops
.to_stratum
= process_stratum
;
2377 monitor_ops
.DONT_USE
= 0;
2378 monitor_ops
.to_has_all_memory
= 1;
2379 monitor_ops
.to_has_memory
= 1;
2380 monitor_ops
.to_has_stack
= 1;
2381 monitor_ops
.to_has_registers
= 1;
2382 monitor_ops
.to_has_execution
= 1;
2383 monitor_ops
.to_sections
= 0;
2384 monitor_ops
.to_sections_end
= 0;
2385 monitor_ops
.to_magic
= OPS_MAGIC
;
2386 } /* init_base_monitor_ops */
2388 /* Init the target_ops structure pointed at by OPS */
2391 init_monitor_ops (ops
)
2392 struct target_ops
*ops
;
2394 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2395 init_base_monitor_ops ();
2397 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2400 /* Define additional commands that are usually only used by monitors. */
2403 _initialize_remote_monitors ()
2405 init_base_monitor_ops ();
2406 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
2408 "Set display of activity while downloading a file.\n\
2409 When enabled, a hashmark \'#\' is displayed.",
2414 /* FIXME: cagney/1999-10-07: Wait until there is a generic ``set
2415 debug ...'' rather than another ``set ...debug'' command. */
2417 (add_set_cmd ("monitordebug", no_class
, var_zinteger
,
2418 (char *) &monitor_debug_p
,
2419 "Set debugging of remote monitor communication.\n\
2420 When enabled, communication between GDB and the remote monitor\n\
2421 is displayed.", &setlist
),