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 static CORE_ADDR
*breakaddr
;
125 /* Extra remote debugging for developing a new rom monitor variation */
126 #if ! defined(EXTRA_RDEBUG)
127 #define EXTRA_RDEBUG 0
129 #define RDEBUG(stuff) { if (EXTRA_RDEBUG && remote_debug) printf stuff ; }
131 /* Descriptor for I/O to remote machine. Initialize it to NULL so
132 that monitor_open knows that we don't have a file open when the
135 static serial_t monitor_desc
= NULL
;
137 /* Pointer to regexp pattern matching data */
139 static struct re_pattern_buffer register_pattern
;
140 static char register_fastmap
[256];
142 static struct re_pattern_buffer getmem_resp_delim_pattern
;
143 static char getmem_resp_delim_fastmap
[256];
145 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
146 monitor_wait wakes up. */
148 static DCACHE
*remote_dcache
;
149 static int first_time
=0; /* is this the first time we're executing after
150 gaving created the child proccess? */
152 /* Convert a string into a printable representation, Return # byte in the
156 monitor_printable_string (newstr
, oldstr
)
163 while ((ch
= *oldstr
++) != '\0')
173 sprintf (newstr
, "\\x%02x", ch
& 0xff);
178 case '\\': *newstr
++ = '\\'; *newstr
++ = '\\'; break;
179 case '\b': *newstr
++ = '\\'; *newstr
++ = 'b'; break;
180 case '\f': *newstr
++ = '\\'; *newstr
++ = 't'; break;
181 case '\n': *newstr
++ = '\\'; *newstr
++ = 'n'; break;
182 case '\r': *newstr
++ = '\\'; *newstr
++ = 'r'; break;
183 case '\t': *newstr
++ = '\\'; *newstr
++ = 't'; break;
184 case '\v': *newstr
++ = '\\'; *newstr
++ = 'v'; break;
189 return newstr
- save
;
192 /* Print monitor errors with a string, converting the string to printable
196 monitor_error (format
, memaddr
, len
, string
, final_char
)
203 int real_len
= (len
== 0 && string
!= (char *)0) ? strlen (string
) : len
;
204 char *safe_string
= alloca ((real_len
* 4) + 1);
207 int safe_len
= monitor_printable_string (safe_string
, string
);
210 error (format
, (int)memaddr
, p
- safe_string
, safe_string
, final_char
);
212 error (format
, (int)memaddr
, p
- safe_string
, safe_string
);
215 /* Convert hex digit A to a number. */
221 if (a
>= '0' && a
<= '9')
223 else if (a
>= 'a' && a
<= 'f')
226 if (a
>= 'A' && a
<= 'F')
227 return a
- 'A' + 10 ;
228 else error ("Invalid hex digit %d", a
);
231 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
233 This function exists to get around the problem that many host platforms
234 don't have a printf that can print 64-bit addresses. The %A format
235 specification is recognized as a special case, and causes the argument
236 to be printed as a 64-bit hexadecimal address.
238 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
239 If it is a '%s' format, the argument is a string; otherwise the
240 argument is assumed to be a long integer.
242 %% is also turned into a single %.
246 monitor_vsprintf (sndbuf
, pattern
, args
)
259 for (p
= pattern
; *p
; p
++)
263 /* Copy the format specifier to a separate buffer. */
265 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
268 format
[i
] = fmt
= *p
;
271 /* Fetch the next argument and print it. */
275 strcpy (sndbuf
, "%");
278 arg_addr
= va_arg (args
, CORE_ADDR
);
279 strcpy (sndbuf
, paddr_nz (arg_addr
));
282 arg_string
= va_arg (args
, char *);
283 sprintf (sndbuf
, format
, arg_string
);
286 arg_int
= va_arg (args
, long);
287 sprintf (sndbuf
, format
, arg_int
);
290 sndbuf
+= strlen (sndbuf
);
299 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
300 Works just like printf. */
303 #ifdef ANSI_PROTOTYPES
304 monitor_printf_noecho (char *pattern
, ...)
306 monitor_printf_noecho (va_alist
)
315 va_start (args
, pattern
);
319 pattern
= va_arg (args
, char *);
322 monitor_vsprintf (sndbuf
, pattern
, args
);
324 len
= strlen (sndbuf
);
325 if (len
+ 1 > sizeof sndbuf
)
329 if (remote_debug
> 0)
330 puts_debug ("sent -->", sndbuf
, "<--");
335 char *safe_string
= (char *) alloca ((strlen (sndbuf
) * 4) + 1);
336 monitor_printable_string (safe_string
, sndbuf
);
337 printf ("sent[%s]\n", safe_string
);
340 monitor_write (sndbuf
, len
);
343 /* monitor_printf -- Send data to monitor and check the echo. Works just like
347 #ifdef ANSI_PROTOTYPES
348 monitor_printf (char *pattern
, ...)
350 monitor_printf (va_alist
)
358 #ifdef ANSI_PROTOTYPES
359 va_start (args
, pattern
);
363 pattern
= va_arg (args
, char *);
366 monitor_vsprintf (sndbuf
, pattern
, args
);
368 len
= strlen (sndbuf
);
369 if (len
+ 1 > sizeof sndbuf
)
373 if (remote_debug
> 0)
374 puts_debug ("sent -->", sndbuf
, "<--");
379 char *safe_string
= (char *) alloca ((len
* 4) + 1);
380 monitor_printable_string (safe_string
, sndbuf
);
381 printf ("sent[%s]\n", safe_string
);
384 monitor_write (sndbuf
, len
);
386 /* We used to expect that the next immediate output was the characters we
387 just output, but sometimes some extra junk appeared before the characters
388 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
389 So, just start searching for what we sent, and skip anything unknown. */
390 RDEBUG(("ExpectEcho\n"))
391 monitor_expect (sndbuf
, (char *)0, 0);
395 /* Write characters to the remote system. */
398 monitor_write (buf
, buflen
)
402 if (SERIAL_WRITE(monitor_desc
, buf
, buflen
))
403 fprintf_unfiltered (gdb_stderr
, "SERIAL_WRITE failed: %s\n",
404 safe_strerror (errno
));
408 /* Read a binary character from the remote system, doing all the fancy
409 timeout stuff, but without interpreting the character in any way,
410 and without printing remote debug information. */
421 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
424 c
&= 0xff; /* don't lose bit 7 */
431 if (c
== SERIAL_TIMEOUT
)
432 error ("Timeout reading from remote system.");
434 perror_with_name ("remote-monitor");
438 /* Read a character from the remote system, doing all the fancy
446 static enum { last_random
, last_nl
, last_cr
, last_crnl
} state
= last_random
;
452 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
458 /* This seems to interfere with proper function of the
460 if (remote_debug
> 0)
465 puts_debug ("read -->", buf
, "<--");
471 /* Canonicialize \n\r combinations into one \r */
472 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
474 if ((c
== '\r' && state
== last_nl
)
475 || (c
== '\n' && state
== last_cr
))
496 if (c
== SERIAL_TIMEOUT
)
498 /* I fail to see how detaching here can be useful */
499 if (in_monitor_wait
) /* Watchdog went off */
501 target_mourn_inferior ();
502 error ("GDB serial timeout has expired. Target detached.\n");
506 error ("Timeout reading from remote system.");
508 perror_with_name ("remote-monitor");
511 /* Scan input from the remote system, until STRING is found. If BUF is non-
512 zero, then collect input until we have collected either STRING or BUFLEN-1
513 chars. In either case we terminate BUF with a 0. If input overflows BUF
514 because STRING can't be found, return -1, else return number of chars in BUF
515 (minus the terminating NUL). Note that in the non-overflow case, STRING
516 will be at the end of BUF. */
519 monitor_expect (string
, buf
, buflen
)
525 int obuflen
= buflen
;
527 extern struct target_ops
*targ_ops
;
532 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
533 monitor_printable_string (safe_string
, string
);
534 printf ("MON Expecting '%s'\n", safe_string
);
549 c
= readchar (timeout
);
556 c
= readchar (timeout
);
558 /* Don't expect any ^C sent to be echoed */
560 if (*p
== '\003' || c
== *p
)
570 return obuflen
- buflen
;
576 else if ((c
== '\021' || c
== '\023') &&
577 (STREQ (targ_ops
->to_shortname
, "m32r")
578 || STREQ (targ_ops
->to_shortname
, "mon2000")))
579 { /* m32r monitor emits random DC1/DC3 chars */
591 /* Search for a regexp. */
594 monitor_expect_regexp (pat
, buf
, buflen
)
595 struct re_pattern_buffer
*pat
;
601 RDEBUG(("MON Expecting regexp\n")) ;
606 mybuf
= alloca (1024);
615 if (p
- mybuf
>= buflen
)
616 { /* Buffer about to overflow */
618 /* On overflow, we copy the upper half of the buffer to the lower half. Not
619 great, but it usually works... */
621 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
622 p
= mybuf
+ buflen
/ 2;
625 *p
++ = readchar (timeout
);
627 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
633 /* Keep discarding input until we see the MONITOR prompt.
635 The convention for dealing with the prompt is that you
637 o *then* wait for the prompt.
639 Thus the last thing that a procedure does with the serial line will
640 be an monitor_expect_prompt(). Exception: monitor_resume does not
641 wait for the prompt, because the terminal is being handed over to
642 the inferior. However, the next thing which happens after that is
643 a monitor_wait which does wait for the prompt. Note that this
644 includes abnormal exit, e.g. error(). This is necessary to prevent
645 getting into states from which we can't recover. */
648 monitor_expect_prompt (buf
, buflen
)
652 RDEBUG(("MON Expecting prompt\n"))
653 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
656 /* Get N 32-bit words from remote, each preceded by a space, and put
657 them in registers starting at REGNO. */
668 ch
= readchar (timeout
);
673 for (i
= 7; i
>= 1; i
--)
675 ch
= readchar (timeout
);
678 val
= (val
<< 4) | from_hex (ch
);
686 compile_pattern (pattern
, compiled_pattern
, fastmap
)
688 struct re_pattern_buffer
*compiled_pattern
;
694 compiled_pattern
->fastmap
= fastmap
;
696 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
697 val
= re_compile_pattern (pattern
,
703 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern
, val
);
706 re_compile_fastmap (compiled_pattern
);
709 /* Open a connection to a remote debugger. NAME is the filename used
710 for communication. */
713 monitor_open (args
, mon_ops
, from_tty
)
715 struct monitor_ops
*mon_ops
;
721 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
722 error ("Magic number of monitor_ops struct wrong.");
724 targ_ops
= mon_ops
->target
;
725 name
= targ_ops
->to_shortname
;
728 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
729 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
731 target_preopen (from_tty
);
733 /* Setup pattern for register dump */
735 if (mon_ops
->register_pattern
)
736 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
739 if (mon_ops
->getmem
.resp_delim
)
740 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
741 getmem_resp_delim_fastmap
);
743 unpush_target (targ_ops
);
747 dev_name
= strsave (args
);
749 monitor_desc
= SERIAL_OPEN (dev_name
);
752 perror_with_name (dev_name
);
756 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
758 SERIAL_CLOSE (monitor_desc
);
759 perror_with_name (dev_name
);
763 SERIAL_RAW (monitor_desc
);
765 SERIAL_FLUSH_INPUT (monitor_desc
);
767 /* some systems only work with 2 stop bits */
769 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
771 current_monitor
= mon_ops
;
773 /* See if we can wake up the monitor. First, try sending a stop sequence,
774 then send the init strings. Last, remove all breakpoints. */
776 if (current_monitor
->stop
)
779 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
781 RDEBUG(("EXP Open echo\n")) ;
782 monitor_expect_prompt (NULL
, 0);
786 /* wake up the monitor and see if it's alive */
787 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
789 /* Some of the characters we send may not be echoed,
790 but we hope to get a prompt at the end of it all. */
792 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
795 monitor_printf_noecho (*p
);
796 monitor_expect_prompt (NULL
, 0);
799 SERIAL_FLUSH_INPUT (monitor_desc
);
801 /* Alloc breakpoints */
802 if (mon_ops
->set_break
!= NULL
)
804 if (mon_ops
->num_breakpoints
== 0)
805 mon_ops
->num_breakpoints
= 8;
807 breakaddr
= (CORE_ADDR
*) xmalloc (mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
808 memset (breakaddr
, 0, mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
811 /* Remove all breakpoints */
813 if (mon_ops
->clr_all_break
)
815 monitor_printf (mon_ops
->clr_all_break
);
816 monitor_expect_prompt (NULL
, 0);
820 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
822 push_target (targ_ops
);
824 inferior_pid
= 42000; /* Make run command think we are busy... */
826 /* Give monitor_wait something to read */
828 monitor_printf (current_monitor
->line_term
);
830 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
831 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory_block
);
833 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory
);
837 /* Close out all files and local state before this target loses
841 monitor_close (quitting
)
845 SERIAL_CLOSE (monitor_desc
);
847 /* Free breakpoint memory */
848 if (breakaddr
!= NULL
)
857 /* Terminate the open connection to the remote debugger. Use this
858 when you want to detach and do something else with your gdb. */
861 monitor_detach (args
, from_tty
)
865 pop_target (); /* calls monitor_close to do the real work */
867 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
870 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
873 monitor_supply_register (regno
, valstr
)
878 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
881 val
= strtoul (valstr
, &p
, 16);
882 RDEBUG(("Supplying Register %d %s\n",regno
,valstr
)) ;
884 if (val
== 0 && valstr
== p
)
885 error ("monitor_supply_register (%d): bad value from monitor: %s.",
888 /* supply register stores in target byte order, so swap here */
890 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
892 supply_register (regno
, regbuf
);
897 /* Tell the remote machine to resume. */
900 flush_monitor_dcache ()
902 dcache_flush (remote_dcache
);
906 monitor_resume (pid
, step
, sig
)
908 enum target_signal sig
;
910 /* Some monitors require a different command when starting a program */
911 RDEBUG(("MON resume\n")) ;
912 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
915 monitor_printf ("run\r");
916 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
920 dcache_flush (remote_dcache
);
922 monitor_printf (current_monitor
->step
);
925 if (current_monitor
->continue_hook
)
926 (*current_monitor
->continue_hook
)() ;
927 else monitor_printf (current_monitor
->cont
);
928 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
933 /* Parse the output of a register dump command. A monitor specific
934 regexp is used to extract individual register descriptions of the
935 form REG=VAL. Each description is split up into a name and a value
936 string which are passed down to monitor specific code. */
939 parse_register_dump (buf
, len
)
943 RDEBUG(("MON Parsing register dump\n"))
946 int regnamelen
, vallen
;
948 /* Element 0 points to start of register name, and element 1
949 points to the start of the register value. */
950 struct re_registers register_strings
;
952 memset (®ister_strings
, 0, sizeof (struct re_registers
));
954 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
955 ®ister_strings
) == -1)
958 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
959 regname
= buf
+ register_strings
.start
[1];
960 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
961 val
= buf
+ register_strings
.start
[2];
963 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
965 buf
+= register_strings
.end
[0];
966 len
-= register_strings
.end
[0];
970 /* Send ^C to target to halt it. Target will respond, and send us a
974 monitor_interrupt (signo
)
977 /* If this doesn't work, try more severe steps. */
978 signal (signo
, monitor_interrupt_twice
);
981 printf_unfiltered ("monitor_interrupt called\n");
986 /* The user typed ^C twice. */
989 monitor_interrupt_twice (signo
)
992 signal (signo
, ofunc
);
994 monitor_interrupt_query ();
996 signal (signo
, monitor_interrupt
);
999 /* Ask the user what to do when an interrupt is received. */
1002 monitor_interrupt_query ()
1004 target_terminal_ours ();
1006 if (query ("Interrupted while waiting for the program.\n\
1007 Give up (and stop debugging it)? "))
1009 target_mourn_inferior ();
1010 return_to_top_level (RETURN_QUIT
);
1013 target_terminal_inferior ();
1017 monitor_wait_cleanup (old_timeout
)
1020 timeout
= *(int*)old_timeout
;
1021 signal (SIGINT
, ofunc
);
1022 in_monitor_wait
= 0;
1027 void monitor_wait_filter(char * buf
,
1030 struct target_waitstatus
* status
1036 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1037 * ext_resp_len
=resp_len
;
1040 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1042 while (resp_len
< 0);
1044 /* Print any output characters that were preceded by ^O. */
1045 /* FIXME - This would be great as a user settabgle flag */
1047 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1051 for (i
= 0; i
< resp_len
- 1; i
++)
1053 putchar_unfiltered (buf
[++i
]);
1059 /* Wait until the remote machine stops, then return, storing status in
1060 status just as `wait' would. */
1063 monitor_wait (pid
, status
)
1065 struct target_waitstatus
*status
;
1067 int old_timeout
= timeout
;
1070 struct cleanup
*old_chain
;
1072 status
->kind
= TARGET_WAITKIND_EXITED
;
1073 status
->value
.integer
= 0;
1075 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1076 RDEBUG(("MON wait\n"))
1079 /* This is somthing other than a maintenance command */
1080 in_monitor_wait
= 1;
1081 timeout
= watchdog
> 0 ? watchdog
: -1;
1083 timeout
= -1; /* Don't time out -- user program is running. */
1086 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1088 if (current_monitor
->wait_filter
)
1089 (*current_monitor
->wait_filter
)(buf
,sizeof (buf
),&resp_len
,status
) ;
1090 else monitor_wait_filter(buf
,sizeof (buf
),&resp_len
,status
) ;
1092 #if 0 /* Transferred to monitor wait filter */
1095 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1098 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1100 while (resp_len
< 0);
1102 /* Print any output characters that were preceded by ^O. */
1103 /* FIXME - This would be great as a user settabgle flag */
1105 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1109 for (i
= 0; i
< resp_len
- 1; i
++)
1111 putchar_unfiltered (buf
[++i
]);
1115 signal (SIGINT
, ofunc
);
1117 timeout
= old_timeout
;
1119 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1122 monitor_printf (current_monitor
->dump_registers
);
1123 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1126 if (current_monitor
->register_pattern
)
1127 parse_register_dump (buf
, resp_len
);
1129 RDEBUG(("Wait fetching registers after stop\n")) ;
1130 monitor_dump_regs() ;
1133 status
->kind
= TARGET_WAITKIND_STOPPED
;
1134 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1136 discard_cleanups (old_chain
);
1138 in_monitor_wait
= 0;
1140 return inferior_pid
;
1143 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1147 monitor_fetch_register (regno
)
1151 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] = {0};
1152 char regbuf
[MAX_REGISTER_RAW_SIZE
* 2 + 1];
1155 name
= current_monitor
->regnames
[regno
];
1156 RDEBUG(("MON fetchreg %d '%s'\n", regno
, name
? name
: "(null name)"))
1158 if (!name
|| (*name
== '\0'))
1160 RDEBUG (("No register known for %d\n", regno
))
1161 supply_register (regno
, zerobuf
);
1165 /* send the register examine command */
1167 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1169 /* If RESP_DELIM is specified, we search for that as a leading
1170 delimiter for the register value. Otherwise, we just start
1171 searching from the start of the buf. */
1173 if (current_monitor
->getreg
.resp_delim
)
1175 RDEBUG(("EXP getreg.resp_delim\n"))
1176 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1177 /* Handle case of first 32 registers listed in pairs. */
1178 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1179 && (regno
& 1) != 0 && regno
< 32)
1180 { RDEBUG(("EXP getreg.resp_delim\n")) ;
1181 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1185 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1186 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1189 c
= readchar (timeout
);
1191 c
= readchar (timeout
);
1192 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1195 error ("Bad value returned from monitor while fetching register %x.",
1199 /* Read upto the maximum number of hex digits for this register, skipping
1200 spaces, but stop reading if something else is seen. Some monitors
1201 like to drop leading zeros. */
1203 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
1206 c
= readchar (timeout
);
1208 c
= readchar (timeout
);
1216 regbuf
[i
] = '\000'; /* terminate the number */
1217 RDEBUG(("REGVAL '%s'\n",regbuf
)) ;
1219 /* If TERM is present, we wait for that to show up. Also, (if TERM
1220 is present), we will send TERM_CMD if that is present. In any
1221 case, we collect all of the output into buf, and then wait for
1222 the normal prompt. */
1224 if (current_monitor
->getreg
.term
)
1226 RDEBUG(("EXP getreg.term\n"))
1227 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1230 if (current_monitor
->getreg
.term_cmd
)
1231 { RDEBUG(("EMIT getreg.term.cmd\n"))
1232 monitor_printf (current_monitor
->getreg
.term_cmd
);
1234 if (! current_monitor
->getreg
.term
|| /* Already expected or */
1235 current_monitor
->getreg
.term_cmd
) /* ack expected */
1236 monitor_expect_prompt (NULL
, 0); /* get response */
1238 monitor_supply_register (regno
, regbuf
);
1241 /* Sometimes, it takes several commands to dump the registers */
1242 /* This is a primitive for use by variations of monitor interfaces in
1243 case they need to compose the operation.
1245 int monitor_dump_reg_block(char * block_cmd
)
1249 monitor_printf (block_cmd
);
1250 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1251 parse_register_dump (buf
, resp_len
);
1256 /* Read the remote registers into the block regs. */
1257 /* Call the specific function if it has been provided */
1260 monitor_dump_regs ()
1264 if (current_monitor
->dumpregs
)
1265 (*(current_monitor
->dumpregs
))() ; /* call supplied function */
1267 if (current_monitor
->dump_registers
) /* default version */
1268 { monitor_printf (current_monitor
->dump_registers
);
1269 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1270 parse_register_dump (buf
, resp_len
);
1273 abort(); /* Need some way to read registers */
1277 monitor_fetch_registers (regno
)
1280 RDEBUG(("MON fetchregs\n")) ;
1281 if (current_monitor
->getreg
.cmd
)
1285 monitor_fetch_register (regno
);
1289 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1290 monitor_fetch_register (regno
);
1293 monitor_dump_regs ();
1297 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1300 monitor_store_register (regno
)
1306 name
= current_monitor
->regnames
[regno
];
1307 if (!name
|| (*name
== '\0'))
1308 { RDEBUG(("MON Cannot store unknown register\n"))
1312 val
= read_register (regno
);
1313 RDEBUG(("MON storeg %d %08x\n",regno
,(unsigned int)val
))
1315 /* send the register deposit command */
1317 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1318 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1319 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1320 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1322 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1324 if (current_monitor
->setreg
.term
)
1325 { RDEBUG(("EXP setreg.term\n"))
1326 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1327 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1328 monitor_printf ("%x\r", val
);
1329 monitor_expect_prompt (NULL
, 0);
1332 monitor_expect_prompt (NULL
, 0);
1333 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1334 { RDEBUG(("EXP setreg_termcmd\n")) ;
1335 monitor_printf("%s",current_monitor
->setreg
.term_cmd
) ;
1336 monitor_expect_prompt(NULL
,0) ;
1338 } /* monitor_store_register */
1340 /* Store the remote registers. */
1343 monitor_store_registers (regno
)
1348 monitor_store_register (regno
);
1352 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1353 monitor_store_register (regno
);
1356 /* Get ready to modify the registers array. On machines which store
1357 individual registers, this doesn't need to do anything. On machines
1358 which store all the registers in one fell swoop, this makes sure
1359 that registers contains all the registers from the program being
1363 monitor_prepare_to_store ()
1365 /* Do nothing, since we can store individual regs */
1369 monitor_files_info (ops
)
1370 struct target_ops
*ops
;
1372 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1376 monitor_write_memory (memaddr
, myaddr
, len
)
1381 unsigned int val
, hostval
;
1385 RDEBUG(("MON write %d %08x\n",len
,(unsigned long)memaddr
))
1387 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1388 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1390 /* Use memory fill command for leading 0 bytes. */
1392 if (current_monitor
->fill
)
1394 for (i
= 0; i
< len
; i
++)
1398 if (i
> 4) /* More than 4 zeros is worth doing */
1400 RDEBUG(("MON FILL %d\n",i
))
1401 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1402 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
)-1, 0);
1404 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1406 monitor_expect_prompt (NULL
, 0);
1413 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1414 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1417 cmd
= current_monitor
->setmem
.cmdll
;
1421 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1424 cmd
= current_monitor
->setmem
.cmdl
;
1426 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1429 cmd
= current_monitor
->setmem
.cmdw
;
1434 cmd
= current_monitor
->setmem
.cmdb
;
1437 val
= extract_unsigned_integer (myaddr
, len
);
1440 { hostval
= * (unsigned int *) myaddr
;
1441 RDEBUG(("Hostval(%08x) val(%08x)\n",hostval
,val
)) ;
1445 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1446 monitor_printf_noecho (cmd
, memaddr
, val
);
1447 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1450 monitor_printf_noecho (cmd
, memaddr
);
1452 if (current_monitor
->setmem
.term
)
1453 { RDEBUG(("EXP setmem.term")) ;
1454 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1455 monitor_printf ("%x\r", val
);
1457 if (current_monitor
->setmem
.term_cmd
)
1458 { /* Emit this to get out of the memory editing state */
1459 monitor_printf("%s",current_monitor
->setmem
.term_cmd
) ;
1460 /* Drop through to expecting a prompt */
1464 monitor_printf (cmd
, memaddr
, val
);
1466 monitor_expect_prompt (NULL
, 0);
1473 monitor_write_even_block(memaddr
,myaddr
,len
)
1480 /* Enter the sub mode */
1481 monitor_printf(current_monitor
->setmem
.cmdl
,memaddr
) ;
1482 monitor_expect_prompt(NULL
,0) ;
1486 val
= extract_unsigned_integer(myaddr
,4) ; /* REALLY */
1487 monitor_printf("%x\r",val
) ;
1491 RDEBUG((" @ %08x\n",memaddr
))
1492 /* If we wanted to, here we could validate the address */
1493 monitor_expect_prompt(NULL
,0) ;
1495 /* Now exit the sub mode */
1496 monitor_printf (current_monitor
->getreg
.term_cmd
);
1497 monitor_expect_prompt(NULL
,0) ;
1502 static int monitor_write_memory_bytes(memaddr
,myaddr
,len
)
1509 if (len
== 0) return 0 ;
1510 /* Enter the sub mode */
1511 monitor_printf(current_monitor
->setmem
.cmdb
,memaddr
) ;
1512 monitor_expect_prompt(NULL
,0) ;
1516 monitor_printf("%x\r",val
) ;
1520 /* If we wanted to, here we could validate the address */
1521 monitor_expect_prompt(NULL
,0) ;
1524 /* Now exit the sub mode */
1525 monitor_printf (current_monitor
->getreg
.term_cmd
);
1526 monitor_expect_prompt(NULL
,0) ;
1532 longlongendswap (unsigned char * a
)
1544 /* Format 32 chars of long long value, advance the pointer */
1545 static char * hexlate
= "0123456789abcdef" ;
1546 static char * longlong_hexchars(unsigned long long value
,
1549 if (value
== 0) { *outbuff
++ = '0' ; return outbuff
; }
1551 { static unsigned char disbuf
[8] ; /* disassembly buffer */
1552 unsigned char * scan
, * limit
; /* loop controls */
1553 unsigned char c
, nib
;
1555 scan
= disbuf
; limit
= scan
+ 8 ;
1556 { unsigned long long * dp
;
1557 dp
= (unsigned long long *) scan
;
1560 longlongendswap(disbuf
) ; /* FIXME: ONly on big endian hosts */
1561 while (scan
< limit
)
1563 c
= *scan
++; /* a byte of our long long value */
1569 leadzero
= 0; /* henceforth we print even zeroes */
1571 nib
= c
>> 4; /* high nibble bits */
1572 *outbuff
++ = hexlate
[nib
];
1573 nib
= c
& 0x0f; /* low nibble bits */
1574 *outbuff
++ = hexlate
[nib
];
1578 } /* longlong_hexchars */
1582 /* I am only going to call this when writing virtual byte streams.
1583 Which possably entails endian conversions
1585 static int monitor_write_memory_longlongs(memaddr
,myaddr
,len
)
1590 static char hexstage
[20] ; /* At least 16 digits required, plus null */
1595 llptr
= (unsigned long long *) myaddr
;
1596 if (len
== 0 ) return 0 ;
1597 monitor_printf(current_monitor
->setmem
.cmdll
,memaddr
) ;
1598 monitor_expect_prompt(NULL
,0) ;
1602 endstring
= longlong_hexchars(*llptr
,hexstage
) ;
1603 *endstring
= '\0' ; /* NUll terminate for printf */
1604 monitor_printf("%s\r",hexstage
) ;
1608 /* If we wanted to, here we could validate the address */
1609 monitor_expect_prompt(NULL
,0) ;
1612 /* Now exit the sub mode */
1613 monitor_printf (current_monitor
->getreg
.term_cmd
);
1614 monitor_expect_prompt(NULL
,0) ;
1620 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1621 /* This is for the large blocks of memory which may occur in downloading.
1622 And for monitors which use interactive entry,
1623 And for monitors which do not have other downloading methods.
1624 Without this, we will end up calling monitor_write_memory many times
1625 and do the entry and exit of the sub mode many times
1626 This currently assumes...
1627 MO_SETMEM_INTERACTIVE
1628 ! MO_NO_ECHO_ON_SETMEM
1629 To use this, the you have to patch the monitor_cmds block with
1630 this function. Otherwise, its not tuned up for use by all
1634 static int monitor_write_memory_block(memaddr
,myaddr
,len
)
1641 /* FIXME: This would be a good place to put the zero test */
1643 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1645 return monitor_write_memory_longlongs(memaddr
,myaddr
,len
) ;
1652 written
= monitor_write_even_block(memaddr
,myaddr
,len
) ;
1653 /* Adjust calling parameters by written amount */
1654 memaddr
+= written
;
1659 written
= monitor_write_memory_bytes(memaddr
,myaddr
,len
) ;
1663 /* This is an alternate form of monitor_read_memory which is used for monitors
1664 which can only read a single byte/word/etc. at a time. */
1667 monitor_read_memory_single (memaddr
, myaddr
, len
)
1673 char membuf
[sizeof(int) * 2 + 1];
1678 RDEBUG(("MON read single\n")) ;
1680 /* Can't actually use long longs (nice idea, though). In fact, the
1681 call to strtoul below will fail if it tries to convert a value
1682 that's too big to fit in a long. */
1683 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1686 cmd
= current_monitor
->getmem
.cmdll
;
1690 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1693 cmd
= current_monitor
->getmem
.cmdl
;
1695 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1698 cmd
= current_monitor
->getmem
.cmdw
;
1703 cmd
= current_monitor
->getmem
.cmdb
;
1706 /* Send the examine command. */
1708 monitor_printf (cmd
, memaddr
);
1710 /* If RESP_DELIM is specified, we search for that as a leading
1711 delimiter for the memory value. Otherwise, we just start
1712 searching from the start of the buf. */
1714 if (current_monitor
->getmem
.resp_delim
)
1715 { RDEBUG(("EXP getmem.resp_delim\n")) ;
1716 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1719 /* Now, read the appropriate number of hex digits for this loc,
1722 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1723 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1727 c
= readchar (timeout
);
1729 c
= readchar (timeout
);
1730 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1733 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1734 memaddr
, i
, membuf
, c
);
1736 for (i
= 0; i
< len
* 2; i
++)
1742 c
= readchar (timeout
);
1748 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1749 memaddr
, i
, membuf
, c
);
1755 membuf
[i
] = '\000'; /* terminate the number */
1757 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1758 present), we will send TERM_CMD if that is present. In any case, we collect
1759 all of the output into buf, and then wait for the normal prompt. */
1761 if (current_monitor
->getmem
.term
)
1763 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1765 if (current_monitor
->getmem
.term_cmd
)
1767 monitor_printf (current_monitor
->getmem
.term_cmd
);
1768 monitor_expect_prompt (NULL
, 0);
1772 monitor_expect_prompt (NULL
, 0); /* get response */
1775 val
= strtoul (membuf
, &p
, 16);
1777 if (val
== 0 && membuf
== p
)
1778 monitor_error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
1779 memaddr
, 0, membuf
, 0);
1781 /* supply register stores in target byte order, so swap here */
1783 store_unsigned_integer (myaddr
, len
, val
);
1788 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1789 memory at MEMADDR. Returns length moved. Currently, we do no more
1790 than 16 bytes at a time. */
1793 monitor_read_memory (memaddr
, myaddr
, len
)
1807 RDEBUG (("Zero length call to monitor_read_memory\n"));
1811 if (remote_debug
) printf("MON read block ta(%08x) ha(%08x) %d\n",
1812 (unsigned long) memaddr
, (unsigned long)myaddr
, len
);
1814 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1815 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1817 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1818 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1820 len
= min (len
, 16);
1822 /* Some dumpers align the first data with the preceeding 16
1823 byte boundary. Some print blanks and start at the
1824 requested boundary. EXACT_DUMPADDR
1827 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1828 ? memaddr
: memaddr
& ~ 0x0f ;
1830 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1831 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1832 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1834 /* send the memory examine command */
1836 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1837 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
);
1838 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1839 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1841 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1843 /* If TERM is present, we wait for that to show up. Also, (if TERM
1844 is present), we will send TERM_CMD if that is present. In any
1845 case, we collect all of the output into buf, and then wait for
1846 the normal prompt. */
1848 if (current_monitor
->getmem
.term
)
1850 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1853 monitor_error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
1854 memaddr
, resp_len
, buf
, 0);
1856 if (current_monitor
->getmem
.term_cmd
)
1858 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1859 strlen (current_monitor
->getmem
.term_cmd
));
1860 monitor_expect_prompt (NULL
, 0);
1864 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1868 /* If RESP_DELIM is specified, we search for that as a leading
1869 delimiter for the values. Otherwise, we just start searching
1870 from the start of the buf. */
1872 if (current_monitor
->getmem
.resp_delim
)
1875 struct re_registers resp_strings
;
1876 RDEBUG(("MON getmem.resp_delim %s\n",current_monitor
->getmem
.resp_delim
)) ;
1878 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1880 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1884 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1885 memaddr
, resp_len
, buf
, 0);
1887 p
+= resp_strings
.end
[0];
1889 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1891 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1892 memaddr
, resp_len
, buf
, 0);
1893 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1896 if (remote_debug
) printf("MON scanning %d ,%08x '%s'\n",len
,p
,p
) ;
1897 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1905 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1907 { if ((dumpaddr
>= memaddr
) && (i
> 0))
1908 { val
= fromhex (c
) * 16 + fromhex (*(p
+1));
1910 if (remote_debug
) printf("[%02x]",val
) ;
1917 ++p
; /* skip a blank or other non hex char */
1920 if (fetched
== 0) error("Failed to read via monitor") ;
1921 if (remote_debug
) printf("\n") ;
1922 return fetched
; /* Return the number of bytes actually read */
1924 RDEBUG(("MON scanning bytes\n")) ;
1926 for (i
= len
; i
> 0; i
--)
1928 /* Skip non-hex chars, but bomb on end of string and newlines */
1935 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1936 monitor_error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s",
1937 memaddr
, resp_len
, buf
, 0);
1941 val
= strtoul (p
, &p1
, 16);
1943 if (val
== 0 && p
== p1
)
1944 monitor_error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.",
1945 memaddr
, resp_len
, buf
, 0);
1959 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1964 struct target_ops
*target
; /* ignored */
1966 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, write
);
1972 return; /* ignore attempts to kill target system */
1975 /* All we actually do is set the PC to the start address of exec_bfd, and start
1976 the program at that point. */
1979 monitor_create_inferior (exec_file
, args
, env
)
1984 if (args
&& (*args
!= '\000'))
1985 error ("Args are not supported by the monitor.");
1988 clear_proceed_status ();
1989 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1992 /* Clean up when a program exits.
1993 The program actually lives on in the remote processor's RAM, and may be
1994 run again without a download. Don't leave it full of breakpoint
1998 monitor_mourn_inferior ()
2000 unpush_target (targ_ops
);
2001 generic_mourn_inferior (); /* Do all the proper things now */
2004 /* Tell the monitor to add a breakpoint. */
2007 monitor_insert_breakpoint (addr
, shadow
)
2015 RDEBUG(("MON inst bkpt %08x\n",addr
))
2016 if (current_monitor
->set_break
== NULL
)
2017 error ("No set_break defined for this monitor");
2019 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2020 addr
= ADDR_BITS_REMOVE (addr
);
2022 /* Determine appropriate breakpoint size for this address. */
2023 bp
= memory_breakpoint_from_pc (&addr
, &bplen
);
2025 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2027 if (breakaddr
[i
] == 0)
2029 breakaddr
[i
] = addr
;
2030 monitor_read_memory (addr
, shadow
, bplen
);
2031 monitor_printf (current_monitor
->set_break
, addr
);
2032 monitor_expect_prompt (NULL
, 0);
2037 error ("Too many breakpoints (> %d) for monitor.", current_monitor
->num_breakpoints
);
2040 /* Tell the monitor to remove a breakpoint. */
2043 monitor_remove_breakpoint (addr
, shadow
)
2049 RDEBUG(("MON rmbkpt %08x\n",addr
))
2050 if (current_monitor
->clr_break
== NULL
)
2051 error ("No clr_break defined for this monitor");
2053 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2054 addr
= ADDR_BITS_REMOVE (addr
);
2056 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2058 if (breakaddr
[i
] == addr
)
2061 /* some monitors remove breakpoints based on the address */
2062 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2063 monitor_printf (current_monitor
->clr_break
, addr
);
2064 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2065 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2067 monitor_printf (current_monitor
->clr_break
, i
);
2068 monitor_expect_prompt (NULL
, 0);
2072 fprintf_unfiltered (gdb_stderr
,
2073 "Can't find breakpoint associated with 0x%x\n", addr
);
2077 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2078 an S-record. Return non-zero if the ACK is received properly. */
2081 monitor_wait_srec_ack ()
2085 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2087 return (readchar (timeout
) == '+');
2089 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2091 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2092 if ((ch
= readchar (1)) < 0)
2094 if ((ch
= readchar (1)) < 0)
2096 if ((ch
= readchar (1)) < 0)
2098 if ((ch
= readchar (1)) < 0)
2104 /* monitor_load -- download a file. */
2107 monitor_load (file
, from_tty
)
2111 dcache_flush (remote_dcache
);
2112 RDEBUG(("MON load\n"))
2114 if (current_monitor
->load_routine
)
2115 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2117 { /* The default is ascii S-records */
2119 unsigned long load_offset
;
2122 /* enable user to specify address for downloading as 2nd arg to load */
2123 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2129 monitor_printf (current_monitor
->load
);
2130 if (current_monitor
->loadresp
)
2131 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2133 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2134 32, SREC_ALL
, hashmark
,
2135 current_monitor
->flags
& MO_SREC_ACK
?
2136 monitor_wait_srec_ack
: NULL
);
2138 monitor_expect_prompt (NULL
, 0);
2141 /* Finally, make the PC point at the start address */
2144 write_pc (bfd_get_start_address (exec_bfd
));
2146 inferior_pid
= 0; /* No process now */
2148 /* This is necessary because many things were based on the PC at the time that
2149 we attached to the monitor, which is no longer valid now that we have loaded
2150 new code (and just changed the PC). Another way to do this might be to call
2151 normal_stop, except that the stack may not be valid, and things would get
2152 horribly confused... */
2154 clear_symtab_users ();
2160 RDEBUG(("MON stop\n")) ;
2161 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2162 SERIAL_SEND_BREAK (monitor_desc
);
2163 if (current_monitor
->stop
)
2164 monitor_printf_noecho (current_monitor
->stop
);
2167 /* Put a command string, in args, out to MONITOR. Output from MONITOR
2168 is placed on the users terminal until the prompt is seen. FIXME: We
2169 read the characters ourseleves here cause of a nasty echo. */
2172 monitor_command (args
, from_tty
)
2180 if (monitor_desc
== NULL
)
2181 error ("monitor target not open.");
2183 p
= current_monitor
->prompt
;
2185 /* Send the command. Note that if no args were supplied, then we're
2186 just sending the monitor a newline, which is sometimes useful. */
2188 monitor_printf ("%s\r", (args
? args
: ""));
2190 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2192 fputs_unfiltered (buf
, gdb_stdout
); /* Output the response */
2195 /* Convert hex digit A to a number. */
2202 if (a
>= '0' && a
<= '9')
2204 if (a
>= 'a' && a
<= 'f')
2205 return a
- 'a' + 10;
2206 if (a
>= 'A' && a
<= 'F')
2207 return a
- 'A' + 10;
2209 error ("Reply contains invalid hex digit 0x%x", a
);
2214 monitor_get_dev_name ()
2219 static struct target_ops monitor_ops
;
2222 init_base_monitor_ops (void)
2224 monitor_ops
.to_shortname
= NULL
;
2225 monitor_ops
.to_longname
= NULL
;
2226 monitor_ops
.to_doc
= NULL
;
2227 monitor_ops
.to_open
= NULL
;
2228 monitor_ops
.to_close
= monitor_close
;
2229 monitor_ops
.to_attach
= NULL
;
2230 monitor_ops
.to_post_attach
= NULL
;
2231 monitor_ops
.to_require_attach
= NULL
;
2232 monitor_ops
.to_detach
= monitor_detach
;
2233 monitor_ops
.to_require_detach
= NULL
;
2234 monitor_ops
.to_resume
= monitor_resume
;
2235 monitor_ops
.to_wait
= monitor_wait
;
2236 monitor_ops
.to_post_wait
= NULL
;
2237 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2238 monitor_ops
.to_store_registers
= monitor_store_registers
;
2239 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2240 monitor_ops
.to_xfer_memory
= monitor_xfer_memory
;
2241 monitor_ops
.to_files_info
= monitor_files_info
;
2242 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2243 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2244 monitor_ops
.to_terminal_init
= 0;
2245 monitor_ops
.to_terminal_inferior
= 0;
2246 monitor_ops
.to_terminal_ours_for_output
= 0;
2247 monitor_ops
.to_terminal_ours
= 0;
2248 monitor_ops
.to_terminal_info
= 0;
2249 monitor_ops
.to_kill
= monitor_kill
;
2250 monitor_ops
.to_load
= monitor_load
;
2251 monitor_ops
.to_lookup_symbol
= 0;
2252 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2253 monitor_ops
.to_post_startup_inferior
= NULL
;
2254 monitor_ops
.to_acknowledge_created_inferior
= NULL
;
2255 monitor_ops
.to_clone_and_follow_inferior
= NULL
;
2256 monitor_ops
.to_post_follow_inferior_by_clone
= NULL
;
2257 monitor_ops
.to_insert_fork_catchpoint
= NULL
;
2258 monitor_ops
.to_remove_fork_catchpoint
= NULL
;
2259 monitor_ops
.to_insert_vfork_catchpoint
= NULL
;
2260 monitor_ops
.to_remove_vfork_catchpoint
= NULL
;
2261 monitor_ops
.to_has_forked
= NULL
;
2262 monitor_ops
.to_has_vforked
= NULL
;
2263 monitor_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2264 monitor_ops
.to_post_follow_vfork
= NULL
;
2265 monitor_ops
.to_insert_exec_catchpoint
= NULL
;
2266 monitor_ops
.to_remove_exec_catchpoint
= NULL
;
2267 monitor_ops
.to_has_execd
= NULL
;
2268 monitor_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2269 monitor_ops
.to_has_exited
= NULL
;
2270 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2271 monitor_ops
.to_can_run
= 0;
2272 monitor_ops
.to_notice_signals
= 0;
2273 monitor_ops
.to_thread_alive
= 0;
2274 monitor_ops
.to_stop
= monitor_stop
;
2275 monitor_ops
.to_pid_to_exec_file
= NULL
;
2276 monitor_ops
.to_core_file_to_sym_file
= NULL
;
2277 monitor_ops
.to_stratum
= process_stratum
;
2278 monitor_ops
.DONT_USE
= 0;
2279 monitor_ops
.to_has_all_memory
= 1;
2280 monitor_ops
.to_has_memory
= 1;
2281 monitor_ops
.to_has_stack
= 1;
2282 monitor_ops
.to_has_registers
= 1;
2283 monitor_ops
.to_has_execution
= 1;
2284 monitor_ops
.to_sections
= 0;
2285 monitor_ops
.to_sections_end
= 0;
2286 monitor_ops
.to_magic
= OPS_MAGIC
;
2287 } /* init_base_monitor_ops */
2289 /* Init the target_ops structure pointed at by OPS */
2292 init_monitor_ops (ops
)
2293 struct target_ops
*ops
;
2295 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2296 init_base_monitor_ops ();
2298 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2301 /* Define additional commands that are usually only used by monitors. */
2304 _initialize_remote_monitors ()
2306 init_base_monitor_ops ();
2307 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
2309 "Set display of activity while downloading a file.\n\
2310 When enabled, a hashmark \'#\' is displayed.",
2314 add_com ("monitor", class_obscure
, monitor_command
,
2315 "Send a command to the debug monitor.");