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
);
339 monitor_write (sndbuf
, len
);
342 /* monitor_printf -- Send data to monitor and check the echo. Works just like
346 #ifdef ANSI_PROTOTYPES
347 monitor_printf (char *pattern
, ...)
349 monitor_printf (va_alist
)
357 #ifdef ANSI_PROTOTYPES
358 va_start (args
, pattern
);
362 pattern
= va_arg (args
, char *);
365 monitor_vsprintf (sndbuf
, pattern
, args
);
367 len
= strlen (sndbuf
);
368 if (len
+ 1 > sizeof sndbuf
)
372 if (remote_debug
> 0)
373 puts_debug ("sent -->", sndbuf
, "<--");
378 char *safe_string
= (char *) alloca ((len
* 4) + 1);
379 monitor_printable_string (safe_string
, sndbuf
);
380 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 (stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
407 /* Read a binary character from the remote system, doing all the fancy
408 timeout stuff, but without interpreting the character in any way,
409 and without printing remote debug information. */
420 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
423 c
&= 0xff; /* don't lose bit 7 */
430 if (c
== SERIAL_TIMEOUT
)
431 error ("Timeout reading from remote system.");
433 perror_with_name ("remote-monitor");
437 /* Read a character from the remote system, doing all the fancy
445 static enum { last_random
, last_nl
, last_cr
, last_crnl
} state
= last_random
;
451 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
457 /* This seems to interfere with proper function of the
459 if (remote_debug
> 0)
464 puts_debug ("read -->", buf
, "<--");
470 /* Canonicialize \n\r combinations into one \r */
471 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
473 if ((c
== '\r' && state
== last_nl
)
474 || (c
== '\n' && state
== last_cr
))
495 if (c
== SERIAL_TIMEOUT
)
496 #if 0 /* MAINTENANCE_CMDS */
497 /* I fail to see how detaching here can be useful */
498 if (in_monitor_wait
) /* Watchdog went off */
500 target_mourn_inferior ();
501 error ("GDB serial timeout has expired. Target detached.\n");
505 error ("Timeout reading from remote system.");
507 perror_with_name ("remote-monitor");
510 /* Scan input from the remote system, until STRING is found. If BUF is non-
511 zero, then collect input until we have collected either STRING or BUFLEN-1
512 chars. In either case we terminate BUF with a 0. If input overflows BUF
513 because STRING can't be found, return -1, else return number of chars in BUF
514 (minus the terminating NUL). Note that in the non-overflow case, STRING
515 will be at the end of BUF. */
518 monitor_expect (string
, buf
, buflen
)
524 int obuflen
= buflen
;
526 extern struct target_ops
*targ_ops
;
531 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
532 monitor_printable_string (safe_string
, string
);
533 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 (strcmp(targ_ops
->to_shortname
, "m32r") == 0))
578 { /* m32r monitor emits random DC1/DC3 chars */
590 /* Search for a regexp. */
593 monitor_expect_regexp (pat
, buf
, buflen
)
594 struct re_pattern_buffer
*pat
;
600 RDEBUG(("MON Expecting regexp\n")) ;
605 mybuf
= alloca (1024);
614 if (p
- mybuf
>= buflen
)
615 { /* Buffer about to overflow */
617 /* On overflow, we copy the upper half of the buffer to the lower half. Not
618 great, but it usually works... */
620 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
621 p
= mybuf
+ buflen
/ 2;
624 *p
++ = readchar (timeout
);
626 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
632 /* Keep discarding input until we see the MONITOR prompt.
634 The convention for dealing with the prompt is that you
636 o *then* wait for the prompt.
638 Thus the last thing that a procedure does with the serial line will
639 be an monitor_expect_prompt(). Exception: monitor_resume does not
640 wait for the prompt, because the terminal is being handed over to
641 the inferior. However, the next thing which happens after that is
642 a monitor_wait which does wait for the prompt. Note that this
643 includes abnormal exit, e.g. error(). This is necessary to prevent
644 getting into states from which we can't recover. */
647 monitor_expect_prompt (buf
, buflen
)
651 RDEBUG(("MON Expecting prompt\n"))
652 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
655 /* Get N 32-bit words from remote, each preceded by a space, and put
656 them in registers starting at REGNO. */
667 ch
= readchar (timeout
);
672 for (i
= 7; i
>= 1; i
--)
674 ch
= readchar (timeout
);
677 val
= (val
<< 4) | from_hex (ch
);
685 compile_pattern (pattern
, compiled_pattern
, fastmap
)
687 struct re_pattern_buffer
*compiled_pattern
;
693 compiled_pattern
->fastmap
= fastmap
;
695 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
696 val
= re_compile_pattern (pattern
,
702 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern
, val
);
705 re_compile_fastmap (compiled_pattern
);
708 /* Open a connection to a remote debugger. NAME is the filename used
709 for communication. */
712 monitor_open (args
, mon_ops
, from_tty
)
714 struct monitor_ops
*mon_ops
;
720 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
721 error ("Magic number of monitor_ops struct wrong.");
723 targ_ops
= mon_ops
->target
;
724 name
= targ_ops
->to_shortname
;
727 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
728 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
730 target_preopen (from_tty
);
732 /* Setup pattern for register dump */
734 if (mon_ops
->register_pattern
)
735 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
738 if (mon_ops
->getmem
.resp_delim
)
739 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
740 getmem_resp_delim_fastmap
);
742 unpush_target (targ_ops
);
746 dev_name
= strsave (args
);
748 monitor_desc
= SERIAL_OPEN (dev_name
);
751 perror_with_name (dev_name
);
755 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
757 SERIAL_CLOSE (monitor_desc
);
758 perror_with_name (dev_name
);
762 SERIAL_RAW (monitor_desc
);
764 SERIAL_FLUSH_INPUT (monitor_desc
);
766 /* some systems only work with 2 stop bits */
768 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
770 current_monitor
= mon_ops
;
772 /* See if we can wake up the monitor. First, try sending a stop sequence,
773 then send the init strings. Last, remove all breakpoints. */
775 if (current_monitor
->stop
)
778 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
780 RDEBUG(("EXP Open echo\n")) ;
781 monitor_expect_prompt (NULL
, 0);
785 /* wake up the monitor and see if it's alive */
786 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
788 /* Some of the characters we send may not be echoed,
789 but we hope to get a prompt at the end of it all. */
791 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
794 monitor_printf_noecho (*p
);
795 monitor_expect_prompt (NULL
, 0);
798 SERIAL_FLUSH_INPUT (monitor_desc
);
800 /* Remove all breakpoints */
802 if (mon_ops
->clr_all_break
)
804 monitor_printf (mon_ops
->clr_all_break
);
805 monitor_expect_prompt (NULL
, 0);
809 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
811 push_target (targ_ops
);
813 inferior_pid
= 42000; /* Make run command think we are busy... */
815 /* Give monitor_wait something to read */
817 monitor_printf (current_monitor
->line_term
);
819 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
820 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory_block
);
822 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory
);
826 /* Close out all files and local state before this target loses
830 monitor_close (quitting
)
834 SERIAL_CLOSE (monitor_desc
);
838 /* Terminate the open connection to the remote debugger. Use this
839 when you want to detach and do something else with your gdb. */
842 monitor_detach (args
, from_tty
)
846 pop_target (); /* calls monitor_close to do the real work */
848 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
851 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
854 monitor_supply_register (regno
, valstr
)
859 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
862 val
= strtoul (valstr
, &p
, 16);
863 RDEBUG(("Supplying Register %d %s\n",regno
,valstr
)) ;
865 if (val
== 0 && valstr
== p
)
866 error ("monitor_supply_register (%d): bad value from monitor: %s.",
869 /* supply register stores in target byte order, so swap here */
871 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
873 supply_register (regno
, regbuf
);
878 /* Tell the remote machine to resume. */
881 flush_monitor_dcache ()
883 dcache_flush (remote_dcache
);
887 monitor_resume (pid
, step
, sig
)
889 enum target_signal sig
;
891 /* Some monitors require a different command when starting a program */
892 RDEBUG(("MON resume\n")) ;
893 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
896 monitor_printf ("run\r");
897 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
901 dcache_flush (remote_dcache
);
903 monitor_printf (current_monitor
->step
);
906 if (current_monitor
->continue_hook
)
907 (*current_monitor
->continue_hook
)() ;
908 else monitor_printf (current_monitor
->cont
);
909 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
914 /* Parse the output of a register dump command. A monitor specific
915 regexp is used to extract individual register descriptions of the
916 form REG=VAL. Each description is split up into a name and a value
917 string which are passed down to monitor specific code. */
920 parse_register_dump (buf
, len
)
924 RDEBUG(("MON Parsing register dump\n"))
927 int regnamelen
, vallen
;
929 /* Element 0 points to start of register name, and element 1
930 points to the start of the register value. */
931 struct re_registers register_strings
;
933 memset (®ister_strings
, 0, sizeof (struct re_registers
));
935 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
936 ®ister_strings
) == -1)
939 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
940 regname
= buf
+ register_strings
.start
[1];
941 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
942 val
= buf
+ register_strings
.start
[2];
944 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
946 buf
+= register_strings
.end
[0];
947 len
-= register_strings
.end
[0];
951 /* Send ^C to target to halt it. Target will respond, and send us a
955 monitor_interrupt (signo
)
958 /* If this doesn't work, try more severe steps. */
959 signal (signo
, monitor_interrupt_twice
);
962 printf_unfiltered ("monitor_interrupt called\n");
967 /* The user typed ^C twice. */
970 monitor_interrupt_twice (signo
)
973 signal (signo
, ofunc
);
975 monitor_interrupt_query ();
977 signal (signo
, monitor_interrupt
);
980 /* Ask the user what to do when an interrupt is received. */
983 monitor_interrupt_query ()
985 target_terminal_ours ();
987 if (query ("Interrupted while waiting for the program.\n\
988 Give up (and stop debugging it)? "))
990 target_mourn_inferior ();
991 return_to_top_level (RETURN_QUIT
);
994 target_terminal_inferior ();
998 monitor_wait_cleanup (old_timeout
)
1001 timeout
= *(int*)old_timeout
;
1002 signal (SIGINT
, ofunc
);
1003 in_monitor_wait
= 0;
1008 void monitor_wait_filter(char * buf
,
1011 struct target_waitstatus
* status
1017 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1018 * ext_resp_len
=resp_len
;
1021 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1023 while (resp_len
< 0);
1025 /* Print any output characters that were preceded by ^O. */
1026 /* FIXME - This would be great as a user settabgle flag */
1028 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1032 for (i
= 0; i
< resp_len
- 1; i
++)
1034 putchar_unfiltered (buf
[++i
]);
1040 /* Wait until the remote machine stops, then return, storing status in
1041 status just as `wait' would. */
1044 monitor_wait (pid
, status
)
1046 struct target_waitstatus
*status
;
1048 int old_timeout
= timeout
;
1051 struct cleanup
*old_chain
;
1053 status
->kind
= TARGET_WAITKIND_EXITED
;
1054 status
->value
.integer
= 0;
1056 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1057 RDEBUG(("MON wait\n"))
1059 #if 0 /* MAINTENANCE_CMDS */
1060 /* This is somthing other than a maintenance command */
1061 in_monitor_wait
= 1;
1062 timeout
= watchdog
> 0 ? watchdog
: -1;
1064 timeout
= -1; /* Don't time out -- user program is running. */
1067 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1069 if (current_monitor
->wait_filter
)
1070 (*current_monitor
->wait_filter
)(buf
,sizeof (buf
),&resp_len
,status
) ;
1071 else monitor_wait_filter(buf
,sizeof (buf
),&resp_len
,status
) ;
1073 #if 0 /* Transferred to monitor wait filter */
1076 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1079 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1081 while (resp_len
< 0);
1083 /* Print any output characters that were preceded by ^O. */
1084 /* FIXME - This would be great as a user settabgle flag */
1086 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1090 for (i
= 0; i
< resp_len
- 1; i
++)
1092 putchar_unfiltered (buf
[++i
]);
1096 signal (SIGINT
, ofunc
);
1098 timeout
= old_timeout
;
1100 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1103 monitor_printf (current_monitor
->dump_registers
);
1104 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1107 if (current_monitor
->register_pattern
)
1108 parse_register_dump (buf
, resp_len
);
1110 RDEBUG(("Wait fetching registers after stop\n")) ;
1111 monitor_dump_regs() ;
1114 status
->kind
= TARGET_WAITKIND_STOPPED
;
1115 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1117 discard_cleanups (old_chain
);
1119 in_monitor_wait
= 0;
1121 return inferior_pid
;
1124 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1128 monitor_fetch_register (regno
)
1132 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] = {0};
1133 char regbuf
[MAX_REGISTER_RAW_SIZE
* 2 + 1];
1136 name
= current_monitor
->regnames
[regno
];
1137 RDEBUG(("MON fetchreg %d '%s'\n",regno
,name
))
1139 if (!name
|| (*name
== '\0'))
1140 { RDEBUG(("No register known for %d\n",regno
))
1141 supply_register (regno
, zerobuf
);
1145 /* send the register examine command */
1147 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1149 /* If RESP_DELIM is specified, we search for that as a leading
1150 delimiter for the register value. Otherwise, we just start
1151 searching from the start of the buf. */
1153 if (current_monitor
->getreg
.resp_delim
)
1155 RDEBUG(("EXP getreg.resp_delim\n"))
1156 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1157 /* Handle case of first 32 registers listed in pairs. */
1158 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1159 && regno
& 1 == 1 && regno
< 32)
1160 { RDEBUG(("EXP getreg.resp_delim\n")) ;
1161 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1165 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1166 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1169 c
= readchar (timeout
);
1171 c
= readchar (timeout
);
1172 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1175 error ("Bad value returned from monitor while fetching register %x.",
1179 /* Read upto the maximum number of hex digits for this register, skipping
1180 spaces, but stop reading if something else is seen. Some monitors
1181 like to drop leading zeros. */
1183 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
1186 c
= readchar (timeout
);
1188 c
= readchar (timeout
);
1196 regbuf
[i
] = '\000'; /* terminate the number */
1197 RDEBUG(("REGVAL '%s'\n",regbuf
)) ;
1199 /* If TERM is present, we wait for that to show up. Also, (if TERM
1200 is present), we will send TERM_CMD if that is present. In any
1201 case, we collect all of the output into buf, and then wait for
1202 the normal prompt. */
1204 if (current_monitor
->getreg
.term
)
1206 RDEBUG(("EXP getreg.term\n"))
1207 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1210 if (current_monitor
->getreg
.term_cmd
)
1211 { RDEBUG(("EMIT getreg.term.cmd\n"))
1212 monitor_printf (current_monitor
->getreg
.term_cmd
);
1214 if (! current_monitor
->getreg
.term
|| /* Already expected or */
1215 current_monitor
->getreg
.term_cmd
) /* ack expected */
1216 monitor_expect_prompt (NULL
, 0); /* get response */
1218 monitor_supply_register (regno
, regbuf
);
1221 /* Sometimes, it takes several commands to dump the registers */
1222 /* This is a primitive for use by variations of monitor interfaces in
1223 case they need to compose the operation.
1225 int monitor_dump_reg_block(char * block_cmd
)
1229 monitor_printf (block_cmd
);
1230 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1231 parse_register_dump (buf
, resp_len
);
1236 /* Read the remote registers into the block regs. */
1237 /* Call the specific function if it has been provided */
1240 monitor_dump_regs ()
1244 if (current_monitor
->dumpregs
)
1245 (*(current_monitor
->dumpregs
))() ; /* call supplied function */
1247 if (current_monitor
->dump_registers
) /* default version */
1248 { monitor_printf (current_monitor
->dump_registers
);
1249 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1250 parse_register_dump (buf
, resp_len
);
1253 abort(); /* Need some way to read registers */
1257 monitor_fetch_registers (regno
)
1260 RDEBUG(("MON fetchregs\n")) ;
1261 if (current_monitor
->getreg
.cmd
)
1265 monitor_fetch_register (regno
);
1269 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1270 monitor_fetch_register (regno
);
1273 monitor_dump_regs ();
1277 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1280 monitor_store_register (regno
)
1286 name
= current_monitor
->regnames
[regno
];
1287 if (!name
|| (*name
== '\0'))
1288 { RDEBUG(("MON Cannot store unknown register\n"))
1292 val
= read_register (regno
);
1293 RDEBUG(("MON storeg %d %08x\n",regno
,(unsigned int)val
))
1295 /* send the register deposit command */
1297 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1298 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1299 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1300 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1302 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1304 if (current_monitor
->setreg
.term
)
1305 { RDEBUG(("EXP setreg.term\n"))
1306 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1307 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1308 monitor_printf ("%x\r", val
);
1309 monitor_expect_prompt (NULL
, 0);
1312 monitor_expect_prompt (NULL
, 0);
1313 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1314 { RDEBUG(("EXP setreg_termcmd\n")) ;
1315 monitor_printf("%s",current_monitor
->setreg
.term_cmd
) ;
1316 monitor_expect_prompt(NULL
,0) ;
1318 } /* monitor_store_register */
1320 /* Store the remote registers. */
1323 monitor_store_registers (regno
)
1328 monitor_store_register (regno
);
1332 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1333 monitor_store_register (regno
);
1336 /* Get ready to modify the registers array. On machines which store
1337 individual registers, this doesn't need to do anything. On machines
1338 which store all the registers in one fell swoop, this makes sure
1339 that registers contains all the registers from the program being
1343 monitor_prepare_to_store ()
1345 /* Do nothing, since we can store individual regs */
1349 monitor_files_info (ops
)
1350 struct target_ops
*ops
;
1352 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1356 monitor_write_memory (memaddr
, myaddr
, len
)
1361 unsigned int val
, hostval
;
1365 RDEBUG(("MON write %d %08x\n",len
,(unsigned long)memaddr
))
1367 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1368 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1370 /* Use memory fill command for leading 0 bytes. */
1372 if (current_monitor
->fill
)
1374 for (i
= 0; i
< len
; i
++)
1378 if (i
> 4) /* More than 4 zeros is worth doing */
1380 RDEBUG(("MON FILL %d\n",i
))
1381 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1382 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
)-1, 0);
1384 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1386 monitor_expect_prompt (NULL
, 0);
1393 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1394 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1397 cmd
= current_monitor
->setmem
.cmdll
;
1401 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1404 cmd
= current_monitor
->setmem
.cmdl
;
1406 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1409 cmd
= current_monitor
->setmem
.cmdw
;
1414 cmd
= current_monitor
->setmem
.cmdb
;
1417 val
= extract_unsigned_integer (myaddr
, len
);
1420 { hostval
= * (unsigned int *) myaddr
;
1421 RDEBUG(("Hostval(%08x) val(%08x)\n",hostval
,val
)) ;
1425 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1426 monitor_printf_noecho (cmd
, memaddr
, val
);
1427 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1430 monitor_printf_noecho (cmd
, memaddr
);
1432 if (current_monitor
->setmem
.term
)
1433 { RDEBUG(("EXP setmem.term")) ;
1434 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1435 monitor_printf ("%x\r", val
);
1437 if (current_monitor
->setmem
.term_cmd
)
1438 { /* Emit this to get out of the memory editing state */
1439 monitor_printf("%s",current_monitor
->setmem
.term_cmd
) ;
1440 /* Drop through to expecting a prompt */
1444 monitor_printf (cmd
, memaddr
, val
);
1446 monitor_expect_prompt (NULL
, 0);
1453 monitor_write_even_block(memaddr
,myaddr
,len
)
1460 /* Enter the sub mode */
1461 monitor_printf(current_monitor
->setmem
.cmdl
,memaddr
) ;
1462 monitor_expect_prompt(NULL
,0) ;
1466 val
= extract_unsigned_integer(myaddr
,4) ; /* REALLY */
1467 monitor_printf("%x\r",val
) ;
1471 RDEBUG((" @ %08x\n",memaddr
))
1472 /* If we wanted to, here we could validate the address */
1473 monitor_expect_prompt(NULL
,0) ;
1475 /* Now exit the sub mode */
1476 monitor_printf (current_monitor
->getreg
.term_cmd
);
1477 monitor_expect_prompt(NULL
,0) ;
1482 static int monitor_write_memory_bytes(memaddr
,myaddr
,len
)
1489 if (len
== 0) return 0 ;
1490 /* Enter the sub mode */
1491 monitor_printf(current_monitor
->setmem
.cmdb
,memaddr
) ;
1492 monitor_expect_prompt(NULL
,0) ;
1496 monitor_printf("%x\r",val
) ;
1500 /* If we wanted to, here we could validate the address */
1501 monitor_expect_prompt(NULL
,0) ;
1504 /* Now exit the sub mode */
1505 monitor_printf (current_monitor
->getreg
.term_cmd
);
1506 monitor_expect_prompt(NULL
,0) ;
1512 longlongendswap (unsigned char * a
)
1524 /* Format 32 chars of long long value, advance the pointer */
1525 static char * hexlate
= "0123456789abcdef" ;
1526 static char * longlong_hexchars(unsigned long long value
,
1529 if (value
== 0) { *outbuff
++ = '0' ; return outbuff
; }
1531 { static unsigned char disbuf
[8] ; /* disassembly buffer */
1532 unsigned char * scan
, * limit
; /* loop controls */
1533 unsigned char c
, nib
;
1535 scan
= disbuf
; limit
= scan
+ 8 ;
1536 { unsigned long long * dp
;
1537 dp
= (unsigned long long *) scan
;
1540 longlongendswap(disbuf
) ; /* FIXME: ONly on big endian hosts */
1541 while (scan
< limit
)
1542 { c
= *scan
++ ; /* a byte of our long long value */
1544 if (c
== 0) continue ;
1545 else leadzero
= 0 ; /* henceforth we print even zeroes */
1546 nib
= c
>> 4 ; /* high nibble bits */
1547 *outbuff
++ = hexlate
[nib
] ;
1548 nib
= c
& 0x0f ; /* low nibble bits */
1549 *outbuff
++ = hexlate
[nib
] ;
1553 } /* longlong_hexchars */
1557 /* I am only going to call this when writing virtual byte streams.
1558 Which possably entails endian conversions
1560 static int monitor_write_memory_longlongs(memaddr
,myaddr
,len
)
1565 static char hexstage
[20] ; /* At least 16 digits required, plus null */
1570 llptr
= (unsigned long long *) myaddr
;
1571 if (len
== 0 ) return 0 ;
1572 monitor_printf(current_monitor
->setmem
.cmdll
,memaddr
) ;
1573 monitor_expect_prompt(NULL
,0) ;
1577 endstring
= longlong_hexchars(*llptr
,hexstage
) ;
1578 *endstring
= '\0' ; /* NUll terminate for printf */
1579 monitor_printf("%s\r",hexstage
) ;
1583 /* If we wanted to, here we could validate the address */
1584 monitor_expect_prompt(NULL
,0) ;
1587 /* Now exit the sub mode */
1588 monitor_printf (current_monitor
->getreg
.term_cmd
);
1589 monitor_expect_prompt(NULL
,0) ;
1595 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1596 /* This is for the large blocks of memory which may occur in downloading.
1597 And for monitors which use interactive entry,
1598 And for monitors which do not have other downloading methods.
1599 Without this, we will end up calling monitor_write_memory many times
1600 and do the entry and exit of the sub mode many times
1601 This currently assumes...
1602 MO_SETMEM_INTERACTIVE
1603 ! MO_NO_ECHO_ON_SETMEM
1604 To use this, the you have to patch the monitor_cmds block with
1605 this function. Otherwise, its not tuned up for use by all
1609 static int monitor_write_memory_block(memaddr
,myaddr
,len
)
1616 /* FIXME: This would be a good place to put the zero test */
1618 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1620 return monitor_write_memory_longlongs(memaddr
,myaddr
,len
) ;
1627 written
= monitor_write_even_block(memaddr
,myaddr
,len
) ;
1628 /* Adjust calling parameters by written amount */
1629 memaddr
+= written
;
1634 written
= monitor_write_memory_bytes(memaddr
,myaddr
,len
) ;
1638 /* This is an alternate form of monitor_read_memory which is used for monitors
1639 which can only read a single byte/word/etc. at a time. */
1642 monitor_read_memory_single (memaddr
, myaddr
, len
)
1648 char membuf
[sizeof(int) * 2 + 1];
1653 RDEBUG(("MON read single\n")) ;
1655 /* Can't actually use long longs (nice idea, though). In fact, the
1656 call to strtoul below will fail if it tries to convert a value
1657 that's too big to fit in a long. */
1658 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1661 cmd
= current_monitor
->getmem
.cmdll
;
1665 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1668 cmd
= current_monitor
->getmem
.cmdl
;
1670 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1673 cmd
= current_monitor
->getmem
.cmdw
;
1678 cmd
= current_monitor
->getmem
.cmdb
;
1681 /* Send the examine command. */
1683 monitor_printf (cmd
, memaddr
);
1685 /* If RESP_DELIM is specified, we search for that as a leading
1686 delimiter for the memory value. Otherwise, we just start
1687 searching from the start of the buf. */
1689 if (current_monitor
->getmem
.resp_delim
)
1690 { RDEBUG(("EXP getmem.resp_delim\n")) ;
1691 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1694 /* Now, read the appropriate number of hex digits for this loc,
1697 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1698 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1702 c
= readchar (timeout
);
1704 c
= readchar (timeout
);
1705 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1708 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1709 memaddr
, i
, membuf
, c
);
1711 for (i
= 0; i
< len
* 2; i
++)
1717 c
= readchar (timeout
);
1723 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1724 memaddr
, i
, membuf
, c
);
1730 membuf
[i
] = '\000'; /* terminate the number */
1732 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1733 present), we will send TERM_CMD if that is present. In any case, we collect
1734 all of the output into buf, and then wait for the normal prompt. */
1736 if (current_monitor
->getmem
.term
)
1738 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1740 if (current_monitor
->getmem
.term_cmd
)
1742 monitor_printf (current_monitor
->getmem
.term_cmd
);
1743 monitor_expect_prompt (NULL
, 0);
1747 monitor_expect_prompt (NULL
, 0); /* get response */
1750 val
= strtoul (membuf
, &p
, 16);
1752 if (val
== 0 && membuf
== p
)
1753 monitor_error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
1754 memaddr
, 0, membuf
, 0);
1756 /* supply register stores in target byte order, so swap here */
1758 store_unsigned_integer (myaddr
, len
, val
);
1763 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1764 memory at MEMADDR. Returns length moved. Currently, we do no more
1765 than 16 bytes at a time. */
1768 monitor_read_memory (memaddr
, myaddr
, len
)
1782 RDEBUG (("Zero length call to monitor_read_memory\n"));
1786 if (remote_debug
) printf("MON read block ta(%08x) ha(%08x) %d\n",
1787 (unsigned long) memaddr
, (unsigned long)myaddr
, len
);
1789 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1790 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1792 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1793 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1795 len
= min (len
, 16);
1797 /* Some dumpers align the first data with the preceeding 16
1798 byte boundary. Some print blanks and start at the
1799 requested boundary. EXACT_DUMPADDR
1802 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1803 ? memaddr
: memaddr
& ~ 0x0f ;
1805 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1806 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1807 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1809 /* send the memory examine command */
1811 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1812 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
- 1);
1813 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1814 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1816 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1818 /* If TERM is present, we wait for that to show up. Also, (if TERM
1819 is present), we will send TERM_CMD if that is present. In any
1820 case, we collect all of the output into buf, and then wait for
1821 the normal prompt. */
1823 if (current_monitor
->getmem
.term
)
1825 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1828 monitor_error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
1829 memaddr
, resp_len
, buf
, 0);
1831 if (current_monitor
->getmem
.term_cmd
)
1833 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1834 strlen (current_monitor
->getmem
.term_cmd
));
1835 monitor_expect_prompt (NULL
, 0);
1839 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1843 /* If RESP_DELIM is specified, we search for that as a leading
1844 delimiter for the values. Otherwise, we just start searching
1845 from the start of the buf. */
1847 if (current_monitor
->getmem
.resp_delim
)
1850 struct re_registers resp_strings
;
1851 RDEBUG(("MON getmem.resp_delim %s\n",current_monitor
->getmem
.resp_delim
)) ;
1853 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1855 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1859 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1860 memaddr
, resp_len
, buf
, 0);
1862 p
+= resp_strings
.end
[0];
1864 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1866 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1867 memaddr
, resp_len
, buf
, 0);
1868 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1871 if (remote_debug
) printf("MON scanning %d ,%08x '%s'\n",len
,p
,p
) ;
1872 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1880 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1882 { if ((dumpaddr
>= memaddr
) && (i
> 0))
1883 { val
= fromhex (c
) * 16 + fromhex (*(p
+1));
1885 if (remote_debug
) printf("[%02x]",val
) ;
1892 ++p
; /* skip a blank or other non hex char */
1895 if (fetched
== 0) error("Failed to read via monitor") ;
1896 if (remote_debug
) printf("\n") ;
1897 return fetched
; /* Return the number of bytes actually read */
1899 RDEBUG(("MON scanning bytes\n")) ;
1901 for (i
= len
; i
> 0; i
--)
1903 /* Skip non-hex chars, but bomb on end of string and newlines */
1910 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1911 monitor_error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s",
1912 memaddr
, resp_len
, buf
, 0);
1916 val
= strtoul (p
, &p1
, 16);
1918 if (val
== 0 && p
== p1
)
1919 monitor_error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.",
1920 memaddr
, resp_len
, buf
, 0);
1934 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1939 struct target_ops
*target
; /* ignored */
1941 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, write
);
1947 return; /* ignore attempts to kill target system */
1950 /* All we actually do is set the PC to the start address of exec_bfd, and start
1951 the program at that point. */
1954 monitor_create_inferior (exec_file
, args
, env
)
1959 if (args
&& (*args
!= '\000'))
1960 error ("Args are not supported by the monitor.");
1963 clear_proceed_status ();
1964 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1967 /* Clean up when a program exits.
1968 The program actually lives on in the remote processor's RAM, and may be
1969 run again without a download. Don't leave it full of breakpoint
1973 monitor_mourn_inferior ()
1975 unpush_target (targ_ops
);
1976 generic_mourn_inferior (); /* Do all the proper things now */
1979 #define NUM_MONITOR_BREAKPOINTS 8
1981 static CORE_ADDR breakaddr
[NUM_MONITOR_BREAKPOINTS
] = {0};
1983 /* Tell the monitor to add a breakpoint. */
1986 monitor_insert_breakpoint (addr
, shadow
)
1994 RDEBUG(("MON inst bkpt %08x\n",addr
))
1995 if (current_monitor
->set_break
== NULL
)
1996 error ("No set_break defined for this monitor");
1998 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1999 addr
= ADDR_BITS_REMOVE (addr
);
2001 /* Determine appropriate breakpoint size for this address. */
2002 bp
= memory_breakpoint_from_pc (&addr
, &bplen
);
2004 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
2006 if (breakaddr
[i
] == 0)
2008 breakaddr
[i
] = addr
;
2009 monitor_read_memory (addr
, shadow
, bplen
);
2010 monitor_printf (current_monitor
->set_break
, addr
);
2011 monitor_expect_prompt (NULL
, 0);
2016 error ("Too many breakpoints (> %d) for monitor.", NUM_MONITOR_BREAKPOINTS
);
2019 /* Tell the monitor to remove a breakpoint. */
2022 monitor_remove_breakpoint (addr
, shadow
)
2028 RDEBUG(("MON rmbkpt %08x\n",addr
))
2029 if (current_monitor
->clr_break
== NULL
)
2030 error ("No clr_break defined for this monitor");
2032 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2033 addr
= ADDR_BITS_REMOVE (addr
);
2035 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
2037 if (breakaddr
[i
] == addr
)
2040 /* some monitors remove breakpoints based on the address */
2041 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2042 monitor_printf (current_monitor
->clr_break
, addr
);
2043 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2044 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2046 monitor_printf (current_monitor
->clr_break
, i
);
2047 monitor_expect_prompt (NULL
, 0);
2051 fprintf_unfiltered (stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
2055 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2056 an S-record. Return non-zero if the ACK is received properly. */
2059 monitor_wait_srec_ack ()
2063 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2065 return (readchar (timeout
) == '+');
2067 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2069 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2070 if ((ch
= readchar (1)) < 0)
2072 if ((ch
= readchar (1)) < 0)
2074 if ((ch
= readchar (1)) < 0)
2076 if ((ch
= readchar (1)) < 0)
2082 /* monitor_load -- download a file. */
2085 monitor_load (file
, from_tty
)
2089 dcache_flush (remote_dcache
);
2090 RDEBUG(("MON load\n"))
2092 if (current_monitor
->load_routine
)
2093 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2095 { /* The default is ascii S-records */
2097 unsigned long load_offset
;
2100 /* enable user to specify address for downloading as 2nd arg to load */
2101 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2107 monitor_printf (current_monitor
->load
);
2108 if (current_monitor
->loadresp
)
2109 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2111 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2112 32, SREC_ALL
, hashmark
,
2113 current_monitor
->flags
& MO_SREC_ACK
?
2114 monitor_wait_srec_ack
: NULL
);
2116 monitor_expect_prompt (NULL
, 0);
2119 /* Finally, make the PC point at the start address */
2122 write_pc (bfd_get_start_address (exec_bfd
));
2124 inferior_pid
= 0; /* No process now */
2126 /* This is necessary because many things were based on the PC at the time that
2127 we attached to the monitor, which is no longer valid now that we have loaded
2128 new code (and just changed the PC). Another way to do this might be to call
2129 normal_stop, except that the stack may not be valid, and things would get
2130 horribly confused... */
2132 clear_symtab_users ();
2138 RDEBUG(("MON stop\n")) ;
2139 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2140 SERIAL_SEND_BREAK (monitor_desc
);
2141 if (current_monitor
->stop
)
2142 monitor_printf_noecho (current_monitor
->stop
);
2145 /* Put a command string, in args, out to MONITOR. Output from MONITOR
2146 is placed on the users terminal until the prompt is seen. FIXME: We
2147 read the characters ourseleves here cause of a nasty echo. */
2150 monitor_command (args
, from_tty
)
2158 if (monitor_desc
== NULL
)
2159 error ("monitor target not open.");
2161 p
= current_monitor
->prompt
;
2163 /* Send the command. Note that if no args were supplied, then we're
2164 just sending the monitor a newline, which is sometimes useful. */
2166 monitor_printf ("%s\r", (args
? args
: ""));
2168 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2170 fputs_unfiltered (buf
, gdb_stdout
); /* Output the response */
2173 /* Convert hex digit A to a number. */
2180 if (a
>= '0' && a
<= '9')
2182 if (a
>= 'a' && a
<= 'f')
2183 return a
- 'a' + 10;
2184 if (a
>= 'A' && a
<= 'F')
2185 return a
- 'A' + 10;
2187 error ("Reply contains invalid hex digit 0x%x", a
);
2192 monitor_get_dev_name ()
2197 static struct target_ops monitor_ops
;
2199 static void init_base_monitor_ops(void)
2201 monitor_ops
.to_shortname
= NULL
;
2202 monitor_ops
.to_longname
= NULL
;
2203 monitor_ops
.to_doc
= NULL
;
2204 monitor_ops
.to_open
= NULL
;
2205 monitor_ops
.to_close
= monitor_close
;
2206 monitor_ops
.to_attach
= NULL
;
2207 monitor_ops
.to_detach
= monitor_detach
;
2208 monitor_ops
.to_resume
= monitor_resume
;
2209 monitor_ops
.to_wait
= monitor_wait
;
2210 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2211 monitor_ops
.to_store_registers
= monitor_store_registers
;
2212 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2213 monitor_ops
.to_xfer_memory
= monitor_xfer_memory
;
2214 monitor_ops
.to_files_info
= monitor_files_info
;
2215 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2216 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2217 monitor_ops
.to_terminal_init
= 0;
2218 monitor_ops
.to_terminal_inferior
= 0;
2219 monitor_ops
.to_terminal_ours_for_output
= 0;
2220 monitor_ops
.to_terminal_ours
= 0;
2221 monitor_ops
.to_terminal_info
= 0;
2222 monitor_ops
.to_kill
= monitor_kill
;
2223 monitor_ops
.to_load
= monitor_load
;
2224 monitor_ops
.to_lookup_symbol
= 0;
2225 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2226 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2227 monitor_ops
.to_can_run
= 0;
2228 monitor_ops
.to_notice_signals
= 0;
2229 monitor_ops
.to_thread_alive
= 0;
2230 monitor_ops
.to_stop
= monitor_stop
;
2231 monitor_ops
.to_stratum
= process_stratum
;
2232 monitor_ops
.DONT_USE
= 0;
2233 monitor_ops
.to_has_all_memory
= 1;
2234 monitor_ops
.to_has_memory
= 1;
2235 monitor_ops
.to_has_stack
= 1;
2236 monitor_ops
.to_has_registers
= 1;
2237 monitor_ops
.to_has_execution
= 1;
2238 monitor_ops
.to_sections
= 0;
2239 monitor_ops
.to_sections_end
= 0;
2240 monitor_ops
.to_magic
= OPS_MAGIC
;
2241 } /* init_monitor_ops */
2243 /* Init the target_ops structure pointed at by OPS */
2246 init_monitor_ops (ops
)
2247 struct target_ops
*ops
;
2249 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2252 /* Define additional commands that are usually only used by monitors. */
2255 _initialize_remote_monitors ()
2257 init_base_monitor_ops() ;
2258 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
2260 "Set display of activity while downloading a file.\n\
2261 When enabled, a hashmark \'#\' is displayed.",
2265 add_com ("monitor", class_obscure
, monitor_command
,
2266 "Send a command to the debug monitor.");