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, 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 char *dev_name
;
63 static struct target_ops
*targ_ops
;
65 static void monitor_vsprintf
PARAMS ((char *sndbuf
, char *pattern
, va_list args
));
67 static int readchar
PARAMS ((int timeout
));
69 static void monitor_command
PARAMS ((char *args
, int fromtty
));
71 static void monitor_fetch_register
PARAMS ((int regno
));
72 static void monitor_store_register
PARAMS ((int regno
));
74 static int monitor_printable_string
PARAMS ((char *newstr
, char *oldstr
));
75 static void monitor_error
PARAMS ((char *format
, CORE_ADDR memaddr
, int len
, char *string
, int final_char
));
76 static void monitor_detach
PARAMS ((char *args
, int from_tty
));
77 static void monitor_resume
PARAMS ((int pid
, int step
, enum target_signal sig
));
78 static void monitor_interrupt
PARAMS ((int signo
));
79 static void monitor_interrupt_twice
PARAMS ((int signo
));
80 static void monitor_interrupt_query
PARAMS ((void));
81 static void monitor_wait_cleanup
PARAMS ((void *old_timeout
));
83 static int monitor_wait
PARAMS ((int pid
, struct target_waitstatus
*status
));
84 static void monitor_fetch_registers
PARAMS ((int regno
));
85 static void monitor_store_registers
PARAMS ((int regno
));
86 static void monitor_prepare_to_store
PARAMS ((void));
87 static int monitor_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
, int len
, int write
, struct target_ops
*target
));
88 static void monitor_files_info
PARAMS ((struct target_ops
*ops
));
89 static int monitor_insert_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
90 static int monitor_remove_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
91 static void monitor_kill
PARAMS ((void));
92 static void monitor_load
PARAMS ((char *file
, int from_tty
));
93 static void monitor_mourn_inferior
PARAMS ((void));
94 static void monitor_stop
PARAMS ((void));
96 static int monitor_read_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
,int len
));
97 static int monitor_write_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
,int len
));
98 static int monitor_write_memory_bytes
PARAMS ((CORE_ADDR addr
,
99 char *myaddr
,int len
));
100 static int monitor_write_memory_block
PARAMS((
104 static int monitor_expect_regexp
PARAMS ((struct re_pattern_buffer
*pat
,
105 char *buf
, int buflen
));
106 static void monitor_dump_regs
PARAMS((void)) ;
108 static int from_hex
PARAMS ((int a
));
109 static unsigned long get_hex_word
PARAMS ((void));
111 static void parse_register_dump
PARAMS ((char *, int));
113 static struct monitor_ops
*current_monitor
;
115 static int hashmark
; /* flag set by "set hash" */
117 static int timeout
= 30;
119 static int in_monitor_wait
= 0; /* Non-zero means we are in monitor_wait() */
121 static void (*ofunc
)(); /* Old SIGINT signal handler */
123 /* Extra remote debugging for developing a new rom monitor variation */
124 #if ! defined(EXTRA_RDEBUG)
125 #define EXTRA_RDEBUG 0
127 #define RDEBUG(stuff) { if (EXTRA_RDEBUG && remote_debug) printf stuff ; }
129 /* Descriptor for I/O to remote machine. Initialize it to NULL so
130 that monitor_open knows that we don't have a file open when the
133 static serial_t monitor_desc
= NULL
;
135 /* Pointer to regexp pattern matching data */
137 static struct re_pattern_buffer register_pattern
;
138 static char register_fastmap
[256];
140 static struct re_pattern_buffer getmem_resp_delim_pattern
;
141 static char getmem_resp_delim_fastmap
[256];
143 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
144 monitor_wait wakes up. */
146 static DCACHE
*remote_dcache
;
147 static int first_time
=0; /* is this the first time we're executing after
148 gaving created the child proccess? */
150 /* Convert a string into a printable representation, Return # byte in the
154 monitor_printable_string (newstr
, oldstr
)
161 while ((ch
= *oldstr
++) != '\0')
171 sprintf (newstr
, "\\x%02x", ch
& 0xff);
176 case '\\': *newstr
++ = '\\'; *newstr
++ = '\\'; break;
177 case '\b': *newstr
++ = '\\'; *newstr
++ = 'b'; break;
178 case '\f': *newstr
++ = '\\'; *newstr
++ = 't'; break;
179 case '\n': *newstr
++ = '\\'; *newstr
++ = 'n'; break;
180 case '\r': *newstr
++ = '\\'; *newstr
++ = 'r'; break;
181 case '\t': *newstr
++ = '\\'; *newstr
++ = 't'; break;
182 case '\v': *newstr
++ = '\\'; *newstr
++ = 'v'; break;
187 return newstr
- save
;
190 /* Print monitor errors with a string, converting the string to printable
194 monitor_error (format
, memaddr
, len
, string
, final_char
)
201 int real_len
= (len
== 0 && string
!= (char *)0) ? strlen (string
) : len
;
202 char *safe_string
= alloca ((real_len
* 4) + 1);
205 int safe_len
= monitor_printable_string (safe_string
, string
);
208 error (format
, (int)memaddr
, p
- safe_string
, safe_string
, final_char
);
210 error (format
, (int)memaddr
, p
- safe_string
, safe_string
);
213 /* Convert hex digit A to a number. */
219 if (a
>= '0' && a
<= '9')
221 else if (a
>= 'a' && a
<= 'f')
224 if (a
>= 'A' && a
<= 'F')
225 return a
- 'A' + 10 ;
226 else error ("Invalid hex digit %d", a
);
229 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
231 This function exists to get around the problem that many host platforms
232 don't have a printf that can print 64-bit addresses. The %A format
233 specification is recognized as a special case, and causes the argument
234 to be printed as a 64-bit hexadecimal address.
236 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
237 If it is a '%s' format, the argument is a string; otherwise the
238 argument is assumed to be a long integer.
240 %% is also turned into a single %.
244 monitor_vsprintf (sndbuf
, pattern
, args
)
257 for (p
= pattern
; *p
; p
++)
261 /* Copy the format specifier to a separate buffer. */
263 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
266 format
[i
] = fmt
= *p
;
269 /* Fetch the next argument and print it. */
273 strcpy (sndbuf
, "%");
276 arg_addr
= va_arg (args
, CORE_ADDR
);
277 strcpy (sndbuf
, paddr_nz (arg_addr
));
280 arg_string
= va_arg (args
, char *);
281 sprintf (sndbuf
, format
, arg_string
);
284 arg_int
= va_arg (args
, long);
285 sprintf (sndbuf
, format
, arg_int
);
288 sndbuf
+= strlen (sndbuf
);
297 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
298 Works just like printf. */
301 #ifdef ANSI_PROTOTYPES
302 monitor_printf_noecho (char *pattern
, ...)
304 monitor_printf_noecho (va_alist
)
313 va_start (args
, pattern
);
317 pattern
= va_arg (args
, char *);
320 monitor_vsprintf (sndbuf
, pattern
, args
);
322 len
= strlen (sndbuf
);
323 if (len
+ 1 > sizeof sndbuf
)
327 if (remote_debug
> 0)
328 puts_debug ("sent -->", sndbuf
, "<--");
333 char *safe_string
= (char *) alloca ((strlen (sndbuf
) * 4) + 1);
334 monitor_printable_string (safe_string
, sndbuf
);
335 printf ("sent[%s]\n", safe_string
);
338 monitor_write (sndbuf
, len
);
341 /* monitor_printf -- Send data to monitor and check the echo. Works just like
345 #ifdef ANSI_PROTOTYPES
346 monitor_printf (char *pattern
, ...)
348 monitor_printf (va_alist
)
356 #ifdef ANSI_PROTOTYPES
357 va_start (args
, pattern
);
361 pattern
= va_arg (args
, char *);
364 monitor_vsprintf (sndbuf
, pattern
, args
);
366 len
= strlen (sndbuf
);
367 if (len
+ 1 > sizeof sndbuf
)
371 if (remote_debug
> 0)
372 puts_debug ("sent -->", sndbuf
, "<--");
377 char *safe_string
= (char *) alloca ((len
* 4) + 1);
378 monitor_printable_string (safe_string
, sndbuf
);
379 printf ("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 RDEBUG(("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
444 static enum { last_random
, last_nl
, last_cr
, last_crnl
} state
= last_random
;
450 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
456 /* This seems to interfere with proper function of the
458 if (remote_debug
> 0)
463 puts_debug ("read -->", buf
, "<--");
469 /* Canonicialize \n\r combinations into one \r */
470 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
472 if ((c
== '\r' && state
== last_nl
)
473 || (c
== '\n' && state
== last_cr
))
494 if (c
== SERIAL_TIMEOUT
)
496 /* I fail to see how detaching here can be useful */
497 if (in_monitor_wait
) /* Watchdog went off */
499 target_mourn_inferior ();
500 error ("GDB serial timeout has expired. Target detached.\n");
504 error ("Timeout reading from remote system.");
506 perror_with_name ("remote-monitor");
509 /* Scan input from the remote system, until STRING is found. If BUF is non-
510 zero, then collect input until we have collected either STRING or BUFLEN-1
511 chars. In either case we terminate BUF with a 0. If input overflows BUF
512 because STRING can't be found, return -1, else return number of chars in BUF
513 (minus the terminating NUL). Note that in the non-overflow case, STRING
514 will be at the end of BUF. */
517 monitor_expect (string
, buf
, buflen
)
523 int obuflen
= buflen
;
525 extern struct target_ops
*targ_ops
;
530 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
531 monitor_printable_string (safe_string
, string
);
532 printf ("MON Expecting '%s'\n", safe_string
);
547 c
= readchar (timeout
);
554 c
= readchar (timeout
);
556 /* Don't expect any ^C sent to be echoed */
558 if (*p
== '\003' || c
== *p
)
568 return obuflen
- buflen
;
574 else if ((c
== '\021' || c
== '\023') &&
575 (STREQ (targ_ops
->to_shortname
, "m32r")
576 || STREQ (targ_ops
->to_shortname
, "mon2000")))
577 { /* m32r monitor emits random DC1/DC3 chars */
589 /* Search for a regexp. */
592 monitor_expect_regexp (pat
, buf
, buflen
)
593 struct re_pattern_buffer
*pat
;
599 RDEBUG(("MON Expecting regexp\n")) ;
604 mybuf
= alloca (1024);
613 if (p
- mybuf
>= buflen
)
614 { /* Buffer about to overflow */
616 /* On overflow, we copy the upper half of the buffer to the lower half. Not
617 great, but it usually works... */
619 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
620 p
= mybuf
+ buflen
/ 2;
623 *p
++ = readchar (timeout
);
625 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
631 /* Keep discarding input until we see the MONITOR prompt.
633 The convention for dealing with the prompt is that you
635 o *then* wait for the prompt.
637 Thus the last thing that a procedure does with the serial line will
638 be an monitor_expect_prompt(). Exception: monitor_resume does not
639 wait for the prompt, because the terminal is being handed over to
640 the inferior. However, the next thing which happens after that is
641 a monitor_wait which does wait for the prompt. Note that this
642 includes abnormal exit, e.g. error(). This is necessary to prevent
643 getting into states from which we can't recover. */
646 monitor_expect_prompt (buf
, buflen
)
650 RDEBUG(("MON Expecting prompt\n"))
651 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
654 /* Get N 32-bit words from remote, each preceded by a space, and put
655 them in registers starting at REGNO. */
666 ch
= readchar (timeout
);
671 for (i
= 7; i
>= 1; i
--)
673 ch
= readchar (timeout
);
676 val
= (val
<< 4) | from_hex (ch
);
684 compile_pattern (pattern
, compiled_pattern
, fastmap
)
686 struct re_pattern_buffer
*compiled_pattern
;
692 compiled_pattern
->fastmap
= fastmap
;
694 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
695 val
= re_compile_pattern (pattern
,
701 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern
, val
);
704 re_compile_fastmap (compiled_pattern
);
707 /* Open a connection to a remote debugger. NAME is the filename used
708 for communication. */
711 monitor_open (args
, mon_ops
, from_tty
)
713 struct monitor_ops
*mon_ops
;
719 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
720 error ("Magic number of monitor_ops struct wrong.");
722 targ_ops
= mon_ops
->target
;
723 name
= targ_ops
->to_shortname
;
726 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
727 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
729 target_preopen (from_tty
);
731 /* Setup pattern for register dump */
733 if (mon_ops
->register_pattern
)
734 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
737 if (mon_ops
->getmem
.resp_delim
)
738 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
739 getmem_resp_delim_fastmap
);
741 unpush_target (targ_ops
);
745 dev_name
= strsave (args
);
747 monitor_desc
= SERIAL_OPEN (dev_name
);
750 perror_with_name (dev_name
);
754 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
756 SERIAL_CLOSE (monitor_desc
);
757 perror_with_name (dev_name
);
761 SERIAL_RAW (monitor_desc
);
763 SERIAL_FLUSH_INPUT (monitor_desc
);
765 /* some systems only work with 2 stop bits */
767 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
769 current_monitor
= mon_ops
;
771 /* See if we can wake up the monitor. First, try sending a stop sequence,
772 then send the init strings. Last, remove all breakpoints. */
774 if (current_monitor
->stop
)
777 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
779 RDEBUG(("EXP Open echo\n")) ;
780 monitor_expect_prompt (NULL
, 0);
784 /* wake up the monitor and see if it's alive */
785 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
787 /* Some of the characters we send may not be echoed,
788 but we hope to get a prompt at the end of it all. */
790 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
793 monitor_printf_noecho (*p
);
794 monitor_expect_prompt (NULL
, 0);
797 SERIAL_FLUSH_INPUT (monitor_desc
);
799 /* Remove all breakpoints */
801 if (mon_ops
->clr_all_break
)
803 monitor_printf (mon_ops
->clr_all_break
);
804 monitor_expect_prompt (NULL
, 0);
808 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
810 push_target (targ_ops
);
812 inferior_pid
= 42000; /* Make run command think we are busy... */
814 /* Give monitor_wait something to read */
816 monitor_printf (current_monitor
->line_term
);
818 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
819 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory_block
);
821 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory
);
825 /* Close out all files and local state before this target loses
829 monitor_close (quitting
)
833 SERIAL_CLOSE (monitor_desc
);
837 /* Terminate the open connection to the remote debugger. Use this
838 when you want to detach and do something else with your gdb. */
841 monitor_detach (args
, from_tty
)
845 pop_target (); /* calls monitor_close to do the real work */
847 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
850 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
853 monitor_supply_register (regno
, valstr
)
858 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
861 val
= strtoul (valstr
, &p
, 16);
862 RDEBUG(("Supplying Register %d %s\n",regno
,valstr
)) ;
864 if (val
== 0 && valstr
== p
)
865 error ("monitor_supply_register (%d): bad value from monitor: %s.",
868 /* supply register stores in target byte order, so swap here */
870 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
872 supply_register (regno
, regbuf
);
877 /* Tell the remote machine to resume. */
880 flush_monitor_dcache ()
882 dcache_flush (remote_dcache
);
886 monitor_resume (pid
, step
, sig
)
888 enum target_signal sig
;
890 /* Some monitors require a different command when starting a program */
891 RDEBUG(("MON resume\n")) ;
892 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
895 monitor_printf ("run\r");
896 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
900 dcache_flush (remote_dcache
);
902 monitor_printf (current_monitor
->step
);
905 if (current_monitor
->continue_hook
)
906 (*current_monitor
->continue_hook
)() ;
907 else monitor_printf (current_monitor
->cont
);
908 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
913 /* Parse the output of a register dump command. A monitor specific
914 regexp is used to extract individual register descriptions of the
915 form REG=VAL. Each description is split up into a name and a value
916 string which are passed down to monitor specific code. */
919 parse_register_dump (buf
, len
)
923 RDEBUG(("MON Parsing register dump\n"))
926 int regnamelen
, vallen
;
928 /* Element 0 points to start of register name, and element 1
929 points to the start of the register value. */
930 struct re_registers register_strings
;
932 memset (®ister_strings
, 0, sizeof (struct re_registers
));
934 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
935 ®ister_strings
) == -1)
938 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
939 regname
= buf
+ register_strings
.start
[1];
940 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
941 val
= buf
+ register_strings
.start
[2];
943 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
945 buf
+= register_strings
.end
[0];
946 len
-= register_strings
.end
[0];
950 /* Send ^C to target to halt it. Target will respond, and send us a
954 monitor_interrupt (signo
)
957 /* If this doesn't work, try more severe steps. */
958 signal (signo
, monitor_interrupt_twice
);
961 printf_unfiltered ("monitor_interrupt called\n");
966 /* The user typed ^C twice. */
969 monitor_interrupt_twice (signo
)
972 signal (signo
, ofunc
);
974 monitor_interrupt_query ();
976 signal (signo
, monitor_interrupt
);
979 /* Ask the user what to do when an interrupt is received. */
982 monitor_interrupt_query ()
984 target_terminal_ours ();
986 if (query ("Interrupted while waiting for the program.\n\
987 Give up (and stop debugging it)? "))
989 target_mourn_inferior ();
990 return_to_top_level (RETURN_QUIT
);
993 target_terminal_inferior ();
997 monitor_wait_cleanup (old_timeout
)
1000 timeout
= *(int*)old_timeout
;
1001 signal (SIGINT
, ofunc
);
1002 in_monitor_wait
= 0;
1007 void monitor_wait_filter(char * buf
,
1010 struct target_waitstatus
* status
1016 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1017 * ext_resp_len
=resp_len
;
1020 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1022 while (resp_len
< 0);
1024 /* Print any output characters that were preceded by ^O. */
1025 /* FIXME - This would be great as a user settabgle flag */
1027 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1031 for (i
= 0; i
< resp_len
- 1; i
++)
1033 putchar_unfiltered (buf
[++i
]);
1039 /* Wait until the remote machine stops, then return, storing status in
1040 status just as `wait' would. */
1043 monitor_wait (pid
, status
)
1045 struct target_waitstatus
*status
;
1047 int old_timeout
= timeout
;
1050 struct cleanup
*old_chain
;
1052 status
->kind
= TARGET_WAITKIND_EXITED
;
1053 status
->value
.integer
= 0;
1055 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1056 RDEBUG(("MON wait\n"))
1059 /* This is somthing other than a maintenance command */
1060 in_monitor_wait
= 1;
1061 timeout
= watchdog
> 0 ? watchdog
: -1;
1063 timeout
= -1; /* Don't time out -- user program is running. */
1066 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1068 if (current_monitor
->wait_filter
)
1069 (*current_monitor
->wait_filter
)(buf
,sizeof (buf
),&resp_len
,status
) ;
1070 else monitor_wait_filter(buf
,sizeof (buf
),&resp_len
,status
) ;
1072 #if 0 /* Transferred to monitor wait filter */
1075 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1078 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1080 while (resp_len
< 0);
1082 /* Print any output characters that were preceded by ^O. */
1083 /* FIXME - This would be great as a user settabgle flag */
1085 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1089 for (i
= 0; i
< resp_len
- 1; i
++)
1091 putchar_unfiltered (buf
[++i
]);
1095 signal (SIGINT
, ofunc
);
1097 timeout
= old_timeout
;
1099 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1102 monitor_printf (current_monitor
->dump_registers
);
1103 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1106 if (current_monitor
->register_pattern
)
1107 parse_register_dump (buf
, resp_len
);
1109 RDEBUG(("Wait fetching registers after stop\n")) ;
1110 monitor_dump_regs() ;
1113 status
->kind
= TARGET_WAITKIND_STOPPED
;
1114 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1116 discard_cleanups (old_chain
);
1118 in_monitor_wait
= 0;
1120 return inferior_pid
;
1123 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1127 monitor_fetch_register (regno
)
1131 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] = {0};
1132 char regbuf
[MAX_REGISTER_RAW_SIZE
* 2 + 1];
1135 name
= current_monitor
->regnames
[regno
];
1136 RDEBUG(("MON fetchreg %d '%s'\n", regno
, name
? name
: "(null name)"))
1138 if (!name
|| (*name
== '\0'))
1140 RDEBUG (("No register known for %d\n", regno
))
1141 supply_register (regno
, zerobuf
);
1145 /* send the register examine command */
1147 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1149 /* If RESP_DELIM is specified, we search for that as a leading
1150 delimiter for the register value. Otherwise, we just start
1151 searching from the start of the buf. */
1153 if (current_monitor
->getreg
.resp_delim
)
1155 RDEBUG(("EXP getreg.resp_delim\n"))
1156 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1157 /* Handle case of first 32 registers listed in pairs. */
1158 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1159 && (regno
& 1) != 0 && regno
< 32)
1160 { RDEBUG(("EXP getreg.resp_delim\n")) ;
1161 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1165 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1166 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1169 c
= readchar (timeout
);
1171 c
= readchar (timeout
);
1172 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1175 error ("Bad value returned from monitor while fetching register %x.",
1179 /* Read upto the maximum number of hex digits for this register, skipping
1180 spaces, but stop reading if something else is seen. Some monitors
1181 like to drop leading zeros. */
1183 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
1186 c
= readchar (timeout
);
1188 c
= readchar (timeout
);
1196 regbuf
[i
] = '\000'; /* terminate the number */
1197 RDEBUG(("REGVAL '%s'\n",regbuf
)) ;
1199 /* If TERM is present, we wait for that to show up. Also, (if TERM
1200 is present), we will send TERM_CMD if that is present. In any
1201 case, we collect all of the output into buf, and then wait for
1202 the normal prompt. */
1204 if (current_monitor
->getreg
.term
)
1206 RDEBUG(("EXP getreg.term\n"))
1207 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1210 if (current_monitor
->getreg
.term_cmd
)
1211 { RDEBUG(("EMIT getreg.term.cmd\n"))
1212 monitor_printf (current_monitor
->getreg
.term_cmd
);
1214 if (! current_monitor
->getreg
.term
|| /* Already expected or */
1215 current_monitor
->getreg
.term_cmd
) /* ack expected */
1216 monitor_expect_prompt (NULL
, 0); /* get response */
1218 monitor_supply_register (regno
, regbuf
);
1221 /* Sometimes, it takes several commands to dump the registers */
1222 /* This is a primitive for use by variations of monitor interfaces in
1223 case they need to compose the operation.
1225 int monitor_dump_reg_block(char * block_cmd
)
1229 monitor_printf (block_cmd
);
1230 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1231 parse_register_dump (buf
, resp_len
);
1236 /* Read the remote registers into the block regs. */
1237 /* Call the specific function if it has been provided */
1240 monitor_dump_regs ()
1244 if (current_monitor
->dumpregs
)
1245 (*(current_monitor
->dumpregs
))() ; /* call supplied function */
1247 if (current_monitor
->dump_registers
) /* default version */
1248 { monitor_printf (current_monitor
->dump_registers
);
1249 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1250 parse_register_dump (buf
, resp_len
);
1253 abort(); /* Need some way to read registers */
1257 monitor_fetch_registers (regno
)
1260 RDEBUG(("MON fetchregs\n")) ;
1261 if (current_monitor
->getreg
.cmd
)
1265 monitor_fetch_register (regno
);
1269 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1270 monitor_fetch_register (regno
);
1273 monitor_dump_regs ();
1277 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1280 monitor_store_register (regno
)
1286 name
= current_monitor
->regnames
[regno
];
1287 if (!name
|| (*name
== '\0'))
1288 { RDEBUG(("MON Cannot store unknown register\n"))
1292 val
= read_register (regno
);
1293 RDEBUG(("MON storeg %d %08x\n",regno
,(unsigned int)val
))
1295 /* send the register deposit command */
1297 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1298 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1299 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1300 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1302 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1304 if (current_monitor
->setreg
.term
)
1305 { RDEBUG(("EXP setreg.term\n"))
1306 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1307 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1308 monitor_printf ("%x\r", val
);
1309 monitor_expect_prompt (NULL
, 0);
1312 monitor_expect_prompt (NULL
, 0);
1313 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1314 { RDEBUG(("EXP setreg_termcmd\n")) ;
1315 monitor_printf("%s",current_monitor
->setreg
.term_cmd
) ;
1316 monitor_expect_prompt(NULL
,0) ;
1318 } /* monitor_store_register */
1320 /* Store the remote registers. */
1323 monitor_store_registers (regno
)
1328 monitor_store_register (regno
);
1332 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1333 monitor_store_register (regno
);
1336 /* Get ready to modify the registers array. On machines which store
1337 individual registers, this doesn't need to do anything. On machines
1338 which store all the registers in one fell swoop, this makes sure
1339 that registers contains all the registers from the program being
1343 monitor_prepare_to_store ()
1345 /* Do nothing, since we can store individual regs */
1349 monitor_files_info (ops
)
1350 struct target_ops
*ops
;
1352 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1356 monitor_write_memory (memaddr
, myaddr
, len
)
1361 unsigned int val
, hostval
;
1365 RDEBUG(("MON write %d %08x\n",len
,(unsigned long)memaddr
))
1367 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1368 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1370 /* Use memory fill command for leading 0 bytes. */
1372 if (current_monitor
->fill
)
1374 for (i
= 0; i
< len
; i
++)
1378 if (i
> 4) /* More than 4 zeros is worth doing */
1380 RDEBUG(("MON FILL %d\n",i
))
1381 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1382 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
)-1, 0);
1384 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1386 monitor_expect_prompt (NULL
, 0);
1393 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1394 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1397 cmd
= current_monitor
->setmem
.cmdll
;
1401 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1404 cmd
= current_monitor
->setmem
.cmdl
;
1406 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1409 cmd
= current_monitor
->setmem
.cmdw
;
1414 cmd
= current_monitor
->setmem
.cmdb
;
1417 val
= extract_unsigned_integer (myaddr
, len
);
1420 { hostval
= * (unsigned int *) myaddr
;
1421 RDEBUG(("Hostval(%08x) val(%08x)\n",hostval
,val
)) ;
1425 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1426 monitor_printf_noecho (cmd
, memaddr
, val
);
1427 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1430 monitor_printf_noecho (cmd
, memaddr
);
1432 if (current_monitor
->setmem
.term
)
1433 { RDEBUG(("EXP setmem.term")) ;
1434 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1435 monitor_printf ("%x\r", val
);
1437 if (current_monitor
->setmem
.term_cmd
)
1438 { /* Emit this to get out of the memory editing state */
1439 monitor_printf("%s",current_monitor
->setmem
.term_cmd
) ;
1440 /* Drop through to expecting a prompt */
1444 monitor_printf (cmd
, memaddr
, val
);
1446 monitor_expect_prompt (NULL
, 0);
1453 monitor_write_even_block(memaddr
,myaddr
,len
)
1460 /* Enter the sub mode */
1461 monitor_printf(current_monitor
->setmem
.cmdl
,memaddr
) ;
1462 monitor_expect_prompt(NULL
,0) ;
1466 val
= extract_unsigned_integer(myaddr
,4) ; /* REALLY */
1467 monitor_printf("%x\r",val
) ;
1471 RDEBUG((" @ %08x\n",memaddr
))
1472 /* If we wanted to, here we could validate the address */
1473 monitor_expect_prompt(NULL
,0) ;
1475 /* Now exit the sub mode */
1476 monitor_printf (current_monitor
->getreg
.term_cmd
);
1477 monitor_expect_prompt(NULL
,0) ;
1482 static int monitor_write_memory_bytes(memaddr
,myaddr
,len
)
1489 if (len
== 0) return 0 ;
1490 /* Enter the sub mode */
1491 monitor_printf(current_monitor
->setmem
.cmdb
,memaddr
) ;
1492 monitor_expect_prompt(NULL
,0) ;
1496 monitor_printf("%x\r",val
) ;
1500 /* If we wanted to, here we could validate the address */
1501 monitor_expect_prompt(NULL
,0) ;
1504 /* Now exit the sub mode */
1505 monitor_printf (current_monitor
->getreg
.term_cmd
);
1506 monitor_expect_prompt(NULL
,0) ;
1512 longlongendswap (unsigned char * a
)
1524 /* Format 32 chars of long long value, advance the pointer */
1525 static char * hexlate
= "0123456789abcdef" ;
1526 static char * longlong_hexchars(unsigned long long value
,
1529 if (value
== 0) { *outbuff
++ = '0' ; return outbuff
; }
1531 { static unsigned char disbuf
[8] ; /* disassembly buffer */
1532 unsigned char * scan
, * limit
; /* loop controls */
1533 unsigned char c
, nib
;
1535 scan
= disbuf
; limit
= scan
+ 8 ;
1536 { unsigned long long * dp
;
1537 dp
= (unsigned long long *) scan
;
1540 longlongendswap(disbuf
) ; /* FIXME: ONly on big endian hosts */
1541 while (scan
< limit
)
1543 c
= *scan
++; /* a byte of our long long value */
1549 leadzero
= 0; /* henceforth we print even zeroes */
1551 nib
= c
>> 4; /* high nibble bits */
1552 *outbuff
++ = hexlate
[nib
];
1553 nib
= c
& 0x0f; /* low nibble bits */
1554 *outbuff
++ = hexlate
[nib
];
1558 } /* longlong_hexchars */
1562 /* I am only going to call this when writing virtual byte streams.
1563 Which possably entails endian conversions
1565 static int monitor_write_memory_longlongs(memaddr
,myaddr
,len
)
1570 static char hexstage
[20] ; /* At least 16 digits required, plus null */
1575 llptr
= (unsigned long long *) myaddr
;
1576 if (len
== 0 ) return 0 ;
1577 monitor_printf(current_monitor
->setmem
.cmdll
,memaddr
) ;
1578 monitor_expect_prompt(NULL
,0) ;
1582 endstring
= longlong_hexchars(*llptr
,hexstage
) ;
1583 *endstring
= '\0' ; /* NUll terminate for printf */
1584 monitor_printf("%s\r",hexstage
) ;
1588 /* If we wanted to, here we could validate the address */
1589 monitor_expect_prompt(NULL
,0) ;
1592 /* Now exit the sub mode */
1593 monitor_printf (current_monitor
->getreg
.term_cmd
);
1594 monitor_expect_prompt(NULL
,0) ;
1600 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1601 /* This is for the large blocks of memory which may occur in downloading.
1602 And for monitors which use interactive entry,
1603 And for monitors which do not have other downloading methods.
1604 Without this, we will end up calling monitor_write_memory many times
1605 and do the entry and exit of the sub mode many times
1606 This currently assumes...
1607 MO_SETMEM_INTERACTIVE
1608 ! MO_NO_ECHO_ON_SETMEM
1609 To use this, the you have to patch the monitor_cmds block with
1610 this function. Otherwise, its not tuned up for use by all
1614 static int monitor_write_memory_block(memaddr
,myaddr
,len
)
1621 /* FIXME: This would be a good place to put the zero test */
1623 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1625 return monitor_write_memory_longlongs(memaddr
,myaddr
,len
) ;
1632 written
= monitor_write_even_block(memaddr
,myaddr
,len
) ;
1633 /* Adjust calling parameters by written amount */
1634 memaddr
+= written
;
1639 written
= monitor_write_memory_bytes(memaddr
,myaddr
,len
) ;
1643 /* This is an alternate form of monitor_read_memory which is used for monitors
1644 which can only read a single byte/word/etc. at a time. */
1647 monitor_read_memory_single (memaddr
, myaddr
, len
)
1653 char membuf
[sizeof(int) * 2 + 1];
1658 RDEBUG(("MON read single\n")) ;
1660 /* Can't actually use long longs (nice idea, though). In fact, the
1661 call to strtoul below will fail if it tries to convert a value
1662 that's too big to fit in a long. */
1663 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1666 cmd
= current_monitor
->getmem
.cmdll
;
1670 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1673 cmd
= current_monitor
->getmem
.cmdl
;
1675 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1678 cmd
= current_monitor
->getmem
.cmdw
;
1683 cmd
= current_monitor
->getmem
.cmdb
;
1686 /* Send the examine command. */
1688 monitor_printf (cmd
, memaddr
);
1690 /* If RESP_DELIM is specified, we search for that as a leading
1691 delimiter for the memory value. Otherwise, we just start
1692 searching from the start of the buf. */
1694 if (current_monitor
->getmem
.resp_delim
)
1695 { RDEBUG(("EXP getmem.resp_delim\n")) ;
1696 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1699 /* Now, read the appropriate number of hex digits for this loc,
1702 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1703 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1707 c
= readchar (timeout
);
1709 c
= readchar (timeout
);
1710 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1713 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1714 memaddr
, i
, membuf
, c
);
1716 for (i
= 0; i
< len
* 2; i
++)
1722 c
= readchar (timeout
);
1728 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1729 memaddr
, i
, membuf
, c
);
1735 membuf
[i
] = '\000'; /* terminate the number */
1737 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1738 present), we will send TERM_CMD if that is present. In any case, we collect
1739 all of the output into buf, and then wait for the normal prompt. */
1741 if (current_monitor
->getmem
.term
)
1743 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1745 if (current_monitor
->getmem
.term_cmd
)
1747 monitor_printf (current_monitor
->getmem
.term_cmd
);
1748 monitor_expect_prompt (NULL
, 0);
1752 monitor_expect_prompt (NULL
, 0); /* get response */
1755 val
= strtoul (membuf
, &p
, 16);
1757 if (val
== 0 && membuf
== p
)
1758 monitor_error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
1759 memaddr
, 0, membuf
, 0);
1761 /* supply register stores in target byte order, so swap here */
1763 store_unsigned_integer (myaddr
, len
, val
);
1768 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1769 memory at MEMADDR. Returns length moved. Currently, we do no more
1770 than 16 bytes at a time. */
1773 monitor_read_memory (memaddr
, myaddr
, len
)
1787 RDEBUG (("Zero length call to monitor_read_memory\n"));
1791 if (remote_debug
) printf("MON read block ta(%08x) ha(%08x) %d\n",
1792 (unsigned long) memaddr
, (unsigned long)myaddr
, len
);
1794 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1795 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1797 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1798 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1800 len
= min (len
, 16);
1802 /* Some dumpers align the first data with the preceeding 16
1803 byte boundary. Some print blanks and start at the
1804 requested boundary. EXACT_DUMPADDR
1807 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1808 ? memaddr
: memaddr
& ~ 0x0f ;
1810 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1811 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1812 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1814 /* send the memory examine command */
1816 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1817 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
);
1818 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1819 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1821 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1823 /* If TERM is present, we wait for that to show up. Also, (if TERM
1824 is present), we will send TERM_CMD if that is present. In any
1825 case, we collect all of the output into buf, and then wait for
1826 the normal prompt. */
1828 if (current_monitor
->getmem
.term
)
1830 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1833 monitor_error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
1834 memaddr
, resp_len
, buf
, 0);
1836 if (current_monitor
->getmem
.term_cmd
)
1838 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1839 strlen (current_monitor
->getmem
.term_cmd
));
1840 monitor_expect_prompt (NULL
, 0);
1844 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1848 /* If RESP_DELIM is specified, we search for that as a leading
1849 delimiter for the values. Otherwise, we just start searching
1850 from the start of the buf. */
1852 if (current_monitor
->getmem
.resp_delim
)
1855 struct re_registers resp_strings
;
1856 RDEBUG(("MON getmem.resp_delim %s\n",current_monitor
->getmem
.resp_delim
)) ;
1858 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1860 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1864 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1865 memaddr
, resp_len
, buf
, 0);
1867 p
+= resp_strings
.end
[0];
1869 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1871 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1872 memaddr
, resp_len
, buf
, 0);
1873 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1876 if (remote_debug
) printf("MON scanning %d ,%08x '%s'\n",len
,p
,p
) ;
1877 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1885 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1887 { if ((dumpaddr
>= memaddr
) && (i
> 0))
1888 { val
= fromhex (c
) * 16 + fromhex (*(p
+1));
1890 if (remote_debug
) printf("[%02x]",val
) ;
1897 ++p
; /* skip a blank or other non hex char */
1900 if (fetched
== 0) error("Failed to read via monitor") ;
1901 if (remote_debug
) printf("\n") ;
1902 return fetched
; /* Return the number of bytes actually read */
1904 RDEBUG(("MON scanning bytes\n")) ;
1906 for (i
= len
; i
> 0; i
--)
1908 /* Skip non-hex chars, but bomb on end of string and newlines */
1915 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1916 monitor_error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s",
1917 memaddr
, resp_len
, buf
, 0);
1921 val
= strtoul (p
, &p1
, 16);
1923 if (val
== 0 && p
== p1
)
1924 monitor_error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.",
1925 memaddr
, resp_len
, buf
, 0);
1939 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1944 struct target_ops
*target
; /* ignored */
1946 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, write
);
1952 return; /* ignore attempts to kill target system */
1955 /* All we actually do is set the PC to the start address of exec_bfd, and start
1956 the program at that point. */
1959 monitor_create_inferior (exec_file
, args
, env
)
1964 if (args
&& (*args
!= '\000'))
1965 error ("Args are not supported by the monitor.");
1968 clear_proceed_status ();
1969 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1972 /* Clean up when a program exits.
1973 The program actually lives on in the remote processor's RAM, and may be
1974 run again without a download. Don't leave it full of breakpoint
1978 monitor_mourn_inferior ()
1980 unpush_target (targ_ops
);
1981 generic_mourn_inferior (); /* Do all the proper things now */
1984 #define NUM_MONITOR_BREAKPOINTS 8
1986 static CORE_ADDR breakaddr
[NUM_MONITOR_BREAKPOINTS
] = {0};
1988 /* Tell the monitor to add a breakpoint. */
1991 monitor_insert_breakpoint (addr
, shadow
)
1999 RDEBUG(("MON inst bkpt %08x\n",addr
))
2000 if (current_monitor
->set_break
== NULL
)
2001 error ("No set_break defined for this monitor");
2003 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2004 addr
= ADDR_BITS_REMOVE (addr
);
2006 /* Determine appropriate breakpoint size for this address. */
2007 bp
= memory_breakpoint_from_pc (&addr
, &bplen
);
2009 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
2011 if (breakaddr
[i
] == 0)
2013 breakaddr
[i
] = addr
;
2014 monitor_read_memory (addr
, shadow
, bplen
);
2015 monitor_printf (current_monitor
->set_break
, addr
);
2016 monitor_expect_prompt (NULL
, 0);
2021 error ("Too many breakpoints (> %d) for monitor.", NUM_MONITOR_BREAKPOINTS
);
2024 /* Tell the monitor to remove a breakpoint. */
2027 monitor_remove_breakpoint (addr
, shadow
)
2033 RDEBUG(("MON rmbkpt %08x\n",addr
))
2034 if (current_monitor
->clr_break
== NULL
)
2035 error ("No clr_break defined for this monitor");
2037 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2038 addr
= ADDR_BITS_REMOVE (addr
);
2040 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
2042 if (breakaddr
[i
] == addr
)
2045 /* some monitors remove breakpoints based on the address */
2046 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2047 monitor_printf (current_monitor
->clr_break
, addr
);
2048 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2049 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2051 monitor_printf (current_monitor
->clr_break
, i
);
2052 monitor_expect_prompt (NULL
, 0);
2056 fprintf_unfiltered (gdb_stderr
,
2057 "Can't find breakpoint associated with 0x%x\n", addr
);
2061 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2062 an S-record. Return non-zero if the ACK is received properly. */
2065 monitor_wait_srec_ack ()
2069 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2071 return (readchar (timeout
) == '+');
2073 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2075 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2076 if ((ch
= readchar (1)) < 0)
2078 if ((ch
= readchar (1)) < 0)
2080 if ((ch
= readchar (1)) < 0)
2082 if ((ch
= readchar (1)) < 0)
2088 /* monitor_load -- download a file. */
2091 monitor_load (file
, from_tty
)
2095 dcache_flush (remote_dcache
);
2096 RDEBUG(("MON load\n"))
2098 if (current_monitor
->load_routine
)
2099 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2101 { /* The default is ascii S-records */
2103 unsigned long load_offset
;
2106 /* enable user to specify address for downloading as 2nd arg to load */
2107 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2113 monitor_printf (current_monitor
->load
);
2114 if (current_monitor
->loadresp
)
2115 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2117 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2118 32, SREC_ALL
, hashmark
,
2119 current_monitor
->flags
& MO_SREC_ACK
?
2120 monitor_wait_srec_ack
: NULL
);
2122 monitor_expect_prompt (NULL
, 0);
2125 /* Finally, make the PC point at the start address */
2128 write_pc (bfd_get_start_address (exec_bfd
));
2130 inferior_pid
= 0; /* No process now */
2132 /* This is necessary because many things were based on the PC at the time that
2133 we attached to the monitor, which is no longer valid now that we have loaded
2134 new code (and just changed the PC). Another way to do this might be to call
2135 normal_stop, except that the stack may not be valid, and things would get
2136 horribly confused... */
2138 clear_symtab_users ();
2144 RDEBUG(("MON stop\n")) ;
2145 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2146 SERIAL_SEND_BREAK (monitor_desc
);
2147 if (current_monitor
->stop
)
2148 monitor_printf_noecho (current_monitor
->stop
);
2151 /* Put a command string, in args, out to MONITOR. Output from MONITOR
2152 is placed on the users terminal until the prompt is seen. FIXME: We
2153 read the characters ourseleves here cause of a nasty echo. */
2156 monitor_command (args
, from_tty
)
2164 if (monitor_desc
== NULL
)
2165 error ("monitor target not open.");
2167 p
= current_monitor
->prompt
;
2169 /* Send the command. Note that if no args were supplied, then we're
2170 just sending the monitor a newline, which is sometimes useful. */
2172 monitor_printf ("%s\r", (args
? args
: ""));
2174 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2176 fputs_unfiltered (buf
, gdb_stdout
); /* Output the response */
2179 /* Convert hex digit A to a number. */
2186 if (a
>= '0' && a
<= '9')
2188 if (a
>= 'a' && a
<= 'f')
2189 return a
- 'a' + 10;
2190 if (a
>= 'A' && a
<= 'F')
2191 return a
- 'A' + 10;
2193 error ("Reply contains invalid hex digit 0x%x", a
);
2198 monitor_get_dev_name ()
2203 static struct target_ops monitor_ops
;
2206 init_base_monitor_ops (void)
2208 monitor_ops
.to_shortname
= NULL
;
2209 monitor_ops
.to_longname
= NULL
;
2210 monitor_ops
.to_doc
= NULL
;
2211 monitor_ops
.to_open
= NULL
;
2212 monitor_ops
.to_close
= monitor_close
;
2213 monitor_ops
.to_attach
= NULL
;
2214 monitor_ops
.to_post_attach
= NULL
;
2215 monitor_ops
.to_require_attach
= NULL
;
2216 monitor_ops
.to_detach
= monitor_detach
;
2217 monitor_ops
.to_require_detach
= NULL
;
2218 monitor_ops
.to_resume
= monitor_resume
;
2219 monitor_ops
.to_wait
= monitor_wait
;
2220 monitor_ops
.to_post_wait
= NULL
;
2221 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2222 monitor_ops
.to_store_registers
= monitor_store_registers
;
2223 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2224 monitor_ops
.to_xfer_memory
= monitor_xfer_memory
;
2225 monitor_ops
.to_files_info
= monitor_files_info
;
2226 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2227 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2228 monitor_ops
.to_terminal_init
= 0;
2229 monitor_ops
.to_terminal_inferior
= 0;
2230 monitor_ops
.to_terminal_ours_for_output
= 0;
2231 monitor_ops
.to_terminal_ours
= 0;
2232 monitor_ops
.to_terminal_info
= 0;
2233 monitor_ops
.to_kill
= monitor_kill
;
2234 monitor_ops
.to_load
= monitor_load
;
2235 monitor_ops
.to_lookup_symbol
= 0;
2236 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2237 monitor_ops
.to_post_startup_inferior
= NULL
;
2238 monitor_ops
.to_acknowledge_created_inferior
= NULL
;
2239 monitor_ops
.to_clone_and_follow_inferior
= NULL
;
2240 monitor_ops
.to_post_follow_inferior_by_clone
= NULL
;
2241 monitor_ops
.to_insert_fork_catchpoint
= NULL
;
2242 monitor_ops
.to_remove_fork_catchpoint
= NULL
;
2243 monitor_ops
.to_insert_vfork_catchpoint
= NULL
;
2244 monitor_ops
.to_remove_vfork_catchpoint
= NULL
;
2245 monitor_ops
.to_has_forked
= NULL
;
2246 monitor_ops
.to_has_vforked
= NULL
;
2247 monitor_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2248 monitor_ops
.to_post_follow_vfork
= NULL
;
2249 monitor_ops
.to_insert_exec_catchpoint
= NULL
;
2250 monitor_ops
.to_remove_exec_catchpoint
= NULL
;
2251 monitor_ops
.to_has_execd
= NULL
;
2252 monitor_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2253 monitor_ops
.to_has_exited
= NULL
;
2254 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2255 monitor_ops
.to_can_run
= 0;
2256 monitor_ops
.to_notice_signals
= 0;
2257 monitor_ops
.to_thread_alive
= 0;
2258 monitor_ops
.to_stop
= monitor_stop
;
2259 monitor_ops
.to_pid_to_exec_file
= NULL
;
2260 monitor_ops
.to_core_file_to_sym_file
= NULL
;
2261 monitor_ops
.to_stratum
= process_stratum
;
2262 monitor_ops
.DONT_USE
= 0;
2263 monitor_ops
.to_has_all_memory
= 1;
2264 monitor_ops
.to_has_memory
= 1;
2265 monitor_ops
.to_has_stack
= 1;
2266 monitor_ops
.to_has_registers
= 1;
2267 monitor_ops
.to_has_execution
= 1;
2268 monitor_ops
.to_sections
= 0;
2269 monitor_ops
.to_sections_end
= 0;
2270 monitor_ops
.to_magic
= OPS_MAGIC
;
2271 } /* init_base_monitor_ops */
2273 /* Init the target_ops structure pointed at by OPS */
2276 init_monitor_ops (ops
)
2277 struct target_ops
*ops
;
2279 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2280 init_base_monitor_ops ();
2282 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2285 /* Define additional commands that are usually only used by monitors. */
2288 _initialize_remote_monitors ()
2290 init_base_monitor_ops ();
2291 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
2293 "Set display of activity while downloading a file.\n\
2294 When enabled, a hashmark \'#\' is displayed.",
2298 add_com ("monitor", class_obscure
, monitor_command
,
2299 "Send a command to the debug monitor.");