1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990, 1991, 1992, 1993, 1995, 1996, 1997, 1999
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
5 Resurrected from the ashes by Stu Grossman.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
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 existance, 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 */
45 #ifdef ANSI_PROTOTYPES
52 #include "gdb_string.h"
53 #include <sys/types.h>
59 #include "gnu-regex.h"
63 static char *dev_name
;
64 static struct target_ops
*targ_ops
;
66 static void monitor_vsprintf
PARAMS ((char *sndbuf
, char *pattern
, va_list args
));
68 static int readchar
PARAMS ((int timeout
));
70 static void monitor_command
PARAMS ((char *args
, int fromtty
));
72 static void monitor_fetch_register
PARAMS ((int regno
));
73 static void monitor_store_register
PARAMS ((int regno
));
75 static int monitor_printable_string
PARAMS ((char *newstr
, char *oldstr
));
76 static void monitor_error
PARAMS ((char *format
, CORE_ADDR memaddr
, int len
, char *string
, int final_char
));
77 static void monitor_detach
PARAMS ((char *args
, int from_tty
));
78 static void monitor_resume
PARAMS ((int pid
, int step
, enum target_signal sig
));
79 static void monitor_interrupt
PARAMS ((int signo
));
80 static void monitor_interrupt_twice
PARAMS ((int signo
));
81 static void monitor_interrupt_query
PARAMS ((void));
82 static void monitor_wait_cleanup
PARAMS ((void *old_timeout
));
84 static int monitor_wait
PARAMS ((int pid
, struct target_waitstatus
* status
));
85 static void monitor_fetch_registers
PARAMS ((int regno
));
86 static void monitor_store_registers
PARAMS ((int regno
));
87 static void monitor_prepare_to_store
PARAMS ((void));
88 static int monitor_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
, int len
, int write
, struct target_ops
* target
));
89 static void monitor_files_info
PARAMS ((struct target_ops
* ops
));
90 static int monitor_insert_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
91 static int monitor_remove_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
92 static void monitor_kill
PARAMS ((void));
93 static void monitor_load
PARAMS ((char *file
, int from_tty
));
94 static void monitor_mourn_inferior
PARAMS ((void));
95 static void monitor_stop
PARAMS ((void));
97 static int monitor_read_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
, int len
));
98 static int monitor_write_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
, int len
));
99 static int monitor_write_memory_bytes
PARAMS ((CORE_ADDR addr
,
100 char *myaddr
, int len
));
101 static int monitor_write_memory_block
PARAMS ((
105 static int monitor_expect_regexp
PARAMS ((struct re_pattern_buffer
* pat
,
106 char *buf
, int buflen
));
107 static void monitor_dump_regs
PARAMS ((void));
109 static int from_hex
PARAMS ((int a
));
110 static unsigned long get_hex_word
PARAMS ((void));
112 static void parse_register_dump
PARAMS ((char *, int));
114 static struct monitor_ops
*current_monitor
;
116 static int hashmark
; /* flag set by "set hash" */
118 static int timeout
= 30;
120 static int in_monitor_wait
= 0; /* Non-zero means we are in monitor_wait() */
122 static void (*ofunc
) (); /* Old SIGINT signal handler */
124 static CORE_ADDR
*breakaddr
;
126 /* Extra remote debugging for developing a new rom monitor variation */
127 #if ! defined(EXTRA_RDEBUG)
128 #define EXTRA_RDEBUG 0
130 #define RDEBUG(stuff) { if (EXTRA_RDEBUG && remote_debug) printf stuff ; }
132 /* Descriptor for I/O to remote machine. Initialize it to NULL so
133 that monitor_open knows that we don't have a file open when the
136 static serial_t monitor_desc
= NULL
;
138 /* Pointer to regexp pattern matching data */
140 static struct re_pattern_buffer register_pattern
;
141 static char register_fastmap
[256];
143 static struct re_pattern_buffer getmem_resp_delim_pattern
;
144 static char getmem_resp_delim_fastmap
[256];
146 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
147 monitor_wait wakes up. */
149 static DCACHE
*remote_dcache
;
150 static int first_time
= 0; /* is this the first time we're executing after
151 gaving created the child proccess? */
153 /* Convert a string into a printable representation, Return # byte in the
157 monitor_printable_string (newstr
, oldstr
)
164 while ((ch
= *oldstr
++) != '\0')
174 sprintf (newstr
, "\\x%02x", ch
& 0xff);
211 return newstr
- save
;
214 /* Print monitor errors with a string, converting the string to printable
218 monitor_error (format
, memaddr
, len
, string
, final_char
)
225 int real_len
= (len
== 0 && string
!= (char *) 0) ? strlen (string
) : len
;
226 char *safe_string
= alloca ((real_len
* 4) + 1);
229 int safe_len
= monitor_printable_string (safe_string
, string
);
232 error (format
, (int) memaddr
, p
- safe_string
, safe_string
, final_char
);
234 error (format
, (int) memaddr
, p
- safe_string
, safe_string
);
237 /* Convert hex digit A to a number. */
243 if (a
>= '0' && a
<= '9')
245 else if (a
>= 'a' && a
<= 'f')
247 else if (a
>= 'A' && a
<= 'F')
250 error ("Invalid hex digit %d", a
);
253 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
255 This function exists to get around the problem that many host platforms
256 don't have a printf that can print 64-bit addresses. The %A format
257 specification is recognized as a special case, and causes the argument
258 to be printed as a 64-bit hexadecimal address.
260 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
261 If it is a '%s' format, the argument is a string; otherwise the
262 argument is assumed to be a long integer.
264 %% is also turned into a single %.
268 monitor_vsprintf (sndbuf
, pattern
, args
)
281 for (p
= pattern
; *p
; p
++)
285 /* Copy the format specifier to a separate buffer. */
287 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
290 format
[i
] = fmt
= *p
;
291 format
[i
+ 1] = '\0';
293 /* Fetch the next argument and print it. */
297 strcpy (sndbuf
, "%");
300 arg_addr
= va_arg (args
, CORE_ADDR
);
301 strcpy (sndbuf
, paddr_nz (arg_addr
));
304 arg_string
= va_arg (args
, char *);
305 sprintf (sndbuf
, format
, arg_string
);
308 arg_int
= va_arg (args
, long);
309 sprintf (sndbuf
, format
, arg_int
);
312 sndbuf
+= strlen (sndbuf
);
321 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
322 Works just like printf. */
325 #ifdef ANSI_PROTOTYPES
326 monitor_printf_noecho (char *pattern
,...)
328 monitor_printf_noecho (va_alist
)
337 va_start (args
, pattern
);
341 pattern
= va_arg (args
, char *);
344 monitor_vsprintf (sndbuf
, pattern
, args
);
346 len
= strlen (sndbuf
);
347 if (len
+ 1 > sizeof sndbuf
)
351 if (remote_debug
> 0)
352 puts_debug ("sent -->", sndbuf
, "<--");
357 char *safe_string
= (char *) alloca ((strlen (sndbuf
) * 4) + 1);
358 monitor_printable_string (safe_string
, sndbuf
);
359 printf ("sent[%s]\n", safe_string
);
362 monitor_write (sndbuf
, len
);
365 /* monitor_printf -- Send data to monitor and check the echo. Works just like
369 #ifdef ANSI_PROTOTYPES
370 monitor_printf (char *pattern
,...)
372 monitor_printf (va_alist
)
380 #ifdef ANSI_PROTOTYPES
381 va_start (args
, pattern
);
385 pattern
= va_arg (args
, char *);
388 monitor_vsprintf (sndbuf
, pattern
, args
);
390 len
= strlen (sndbuf
);
391 if (len
+ 1 > sizeof sndbuf
)
395 if (remote_debug
> 0)
396 puts_debug ("sent -->", sndbuf
, "<--");
401 char *safe_string
= (char *) alloca ((len
* 4) + 1);
402 monitor_printable_string (safe_string
, sndbuf
);
403 printf ("sent[%s]\n", safe_string
);
406 monitor_write (sndbuf
, len
);
408 /* We used to expect that the next immediate output was the characters we
409 just output, but sometimes some extra junk appeared before the characters
410 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
411 So, just start searching for what we sent, and skip anything unknown. */
412 RDEBUG (("ExpectEcho\n"))
413 monitor_expect (sndbuf
, (char *) 0, 0);
417 /* Write characters to the remote system. */
420 monitor_write (buf
, buflen
)
424 if (SERIAL_WRITE (monitor_desc
, buf
, buflen
))
425 fprintf_unfiltered (gdb_stderr
, "SERIAL_WRITE failed: %s\n",
426 safe_strerror (errno
));
430 /* Read a binary character from the remote system, doing all the fancy
431 timeout stuff, but without interpreting the character in any way,
432 and without printing remote debug information. */
443 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
446 c
&= 0xff; /* don't lose bit 7 */
453 if (c
== SERIAL_TIMEOUT
)
454 error ("Timeout reading from remote system.");
456 perror_with_name ("remote-monitor");
460 /* Read a character from the remote system, doing all the fancy
470 last_random
, last_nl
, last_cr
, last_crnl
478 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
484 /* This seems to interfere with proper function of the
486 if (remote_debug
> 0)
491 puts_debug ("read -->", buf
, "<--");
497 /* Canonicialize \n\r combinations into one \r */
498 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
500 if ((c
== '\r' && state
== last_nl
)
501 || (c
== '\n' && state
== last_cr
))
522 if (c
== SERIAL_TIMEOUT
)
524 /* I fail to see how detaching here can be useful */
525 if (in_monitor_wait
) /* Watchdog went off */
527 target_mourn_inferior ();
528 error ("GDB serial timeout has expired. Target detached.\n");
532 error ("Timeout reading from remote system.");
534 perror_with_name ("remote-monitor");
537 /* Scan input from the remote system, until STRING is found. If BUF is non-
538 zero, then collect input until we have collected either STRING or BUFLEN-1
539 chars. In either case we terminate BUF with a 0. If input overflows BUF
540 because STRING can't be found, return -1, else return number of chars in BUF
541 (minus the terminating NUL). Note that in the non-overflow case, STRING
542 will be at the end of BUF. */
545 monitor_expect (string
, buf
, buflen
)
551 int obuflen
= buflen
;
553 extern struct target_ops
*targ_ops
;
558 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
559 monitor_printable_string (safe_string
, string
);
560 printf ("MON Expecting '%s'\n", safe_string
);
575 c
= readchar (timeout
);
582 c
= readchar (timeout
);
584 /* Don't expect any ^C sent to be echoed */
586 if (*p
== '\003' || c
== *p
)
596 return obuflen
- buflen
;
602 else if ((c
== '\021' || c
== '\023') &&
603 (STREQ (targ_ops
->to_shortname
, "m32r")
604 || STREQ (targ_ops
->to_shortname
, "mon2000")))
605 { /* m32r monitor emits random DC1/DC3 chars */
617 /* Search for a regexp. */
620 monitor_expect_regexp (pat
, buf
, buflen
)
621 struct re_pattern_buffer
*pat
;
627 RDEBUG (("MON Expecting regexp\n"));
632 mybuf
= alloca (1024);
641 if (p
- mybuf
>= buflen
)
642 { /* Buffer about to overflow */
644 /* On overflow, we copy the upper half of the buffer to the lower half. Not
645 great, but it usually works... */
647 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
648 p
= mybuf
+ buflen
/ 2;
651 *p
++ = readchar (timeout
);
653 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
659 /* Keep discarding input until we see the MONITOR prompt.
661 The convention for dealing with the prompt is that you
663 o *then* wait for the prompt.
665 Thus the last thing that a procedure does with the serial line will
666 be an monitor_expect_prompt(). Exception: monitor_resume does not
667 wait for the prompt, because the terminal is being handed over to
668 the inferior. However, the next thing which happens after that is
669 a monitor_wait which does wait for the prompt. Note that this
670 includes abnormal exit, e.g. error(). This is necessary to prevent
671 getting into states from which we can't recover. */
674 monitor_expect_prompt (buf
, buflen
)
678 RDEBUG (("MON Expecting prompt\n"))
679 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
682 /* Get N 32-bit words from remote, each preceded by a space, and put
683 them in registers starting at REGNO. */
694 ch
= readchar (timeout
);
695 while (isspace (ch
));
699 for (i
= 7; i
>= 1; i
--)
701 ch
= readchar (timeout
);
704 val
= (val
<< 4) | from_hex (ch
);
712 compile_pattern (pattern
, compiled_pattern
, fastmap
)
714 struct re_pattern_buffer
*compiled_pattern
;
720 compiled_pattern
->fastmap
= fastmap
;
722 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
723 val
= re_compile_pattern (pattern
,
729 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern
, val
);
732 re_compile_fastmap (compiled_pattern
);
735 /* Open a connection to a remote debugger. NAME is the filename used
736 for communication. */
739 monitor_open (args
, mon_ops
, from_tty
)
741 struct monitor_ops
*mon_ops
;
747 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
748 error ("Magic number of monitor_ops struct wrong.");
750 targ_ops
= mon_ops
->target
;
751 name
= targ_ops
->to_shortname
;
754 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
755 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
757 target_preopen (from_tty
);
759 /* Setup pattern for register dump */
761 if (mon_ops
->register_pattern
)
762 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
765 if (mon_ops
->getmem
.resp_delim
)
766 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
767 getmem_resp_delim_fastmap
);
769 unpush_target (targ_ops
);
773 dev_name
= strsave (args
);
775 monitor_desc
= SERIAL_OPEN (dev_name
);
778 perror_with_name (dev_name
);
782 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
784 SERIAL_CLOSE (monitor_desc
);
785 perror_with_name (dev_name
);
789 SERIAL_RAW (monitor_desc
);
791 SERIAL_FLUSH_INPUT (monitor_desc
);
793 /* some systems only work with 2 stop bits */
795 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
797 current_monitor
= mon_ops
;
799 /* See if we can wake up the monitor. First, try sending a stop sequence,
800 then send the init strings. Last, remove all breakpoints. */
802 if (current_monitor
->stop
)
805 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
807 RDEBUG (("EXP Open echo\n"));
808 monitor_expect_prompt (NULL
, 0);
812 /* wake up the monitor and see if it's alive */
813 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
815 /* Some of the characters we send may not be echoed,
816 but we hope to get a prompt at the end of it all. */
818 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
821 monitor_printf_noecho (*p
);
822 monitor_expect_prompt (NULL
, 0);
825 SERIAL_FLUSH_INPUT (monitor_desc
);
827 /* Alloc breakpoints */
828 if (mon_ops
->set_break
!= NULL
)
830 if (mon_ops
->num_breakpoints
== 0)
831 mon_ops
->num_breakpoints
= 8;
833 breakaddr
= (CORE_ADDR
*) xmalloc (mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
834 memset (breakaddr
, 0, mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
837 /* Remove all breakpoints */
839 if (mon_ops
->clr_all_break
)
841 monitor_printf (mon_ops
->clr_all_break
);
842 monitor_expect_prompt (NULL
, 0);
846 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
848 push_target (targ_ops
);
850 inferior_pid
= 42000; /* Make run command think we are busy... */
852 /* Give monitor_wait something to read */
854 monitor_printf (current_monitor
->line_term
);
856 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
857 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory_block
);
859 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory
);
863 /* Close out all files and local state before this target loses
867 monitor_close (quitting
)
871 SERIAL_CLOSE (monitor_desc
);
873 /* Free breakpoint memory */
874 if (breakaddr
!= NULL
)
883 /* Terminate the open connection to the remote debugger. Use this
884 when you want to detach and do something else with your gdb. */
887 monitor_detach (args
, from_tty
)
891 pop_target (); /* calls monitor_close to do the real work */
893 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
896 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
899 monitor_supply_register (regno
, valstr
)
904 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
907 val
= strtoul (valstr
, &p
, 16);
908 RDEBUG (("Supplying Register %d %s\n", regno
, valstr
));
910 if (val
== 0 && valstr
== p
)
911 error ("monitor_supply_register (%d): bad value from monitor: %s.",
914 /* supply register stores in target byte order, so swap here */
916 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
918 supply_register (regno
, regbuf
);
923 /* Tell the remote machine to resume. */
926 flush_monitor_dcache ()
928 dcache_flush (remote_dcache
);
932 monitor_resume (pid
, step
, sig
)
934 enum target_signal sig
;
936 /* Some monitors require a different command when starting a program */
937 RDEBUG (("MON resume\n"));
938 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
941 monitor_printf ("run\r");
942 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
946 dcache_flush (remote_dcache
);
948 monitor_printf (current_monitor
->step
);
951 if (current_monitor
->continue_hook
)
952 (*current_monitor
->continue_hook
) ();
954 monitor_printf (current_monitor
->cont
);
955 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
960 /* Parse the output of a register dump command. A monitor specific
961 regexp is used to extract individual register descriptions of the
962 form REG=VAL. Each description is split up into a name and a value
963 string which are passed down to monitor specific code. */
966 parse_register_dump (buf
, len
)
970 RDEBUG (("MON Parsing register dump\n"))
973 int regnamelen
, vallen
;
975 /* Element 0 points to start of register name, and element 1
976 points to the start of the register value. */
977 struct re_registers register_strings
;
979 memset (®ister_strings
, 0, sizeof (struct re_registers
));
981 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
982 ®ister_strings
) == -1)
985 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
986 regname
= buf
+ register_strings
.start
[1];
987 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
988 val
= buf
+ register_strings
.start
[2];
990 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
992 buf
+= register_strings
.end
[0];
993 len
-= register_strings
.end
[0];
997 /* Send ^C to target to halt it. Target will respond, and send us a
1001 monitor_interrupt (signo
)
1004 /* If this doesn't work, try more severe steps. */
1005 signal (signo
, monitor_interrupt_twice
);
1008 printf_unfiltered ("monitor_interrupt called\n");
1013 /* The user typed ^C twice. */
1016 monitor_interrupt_twice (signo
)
1019 signal (signo
, ofunc
);
1021 monitor_interrupt_query ();
1023 signal (signo
, monitor_interrupt
);
1026 /* Ask the user what to do when an interrupt is received. */
1029 monitor_interrupt_query ()
1031 target_terminal_ours ();
1033 if (query ("Interrupted while waiting for the program.\n\
1034 Give up (and stop debugging it)? "))
1036 target_mourn_inferior ();
1037 return_to_top_level (RETURN_QUIT
);
1040 target_terminal_inferior ();
1044 monitor_wait_cleanup (old_timeout
)
1047 timeout
= *(int *) old_timeout
;
1048 signal (SIGINT
, ofunc
);
1049 in_monitor_wait
= 0;
1055 monitor_wait_filter (char *buf
,
1058 struct target_waitstatus
*status
1064 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1065 *ext_resp_len
= resp_len
;
1068 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1070 while (resp_len
< 0);
1072 /* Print any output characters that were preceded by ^O. */
1073 /* FIXME - This would be great as a user settabgle flag */
1075 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1079 for (i
= 0; i
< resp_len
- 1; i
++)
1081 putchar_unfiltered (buf
[++i
]);
1087 /* Wait until the remote machine stops, then return, storing status in
1088 status just as `wait' would. */
1091 monitor_wait (pid
, status
)
1093 struct target_waitstatus
*status
;
1095 int old_timeout
= timeout
;
1098 struct cleanup
*old_chain
;
1100 status
->kind
= TARGET_WAITKIND_EXITED
;
1101 status
->value
.integer
= 0;
1103 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1104 RDEBUG (("MON wait\n"))
1107 /* This is somthing other than a maintenance command */
1108 in_monitor_wait
= 1;
1109 timeout
= watchdog
> 0 ? watchdog
: -1;
1111 timeout
= -1; /* Don't time out -- user program is running. */
1114 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1116 if (current_monitor
->wait_filter
)
1117 (*current_monitor
->wait_filter
) (buf
, sizeof (buf
), &resp_len
, status
);
1119 monitor_wait_filter (buf
, sizeof (buf
), &resp_len
, status
);
1121 #if 0 /* Transferred to monitor wait filter */
1124 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1127 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1129 while (resp_len
< 0);
1131 /* Print any output characters that were preceded by ^O. */
1132 /* FIXME - This would be great as a user settabgle flag */
1134 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1138 for (i
= 0; i
< resp_len
- 1; i
++)
1140 putchar_unfiltered (buf
[++i
]);
1144 signal (SIGINT
, ofunc
);
1146 timeout
= old_timeout
;
1148 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1151 monitor_printf (current_monitor
->dump_registers
);
1152 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1155 if (current_monitor
->register_pattern
)
1156 parse_register_dump (buf
, resp_len
);
1158 RDEBUG (("Wait fetching registers after stop\n"));
1159 monitor_dump_regs ();
1162 status
->kind
= TARGET_WAITKIND_STOPPED
;
1163 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1165 discard_cleanups (old_chain
);
1167 in_monitor_wait
= 0;
1169 return inferior_pid
;
1172 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1176 monitor_fetch_register (regno
)
1180 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] =
1182 char regbuf
[MAX_REGISTER_RAW_SIZE
* 2 + 1];
1185 name
= current_monitor
->regnames
[regno
];
1186 RDEBUG (("MON fetchreg %d '%s'\n", regno
, name
? name
: "(null name)"))
1188 if (!name
|| (*name
== '\0'))
1190 RDEBUG (("No register known for %d\n", regno
))
1191 supply_register (regno
, zerobuf
);
1195 /* send the register examine command */
1197 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1199 /* If RESP_DELIM is specified, we search for that as a leading
1200 delimiter for the register value. Otherwise, we just start
1201 searching from the start of the buf. */
1203 if (current_monitor
->getreg
.resp_delim
)
1205 RDEBUG (("EXP getreg.resp_delim\n"))
1206 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1207 /* Handle case of first 32 registers listed in pairs. */
1208 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1209 && (regno
& 1) != 0 && regno
< 32)
1211 RDEBUG (("EXP getreg.resp_delim\n"));
1212 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1216 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1217 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1220 c
= readchar (timeout
);
1222 c
= readchar (timeout
);
1223 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1226 error ("Bad value returned from monitor while fetching register %x.",
1230 /* Read upto the maximum number of hex digits for this register, skipping
1231 spaces, but stop reading if something else is seen. Some monitors
1232 like to drop leading zeros. */
1234 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
1237 c
= readchar (timeout
);
1239 c
= readchar (timeout
);
1247 regbuf
[i
] = '\000'; /* terminate the number */
1248 RDEBUG (("REGVAL '%s'\n", regbuf
));
1250 /* If TERM is present, we wait for that to show up. Also, (if TERM
1251 is present), we will send TERM_CMD if that is present. In any
1252 case, we collect all of the output into buf, and then wait for
1253 the normal prompt. */
1255 if (current_monitor
->getreg
.term
)
1257 RDEBUG (("EXP getreg.term\n"))
1258 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1261 if (current_monitor
->getreg
.term_cmd
)
1263 RDEBUG (("EMIT getreg.term.cmd\n"))
1264 monitor_printf (current_monitor
->getreg
.term_cmd
);
1266 if (!current_monitor
->getreg
.term
|| /* Already expected or */
1267 current_monitor
->getreg
.term_cmd
) /* ack expected */
1268 monitor_expect_prompt (NULL
, 0); /* get response */
1270 monitor_supply_register (regno
, regbuf
);
1273 /* Sometimes, it takes several commands to dump the registers */
1274 /* This is a primitive for use by variations of monitor interfaces in
1275 case they need to compose the operation.
1278 monitor_dump_reg_block (char *block_cmd
)
1282 monitor_printf (block_cmd
);
1283 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1284 parse_register_dump (buf
, resp_len
);
1289 /* Read the remote registers into the block regs. */
1290 /* Call the specific function if it has been provided */
1293 monitor_dump_regs ()
1297 if (current_monitor
->dumpregs
)
1298 (*(current_monitor
->dumpregs
)) (); /* call supplied function */
1299 else if (current_monitor
->dump_registers
) /* default version */
1301 monitor_printf (current_monitor
->dump_registers
);
1302 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1303 parse_register_dump (buf
, resp_len
);
1306 abort (); /* Need some way to read registers */
1310 monitor_fetch_registers (regno
)
1313 RDEBUG (("MON fetchregs\n"));
1314 if (current_monitor
->getreg
.cmd
)
1318 monitor_fetch_register (regno
);
1322 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1323 monitor_fetch_register (regno
);
1327 monitor_dump_regs ();
1331 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1334 monitor_store_register (regno
)
1340 name
= current_monitor
->regnames
[regno
];
1341 if (!name
|| (*name
== '\0'))
1343 RDEBUG (("MON Cannot store unknown register\n"))
1347 val
= read_register (regno
);
1348 RDEBUG (("MON storeg %d %08x\n", regno
, (unsigned int) val
))
1350 /* send the register deposit command */
1352 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1353 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1354 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1355 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1357 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1359 if (current_monitor
->setreg
.term
)
1361 RDEBUG (("EXP setreg.term\n"))
1362 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1363 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1364 monitor_printf ("%x\r", val
);
1365 monitor_expect_prompt (NULL
, 0);
1368 monitor_expect_prompt (NULL
, 0);
1369 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1371 RDEBUG (("EXP setreg_termcmd\n"));
1372 monitor_printf ("%s", current_monitor
->setreg
.term_cmd
);
1373 monitor_expect_prompt (NULL
, 0);
1375 } /* monitor_store_register */
1377 /* Store the remote registers. */
1380 monitor_store_registers (regno
)
1385 monitor_store_register (regno
);
1389 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1390 monitor_store_register (regno
);
1393 /* Get ready to modify the registers array. On machines which store
1394 individual registers, this doesn't need to do anything. On machines
1395 which store all the registers in one fell swoop, this makes sure
1396 that registers contains all the registers from the program being
1400 monitor_prepare_to_store ()
1402 /* Do nothing, since we can store individual regs */
1406 monitor_files_info (ops
)
1407 struct target_ops
*ops
;
1409 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1413 monitor_write_memory (memaddr
, myaddr
, len
)
1418 unsigned int val
, hostval
;
1422 RDEBUG (("MON write %d %08x\n", len
, (unsigned long) memaddr
))
1424 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1425 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1427 /* Use memory fill command for leading 0 bytes. */
1429 if (current_monitor
->fill
)
1431 for (i
= 0; i
< len
; i
++)
1435 if (i
> 4) /* More than 4 zeros is worth doing */
1437 RDEBUG (("MON FILL %d\n", i
))
1438 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1439 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
) - 1, 0);
1441 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1443 monitor_expect_prompt (NULL
, 0);
1450 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1451 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1454 cmd
= current_monitor
->setmem
.cmdll
;
1458 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1461 cmd
= current_monitor
->setmem
.cmdl
;
1463 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1466 cmd
= current_monitor
->setmem
.cmdw
;
1471 cmd
= current_monitor
->setmem
.cmdb
;
1474 val
= extract_unsigned_integer (myaddr
, len
);
1478 hostval
= *(unsigned int *) myaddr
;
1479 RDEBUG (("Hostval(%08x) val(%08x)\n", hostval
, val
));
1483 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1484 monitor_printf_noecho (cmd
, memaddr
, val
);
1485 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1488 monitor_printf_noecho (cmd
, memaddr
);
1490 if (current_monitor
->setmem
.term
)
1492 RDEBUG (("EXP setmem.term"));
1493 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1494 monitor_printf ("%x\r", val
);
1496 if (current_monitor
->setmem
.term_cmd
)
1497 { /* Emit this to get out of the memory editing state */
1498 monitor_printf ("%s", current_monitor
->setmem
.term_cmd
);
1499 /* Drop through to expecting a prompt */
1503 monitor_printf (cmd
, memaddr
, val
);
1505 monitor_expect_prompt (NULL
, 0);
1512 monitor_write_even_block (memaddr
, myaddr
, len
)
1519 /* Enter the sub mode */
1520 monitor_printf (current_monitor
->setmem
.cmdl
, memaddr
);
1521 monitor_expect_prompt (NULL
, 0);
1525 val
= extract_unsigned_integer (myaddr
, 4); /* REALLY */
1526 monitor_printf ("%x\r", val
);
1530 RDEBUG ((" @ %08x\n", memaddr
))
1531 /* If we wanted to, here we could validate the address */
1532 monitor_expect_prompt (NULL
, 0);
1534 /* Now exit the sub mode */
1535 monitor_printf (current_monitor
->getreg
.term_cmd
);
1536 monitor_expect_prompt (NULL
, 0);
1542 monitor_write_memory_bytes (memaddr
, myaddr
, len
)
1551 /* Enter the sub mode */
1552 monitor_printf (current_monitor
->setmem
.cmdb
, memaddr
);
1553 monitor_expect_prompt (NULL
, 0);
1557 monitor_printf ("%x\r", val
);
1561 /* If we wanted to, here we could validate the address */
1562 monitor_expect_prompt (NULL
, 0);
1565 /* Now exit the sub mode */
1566 monitor_printf (current_monitor
->getreg
.term_cmd
);
1567 monitor_expect_prompt (NULL
, 0);
1573 longlongendswap (unsigned char *a
)
1582 *(a
+ i
) = *(a
+ j
);
1587 /* Format 32 chars of long long value, advance the pointer */
1588 static char *hexlate
= "0123456789abcdef";
1590 longlong_hexchars (unsigned long long value
,
1600 static unsigned char disbuf
[8]; /* disassembly buffer */
1601 unsigned char *scan
, *limit
; /* loop controls */
1602 unsigned char c
, nib
;
1607 unsigned long long *dp
;
1608 dp
= (unsigned long long *) scan
;
1611 longlongendswap (disbuf
); /* FIXME: ONly on big endian hosts */
1612 while (scan
< limit
)
1614 c
= *scan
++; /* a byte of our long long value */
1620 leadzero
= 0; /* henceforth we print even zeroes */
1622 nib
= c
>> 4; /* high nibble bits */
1623 *outbuff
++ = hexlate
[nib
];
1624 nib
= c
& 0x0f; /* low nibble bits */
1625 *outbuff
++ = hexlate
[nib
];
1629 } /* longlong_hexchars */
1633 /* I am only going to call this when writing virtual byte streams.
1634 Which possably entails endian conversions
1637 monitor_write_memory_longlongs (memaddr
, myaddr
, len
)
1642 static char hexstage
[20]; /* At least 16 digits required, plus null */
1647 llptr
= (unsigned long long *) myaddr
;
1650 monitor_printf (current_monitor
->setmem
.cmdll
, memaddr
);
1651 monitor_expect_prompt (NULL
, 0);
1655 endstring
= longlong_hexchars (*llptr
, hexstage
);
1656 *endstring
= '\0'; /* NUll terminate for printf */
1657 monitor_printf ("%s\r", hexstage
);
1661 /* If we wanted to, here we could validate the address */
1662 monitor_expect_prompt (NULL
, 0);
1665 /* Now exit the sub mode */
1666 monitor_printf (current_monitor
->getreg
.term_cmd
);
1667 monitor_expect_prompt (NULL
, 0);
1673 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1674 /* This is for the large blocks of memory which may occur in downloading.
1675 And for monitors which use interactive entry,
1676 And for monitors which do not have other downloading methods.
1677 Without this, we will end up calling monitor_write_memory many times
1678 and do the entry and exit of the sub mode many times
1679 This currently assumes...
1680 MO_SETMEM_INTERACTIVE
1681 ! MO_NO_ECHO_ON_SETMEM
1682 To use this, the you have to patch the monitor_cmds block with
1683 this function. Otherwise, its not tuned up for use by all
1688 monitor_write_memory_block (memaddr
, myaddr
, len
)
1695 /* FIXME: This would be a good place to put the zero test */
1697 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1699 return monitor_write_memory_longlongs (memaddr
, myaddr
, len
);
1706 written
= monitor_write_even_block (memaddr
, myaddr
, len
);
1707 /* Adjust calling parameters by written amount */
1713 written
= monitor_write_memory_bytes (memaddr
, myaddr
, len
);
1717 /* This is an alternate form of monitor_read_memory which is used for monitors
1718 which can only read a single byte/word/etc. at a time. */
1721 monitor_read_memory_single (memaddr
, myaddr
, len
)
1727 char membuf
[sizeof (int) * 2 + 1];
1732 RDEBUG (("MON read single\n"));
1734 /* Can't actually use long longs (nice idea, though). In fact, the
1735 call to strtoul below will fail if it tries to convert a value
1736 that's too big to fit in a long. */
1737 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1740 cmd
= current_monitor
->getmem
.cmdll
;
1744 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1747 cmd
= current_monitor
->getmem
.cmdl
;
1749 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1752 cmd
= current_monitor
->getmem
.cmdw
;
1757 cmd
= current_monitor
->getmem
.cmdb
;
1760 /* Send the examine command. */
1762 monitor_printf (cmd
, memaddr
);
1764 /* If RESP_DELIM is specified, we search for that as a leading
1765 delimiter for the memory value. Otherwise, we just start
1766 searching from the start of the buf. */
1768 if (current_monitor
->getmem
.resp_delim
)
1770 RDEBUG (("EXP getmem.resp_delim\n"));
1771 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1774 /* Now, read the appropriate number of hex digits for this loc,
1777 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1778 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1782 c
= readchar (timeout
);
1784 c
= readchar (timeout
);
1785 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1788 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1789 memaddr
, i
, membuf
, c
);
1791 for (i
= 0; i
< len
* 2; i
++)
1797 c
= readchar (timeout
);
1803 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1804 memaddr
, i
, membuf
, c
);
1810 membuf
[i
] = '\000'; /* terminate the number */
1812 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1813 present), we will send TERM_CMD if that is present. In any case, we collect
1814 all of the output into buf, and then wait for the normal prompt. */
1816 if (current_monitor
->getmem
.term
)
1818 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1820 if (current_monitor
->getmem
.term_cmd
)
1822 monitor_printf (current_monitor
->getmem
.term_cmd
);
1823 monitor_expect_prompt (NULL
, 0);
1827 monitor_expect_prompt (NULL
, 0); /* get response */
1830 val
= strtoul (membuf
, &p
, 16);
1832 if (val
== 0 && membuf
== p
)
1833 monitor_error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
1834 memaddr
, 0, membuf
, 0);
1836 /* supply register stores in target byte order, so swap here */
1838 store_unsigned_integer (myaddr
, len
, val
);
1843 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1844 memory at MEMADDR. Returns length moved. Currently, we do no more
1845 than 16 bytes at a time. */
1848 monitor_read_memory (memaddr
, myaddr
, len
)
1862 RDEBUG (("Zero length call to monitor_read_memory\n"));
1867 printf ("MON read block ta(%08x) ha(%08x) %d\n",
1868 (unsigned long) memaddr
, (unsigned long) myaddr
, len
);
1870 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1871 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1873 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1874 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1876 len
= min (len
, 16);
1878 /* Some dumpers align the first data with the preceeding 16
1879 byte boundary. Some print blanks and start at the
1880 requested boundary. EXACT_DUMPADDR
1883 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1884 ? memaddr
: memaddr
& ~0x0f;
1886 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1887 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1888 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1890 /* send the memory examine command */
1892 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1893 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
);
1894 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1895 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1897 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1899 /* If TERM is present, we wait for that to show up. Also, (if TERM
1900 is present), we will send TERM_CMD if that is present. In any
1901 case, we collect all of the output into buf, and then wait for
1902 the normal prompt. */
1904 if (current_monitor
->getmem
.term
)
1906 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1909 monitor_error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
1910 memaddr
, resp_len
, buf
, 0);
1912 if (current_monitor
->getmem
.term_cmd
)
1914 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1915 strlen (current_monitor
->getmem
.term_cmd
));
1916 monitor_expect_prompt (NULL
, 0);
1920 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1924 /* If RESP_DELIM is specified, we search for that as a leading
1925 delimiter for the values. Otherwise, we just start searching
1926 from the start of the buf. */
1928 if (current_monitor
->getmem
.resp_delim
)
1931 struct re_registers resp_strings
;
1932 RDEBUG (("MON getmem.resp_delim %s\n", current_monitor
->getmem
.resp_delim
));
1934 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1936 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1940 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1941 memaddr
, resp_len
, buf
, 0);
1943 p
+= resp_strings
.end
[0];
1945 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1947 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1948 memaddr
, resp_len
, buf
, 0);
1949 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1953 printf ("MON scanning %d ,%08x '%s'\n", len
, p
, p
);
1954 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1962 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1966 if ((dumpaddr
>= memaddr
) && (i
> 0))
1968 val
= fromhex (c
) * 16 + fromhex (*(p
+ 1));
1971 printf ("[%02x]", val
);
1978 ++p
; /* skip a blank or other non hex char */
1982 error ("Failed to read via monitor");
1985 return fetched
; /* Return the number of bytes actually read */
1987 RDEBUG (("MON scanning bytes\n"));
1989 for (i
= len
; i
> 0; i
--)
1991 /* Skip non-hex chars, but bomb on end of string and newlines */
1998 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1999 monitor_error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s",
2000 memaddr
, resp_len
, buf
, 0);
2004 val
= strtoul (p
, &p1
, 16);
2006 if (val
== 0 && p
== p1
)
2007 monitor_error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.",
2008 memaddr
, resp_len
, buf
, 0);
2022 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
2027 struct target_ops
*target
; /* ignored */
2029 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, write
);
2035 return; /* ignore attempts to kill target system */
2038 /* All we actually do is set the PC to the start address of exec_bfd, and start
2039 the program at that point. */
2042 monitor_create_inferior (exec_file
, args
, env
)
2047 if (args
&& (*args
!= '\000'))
2048 error ("Args are not supported by the monitor.");
2051 clear_proceed_status ();
2052 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
2055 /* Clean up when a program exits.
2056 The program actually lives on in the remote processor's RAM, and may be
2057 run again without a download. Don't leave it full of breakpoint
2061 monitor_mourn_inferior ()
2063 unpush_target (targ_ops
);
2064 generic_mourn_inferior (); /* Do all the proper things now */
2067 /* Tell the monitor to add a breakpoint. */
2070 monitor_insert_breakpoint (addr
, shadow
)
2078 RDEBUG (("MON inst bkpt %08x\n", addr
))
2079 if (current_monitor
->set_break
== NULL
)
2080 error ("No set_break defined for this monitor");
2082 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2083 addr
= ADDR_BITS_REMOVE (addr
);
2085 /* Determine appropriate breakpoint size for this address. */
2086 bp
= memory_breakpoint_from_pc (&addr
, &bplen
);
2088 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2090 if (breakaddr
[i
] == 0)
2092 breakaddr
[i
] = addr
;
2093 monitor_read_memory (addr
, shadow
, bplen
);
2094 monitor_printf (current_monitor
->set_break
, addr
);
2095 monitor_expect_prompt (NULL
, 0);
2100 error ("Too many breakpoints (> %d) for monitor.", current_monitor
->num_breakpoints
);
2103 /* Tell the monitor to remove a breakpoint. */
2106 monitor_remove_breakpoint (addr
, shadow
)
2112 RDEBUG (("MON rmbkpt %08x\n", addr
))
2113 if (current_monitor
->clr_break
== NULL
)
2114 error ("No clr_break defined for this monitor");
2116 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2117 addr
= ADDR_BITS_REMOVE (addr
);
2119 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2121 if (breakaddr
[i
] == addr
)
2124 /* some monitors remove breakpoints based on the address */
2125 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2126 monitor_printf (current_monitor
->clr_break
, addr
);
2127 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2128 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2130 monitor_printf (current_monitor
->clr_break
, i
);
2131 monitor_expect_prompt (NULL
, 0);
2135 fprintf_unfiltered (gdb_stderr
,
2136 "Can't find breakpoint associated with 0x%x\n", addr
);
2140 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2141 an S-record. Return non-zero if the ACK is received properly. */
2144 monitor_wait_srec_ack ()
2148 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2150 return (readchar (timeout
) == '+');
2152 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2154 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2155 if ((ch
= readchar (1)) < 0)
2157 if ((ch
= readchar (1)) < 0)
2159 if ((ch
= readchar (1)) < 0)
2161 if ((ch
= readchar (1)) < 0)
2167 /* monitor_load -- download a file. */
2170 monitor_load (file
, from_tty
)
2174 dcache_flush (remote_dcache
);
2175 RDEBUG (("MON load\n"))
2177 if (current_monitor
->load_routine
)
2178 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2180 { /* The default is ascii S-records */
2182 unsigned long load_offset
;
2185 /* enable user to specify address for downloading as 2nd arg to load */
2186 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2192 monitor_printf (current_monitor
->load
);
2193 if (current_monitor
->loadresp
)
2194 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2196 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2197 32, SREC_ALL
, hashmark
,
2198 current_monitor
->flags
& MO_SREC_ACK
?
2199 monitor_wait_srec_ack
: NULL
);
2201 monitor_expect_prompt (NULL
, 0);
2204 /* Finally, make the PC point at the start address */
2207 write_pc (bfd_get_start_address (exec_bfd
));
2209 inferior_pid
= 0; /* No process now */
2211 /* This is necessary because many things were based on the PC at the time that
2212 we attached to the monitor, which is no longer valid now that we have loaded
2213 new code (and just changed the PC). Another way to do this might be to call
2214 normal_stop, except that the stack may not be valid, and things would get
2215 horribly confused... */
2217 clear_symtab_users ();
2223 RDEBUG (("MON stop\n"));
2224 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2225 SERIAL_SEND_BREAK (monitor_desc
);
2226 if (current_monitor
->stop
)
2227 monitor_printf_noecho (current_monitor
->stop
);
2230 /* Put a command string, in args, out to MONITOR. Output from MONITOR
2231 is placed on the users terminal until the prompt is seen. FIXME: We
2232 read the characters ourseleves here cause of a nasty echo. */
2235 monitor_command (args
, from_tty
)
2243 if (monitor_desc
== NULL
)
2244 error ("monitor target not open.");
2246 p
= current_monitor
->prompt
;
2248 /* Send the command. Note that if no args were supplied, then we're
2249 just sending the monitor a newline, which is sometimes useful. */
2251 monitor_printf ("%s\r", (args
? args
: ""));
2253 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2255 fputs_unfiltered (buf
, gdb_stdout
); /* Output the response */
2258 /* Convert hex digit A to a number. */
2265 if (a
>= '0' && a
<= '9')
2267 if (a
>= 'a' && a
<= 'f')
2268 return a
- 'a' + 10;
2269 if (a
>= 'A' && a
<= 'F')
2270 return a
- 'A' + 10;
2272 error ("Reply contains invalid hex digit 0x%x", a
);
2277 monitor_get_dev_name ()
2282 static struct target_ops monitor_ops
;
2285 init_base_monitor_ops (void)
2287 monitor_ops
.to_shortname
= NULL
;
2288 monitor_ops
.to_longname
= NULL
;
2289 monitor_ops
.to_doc
= NULL
;
2290 monitor_ops
.to_open
= NULL
;
2291 monitor_ops
.to_close
= monitor_close
;
2292 monitor_ops
.to_attach
= NULL
;
2293 monitor_ops
.to_post_attach
= NULL
;
2294 monitor_ops
.to_require_attach
= NULL
;
2295 monitor_ops
.to_detach
= monitor_detach
;
2296 monitor_ops
.to_require_detach
= NULL
;
2297 monitor_ops
.to_resume
= monitor_resume
;
2298 monitor_ops
.to_wait
= monitor_wait
;
2299 monitor_ops
.to_post_wait
= NULL
;
2300 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2301 monitor_ops
.to_store_registers
= monitor_store_registers
;
2302 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2303 monitor_ops
.to_xfer_memory
= monitor_xfer_memory
;
2304 monitor_ops
.to_files_info
= monitor_files_info
;
2305 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2306 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2307 monitor_ops
.to_terminal_init
= 0;
2308 monitor_ops
.to_terminal_inferior
= 0;
2309 monitor_ops
.to_terminal_ours_for_output
= 0;
2310 monitor_ops
.to_terminal_ours
= 0;
2311 monitor_ops
.to_terminal_info
= 0;
2312 monitor_ops
.to_kill
= monitor_kill
;
2313 monitor_ops
.to_load
= monitor_load
;
2314 monitor_ops
.to_lookup_symbol
= 0;
2315 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2316 monitor_ops
.to_post_startup_inferior
= NULL
;
2317 monitor_ops
.to_acknowledge_created_inferior
= NULL
;
2318 monitor_ops
.to_clone_and_follow_inferior
= NULL
;
2319 monitor_ops
.to_post_follow_inferior_by_clone
= NULL
;
2320 monitor_ops
.to_insert_fork_catchpoint
= NULL
;
2321 monitor_ops
.to_remove_fork_catchpoint
= NULL
;
2322 monitor_ops
.to_insert_vfork_catchpoint
= NULL
;
2323 monitor_ops
.to_remove_vfork_catchpoint
= NULL
;
2324 monitor_ops
.to_has_forked
= NULL
;
2325 monitor_ops
.to_has_vforked
= NULL
;
2326 monitor_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2327 monitor_ops
.to_post_follow_vfork
= NULL
;
2328 monitor_ops
.to_insert_exec_catchpoint
= NULL
;
2329 monitor_ops
.to_remove_exec_catchpoint
= NULL
;
2330 monitor_ops
.to_has_execd
= NULL
;
2331 monitor_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2332 monitor_ops
.to_has_exited
= NULL
;
2333 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2334 monitor_ops
.to_can_run
= 0;
2335 monitor_ops
.to_notice_signals
= 0;
2336 monitor_ops
.to_thread_alive
= 0;
2337 monitor_ops
.to_stop
= monitor_stop
;
2338 monitor_ops
.to_pid_to_exec_file
= NULL
;
2339 monitor_ops
.to_core_file_to_sym_file
= NULL
;
2340 monitor_ops
.to_stratum
= process_stratum
;
2341 monitor_ops
.DONT_USE
= 0;
2342 monitor_ops
.to_has_all_memory
= 1;
2343 monitor_ops
.to_has_memory
= 1;
2344 monitor_ops
.to_has_stack
= 1;
2345 monitor_ops
.to_has_registers
= 1;
2346 monitor_ops
.to_has_execution
= 1;
2347 monitor_ops
.to_sections
= 0;
2348 monitor_ops
.to_sections_end
= 0;
2349 monitor_ops
.to_magic
= OPS_MAGIC
;
2350 } /* init_base_monitor_ops */
2352 /* Init the target_ops structure pointed at by OPS */
2355 init_monitor_ops (ops
)
2356 struct target_ops
*ops
;
2358 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2359 init_base_monitor_ops ();
2361 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2364 /* Define additional commands that are usually only used by monitors. */
2367 _initialize_remote_monitors ()
2369 init_base_monitor_ops ();
2370 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
2372 "Set display of activity while downloading a file.\n\
2373 When enabled, a hashmark \'#\' is displayed.",
2377 add_com ("monitor", class_obscure
, monitor_command
,
2378 "Send a command to the debug monitor.");