1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990, 1991, 1992, 1993, 1995, 1996, 1997
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
)
495 #if 0 /* MAINTENANCE_CMDS */
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 (strcmp(targ_ops
->to_shortname
, "m32r") == 0))
576 { /* m32r monitor emits random DC1/DC3 chars */
588 /* Search for a regexp. */
591 monitor_expect_regexp (pat
, buf
, buflen
)
592 struct re_pattern_buffer
*pat
;
598 RDEBUG(("MON Expecting regexp\n")) ;
603 mybuf
= alloca (1024);
612 if (p
- mybuf
>= buflen
)
613 { /* Buffer about to overflow */
615 /* On overflow, we copy the upper half of the buffer to the lower half. Not
616 great, but it usually works... */
618 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
619 p
= mybuf
+ buflen
/ 2;
622 *p
++ = readchar (timeout
);
624 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
630 /* Keep discarding input until we see the MONITOR prompt.
632 The convention for dealing with the prompt is that you
634 o *then* wait for the prompt.
636 Thus the last thing that a procedure does with the serial line will
637 be an monitor_expect_prompt(). Exception: monitor_resume does not
638 wait for the prompt, because the terminal is being handed over to
639 the inferior. However, the next thing which happens after that is
640 a monitor_wait which does wait for the prompt. Note that this
641 includes abnormal exit, e.g. error(). This is necessary to prevent
642 getting into states from which we can't recover. */
645 monitor_expect_prompt (buf
, buflen
)
649 RDEBUG(("MON Expecting prompt\n"))
650 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
653 /* Get N 32-bit words from remote, each preceded by a space, and put
654 them in registers starting at REGNO. */
665 ch
= readchar (timeout
);
670 for (i
= 7; i
>= 1; i
--)
672 ch
= readchar (timeout
);
675 val
= (val
<< 4) | from_hex (ch
);
683 compile_pattern (pattern
, compiled_pattern
, fastmap
)
685 struct re_pattern_buffer
*compiled_pattern
;
691 compiled_pattern
->fastmap
= fastmap
;
693 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
694 val
= re_compile_pattern (pattern
,
700 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern
, val
);
703 re_compile_fastmap (compiled_pattern
);
706 /* Open a connection to a remote debugger. NAME is the filename used
707 for communication. */
710 monitor_open (args
, mon_ops
, from_tty
)
712 struct monitor_ops
*mon_ops
;
718 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
719 error ("Magic number of monitor_ops struct wrong.");
721 targ_ops
= mon_ops
->target
;
722 name
= targ_ops
->to_shortname
;
725 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
726 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
728 target_preopen (from_tty
);
730 /* Setup pattern for register dump */
732 if (mon_ops
->register_pattern
)
733 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
736 if (mon_ops
->getmem
.resp_delim
)
737 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
738 getmem_resp_delim_fastmap
);
740 unpush_target (targ_ops
);
744 dev_name
= strsave (args
);
746 monitor_desc
= SERIAL_OPEN (dev_name
);
749 perror_with_name (dev_name
);
753 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
755 SERIAL_CLOSE (monitor_desc
);
756 perror_with_name (dev_name
);
760 SERIAL_RAW (monitor_desc
);
762 SERIAL_FLUSH_INPUT (monitor_desc
);
764 /* some systems only work with 2 stop bits */
766 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
768 current_monitor
= mon_ops
;
770 /* See if we can wake up the monitor. First, try sending a stop sequence,
771 then send the init strings. Last, remove all breakpoints. */
773 if (current_monitor
->stop
)
776 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
778 RDEBUG(("EXP Open echo\n")) ;
779 monitor_expect_prompt (NULL
, 0);
783 /* wake up the monitor and see if it's alive */
784 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
786 /* Some of the characters we send may not be echoed,
787 but we hope to get a prompt at the end of it all. */
789 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
792 monitor_printf_noecho (*p
);
793 monitor_expect_prompt (NULL
, 0);
796 SERIAL_FLUSH_INPUT (monitor_desc
);
798 /* Remove all breakpoints */
800 if (mon_ops
->clr_all_break
)
802 monitor_printf (mon_ops
->clr_all_break
);
803 monitor_expect_prompt (NULL
, 0);
807 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
809 push_target (targ_ops
);
811 inferior_pid
= 42000; /* Make run command think we are busy... */
813 /* Give monitor_wait something to read */
815 monitor_printf (current_monitor
->line_term
);
817 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
818 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory_block
);
820 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory
);
824 /* Close out all files and local state before this target loses
828 monitor_close (quitting
)
832 SERIAL_CLOSE (monitor_desc
);
836 /* Terminate the open connection to the remote debugger. Use this
837 when you want to detach and do something else with your gdb. */
840 monitor_detach (args
, from_tty
)
844 pop_target (); /* calls monitor_close to do the real work */
846 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
849 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
852 monitor_supply_register (regno
, valstr
)
857 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
860 val
= strtoul (valstr
, &p
, 16);
861 RDEBUG(("Supplying Register %d %s\n",regno
,valstr
)) ;
863 if (val
== 0 && valstr
== p
)
864 error ("monitor_supply_register (%d): bad value from monitor: %s.",
867 /* supply register stores in target byte order, so swap here */
869 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
871 supply_register (regno
, regbuf
);
876 /* Tell the remote machine to resume. */
879 flush_monitor_dcache ()
881 dcache_flush (remote_dcache
);
885 monitor_resume (pid
, step
, sig
)
887 enum target_signal sig
;
889 /* Some monitors require a different command when starting a program */
890 RDEBUG(("MON resume\n")) ;
891 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
894 monitor_printf ("run\r");
895 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
899 dcache_flush (remote_dcache
);
901 monitor_printf (current_monitor
->step
);
904 if (current_monitor
->continue_hook
)
905 (*current_monitor
->continue_hook
)() ;
906 else monitor_printf (current_monitor
->cont
);
907 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
912 /* Parse the output of a register dump command. A monitor specific
913 regexp is used to extract individual register descriptions of the
914 form REG=VAL. Each description is split up into a name and a value
915 string which are passed down to monitor specific code. */
918 parse_register_dump (buf
, len
)
922 RDEBUG(("MON Parsing register dump\n"))
925 int regnamelen
, vallen
;
927 /* Element 0 points to start of register name, and element 1
928 points to the start of the register value. */
929 struct re_registers register_strings
;
931 memset (®ister_strings
, 0, sizeof (struct re_registers
));
933 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
934 ®ister_strings
) == -1)
937 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
938 regname
= buf
+ register_strings
.start
[1];
939 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
940 val
= buf
+ register_strings
.start
[2];
942 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
944 buf
+= register_strings
.end
[0];
945 len
-= register_strings
.end
[0];
949 /* Send ^C to target to halt it. Target will respond, and send us a
953 monitor_interrupt (signo
)
956 /* If this doesn't work, try more severe steps. */
957 signal (signo
, monitor_interrupt_twice
);
960 printf_unfiltered ("monitor_interrupt called\n");
965 /* The user typed ^C twice. */
968 monitor_interrupt_twice (signo
)
971 signal (signo
, ofunc
);
973 monitor_interrupt_query ();
975 signal (signo
, monitor_interrupt
);
978 /* Ask the user what to do when an interrupt is received. */
981 monitor_interrupt_query ()
983 target_terminal_ours ();
985 if (query ("Interrupted while waiting for the program.\n\
986 Give up (and stop debugging it)? "))
988 target_mourn_inferior ();
989 return_to_top_level (RETURN_QUIT
);
992 target_terminal_inferior ();
996 monitor_wait_cleanup (old_timeout
)
999 timeout
= *(int*)old_timeout
;
1000 signal (SIGINT
, ofunc
);
1001 in_monitor_wait
= 0;
1006 void monitor_wait_filter(char * buf
,
1009 struct target_waitstatus
* status
1015 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1016 * ext_resp_len
=resp_len
;
1019 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1021 while (resp_len
< 0);
1023 /* Print any output characters that were preceded by ^O. */
1024 /* FIXME - This would be great as a user settabgle flag */
1026 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1030 for (i
= 0; i
< resp_len
- 1; i
++)
1032 putchar_unfiltered (buf
[++i
]);
1038 /* Wait until the remote machine stops, then return, storing status in
1039 status just as `wait' would. */
1042 monitor_wait (pid
, status
)
1044 struct target_waitstatus
*status
;
1046 int old_timeout
= timeout
;
1049 struct cleanup
*old_chain
;
1051 status
->kind
= TARGET_WAITKIND_EXITED
;
1052 status
->value
.integer
= 0;
1054 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1055 RDEBUG(("MON wait\n"))
1057 #if 0 /* MAINTENANCE_CMDS */
1058 /* This is somthing other than a maintenance command */
1059 in_monitor_wait
= 1;
1060 timeout
= watchdog
> 0 ? watchdog
: -1;
1062 timeout
= -1; /* Don't time out -- user program is running. */
1065 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1067 if (current_monitor
->wait_filter
)
1068 (*current_monitor
->wait_filter
)(buf
,sizeof (buf
),&resp_len
,status
) ;
1069 else monitor_wait_filter(buf
,sizeof (buf
),&resp_len
,status
) ;
1071 #if 0 /* Transferred to monitor wait filter */
1074 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1077 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1079 while (resp_len
< 0);
1081 /* Print any output characters that were preceded by ^O. */
1082 /* FIXME - This would be great as a user settabgle flag */
1084 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1088 for (i
= 0; i
< resp_len
- 1; i
++)
1090 putchar_unfiltered (buf
[++i
]);
1094 signal (SIGINT
, ofunc
);
1096 timeout
= old_timeout
;
1098 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1101 monitor_printf (current_monitor
->dump_registers
);
1102 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1105 if (current_monitor
->register_pattern
)
1106 parse_register_dump (buf
, resp_len
);
1108 RDEBUG(("Wait fetching registers after stop\n")) ;
1109 monitor_dump_regs() ;
1112 status
->kind
= TARGET_WAITKIND_STOPPED
;
1113 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1115 discard_cleanups (old_chain
);
1117 in_monitor_wait
= 0;
1119 return inferior_pid
;
1122 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1126 monitor_fetch_register (regno
)
1130 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] = {0};
1131 char regbuf
[MAX_REGISTER_RAW_SIZE
* 2 + 1];
1134 name
= current_monitor
->regnames
[regno
];
1135 RDEBUG(("MON fetchreg %d '%s'\n",regno
,name
))
1137 if (!name
|| (*name
== '\0'))
1138 { RDEBUG(("No register known for %d\n",regno
))
1139 supply_register (regno
, zerobuf
);
1143 /* send the register examine command */
1145 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1147 /* If RESP_DELIM is specified, we search for that as a leading
1148 delimiter for the register value. Otherwise, we just start
1149 searching from the start of the buf. */
1151 if (current_monitor
->getreg
.resp_delim
)
1153 RDEBUG(("EXP getreg.resp_delim\n"))
1154 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1155 /* Handle case of first 32 registers listed in pairs. */
1156 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1157 && regno
& 1 == 1 && regno
< 32)
1158 { RDEBUG(("EXP getreg.resp_delim\n")) ;
1159 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1163 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1164 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1167 c
= readchar (timeout
);
1169 c
= readchar (timeout
);
1170 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1173 error ("Bad value returned from monitor while fetching register %x.",
1177 /* Read upto the maximum number of hex digits for this register, skipping
1178 spaces, but stop reading if something else is seen. Some monitors
1179 like to drop leading zeros. */
1181 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
1184 c
= readchar (timeout
);
1186 c
= readchar (timeout
);
1194 regbuf
[i
] = '\000'; /* terminate the number */
1195 RDEBUG(("REGVAL '%s'\n",regbuf
)) ;
1197 /* If TERM is present, we wait for that to show up. Also, (if TERM
1198 is present), we will send TERM_CMD if that is present. In any
1199 case, we collect all of the output into buf, and then wait for
1200 the normal prompt. */
1202 if (current_monitor
->getreg
.term
)
1204 RDEBUG(("EXP getreg.term\n"))
1205 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1208 if (current_monitor
->getreg
.term_cmd
)
1209 { RDEBUG(("EMIT getreg.term.cmd\n"))
1210 monitor_printf (current_monitor
->getreg
.term_cmd
);
1212 if (! current_monitor
->getreg
.term
|| /* Already expected or */
1213 current_monitor
->getreg
.term_cmd
) /* ack expected */
1214 monitor_expect_prompt (NULL
, 0); /* get response */
1216 monitor_supply_register (regno
, regbuf
);
1219 /* Sometimes, it takes several commands to dump the registers */
1220 /* This is a primitive for use by variations of monitor interfaces in
1221 case they need to compose the operation.
1223 int monitor_dump_reg_block(char * block_cmd
)
1227 monitor_printf (block_cmd
);
1228 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1229 parse_register_dump (buf
, resp_len
);
1234 /* Read the remote registers into the block regs. */
1235 /* Call the specific function if it has been provided */
1238 monitor_dump_regs ()
1242 if (current_monitor
->dumpregs
)
1243 (*(current_monitor
->dumpregs
))() ; /* call supplied function */
1245 if (current_monitor
->dump_registers
) /* default version */
1246 { monitor_printf (current_monitor
->dump_registers
);
1247 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1248 parse_register_dump (buf
, resp_len
);
1251 abort(); /* Need some way to read registers */
1255 monitor_fetch_registers (regno
)
1258 RDEBUG(("MON fetchregs\n")) ;
1259 if (current_monitor
->getreg
.cmd
)
1263 monitor_fetch_register (regno
);
1267 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1268 monitor_fetch_register (regno
);
1271 monitor_dump_regs ();
1275 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1278 monitor_store_register (regno
)
1284 name
= current_monitor
->regnames
[regno
];
1285 if (!name
|| (*name
== '\0'))
1286 { RDEBUG(("MON Cannot store unknown register\n"))
1290 val
= read_register (regno
);
1291 RDEBUG(("MON storeg %d %08x\n",regno
,(unsigned int)val
))
1293 /* send the register deposit command */
1295 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1296 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1297 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1298 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1300 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1302 if (current_monitor
->setreg
.term
)
1303 { RDEBUG(("EXP setreg.term\n"))
1304 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1305 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1306 monitor_printf ("%x\r", val
);
1307 monitor_expect_prompt (NULL
, 0);
1310 monitor_expect_prompt (NULL
, 0);
1311 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1312 { RDEBUG(("EXP setreg_termcmd\n")) ;
1313 monitor_printf("%s",current_monitor
->setreg
.term_cmd
) ;
1314 monitor_expect_prompt(NULL
,0) ;
1316 } /* monitor_store_register */
1318 /* Store the remote registers. */
1321 monitor_store_registers (regno
)
1326 monitor_store_register (regno
);
1330 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1331 monitor_store_register (regno
);
1334 /* Get ready to modify the registers array. On machines which store
1335 individual registers, this doesn't need to do anything. On machines
1336 which store all the registers in one fell swoop, this makes sure
1337 that registers contains all the registers from the program being
1341 monitor_prepare_to_store ()
1343 /* Do nothing, since we can store individual regs */
1347 monitor_files_info (ops
)
1348 struct target_ops
*ops
;
1350 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1354 monitor_write_memory (memaddr
, myaddr
, len
)
1359 unsigned int val
, hostval
;
1363 RDEBUG(("MON write %d %08x\n",len
,(unsigned long)memaddr
))
1365 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1366 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1368 /* Use memory fill command for leading 0 bytes. */
1370 if (current_monitor
->fill
)
1372 for (i
= 0; i
< len
; i
++)
1376 if (i
> 4) /* More than 4 zeros is worth doing */
1378 RDEBUG(("MON FILL %d\n",i
))
1379 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1380 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
)-1, 0);
1382 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1384 monitor_expect_prompt (NULL
, 0);
1391 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1392 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1395 cmd
= current_monitor
->setmem
.cmdll
;
1399 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1402 cmd
= current_monitor
->setmem
.cmdl
;
1404 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1407 cmd
= current_monitor
->setmem
.cmdw
;
1412 cmd
= current_monitor
->setmem
.cmdb
;
1415 val
= extract_unsigned_integer (myaddr
, len
);
1418 { hostval
= * (unsigned int *) myaddr
;
1419 RDEBUG(("Hostval(%08x) val(%08x)\n",hostval
,val
)) ;
1423 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1424 monitor_printf_noecho (cmd
, memaddr
, val
);
1425 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1428 monitor_printf_noecho (cmd
, memaddr
);
1430 if (current_monitor
->setmem
.term
)
1431 { RDEBUG(("EXP setmem.term")) ;
1432 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1433 monitor_printf ("%x\r", val
);
1435 if (current_monitor
->setmem
.term_cmd
)
1436 { /* Emit this to get out of the memory editing state */
1437 monitor_printf("%s",current_monitor
->setmem
.term_cmd
) ;
1438 /* Drop through to expecting a prompt */
1442 monitor_printf (cmd
, memaddr
, val
);
1444 monitor_expect_prompt (NULL
, 0);
1451 monitor_write_even_block(memaddr
,myaddr
,len
)
1458 /* Enter the sub mode */
1459 monitor_printf(current_monitor
->setmem
.cmdl
,memaddr
) ;
1460 monitor_expect_prompt(NULL
,0) ;
1464 val
= extract_unsigned_integer(myaddr
,4) ; /* REALLY */
1465 monitor_printf("%x\r",val
) ;
1469 RDEBUG((" @ %08x\n",memaddr
))
1470 /* If we wanted to, here we could validate the address */
1471 monitor_expect_prompt(NULL
,0) ;
1473 /* Now exit the sub mode */
1474 monitor_printf (current_monitor
->getreg
.term_cmd
);
1475 monitor_expect_prompt(NULL
,0) ;
1480 static int monitor_write_memory_bytes(memaddr
,myaddr
,len
)
1487 if (len
== 0) return 0 ;
1488 /* Enter the sub mode */
1489 monitor_printf(current_monitor
->setmem
.cmdb
,memaddr
) ;
1490 monitor_expect_prompt(NULL
,0) ;
1494 monitor_printf("%x\r",val
) ;
1498 /* If we wanted to, here we could validate the address */
1499 monitor_expect_prompt(NULL
,0) ;
1502 /* Now exit the sub mode */
1503 monitor_printf (current_monitor
->getreg
.term_cmd
);
1504 monitor_expect_prompt(NULL
,0) ;
1510 longlongendswap (unsigned char * a
)
1522 /* Format 32 chars of long long value, advance the pointer */
1523 static char * hexlate
= "0123456789abcdef" ;
1524 static char * longlong_hexchars(unsigned long long value
,
1527 if (value
== 0) { *outbuff
++ = '0' ; return outbuff
; }
1529 { static unsigned char disbuf
[8] ; /* disassembly buffer */
1530 unsigned char * scan
, * limit
; /* loop controls */
1531 unsigned char c
, nib
;
1533 scan
= disbuf
; limit
= scan
+ 8 ;
1534 { unsigned long long * dp
;
1535 dp
= (unsigned long long *) scan
;
1538 longlongendswap(disbuf
) ; /* FIXME: ONly on big endian hosts */
1539 while (scan
< limit
)
1540 { c
= *scan
++ ; /* a byte of our long long value */
1542 if (c
== 0) continue ;
1543 else leadzero
= 0 ; /* henceforth we print even zeroes */
1544 nib
= c
>> 4 ; /* high nibble bits */
1545 *outbuff
++ = hexlate
[nib
] ;
1546 nib
= c
& 0x0f ; /* low nibble bits */
1547 *outbuff
++ = hexlate
[nib
] ;
1551 } /* longlong_hexchars */
1555 /* I am only going to call this when writing virtual byte streams.
1556 Which possably entails endian conversions
1558 static int monitor_write_memory_longlongs(memaddr
,myaddr
,len
)
1563 static char hexstage
[20] ; /* At least 16 digits required, plus null */
1568 llptr
= (unsigned long long *) myaddr
;
1569 if (len
== 0 ) return 0 ;
1570 monitor_printf(current_monitor
->setmem
.cmdll
,memaddr
) ;
1571 monitor_expect_prompt(NULL
,0) ;
1575 endstring
= longlong_hexchars(*llptr
,hexstage
) ;
1576 *endstring
= '\0' ; /* NUll terminate for printf */
1577 monitor_printf("%s\r",hexstage
) ;
1581 /* If we wanted to, here we could validate the address */
1582 monitor_expect_prompt(NULL
,0) ;
1585 /* Now exit the sub mode */
1586 monitor_printf (current_monitor
->getreg
.term_cmd
);
1587 monitor_expect_prompt(NULL
,0) ;
1593 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1594 /* This is for the large blocks of memory which may occur in downloading.
1595 And for monitors which use interactive entry,
1596 And for monitors which do not have other downloading methods.
1597 Without this, we will end up calling monitor_write_memory many times
1598 and do the entry and exit of the sub mode many times
1599 This currently assumes...
1600 MO_SETMEM_INTERACTIVE
1601 ! MO_NO_ECHO_ON_SETMEM
1602 To use this, the you have to patch the monitor_cmds block with
1603 this function. Otherwise, its not tuned up for use by all
1607 static int monitor_write_memory_block(memaddr
,myaddr
,len
)
1614 /* FIXME: This would be a good place to put the zero test */
1616 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1618 return monitor_write_memory_longlongs(memaddr
,myaddr
,len
) ;
1625 written
= monitor_write_even_block(memaddr
,myaddr
,len
) ;
1626 /* Adjust calling parameters by written amount */
1627 memaddr
+= written
;
1632 written
= monitor_write_memory_bytes(memaddr
,myaddr
,len
) ;
1636 /* This is an alternate form of monitor_read_memory which is used for monitors
1637 which can only read a single byte/word/etc. at a time. */
1640 monitor_read_memory_single (memaddr
, myaddr
, len
)
1646 char membuf
[sizeof(int) * 2 + 1];
1651 RDEBUG(("MON read single\n")) ;
1653 /* Can't actually use long longs (nice idea, though). In fact, the
1654 call to strtoul below will fail if it tries to convert a value
1655 that's too big to fit in a long. */
1656 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1659 cmd
= current_monitor
->getmem
.cmdll
;
1663 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1666 cmd
= current_monitor
->getmem
.cmdl
;
1668 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1671 cmd
= current_monitor
->getmem
.cmdw
;
1676 cmd
= current_monitor
->getmem
.cmdb
;
1679 /* Send the examine command. */
1681 monitor_printf (cmd
, memaddr
);
1683 /* If RESP_DELIM is specified, we search for that as a leading
1684 delimiter for the memory value. Otherwise, we just start
1685 searching from the start of the buf. */
1687 if (current_monitor
->getmem
.resp_delim
)
1688 { RDEBUG(("EXP getmem.resp_delim\n")) ;
1689 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1692 /* Now, read the appropriate number of hex digits for this loc,
1695 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1696 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1700 c
= readchar (timeout
);
1702 c
= readchar (timeout
);
1703 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1706 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1707 memaddr
, i
, membuf
, c
);
1709 for (i
= 0; i
< len
* 2; i
++)
1715 c
= readchar (timeout
);
1721 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1722 memaddr
, i
, membuf
, c
);
1728 membuf
[i
] = '\000'; /* terminate the number */
1730 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1731 present), we will send TERM_CMD if that is present. In any case, we collect
1732 all of the output into buf, and then wait for the normal prompt. */
1734 if (current_monitor
->getmem
.term
)
1736 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1738 if (current_monitor
->getmem
.term_cmd
)
1740 monitor_printf (current_monitor
->getmem
.term_cmd
);
1741 monitor_expect_prompt (NULL
, 0);
1745 monitor_expect_prompt (NULL
, 0); /* get response */
1748 val
= strtoul (membuf
, &p
, 16);
1750 if (val
== 0 && membuf
== p
)
1751 monitor_error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
1752 memaddr
, 0, membuf
, 0);
1754 /* supply register stores in target byte order, so swap here */
1756 store_unsigned_integer (myaddr
, len
, val
);
1761 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1762 memory at MEMADDR. Returns length moved. Currently, we do no more
1763 than 16 bytes at a time. */
1766 monitor_read_memory (memaddr
, myaddr
, len
)
1780 RDEBUG (("Zero length call to monitor_read_memory\n"));
1784 if (remote_debug
) printf("MON read block ta(%08x) ha(%08x) %d\n",
1785 (unsigned long) memaddr
, (unsigned long)myaddr
, len
);
1787 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1788 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1790 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1791 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1793 len
= min (len
, 16);
1795 /* Some dumpers align the first data with the preceeding 16
1796 byte boundary. Some print blanks and start at the
1797 requested boundary. EXACT_DUMPADDR
1800 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1801 ? memaddr
: memaddr
& ~ 0x0f ;
1803 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1804 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1805 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1807 /* send the memory examine command */
1809 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1810 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
- 1);
1811 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1812 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1814 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1816 /* If TERM is present, we wait for that to show up. Also, (if TERM
1817 is present), we will send TERM_CMD if that is present. In any
1818 case, we collect all of the output into buf, and then wait for
1819 the normal prompt. */
1821 if (current_monitor
->getmem
.term
)
1823 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1826 monitor_error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
1827 memaddr
, resp_len
, buf
, 0);
1829 if (current_monitor
->getmem
.term_cmd
)
1831 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1832 strlen (current_monitor
->getmem
.term_cmd
));
1833 monitor_expect_prompt (NULL
, 0);
1837 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1841 /* If RESP_DELIM is specified, we search for that as a leading
1842 delimiter for the values. Otherwise, we just start searching
1843 from the start of the buf. */
1845 if (current_monitor
->getmem
.resp_delim
)
1848 struct re_registers resp_strings
;
1849 RDEBUG(("MON getmem.resp_delim %s\n",current_monitor
->getmem
.resp_delim
)) ;
1851 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1853 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1857 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1858 memaddr
, resp_len
, buf
, 0);
1860 p
+= resp_strings
.end
[0];
1862 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1864 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1865 memaddr
, resp_len
, buf
, 0);
1866 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1869 if (remote_debug
) printf("MON scanning %d ,%08x '%s'\n",len
,p
,p
) ;
1870 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1878 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1880 { if ((dumpaddr
>= memaddr
) && (i
> 0))
1881 { val
= fromhex (c
) * 16 + fromhex (*(p
+1));
1883 if (remote_debug
) printf("[%02x]",val
) ;
1890 ++p
; /* skip a blank or other non hex char */
1893 if (fetched
== 0) error("Failed to read via monitor") ;
1894 if (remote_debug
) printf("\n") ;
1895 return fetched
; /* Return the number of bytes actually read */
1897 RDEBUG(("MON scanning bytes\n")) ;
1899 for (i
= len
; i
> 0; i
--)
1901 /* Skip non-hex chars, but bomb on end of string and newlines */
1908 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1909 monitor_error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s",
1910 memaddr
, resp_len
, buf
, 0);
1914 val
= strtoul (p
, &p1
, 16);
1916 if (val
== 0 && p
== p1
)
1917 monitor_error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.",
1918 memaddr
, resp_len
, buf
, 0);
1932 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1937 struct target_ops
*target
; /* ignored */
1939 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, write
);
1945 return; /* ignore attempts to kill target system */
1948 /* All we actually do is set the PC to the start address of exec_bfd, and start
1949 the program at that point. */
1952 monitor_create_inferior (exec_file
, args
, env
)
1957 if (args
&& (*args
!= '\000'))
1958 error ("Args are not supported by the monitor.");
1961 clear_proceed_status ();
1962 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1965 /* Clean up when a program exits.
1966 The program actually lives on in the remote processor's RAM, and may be
1967 run again without a download. Don't leave it full of breakpoint
1971 monitor_mourn_inferior ()
1973 unpush_target (targ_ops
);
1974 generic_mourn_inferior (); /* Do all the proper things now */
1977 #define NUM_MONITOR_BREAKPOINTS 8
1979 static CORE_ADDR breakaddr
[NUM_MONITOR_BREAKPOINTS
] = {0};
1981 /* Tell the monitor to add a breakpoint. */
1984 monitor_insert_breakpoint (addr
, shadow
)
1992 RDEBUG(("MON inst bkpt %08x\n",addr
))
1993 if (current_monitor
->set_break
== NULL
)
1994 error ("No set_break defined for this monitor");
1996 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1997 addr
= ADDR_BITS_REMOVE (addr
);
1999 /* Determine appropriate breakpoint size for this address. */
2000 bp
= memory_breakpoint_from_pc (&addr
, &bplen
);
2002 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
2004 if (breakaddr
[i
] == 0)
2006 breakaddr
[i
] = addr
;
2007 monitor_read_memory (addr
, shadow
, bplen
);
2008 monitor_printf (current_monitor
->set_break
, addr
);
2009 monitor_expect_prompt (NULL
, 0);
2014 error ("Too many breakpoints (> %d) for monitor.", NUM_MONITOR_BREAKPOINTS
);
2017 /* Tell the monitor to remove a breakpoint. */
2020 monitor_remove_breakpoint (addr
, shadow
)
2026 RDEBUG(("MON rmbkpt %08x\n",addr
))
2027 if (current_monitor
->clr_break
== NULL
)
2028 error ("No clr_break defined for this monitor");
2030 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2031 addr
= ADDR_BITS_REMOVE (addr
);
2033 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
2035 if (breakaddr
[i
] == addr
)
2038 /* some monitors remove breakpoints based on the address */
2039 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2040 monitor_printf (current_monitor
->clr_break
, addr
);
2041 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2042 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2044 monitor_printf (current_monitor
->clr_break
, i
);
2045 monitor_expect_prompt (NULL
, 0);
2049 fprintf_unfiltered (gdb_stderr
,
2050 "Can't find breakpoint associated with 0x%x\n", addr
);
2054 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2055 an S-record. Return non-zero if the ACK is received properly. */
2058 monitor_wait_srec_ack ()
2062 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2064 return (readchar (timeout
) == '+');
2066 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2068 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2069 if ((ch
= readchar (1)) < 0)
2071 if ((ch
= readchar (1)) < 0)
2073 if ((ch
= readchar (1)) < 0)
2075 if ((ch
= readchar (1)) < 0)
2081 /* monitor_load -- download a file. */
2084 monitor_load (file
, from_tty
)
2088 dcache_flush (remote_dcache
);
2089 RDEBUG(("MON load\n"))
2091 if (current_monitor
->load_routine
)
2092 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2094 { /* The default is ascii S-records */
2096 unsigned long load_offset
;
2099 /* enable user to specify address for downloading as 2nd arg to load */
2100 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2106 monitor_printf (current_monitor
->load
);
2107 if (current_monitor
->loadresp
)
2108 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2110 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2111 32, SREC_ALL
, hashmark
,
2112 current_monitor
->flags
& MO_SREC_ACK
?
2113 monitor_wait_srec_ack
: NULL
);
2115 monitor_expect_prompt (NULL
, 0);
2118 /* Finally, make the PC point at the start address */
2121 write_pc (bfd_get_start_address (exec_bfd
));
2123 inferior_pid
= 0; /* No process now */
2125 /* This is necessary because many things were based on the PC at the time that
2126 we attached to the monitor, which is no longer valid now that we have loaded
2127 new code (and just changed the PC). Another way to do this might be to call
2128 normal_stop, except that the stack may not be valid, and things would get
2129 horribly confused... */
2131 clear_symtab_users ();
2137 RDEBUG(("MON stop\n")) ;
2138 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2139 SERIAL_SEND_BREAK (monitor_desc
);
2140 if (current_monitor
->stop
)
2141 monitor_printf_noecho (current_monitor
->stop
);
2144 /* Put a command string, in args, out to MONITOR. Output from MONITOR
2145 is placed on the users terminal until the prompt is seen. FIXME: We
2146 read the characters ourseleves here cause of a nasty echo. */
2149 monitor_command (args
, from_tty
)
2157 if (monitor_desc
== NULL
)
2158 error ("monitor target not open.");
2160 p
= current_monitor
->prompt
;
2162 /* Send the command. Note that if no args were supplied, then we're
2163 just sending the monitor a newline, which is sometimes useful. */
2165 monitor_printf ("%s\r", (args
? args
: ""));
2167 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2169 fputs_unfiltered (buf
, gdb_stdout
); /* Output the response */
2172 /* Convert hex digit A to a number. */
2179 if (a
>= '0' && a
<= '9')
2181 if (a
>= 'a' && a
<= 'f')
2182 return a
- 'a' + 10;
2183 if (a
>= 'A' && a
<= 'F')
2184 return a
- 'A' + 10;
2186 error ("Reply contains invalid hex digit 0x%x", a
);
2191 monitor_get_dev_name ()
2196 static struct target_ops monitor_ops
;
2198 static void init_base_monitor_ops(void)
2200 monitor_ops
.to_shortname
= NULL
;
2201 monitor_ops
.to_longname
= NULL
;
2202 monitor_ops
.to_doc
= NULL
;
2203 monitor_ops
.to_open
= NULL
;
2204 monitor_ops
.to_close
= monitor_close
;
2205 monitor_ops
.to_attach
= NULL
;
2206 monitor_ops
.to_post_attach
= NULL
;
2207 monitor_ops
.to_require_attach
= NULL
;
2208 monitor_ops
.to_detach
= monitor_detach
;
2209 monitor_ops
.to_require_detach
= NULL
;
2210 monitor_ops
.to_resume
= monitor_resume
;
2211 monitor_ops
.to_wait
= monitor_wait
;
2212 monitor_ops
.to_post_wait
= NULL
;
2213 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2214 monitor_ops
.to_store_registers
= monitor_store_registers
;
2215 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2216 monitor_ops
.to_xfer_memory
= monitor_xfer_memory
;
2217 monitor_ops
.to_files_info
= monitor_files_info
;
2218 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2219 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2220 monitor_ops
.to_terminal_init
= 0;
2221 monitor_ops
.to_terminal_inferior
= 0;
2222 monitor_ops
.to_terminal_ours_for_output
= 0;
2223 monitor_ops
.to_terminal_ours
= 0;
2224 monitor_ops
.to_terminal_info
= 0;
2225 monitor_ops
.to_kill
= monitor_kill
;
2226 monitor_ops
.to_load
= monitor_load
;
2227 monitor_ops
.to_lookup_symbol
= 0;
2228 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2229 monitor_ops
.to_post_startup_inferior
= NULL
;
2230 monitor_ops
.to_acknowledge_created_inferior
= NULL
;
2231 monitor_ops
.to_clone_and_follow_inferior
= NULL
;
2232 monitor_ops
.to_post_follow_inferior_by_clone
= NULL
;
2233 monitor_ops
.to_insert_fork_catchpoint
= NULL
;
2234 monitor_ops
.to_remove_fork_catchpoint
= NULL
;
2235 monitor_ops
.to_insert_vfork_catchpoint
= NULL
;
2236 monitor_ops
.to_remove_vfork_catchpoint
= NULL
;
2237 monitor_ops
.to_has_forked
= NULL
;
2238 monitor_ops
.to_has_vforked
= NULL
;
2239 monitor_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2240 monitor_ops
.to_post_follow_vfork
= NULL
;
2241 monitor_ops
.to_insert_exec_catchpoint
= NULL
;
2242 monitor_ops
.to_remove_exec_catchpoint
= NULL
;
2243 monitor_ops
.to_has_execd
= NULL
;
2244 monitor_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2245 monitor_ops
.to_has_exited
= NULL
;
2246 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2247 monitor_ops
.to_can_run
= 0;
2248 monitor_ops
.to_notice_signals
= 0;
2249 monitor_ops
.to_thread_alive
= 0;
2250 monitor_ops
.to_stop
= monitor_stop
;
2251 monitor_ops
.to_pid_to_exec_file
= NULL
;
2252 monitor_ops
.to_core_file_to_sym_file
= NULL
;
2253 monitor_ops
.to_stratum
= process_stratum
;
2254 monitor_ops
.DONT_USE
= 0;
2255 monitor_ops
.to_has_all_memory
= 1;
2256 monitor_ops
.to_has_memory
= 1;
2257 monitor_ops
.to_has_stack
= 1;
2258 monitor_ops
.to_has_registers
= 1;
2259 monitor_ops
.to_has_execution
= 1;
2260 monitor_ops
.to_sections
= 0;
2261 monitor_ops
.to_sections_end
= 0;
2262 monitor_ops
.to_magic
= OPS_MAGIC
;
2263 } /* init_monitor_ops */
2265 /* Init the target_ops structure pointed at by OPS */
2268 init_monitor_ops (ops
)
2269 struct target_ops
*ops
;
2271 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2274 /* Define additional commands that are usually only used by monitors. */
2277 _initialize_remote_monitors ()
2279 init_base_monitor_ops() ;
2280 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
2282 "Set display of activity while downloading a file.\n\
2283 When enabled, a hashmark \'#\' is displayed.",
2287 add_com ("monitor", class_obscure
, monitor_command
,
2288 "Send a command to the debug monitor.");