1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990, 1991, 1992, 1993, 1995, 1996
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, 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 */
44 #ifdef ANSI_PROTOTYPES
51 #include "gdb_string.h"
52 #include <sys/types.h>
58 #include "gnu-regex.h"
62 static int readchar
PARAMS ((int timeout
));
64 static void monitor_command
PARAMS ((char *args
, int fromtty
));
66 static void monitor_fetch_register
PARAMS ((int regno
));
67 static void monitor_store_register
PARAMS ((int regno
));
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 ((int 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));
88 static void monitor_debug
PARAMS ((char *prefix
, char *string
, char *suffix
));
90 static int monitor_read_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
,int len
));
91 static int monitor_write_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
,int len
));
93 static int monitor_expect_regexp
PARAMS ((struct re_pattern_buffer
*pat
,
94 char *buf
, int buflen
));
95 static int from_hex
PARAMS ((int a
));
96 static unsigned long get_hex_word
PARAMS ((void));
98 static struct monitor_ops
*current_monitor
;
100 static int hashmark
; /* flag set by "set hash" */
102 static int timeout
= 30;
104 static int in_monitor_wait
= 0; /* Non-zero means we are in monitor_wait() */
106 static void (*ofunc
)(); /* Old SIGINT signal handler */
108 /* Descriptor for I/O to remote machine. Initialize it to NULL so
109 that monitor_open knows that we don't have a file open when the
112 static serial_t monitor_desc
= NULL
;
114 /* Pointer to regexp pattern matching data */
116 static struct re_pattern_buffer register_pattern
;
117 static char register_fastmap
[256];
119 static struct re_pattern_buffer getmem_resp_delim_pattern
;
120 static char getmem_resp_delim_fastmap
[256];
122 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
123 monitor_wait wakes up. */
125 static DCACHE
*remote_dcache
;
126 static int first_time
=0; /* is this the first time we're executing after
127 gaving created the child proccess? */
129 /* monitor_debug is like fputs_unfiltered, except it prints special
130 characters in printable fashion. */
133 monitor_debug (prefix
, string
, suffix
)
140 /* print prefix and suffix after each line */
141 static int new_line
=1;
142 static char *prev_prefix
= "";
143 static char *prev_suffix
= "";
145 /* if the prefix is changing, print the previous suffix, a new line,
146 and the new prefix */
147 if (strcmp(prev_prefix
, prefix
) != 0 && !new_line
)
149 fputs_unfiltered (prev_suffix
, gdb_stderr
);
150 fputs_unfiltered ("\n", gdb_stderr
);
151 fputs_unfiltered (prefix
, gdb_stderr
);
153 prev_prefix
= prefix
;
154 prev_suffix
= suffix
;
156 /* print prefix if last char was a newline*/
159 fputs_unfiltered (prefix
, gdb_stderr
);
162 if (strchr(string
,'\n')) /* save state for next call */
165 while ((ch
= *string
++) != '\0')
170 fputc_unfiltered (ch
, gdb_stderr
);
173 fprintf_unfiltered (gdb_stderr
, "\\%03o", ch
);
177 case '\\': fputs_unfiltered ("\\\\", gdb_stderr
); break;
178 case '\b': fputs_unfiltered ("\\b", gdb_stderr
); break;
179 case '\f': fputs_unfiltered ("\\f", gdb_stderr
); break;
180 case '\n': fputs_unfiltered ("\\n", gdb_stderr
); break;
181 case '\r': fputs_unfiltered ("\\r", gdb_stderr
); break;
182 case '\t': fputs_unfiltered ("\\t", gdb_stderr
); break;
183 case '\v': fputs_unfiltered ("\\v", gdb_stderr
); break;
187 if (new_line
==1) { /* print suffix if last char was a newline */
188 fputs_unfiltered (suffix
, gdb_stderr
);
189 fputs_unfiltered ("\n", gdb_stderr
);
193 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
194 Works just like printf. */
197 #ifdef ANSI_PROTOTYPES
198 monitor_printf_noecho (char *pattern
, ...)
200 monitor_printf_noecho (va_alist
)
209 va_start (args
, pattern
);
213 pattern
= va_arg (args
, char *);
216 vsprintf (sndbuf
, pattern
, args
);
218 if (remote_debug
> 0)
219 monitor_debug ("sent -->", sndbuf
, "<--");
221 len
= strlen (sndbuf
);
223 if (len
+ 1 > sizeof sndbuf
)
226 if (SERIAL_WRITE(monitor_desc
, sndbuf
, len
))
227 fprintf_unfiltered (stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
230 /* monitor_printf -- Send data to monitor and check the echo. Works just like
234 #ifdef ANSI_PROTOTYPES
235 monitor_printf (char *pattern
, ...)
237 monitor_printf (va_alist
)
245 #ifdef ANSI_PROTOTYPES
246 va_start (args
, pattern
);
250 pattern
= va_arg (args
, char *);
253 vsprintf (sndbuf
, pattern
, args
);
255 if (remote_debug
> 0)
256 monitor_debug ("sent -->", sndbuf
, "<--");
258 len
= strlen (sndbuf
);
260 if (len
+ 1 > sizeof sndbuf
)
263 if (SERIAL_WRITE(monitor_desc
, sndbuf
, len
))
264 fprintf_unfiltered (stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
266 /* We used to expect that the next immediate output was the characters we
267 just output, but sometimes some extra junk appeared before the characters
268 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
269 So, just start searching for what we sent, and skip anything unknown. */
270 monitor_expect (sndbuf
, (char *)0, 0);
273 /* Read a character from the remote system, doing all the fancy
281 static enum { last_random
, last_nl
, last_cr
, last_crnl
} state
= last_random
;
287 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
292 if (remote_debug
> 0)
297 monitor_debug ("read -->", buf
, "<--");
301 /* Canonicialize \n\r combinations into one \r */
302 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
304 if ((c
== '\r' && state
== last_nl
)
305 || (c
== '\n' && state
== last_cr
))
326 if (c
== SERIAL_TIMEOUT
)
327 #ifdef MAINTENANCE_CMDS
328 if (in_monitor_wait
) /* Watchdog went off */
330 target_mourn_inferior ();
331 error ("Watchdog has expired. Target detached.\n");
335 error ("Timeout reading from remote system.");
337 perror_with_name ("remote-monitor");
340 /* Scan input from the remote system, until STRING is found. If BUF is non-
341 zero, then collect input until we have collected either STRING or BUFLEN-1
342 chars. In either case we terminate BUF with a 0. If input overflows BUF
343 because STRING can't be found, return -1, else return number of chars in BUF
344 (minus the terminating NUL). Note that in the non-overflow case, STRING
345 will be at the end of BUF. */
348 monitor_expect (string
, buf
, buflen
)
354 int obuflen
= buflen
;
356 extern struct target_ops
*targ_ops
;
370 c
= readchar (timeout
);
377 c
= readchar (timeout
);
379 /* Don't expect any ^C sent to be echoed */
381 if (*p
== '\003' || c
== *p
)
391 return obuflen
- buflen
;
397 else if ((c
== '\021' || c
== '\023') &&
398 (strcmp(targ_ops
->to_shortname
, "m32r") == 0))
399 { /* m32r monitor emits random DC1/DC3 chars */
411 /* Search for a regexp. */
414 monitor_expect_regexp (pat
, buf
, buflen
)
415 struct re_pattern_buffer
*pat
;
426 mybuf
= alloca (1024);
435 if (p
- mybuf
>= buflen
)
436 { /* Buffer about to overflow */
438 /* On overflow, we copy the upper half of the buffer to the lower half. Not
439 great, but it usually works... */
441 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
442 p
= mybuf
+ buflen
/ 2;
445 *p
++ = readchar (timeout
);
447 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
453 /* Keep discarding input until we see the MONITOR prompt.
455 The convention for dealing with the prompt is that you
457 o *then* wait for the prompt.
459 Thus the last thing that a procedure does with the serial line
460 will be an monitor_expect_prompt(). Exception: monitor_resume does not
461 wait for the prompt, because the terminal is being handed over
462 to the inferior. However, the next thing which happens after that
463 is a monitor_wait which does wait for the prompt.
464 Note that this includes abnormal exit, e.g. error(). This is
465 necessary to prevent getting into states from which we can't
469 monitor_expect_prompt (buf
, buflen
)
473 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
476 /* Get N 32-bit words from remote, each preceded by a space, and put
477 them in registers starting at REGNO. */
487 ch
= readchar (timeout
);
492 for (i
= 7; i
>= 1; i
--)
494 ch
= readchar (timeout
);
497 val
= (val
<< 4) | from_hex (ch
);
504 compile_pattern (pattern
, compiled_pattern
, fastmap
)
506 struct re_pattern_buffer
*compiled_pattern
;
512 compiled_pattern
->fastmap
= fastmap
;
514 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
515 val
= re_compile_pattern (pattern
,
521 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern
, val
);
524 re_compile_fastmap (compiled_pattern
);
527 /* Open a connection to a remote debugger. NAME is the filename used
528 for communication. */
530 static char *dev_name
;
531 static struct target_ops
*targ_ops
;
534 monitor_open (args
, mon_ops
, from_tty
)
536 struct monitor_ops
*mon_ops
;
543 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
544 error ("Magic number of monitor_ops struct wrong.");
546 targ_ops
= mon_ops
->target
;
547 name
= targ_ops
->to_shortname
;
550 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
551 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
553 target_preopen (from_tty
);
555 /* Setup pattern for register dump */
557 if (mon_ops
->register_pattern
)
558 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
561 if (mon_ops
->getmem
.resp_delim
)
562 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
563 getmem_resp_delim_fastmap
);
565 unpush_target (targ_ops
);
569 dev_name
= strsave (args
);
571 monitor_desc
= SERIAL_OPEN (dev_name
);
574 perror_with_name (dev_name
);
578 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
580 SERIAL_CLOSE (monitor_desc
);
581 perror_with_name (dev_name
);
585 SERIAL_RAW (monitor_desc
);
587 SERIAL_FLUSH_INPUT (monitor_desc
);
589 /* some systems only work with 2 stop bits */
591 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
593 current_monitor
= mon_ops
;
595 /* See if we can wake up the monitor. First, try sending a stop sequence,
596 then send the init strings. Last, remove all breakpoints. */
598 if (current_monitor
->stop
)
601 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
603 monitor_expect_prompt (NULL
, 0);
607 /* wake up the monitor and see if it's alive */
608 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
610 /* Some of the characters we send may not be echoed,
611 but we hope to get a prompt at the end of it all. */
613 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
616 monitor_printf_noecho (*p
);
617 monitor_expect_prompt (NULL
, 0);
620 SERIAL_FLUSH_INPUT (monitor_desc
);
622 /* Remove all breakpoints */
624 if (mon_ops
->clr_all_break
)
626 monitor_printf (mon_ops
->clr_all_break
);
627 monitor_expect_prompt (NULL
, 0);
631 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
633 push_target (targ_ops
);
635 inferior_pid
= 42000; /* Make run command think we are busy... */
637 /* Give monitor_wait something to read */
639 monitor_printf (current_monitor
->line_term
);
641 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory
);
646 /* Close out all files and local state before this target loses
650 monitor_close (quitting
)
654 SERIAL_CLOSE (monitor_desc
);
658 /* Terminate the open connection to the remote debugger. Use this
659 when you want to detach and do something else with your gdb. */
662 monitor_detach (args
, from_tty
)
666 pop_target (); /* calls monitor_close to do the real work */
668 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
671 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
674 monitor_supply_register (regno
, valstr
)
679 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
682 val
= strtoul (valstr
, &p
, 16);
684 if (val
== 0 && valstr
== p
)
685 error ("monitor_supply_register (%d): bad value from monitor: %s.",
688 /* supply register stores in target byte order, so swap here */
690 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
692 supply_register (regno
, regbuf
);
697 /* Tell the remote machine to resume. */
700 monitor_resume (pid
, step
, sig
)
702 enum target_signal sig
;
704 /* Some monitors require a different command when starting a program */
705 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
708 monitor_printf ("run\r");
709 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
713 dcache_flush (remote_dcache
);
715 monitor_printf (current_monitor
->step
);
718 monitor_printf (current_monitor
->cont
);
719 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
724 /* Parse the output of a register dump command. A monitor specific
725 regexp is used to extract individual register descriptions of the
726 form REG=VAL. Each description is split up into a name and a value
727 string which are passed down to monitor specific code. */
730 parse_register_dump (buf
, len
)
736 int regnamelen
, vallen
;
738 /* Element 0 points to start of register name, and element 1
739 points to the start of the register value. */
740 struct re_registers register_strings
;
742 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
743 ®ister_strings
) == -1)
746 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
747 regname
= buf
+ register_strings
.start
[1];
748 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
749 val
= buf
+ register_strings
.start
[2];
751 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
753 buf
+= register_strings
.end
[0];
754 len
-= register_strings
.end
[0];
758 /* Send ^C to target to halt it. Target will respond, and send us a
762 monitor_interrupt (signo
)
765 /* If this doesn't work, try more severe steps. */
766 signal (signo
, monitor_interrupt_twice
);
769 printf_unfiltered ("monitor_interrupt called\n");
774 /* The user typed ^C twice. */
777 monitor_interrupt_twice (signo
)
780 signal (signo
, ofunc
);
782 monitor_interrupt_query ();
784 signal (signo
, monitor_interrupt
);
787 /* Ask the user what to do when an interrupt is received. */
790 monitor_interrupt_query ()
792 target_terminal_ours ();
794 if (query ("Interrupted while waiting for the program.\n\
795 Give up (and stop debugging it)? "))
797 target_mourn_inferior ();
798 return_to_top_level (RETURN_QUIT
);
801 target_terminal_inferior ();
805 monitor_wait_cleanup (old_timeout
)
808 timeout
= old_timeout
;
809 signal (SIGINT
, ofunc
);
813 /* Wait until the remote machine stops, then return, storing status in
814 status just as `wait' would. */
817 monitor_wait (pid
, status
)
819 struct target_waitstatus
*status
;
821 int old_timeout
= timeout
;
824 struct cleanup
*old_chain
;
826 status
->kind
= TARGET_WAITKIND_EXITED
;
827 status
->value
.integer
= 0;
829 old_chain
= make_cleanup (monitor_wait_cleanup
, old_timeout
);
831 #ifdef MAINTENANCE_CMDS
833 timeout
= watchdog
> 0 ? watchdog
: -1;
835 timeout
= -1; /* Don't time out -- user program is running. */
838 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
842 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
845 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
847 while (resp_len
< 0);
849 signal (SIGINT
, ofunc
);
851 timeout
= old_timeout
;
853 if (dump_reg_flag
&& current_monitor
->dump_registers
)
857 monitor_printf (current_monitor
->dump_registers
);
858 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
861 if (current_monitor
->register_pattern
)
862 parse_register_dump (buf
, resp_len
);
864 status
->kind
= TARGET_WAITKIND_STOPPED
;
865 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
867 discard_cleanups (old_chain
);
874 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
878 monitor_fetch_register (regno
)
882 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] = {0};
883 char regbuf
[MAX_REGISTER_RAW_SIZE
* 2 + 1];
886 name
= current_monitor
->regnames
[regno
];
890 supply_register (regno
, zerobuf
);
894 /* send the register examine command */
896 monitor_printf (current_monitor
->getreg
.cmd
, name
);
898 /* If RESP_DELIM is specified, we search for that as a leading
899 delimiter for the register value. Otherwise, we just start
900 searching from the start of the buf. */
902 if (current_monitor
->getreg
.resp_delim
)
903 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
905 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
906 if (current_monitor
->flags
& MO_HEX_PREFIX
)
909 c
= readchar (timeout
);
911 c
= readchar (timeout
);
912 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
915 error ("Bad value returned from monitor while fetching register %x.",
919 /* Read upto the maximum number of hex digits for this register, skipping
920 spaces, but stop reading if something else is seen. Some monitors
921 like to drop leading zeros. */
923 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
926 c
= readchar (timeout
);
928 c
= readchar (timeout
);
936 regbuf
[i
] = '\000'; /* terminate the number */
938 /* If TERM is present, we wait for that to show up. Also, (if TERM
939 is present), we will send TERM_CMD if that is present. In any
940 case, we collect all of the output into buf, and then wait for
941 the normal prompt. */
943 if (current_monitor
->getreg
.term
)
945 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
947 if (current_monitor
->getreg
.term_cmd
)
949 monitor_printf (current_monitor
->getreg
.term_cmd
);
950 monitor_expect_prompt (NULL
, 0);
954 monitor_expect_prompt (NULL
, 0); /* get response */
956 monitor_supply_register (regno
, regbuf
);
959 /* Read the remote registers into the block regs. */
961 static void monitor_dump_regs ()
966 if (current_monitor
->dump_registers
)
968 monitor_printf (current_monitor
->dump_registers
);
969 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
970 parse_register_dump (buf
, resp_len
);
973 abort(); /* Need some way to read registers */
977 monitor_fetch_registers (regno
)
980 if (current_monitor
->getreg
.cmd
)
984 monitor_fetch_register (regno
);
988 for (regno
= 0; regno
< NUM_REGS
; regno
++)
989 monitor_fetch_register (regno
);
992 monitor_dump_regs ();
996 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
999 monitor_store_register (regno
)
1005 name
= current_monitor
->regnames
[regno
];
1009 val
= read_register (regno
);
1011 /* send the register deposit command */
1013 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1014 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1016 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1018 /* It's possible that there are actually some monitors out there that
1019 will prompt you when you set a register. In that case, you may
1020 need to add some code here to deal with TERM and TERM_CMD (see
1021 monitor_fetch_register to get an idea of what's needed...) */
1023 monitor_expect_prompt (NULL
, 0);
1026 /* Store the remote registers. */
1029 monitor_store_registers (regno
)
1034 monitor_store_register (regno
);
1038 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1039 monitor_store_register (regno
);
1042 /* Get ready to modify the registers array. On machines which store
1043 individual registers, this doesn't need to do anything. On machines
1044 which store all the registers in one fell swoop, this makes sure
1045 that registers contains all the registers from the program being
1049 monitor_prepare_to_store ()
1051 /* Do nothing, since we can store individual regs */
1055 monitor_files_info (ops
)
1056 struct target_ops
*ops
;
1058 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1062 monitor_write_memory (memaddr
, myaddr
, len
)
1071 /* Use memory fill command for leading 0 bytes. */
1073 if (current_monitor
->fill
)
1075 for (i
= 0; i
< len
; i
++)
1079 if (i
> 4) /* More than 4 zeros is worth doing */
1081 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1082 monitor_printf (current_monitor
->fill
, memaddr
, memaddr
+ i
, 0);
1084 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1086 monitor_expect_prompt (NULL
, 0);
1093 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1094 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1097 cmd
= current_monitor
->setmem
.cmdll
;
1101 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1104 cmd
= current_monitor
->setmem
.cmdl
;
1106 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1109 cmd
= current_monitor
->setmem
.cmdw
;
1114 cmd
= current_monitor
->setmem
.cmdb
;
1117 val
= extract_unsigned_integer (myaddr
, len
);
1119 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1120 monitor_printf_noecho (cmd
, memaddr
, val
);
1122 monitor_printf (cmd
, memaddr
, val
);
1124 monitor_expect_prompt (NULL
, 0);
1129 /* This is an alternate form of monitor_read_memory which is used for monitors
1130 which can only read a single byte/word/etc. at a time. */
1133 monitor_read_memory_single (memaddr
, myaddr
, len
)
1139 char membuf
[sizeof(int) * 2 + 1];
1145 /* Can't actually use long longs (nice idea, though). In fact, the
1146 call to strtoul below will fail if it tries to convert a value
1147 that's too big to fit in a long. */
1148 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1151 cmd
= current_monitor
->getmem
.cmdll
;
1155 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1158 cmd
= current_monitor
->getmem
.cmdl
;
1160 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1163 cmd
= current_monitor
->getmem
.cmdw
;
1168 cmd
= current_monitor
->getmem
.cmdb
;
1171 /* Send the examine command. */
1173 monitor_printf (cmd
, memaddr
);
1175 /* If RESP_DELIM is specified, we search for that as a leading delimiter for
1176 the register value. Otherwise, we just start searching from the start of
1179 if (current_monitor
->getmem
.resp_delim
)
1180 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1182 /* Now, read the appropriate number of hex digits for this loc, skipping
1185 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1186 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1189 c
= readchar (timeout
);
1191 c
= readchar (timeout
);
1192 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1195 error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1196 memaddr
, i
, membuf
, c
);
1198 for (i
= 0; i
< len
* 2; i
++)
1204 c
= readchar (timeout
);
1210 error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1211 memaddr
, i
, membuf
, c
);
1217 membuf
[i
] = '\000'; /* terminate the number */
1219 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1220 present), we will send TERM_CMD if that is present. In any case, we collect
1221 all of the output into buf, and then wait for the normal prompt. */
1223 if (current_monitor
->getmem
.term
)
1225 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1227 if (current_monitor
->getmem
.term_cmd
)
1229 monitor_printf (current_monitor
->getmem
.term_cmd
);
1230 monitor_expect_prompt (NULL
, 0);
1234 monitor_expect_prompt (NULL
, 0); /* get response */
1237 val
= strtoul (membuf
, &p
, 16);
1239 if (val
== 0 && membuf
== p
)
1240 error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
1243 /* supply register stores in target byte order, so swap here */
1245 store_unsigned_integer (myaddr
, len
, val
);
1250 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's memory
1251 at MEMADDR. Returns length moved. Currently, we only do one byte at a
1255 monitor_read_memory (memaddr
, myaddr
, len
)
1261 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
1268 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1269 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1271 len
= min (len
, 16);
1273 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1274 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1275 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1277 /* send the memory examine command */
1279 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1280 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
- 1);
1282 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1284 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1285 present), we will send TERM_CMD if that is present. In any case, we collect
1286 all of the output into buf, and then wait for the normal prompt. */
1288 if (current_monitor
->getmem
.term
)
1290 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1293 error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
1294 memaddr
, resp_len
, buf
);
1296 if (current_monitor
->getmem
.term_cmd
)
1298 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1299 strlen (current_monitor
->getmem
.term_cmd
));
1300 monitor_expect_prompt (NULL
, 0);
1304 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1308 /* If RESP_DELIM is specified, we search for that as a leading delimiter for
1309 the values. Otherwise, we just start searching from the start of the buf.
1312 if (current_monitor
->getmem
.resp_delim
)
1315 struct re_registers resp_strings
;
1318 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1322 error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1323 memaddr
, resp_len
, buf
);
1325 p
+= resp_strings
.end
[0];
1327 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1329 error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1330 memaddr
, resp_len
, buf
);
1331 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1335 for (i
= len
; i
> 0; i
--)
1337 /* Skip non-hex chars, but bomb on end of string and newlines */
1343 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1344 error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s", memaddr
, resp_len
, buf
);
1348 val
= strtoul (p
, &p1
, 16);
1350 if (val
== 0 && p
== p1
)
1351 error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.", memaddr
,
1366 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1371 struct target_ops
*target
; /* ignored */
1373 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, write
);
1379 return; /* ignore attempts to kill target system */
1382 /* All we actually do is set the PC to the start address of exec_bfd, and start
1383 the program at that point. */
1386 monitor_create_inferior (exec_file
, args
, env
)
1391 if (args
&& (*args
!= '\000'))
1392 error ("Args are not supported by the monitor.");
1395 clear_proceed_status ();
1396 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1399 /* Clean up when a program exits.
1400 The program actually lives on in the remote processor's RAM, and may be
1401 run again without a download. Don't leave it full of breakpoint
1405 monitor_mourn_inferior ()
1407 unpush_target (targ_ops
);
1408 generic_mourn_inferior (); /* Do all the proper things now */
1411 #define NUM_MONITOR_BREAKPOINTS 8
1413 static CORE_ADDR breakaddr
[NUM_MONITOR_BREAKPOINTS
] = {0};
1415 /* Tell the monitor to add a breakpoint. */
1418 monitor_insert_breakpoint (addr
, shadow
)
1423 static unsigned char break_insn
[] = BREAKPOINT
;
1425 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
1427 if (breakaddr
[i
] == 0)
1429 breakaddr
[i
] = addr
;
1430 monitor_read_memory (addr
, shadow
, sizeof (break_insn
));
1431 monitor_printf (current_monitor
->set_break
, addr
);
1432 monitor_expect_prompt (NULL
, 0);
1437 error ("Too many breakpoints (> %d) for monitor.", NUM_MONITOR_BREAKPOINTS
);
1440 /* Tell the monitor to remove a breakpoint. */
1443 monitor_remove_breakpoint (addr
, shadow
)
1449 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
1451 if (breakaddr
[i
] == addr
)
1454 /* some monitors remove breakpoints based on the address */
1455 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
1456 monitor_printf (current_monitor
->clr_break
, addr
);
1458 monitor_printf (current_monitor
->clr_break
, i
);
1459 monitor_expect_prompt (NULL
, 0);
1463 fprintf_unfiltered (stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
1467 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
1468 an S-record. Return non-zero if the ACK is received properly. */
1471 monitor_wait_srec_ack ()
1473 /* FIXME: eventually we'll want to be able to handle acknowledgements
1474 of something other than a '+' character. Right now this is only
1475 going to work for EST visionICE. */
1476 return readchar (timeout
) == '+';
1479 /* monitor_load -- download a file. */
1482 monitor_load (file
, from_tty
)
1486 dcache_flush (remote_dcache
);
1488 if (current_monitor
->load_routine
)
1489 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
1491 { /* The default is ascii S-records */
1492 monitor_printf (current_monitor
->load
);
1493 if (current_monitor
->loadresp
)
1494 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
1496 /* FIXME Should add arg here for load_offset (already done for generic_load) */
1497 load_srec (monitor_desc
, file
, 32, SREC_ALL
, hashmark
,
1498 current_monitor
->flags
& MO_SREC_ACK
?
1499 monitor_wait_srec_ack
: NULL
);
1501 monitor_expect_prompt (NULL
, 0);
1504 /* Finally, make the PC point at the start address */
1507 write_pc (bfd_get_start_address (exec_bfd
));
1509 inferior_pid
= 0; /* No process now */
1511 /* This is necessary because many things were based on the PC at the time that
1512 we attached to the monitor, which is no longer valid now that we have loaded
1513 new code (and just changed the PC). Another way to do this might be to call
1514 normal_stop, except that the stack may not be valid, and things would get
1515 horribly confused... */
1517 clear_symtab_users ();
1523 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
1524 SERIAL_SEND_BREAK (monitor_desc
);
1525 if (current_monitor
->stop
)
1526 monitor_printf_noecho (current_monitor
->stop
);
1529 /* Put a command string, in args, out to MONITOR. Output from MONITOR
1530 is placed on the users terminal until the prompt is seen. FIXME: We
1531 read the characters ourseleves here cause of a nasty echo. */
1534 monitor_command (args
, from_tty
)
1542 if (monitor_desc
== NULL
)
1543 error ("monitor target not open.");
1545 p
= current_monitor
->prompt
;
1547 /* Send the command. Note that if no args were supplied, then we're
1548 just sending the monitor a newline, which is sometimes useful. */
1550 monitor_printf ("%s\r", (args
? args
: ""));
1552 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
1554 fputs_unfiltered (buf
, gdb_stdout
); /* Output the response */
1557 /* Convert hex digit A to a number. */
1563 if (a
>= '0' && a
<= '9')
1565 if (a
>= 'a' && a
<= 'f')
1566 return a
- 'a' + 10;
1567 if (a
>= 'A' && a
<= 'F')
1568 return a
- 'A' + 10;
1570 error ("Reply contains invalid hex digit 0x%x", a
);
1573 static struct target_ops monitor_ops
=
1575 NULL
, /* to_shortname */
1576 NULL
, /* to_longname */
1579 monitor_close
, /* to_close */
1580 NULL
, /* to_attach */
1581 monitor_detach
, /* to_detach */
1582 monitor_resume
, /* to_resume */
1583 monitor_wait
, /* to_wait */
1584 monitor_fetch_registers
, /* to_fetch_registers */
1585 monitor_store_registers
, /* to_store_registers */
1586 monitor_prepare_to_store
, /* to_prepare_to_store */
1587 monitor_xfer_memory
, /* to_xfer_memory */
1588 monitor_files_info
, /* to_files_info */
1589 monitor_insert_breakpoint
, /* to_insert_breakpoint */
1590 monitor_remove_breakpoint
, /* to_remove_breakpoint */
1591 0, /* to_terminal_init */
1592 0, /* to_terminal_inferior */
1593 0, /* to_terminal_ours_for_output */
1594 0, /* to_terminal_ours */
1595 0, /* to_terminal_info */
1596 monitor_kill
, /* to_kill */
1597 monitor_load
, /* to_load */
1598 0, /* to_lookup_symbol */
1599 monitor_create_inferior
, /* to_create_inferior */
1600 monitor_mourn_inferior
, /* to_mourn_inferior */
1602 0, /* to_notice_signals */
1603 0, /* to_thread_alive */
1604 monitor_stop
, /* to_stop */
1605 process_stratum
, /* to_stratum */
1607 1, /* to_has_all_memory */
1608 1, /* to_has_memory */
1609 1, /* to_has_stack */
1610 1, /* to_has_registers */
1611 1, /* to_has_execution */
1613 0, /* sections_end */
1614 OPS_MAGIC
/* to_magic */
1617 /* Init the target_ops structure pointed at by OPS */
1620 init_monitor_ops (ops
)
1621 struct target_ops
*ops
;
1623 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
1626 /* Define additional commands that are usually only used by monitors. */
1629 _initialize_remote_monitors ()
1631 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
1633 "Set display of activity while downloading a file.\n\
1634 When enabled, a hashmark \'#\' is displayed.",
1638 add_com ("monitor", class_obscure
, monitor_command
,
1639 "Send a command to the debug monitor.");