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 void monitor_detach
PARAMS ((char *args
, int from_tty
));
75 static void monitor_resume
PARAMS ((int pid
, int step
, enum target_signal sig
));
76 static void monitor_interrupt
PARAMS ((int signo
));
77 static void monitor_interrupt_twice
PARAMS ((int signo
));
78 static void monitor_interrupt_query
PARAMS ((void));
79 static void monitor_wait_cleanup
PARAMS ((void *old_timeout
));
81 static int monitor_wait
PARAMS ((int pid
, struct target_waitstatus
*status
));
82 static void monitor_fetch_registers
PARAMS ((int regno
));
83 static void monitor_store_registers
PARAMS ((int regno
));
84 static void monitor_prepare_to_store
PARAMS ((void));
85 static int monitor_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
, int len
, int write
, struct target_ops
*target
));
86 static void monitor_files_info
PARAMS ((struct target_ops
*ops
));
87 static int monitor_insert_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
88 static int monitor_remove_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
89 static void monitor_kill
PARAMS ((void));
90 static void monitor_load
PARAMS ((char *file
, int from_tty
));
91 static void monitor_mourn_inferior
PARAMS ((void));
92 static void monitor_stop
PARAMS ((void));
94 static int monitor_read_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
,int len
));
95 static int monitor_write_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
,int len
));
96 static int monitor_write_memory_bytes
PARAMS ((CORE_ADDR addr
,
97 char *myaddr
,int len
));
98 static int monitor_write_memory_block
PARAMS((
102 static int monitor_expect_regexp
PARAMS ((struct re_pattern_buffer
*pat
,
103 char *buf
, int buflen
));
104 static void monitor_dump_regs
PARAMS((void)) ;
106 static int from_hex
PARAMS ((int a
));
107 static unsigned long get_hex_word
PARAMS ((void));
109 static void parse_register_dump
PARAMS ((char *, int));
111 static struct monitor_ops
*current_monitor
;
113 static int hashmark
; /* flag set by "set hash" */
115 static int timeout
= 30;
117 static int in_monitor_wait
= 0; /* Non-zero means we are in monitor_wait() */
119 static void (*ofunc
)(); /* Old SIGINT signal handler */
121 /* Extra remote debugging for developing a new rom monitor variation */
122 #if ! defined(EXTRA_RDEBUG)
123 #define EXTRA_RDEBUG 0
126 #define RDEBUG(stuff) { if (remote_debug) printf stuff ; }
128 #define RDEBUG(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 hex digit A to a number. */
158 if (a
>= '0' && a
<= '9')
160 else if (a
>= 'a' && a
<= 'f')
163 if (a
>= 'A' && a
<= 'F')
164 return a
- 'A' + 10 ;
165 else error ("Invalid hex digit %d", a
);
168 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
170 This function exists to get around the problem that many host platforms
171 don't have a printf that can print 64-bit addresses. The %A format
172 specification is recognized as a special case, and causes the argument
173 to be printed as a 64-bit hexadecimal address.
175 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
176 If it is a '%s' format, the argument is a string; otherwise the
177 argument is assumed to be a long integer.
179 %% is also turned into a single %.
183 monitor_vsprintf (sndbuf
, pattern
, args
)
196 for (p
= pattern
; *p
; p
++)
200 /* Copy the format specifier to a separate buffer. */
202 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
205 format
[i
] = fmt
= *p
;
208 /* Fetch the next argument and print it. */
212 strcpy (sndbuf
, "%");
215 arg_addr
= va_arg (args
, CORE_ADDR
);
216 strcpy (sndbuf
, paddr_nz (arg_addr
));
219 arg_string
= va_arg (args
, char *);
220 sprintf (sndbuf
, format
, arg_string
);
223 arg_int
= va_arg (args
, long);
224 sprintf (sndbuf
, format
, arg_int
);
227 sndbuf
+= strlen (sndbuf
);
236 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
237 Works just like printf. */
240 #ifdef ANSI_PROTOTYPES
241 monitor_printf_noecho (char *pattern
, ...)
243 monitor_printf_noecho (va_alist
)
252 va_start (args
, pattern
);
256 pattern
= va_arg (args
, char *);
259 monitor_vsprintf (sndbuf
, pattern
, args
);
262 if (remote_debug
> 0)
263 puts_debug ("sent -->", sndbuf
, "<--");
265 RDEBUG(("sent[%s]\n",sndbuf
)) ;
267 len
= strlen (sndbuf
);
269 if (len
+ 1 > sizeof sndbuf
)
272 monitor_write (sndbuf
, len
);
275 /* monitor_printf -- Send data to monitor and check the echo. Works just like
279 #ifdef ANSI_PROTOTYPES
280 monitor_printf (char *pattern
, ...)
282 monitor_printf (va_alist
)
290 #ifdef ANSI_PROTOTYPES
291 va_start (args
, pattern
);
295 pattern
= va_arg (args
, char *);
298 monitor_vsprintf (sndbuf
, pattern
, args
);
301 if (remote_debug
> 0)
302 puts_debug ("sent -->", sndbuf
, "<--");
304 RDEBUG(("sent[%s]\n",sndbuf
))
305 len
= strlen (sndbuf
);
306 if (len
+ 1 > sizeof sndbuf
)
309 monitor_write (sndbuf
, len
);
311 /* We used to expect that the next immediate output was the characters we
312 just output, but sometimes some extra junk appeared before the characters
313 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
314 So, just start searching for what we sent, and skip anything unknown. */
315 RDEBUG(("ExpectEcho\n"))
316 monitor_expect (sndbuf
, (char *)0, 0);
320 /* Write characters to the remote system. */
323 monitor_write (buf
, buflen
)
327 if (SERIAL_WRITE(monitor_desc
, buf
, buflen
))
328 fprintf_unfiltered (stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
332 /* Read a binary character from the remote system, doing all the fancy
333 timeout stuff, but without interpreting the character in any way,
334 and without printing remote debug information. */
345 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
348 c
&= 0xff; /* don't lose bit 7 */
355 if (c
== SERIAL_TIMEOUT
)
356 error ("Timeout reading from remote system.");
358 perror_with_name ("remote-monitor");
362 /* Read a character from the remote system, doing all the fancy
370 static enum { last_random
, last_nl
, last_cr
, last_crnl
} state
= last_random
;
376 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
382 /* This seems to interfere with proper function of the
384 if (remote_debug
> 0)
389 puts_debug ("read -->", buf
, "<--");
395 /* Canonicialize \n\r combinations into one \r */
396 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
398 if ((c
== '\r' && state
== last_nl
)
399 || (c
== '\n' && state
== last_cr
))
420 if (c
== SERIAL_TIMEOUT
)
421 #if 0 /* MAINTENANCE_CMDS */
422 /* I fail to see how detaching here can be useful
423 if (in_monitor_wait) /* Watchdog went off */
425 target_mourn_inferior ();
426 error ("GDB serial timeout has expired. Target detached.\n");
430 error ("Timeout reading from remote system.");
432 perror_with_name ("remote-monitor");
435 /* Scan input from the remote system, until STRING is found. If BUF is non-
436 zero, then collect input until we have collected either STRING or BUFLEN-1
437 chars. In either case we terminate BUF with a 0. If input overflows BUF
438 because STRING can't be found, return -1, else return number of chars in BUF
439 (minus the terminating NUL). Note that in the non-overflow case, STRING
440 will be at the end of BUF. */
443 monitor_expect (string
, buf
, buflen
)
449 int obuflen
= buflen
;
451 extern struct target_ops
*targ_ops
;
452 RDEBUG(("MON Expecting '%s'\n",string
)) ;
466 c
= readchar (timeout
);
473 c
= readchar (timeout
);
475 /* Don't expect any ^C sent to be echoed */
477 if (*p
== '\003' || c
== *p
)
487 return obuflen
- buflen
;
493 else if ((c
== '\021' || c
== '\023') &&
494 (strcmp(targ_ops
->to_shortname
, "m32r") == 0))
495 { /* m32r monitor emits random DC1/DC3 chars */
507 /* Search for a regexp. */
510 monitor_expect_regexp (pat
, buf
, buflen
)
511 struct re_pattern_buffer
*pat
;
517 RDEBUG(("MON Expecting regexp\n")) ;
522 mybuf
= alloca (1024);
531 if (p
- mybuf
>= buflen
)
532 { /* Buffer about to overflow */
534 /* On overflow, we copy the upper half of the buffer to the lower half. Not
535 great, but it usually works... */
537 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
538 p
= mybuf
+ buflen
/ 2;
541 *p
++ = readchar (timeout
);
543 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
549 /* Keep discarding input until we see the MONITOR prompt.
551 The convention for dealing with the prompt is that you
553 o *then* wait for the prompt.
555 Thus the last thing that a procedure does with the serial line will
556 be an monitor_expect_prompt(). Exception: monitor_resume does not
557 wait for the prompt, because the terminal is being handed over to
558 the inferior. However, the next thing which happens after that is
559 a monitor_wait which does wait for the prompt. Note that this
560 includes abnormal exit, e.g. error(). This is necessary to prevent
561 getting into states from which we can't recover. */
564 monitor_expect_prompt (buf
, buflen
)
568 RDEBUG(("MON Expecting prompt\n"))
569 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
572 /* Get N 32-bit words from remote, each preceded by a space, and put
573 them in registers starting at REGNO. */
584 ch
= readchar (timeout
);
589 for (i
= 7; i
>= 1; i
--)
591 ch
= readchar (timeout
);
594 val
= (val
<< 4) | from_hex (ch
);
602 compile_pattern (pattern
, compiled_pattern
, fastmap
)
604 struct re_pattern_buffer
*compiled_pattern
;
610 compiled_pattern
->fastmap
= fastmap
;
612 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
613 val
= re_compile_pattern (pattern
,
619 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern
, val
);
622 re_compile_fastmap (compiled_pattern
);
625 /* Open a connection to a remote debugger. NAME is the filename used
626 for communication. */
629 monitor_open (args
, mon_ops
, from_tty
)
631 struct monitor_ops
*mon_ops
;
637 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
638 error ("Magic number of monitor_ops struct wrong.");
640 targ_ops
= mon_ops
->target
;
641 name
= targ_ops
->to_shortname
;
644 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
645 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
647 target_preopen (from_tty
);
649 /* Setup pattern for register dump */
651 if (mon_ops
->register_pattern
)
652 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
655 if (mon_ops
->getmem
.resp_delim
)
656 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
657 getmem_resp_delim_fastmap
);
659 unpush_target (targ_ops
);
663 dev_name
= strsave (args
);
665 monitor_desc
= SERIAL_OPEN (dev_name
);
668 perror_with_name (dev_name
);
672 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
674 SERIAL_CLOSE (monitor_desc
);
675 perror_with_name (dev_name
);
679 SERIAL_RAW (monitor_desc
);
681 SERIAL_FLUSH_INPUT (monitor_desc
);
683 /* some systems only work with 2 stop bits */
685 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
687 current_monitor
= mon_ops
;
689 /* See if we can wake up the monitor. First, try sending a stop sequence,
690 then send the init strings. Last, remove all breakpoints. */
692 if (current_monitor
->stop
)
695 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
697 RDEBUG(("EXP Open echo\n")) ;
698 monitor_expect_prompt (NULL
, 0);
702 /* wake up the monitor and see if it's alive */
703 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
705 /* Some of the characters we send may not be echoed,
706 but we hope to get a prompt at the end of it all. */
708 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
711 monitor_printf_noecho (*p
);
712 monitor_expect_prompt (NULL
, 0);
715 SERIAL_FLUSH_INPUT (monitor_desc
);
717 /* Remove all breakpoints */
719 if (mon_ops
->clr_all_break
)
721 monitor_printf (mon_ops
->clr_all_break
);
722 monitor_expect_prompt (NULL
, 0);
726 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
728 push_target (targ_ops
);
730 inferior_pid
= 42000; /* Make run command think we are busy... */
732 /* Give monitor_wait something to read */
734 monitor_printf (current_monitor
->line_term
);
736 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
737 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory_block
);
739 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory
);
743 /* Close out all files and local state before this target loses
747 monitor_close (quitting
)
751 SERIAL_CLOSE (monitor_desc
);
755 /* Terminate the open connection to the remote debugger. Use this
756 when you want to detach and do something else with your gdb. */
759 monitor_detach (args
, from_tty
)
763 pop_target (); /* calls monitor_close to do the real work */
765 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
768 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
771 monitor_supply_register (regno
, valstr
)
776 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
779 val
= strtoul (valstr
, &p
, 16);
780 RDEBUG(("Supplying Register %d %s\n",regno
,valstr
)) ;
782 if (val
== 0 && valstr
== p
)
783 error ("monitor_supply_register (%d): bad value from monitor: %s.",
786 /* supply register stores in target byte order, so swap here */
788 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
790 supply_register (regno
, regbuf
);
795 /* Tell the remote machine to resume. */
797 int flush_monitor_dcache(void) { dcache_flush (remote_dcache
); }
800 monitor_resume (pid
, step
, sig
)
802 enum target_signal sig
;
804 /* Some monitors require a different command when starting a program */
805 RDEBUG(("MON resume\n")) ;
806 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
809 monitor_printf ("run\r");
810 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
814 dcache_flush (remote_dcache
);
816 monitor_printf (current_monitor
->step
);
819 if (current_monitor
->continue_hook
)
820 (*current_monitor
->continue_hook
)() ;
821 else monitor_printf (current_monitor
->cont
);
822 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
827 /* Parse the output of a register dump command. A monitor specific
828 regexp is used to extract individual register descriptions of the
829 form REG=VAL. Each description is split up into a name and a value
830 string which are passed down to monitor specific code. */
833 parse_register_dump (buf
, len
)
837 RDEBUG(("MON Parsing register dump\n"))
840 int regnamelen
, vallen
;
842 /* Element 0 points to start of register name, and element 1
843 points to the start of the register value. */
844 struct re_registers register_strings
;
846 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
847 ®ister_strings
) == -1)
850 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
851 regname
= buf
+ register_strings
.start
[1];
852 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
853 val
= buf
+ register_strings
.start
[2];
855 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
857 buf
+= register_strings
.end
[0];
858 len
-= register_strings
.end
[0];
862 /* Send ^C to target to halt it. Target will respond, and send us a
866 monitor_interrupt (signo
)
869 /* If this doesn't work, try more severe steps. */
870 signal (signo
, monitor_interrupt_twice
);
873 printf_unfiltered ("monitor_interrupt called\n");
878 /* The user typed ^C twice. */
881 monitor_interrupt_twice (signo
)
884 signal (signo
, ofunc
);
886 monitor_interrupt_query ();
888 signal (signo
, monitor_interrupt
);
891 /* Ask the user what to do when an interrupt is received. */
894 monitor_interrupt_query ()
896 target_terminal_ours ();
898 if (query ("Interrupted while waiting for the program.\n\
899 Give up (and stop debugging it)? "))
901 target_mourn_inferior ();
902 return_to_top_level (RETURN_QUIT
);
905 target_terminal_inferior ();
909 monitor_wait_cleanup (old_timeout
)
912 timeout
= *(int*)old_timeout
;
913 signal (SIGINT
, ofunc
);
919 void monitor_wait_filter(char * buf
,
922 struct target_waitstatus
* status
928 resp_len
= monitor_expect_prompt (buf
, bufmax
);
929 * ext_resp_len
=resp_len
;
932 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
934 while (resp_len
< 0);
936 /* Print any output characters that were preceded by ^O. */
937 /* FIXME - This would be great as a user settabgle flag */
939 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
943 for (i
= 0; i
< resp_len
- 1; i
++)
945 putchar_unfiltered (buf
[++i
]);
951 /* Wait until the remote machine stops, then return, storing status in
952 status just as `wait' would. */
955 monitor_wait (pid
, status
)
957 struct target_waitstatus
*status
;
959 int old_timeout
= timeout
;
962 struct cleanup
*old_chain
;
964 status
->kind
= TARGET_WAITKIND_EXITED
;
965 status
->value
.integer
= 0;
967 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
968 RDEBUG(("MON wait\n"))
970 #if 0 /* MAINTENANCE_CMDS */
971 /* This is somthing other than a maintenance command */
973 timeout
= watchdog
> 0 ? watchdog
: -1;
975 timeout
= -1; /* Don't time out -- user program is running. */
978 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
980 if (current_monitor
->wait_filter
)
981 (*current_monitor
->wait_filter
)(buf
,sizeof (buf
),&resp_len
,status
) ;
982 else monitor_wait_filter(buf
,sizeof (buf
),&resp_len
,status
) ;
984 #if 0 /* Transferred to monitor wait filter */
987 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
990 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
992 while (resp_len
< 0);
994 /* Print any output characters that were preceded by ^O. */
995 /* FIXME - This would be great as a user settabgle flag */
997 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1001 for (i
= 0; i
< resp_len
- 1; i
++)
1003 putchar_unfiltered (buf
[++i
]);
1007 signal (SIGINT
, ofunc
);
1009 timeout
= old_timeout
;
1011 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1014 monitor_printf (current_monitor
->dump_registers
);
1015 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1018 if (current_monitor
->register_pattern
)
1019 parse_register_dump (buf
, resp_len
);
1021 RDEBUG(("Wait fetching registers after stop\n")) ;
1022 monitor_dump_regs() ;
1025 status
->kind
= TARGET_WAITKIND_STOPPED
;
1026 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1028 discard_cleanups (old_chain
);
1030 in_monitor_wait
= 0;
1032 return inferior_pid
;
1035 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1039 monitor_fetch_register (regno
)
1043 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] = {0};
1044 char regbuf
[MAX_REGISTER_RAW_SIZE
* 2 + 1];
1047 name
= current_monitor
->regnames
[regno
];
1048 RDEBUG(("MON fetchreg %d '%s'\n",regno
,name
))
1050 if (!name
|| (*name
== '\0'))
1051 { RDEBUG(("No register known for %d\n",regno
))
1052 supply_register (regno
, zerobuf
);
1056 /* send the register examine command */
1058 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1060 /* If RESP_DELIM is specified, we search for that as a leading
1061 delimiter for the register value. Otherwise, we just start
1062 searching from the start of the buf. */
1064 if (current_monitor
->getreg
.resp_delim
)
1066 RDEBUG(("EXP getreg.resp_delim\n"))
1067 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1068 /* Handle case of first 32 registers listed in pairs. */
1069 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1070 && regno
& 1 == 1 && regno
< 32)
1071 { RDEBUG(("EXP getreg.resp_delim\n")) ;
1072 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1076 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1077 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1080 c
= readchar (timeout
);
1082 c
= readchar (timeout
);
1083 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1086 error ("Bad value returned from monitor while fetching register %x.",
1090 /* Read upto the maximum number of hex digits for this register, skipping
1091 spaces, but stop reading if something else is seen. Some monitors
1092 like to drop leading zeros. */
1094 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
1097 c
= readchar (timeout
);
1099 c
= readchar (timeout
);
1107 regbuf
[i
] = '\000'; /* terminate the number */
1108 RDEBUG(("REGVAL '%s'\n",regbuf
)) ;
1110 /* If TERM is present, we wait for that to show up. Also, (if TERM
1111 is present), we will send TERM_CMD if that is present. In any
1112 case, we collect all of the output into buf, and then wait for
1113 the normal prompt. */
1115 if (current_monitor
->getreg
.term
)
1117 RDEBUG(("EXP getreg.term\n"))
1118 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1121 if (current_monitor
->getreg
.term_cmd
)
1122 { RDEBUG(("EMIT getreg.term.cmd\n"))
1123 monitor_printf (current_monitor
->getreg
.term_cmd
);
1125 if (! current_monitor
->getreg
.term
|| /* Already expected or */
1126 current_monitor
->getreg
.term_cmd
) /* ack expected */
1127 monitor_expect_prompt (NULL
, 0); /* get response */
1129 monitor_supply_register (regno
, regbuf
);
1132 /* Sometimes, it takes several commands to dump the registers */
1133 /* This is a primitive for use by variations of monitor interfaces in
1134 case they need to compose the operation.
1136 int monitor_dump_reg_block(char * block_cmd
)
1140 monitor_printf (block_cmd
);
1141 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1142 parse_register_dump (buf
, resp_len
);
1147 /* Read the remote registers into the block regs. */
1148 /* Call the specific function if it has been provided */
1151 monitor_dump_regs ()
1155 if (current_monitor
->dumpregs
)
1156 (*(current_monitor
->dumpregs
))() ; /* call supplied function */
1158 if (current_monitor
->dump_registers
) /* default version */
1159 { monitor_printf (current_monitor
->dump_registers
);
1160 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1161 parse_register_dump (buf
, resp_len
);
1164 abort(); /* Need some way to read registers */
1168 monitor_fetch_registers (regno
)
1171 RDEBUG(("MON fetchregs\n")) ;
1172 if (current_monitor
->getreg
.cmd
)
1176 monitor_fetch_register (regno
);
1180 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1181 monitor_fetch_register (regno
);
1184 monitor_dump_regs ();
1188 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1191 monitor_store_register (regno
)
1197 name
= current_monitor
->regnames
[regno
];
1198 if (!name
|| (*name
== '\0'))
1199 { RDEBUG(("MON Cannot store unknown register\n"))
1203 val
= read_register (regno
);
1204 RDEBUG(("MON storeg %d %08x\n",regno
,(unsigned int)val
))
1206 /* send the register deposit command */
1208 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1209 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1210 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1211 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1213 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1215 if (current_monitor
->setreg
.term
)
1216 { RDEBUG(("EXP setreg.term\n"))
1217 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1218 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1219 monitor_printf ("%x\r", val
);
1220 monitor_expect_prompt (NULL
, 0);
1223 monitor_expect_prompt (NULL
, 0);
1224 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1225 { RDEBUG(("EXP setreg_termcmd\n")) ;
1226 monitor_printf("%s",current_monitor
->setreg
.term_cmd
) ;
1227 monitor_expect_prompt(NULL
,0) ;
1229 } /* monitor_store_register */
1231 /* Store the remote registers. */
1234 monitor_store_registers (regno
)
1239 monitor_store_register (regno
);
1243 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1244 monitor_store_register (regno
);
1247 /* Get ready to modify the registers array. On machines which store
1248 individual registers, this doesn't need to do anything. On machines
1249 which store all the registers in one fell swoop, this makes sure
1250 that registers contains all the registers from the program being
1254 monitor_prepare_to_store ()
1256 /* Do nothing, since we can store individual regs */
1260 monitor_files_info (ops
)
1261 struct target_ops
*ops
;
1263 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1267 monitor_write_memory (memaddr
, myaddr
, len
)
1272 unsigned int val
, hostval
;
1276 RDEBUG(("MON write %d %08x\n",len
,(unsigned long)memaddr
))
1278 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1279 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1281 /* Use memory fill command for leading 0 bytes. */
1283 if (current_monitor
->fill
)
1285 for (i
= 0; i
< len
; i
++)
1289 if (i
> 4) /* More than 4 zeros is worth doing */
1291 RDEBUG(("MON FILL %d\n",i
))
1292 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1293 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
)-1, 0);
1295 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1297 monitor_expect_prompt (NULL
, 0);
1304 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1305 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1308 cmd
= current_monitor
->setmem
.cmdll
;
1312 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1315 cmd
= current_monitor
->setmem
.cmdl
;
1317 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1320 cmd
= current_monitor
->setmem
.cmdw
;
1325 cmd
= current_monitor
->setmem
.cmdb
;
1328 val
= extract_unsigned_integer (myaddr
, len
);
1331 { hostval
= * (unsigned int *) myaddr
;
1332 RDEBUG(("Hostval(%08x) val(%08x)\n",hostval
,val
)) ;
1336 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1337 monitor_printf_noecho (cmd
, memaddr
, val
);
1338 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1341 monitor_printf_noecho (cmd
, memaddr
);
1343 if (current_monitor
->setmem
.term
)
1344 { RDEBUG(("EXP setmem.term")) ;
1345 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1346 monitor_printf ("%x\r", val
);
1348 if (current_monitor
->setmem
.term_cmd
)
1349 { /* Emit this to get out of the memory editing state */
1350 monitor_printf("%s",current_monitor
->setmem
.term_cmd
) ;
1351 /* Drop through to expecting a prompt */
1355 monitor_printf (cmd
, memaddr
, val
);
1357 monitor_expect_prompt (NULL
, 0);
1363 static monitor_write_even_block(memaddr
,myaddr
,len
)
1370 /* Enter the sub mode */
1371 monitor_printf(current_monitor
->setmem
.cmdl
,memaddr
) ;
1372 monitor_expect_prompt(NULL
,0) ;
1376 val
= extract_unsigned_integer(myaddr
,4) ; /* REALLY */
1377 monitor_printf("%x\r",val
) ;
1381 RDEBUG((" @ %08x\n",memaddr
))
1382 /* If we wanted to, here we could validate the address */
1383 monitor_expect_prompt(NULL
,0) ;
1385 /* Now exit the sub mode */
1386 monitor_printf (current_monitor
->getreg
.term_cmd
);
1387 monitor_expect_prompt(NULL
,0) ;
1392 static int monitor_write_memory_bytes(memaddr
,myaddr
,len
)
1399 if (len
== 0) return 0 ;
1400 /* Enter the sub mode */
1401 monitor_printf(current_monitor
->setmem
.cmdb
,memaddr
) ;
1402 monitor_expect_prompt(NULL
,0) ;
1406 monitor_printf("%x\r",val
) ;
1410 /* If we wanted to, here we could validate the address */
1411 monitor_expect_prompt(NULL
,0) ;
1414 /* Now exit the sub mode */
1415 monitor_printf (current_monitor
->getreg
.term_cmd
);
1416 monitor_expect_prompt(NULL
,0) ;
1421 static longlongendswap(unsigned char * a
)
1433 /* Format 32 chars of long long value, advance the pointer */
1434 static char * hexlate
= "0123456789abcdef" ;
1435 static char * longlong_hexchars(unsigned long long value
,
1438 if (value
== 0) { *outbuff
++ = '0' ; return outbuff
; }
1440 { static unsigned char disbuf
[8] ; /* disassembly buffer */
1441 unsigned char * scan
, * limit
; /* loop controls */
1442 unsigned char c
, nib
;
1444 scan
= disbuf
; limit
= scan
+ 8 ;
1445 { unsigned long long * dp
;
1446 dp
= (unsigned long long *) scan
;
1449 longlongendswap(disbuf
) ; /* FIXME: ONly on big endian hosts */
1450 while (scan
< limit
)
1451 { c
= *scan
++ ; /* a byte of our long long value */
1453 if (c
== 0) continue ;
1454 else leadzero
= 0 ; /* henceforth we print even zeroes */
1455 nib
= c
>> 4 ; /* high nibble bits */
1456 *outbuff
++ = hexlate
[nib
] ;
1457 nib
= c
& 0x0f ; /* low nibble bits */
1458 *outbuff
++ = hexlate
[nib
] ;
1462 } /* longlong_hexchars */
1466 /* I am only going to call this when writing virtual byte streams.
1467 Which possably entails endian conversions
1469 static int monitor_write_memory_longlongs(memaddr
,myaddr
,len
)
1474 static char hexstage
[20] ; /* At least 16 digits required, plus null */
1479 llptr
= (unsigned long long *) myaddr
;
1480 if (len
== 0 ) return 0 ;
1481 monitor_printf(current_monitor
->setmem
.cmdll
,memaddr
) ;
1482 monitor_expect_prompt(NULL
,0) ;
1486 endstring
= longlong_hexchars(*llptr
,hexstage
) ;
1487 *endstring
= '\0' ; /* NUll terminate for printf */
1488 monitor_printf("%s\r",hexstage
) ;
1492 /* If we wanted to, here we could validate the address */
1493 monitor_expect_prompt(NULL
,0) ;
1496 /* Now exit the sub mode */
1497 monitor_printf (current_monitor
->getreg
.term_cmd
);
1498 monitor_expect_prompt(NULL
,0) ;
1504 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1505 /* This is for the large blocks of memory which may occur in downloading.
1506 And for monitors which use interactive entry,
1507 And for monitors which do not have other downloading methods.
1508 Without this, we will end up calling monitor_write_memory many times
1509 and do the entry and exit of the sub mode many times
1510 This currently assumes...
1511 MO_SETMEM_INTERACTIVE
1512 ! MO_NO_ECHO_ON_SETMEM
1513 To use this, the you have to patch the monitor_cmds block with
1514 this function. Otherwise, its not tuned up for use by all
1518 static int monitor_write_memory_block(memaddr
,myaddr
,len
)
1525 /* FIXME: This would be a good place to put the zero test */
1527 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1529 return monitor_write_memory_longlongs(memaddr
,myaddr
,len
) ;
1536 written
= monitor_write_even_block(memaddr
,myaddr
,len
) ;
1537 /* Adjust calling parameters by written amount */
1538 memaddr
+= written
;
1543 written
= monitor_write_memory_bytes(memaddr
,myaddr
,len
) ;
1547 /* This is an alternate form of monitor_read_memory which is used for monitors
1548 which can only read a single byte/word/etc. at a time. */
1551 monitor_read_memory_single (memaddr
, myaddr
, len
)
1557 char membuf
[sizeof(int) * 2 + 1];
1562 RDEBUG(("MON read single\n")) ;
1564 /* Can't actually use long longs (nice idea, though). In fact, the
1565 call to strtoul below will fail if it tries to convert a value
1566 that's too big to fit in a long. */
1567 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1570 cmd
= current_monitor
->getmem
.cmdll
;
1574 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1577 cmd
= current_monitor
->getmem
.cmdl
;
1579 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1582 cmd
= current_monitor
->getmem
.cmdw
;
1587 cmd
= current_monitor
->getmem
.cmdb
;
1590 /* Send the examine command. */
1592 monitor_printf (cmd
, memaddr
);
1594 /* If RESP_DELIM is specified, we search for that as a leading
1595 delimiter for the memory value. Otherwise, we just start
1596 searching from the start of the buf. */
1598 if (current_monitor
->getmem
.resp_delim
)
1599 { RDEBUG(("EXP getmem.resp_delim\n")) ;
1600 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1603 /* Now, read the appropriate number of hex digits for this loc,
1606 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1607 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1611 c
= readchar (timeout
);
1613 c
= readchar (timeout
);
1614 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1617 error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1618 memaddr
, i
, membuf
, c
);
1620 for (i
= 0; i
< len
* 2; i
++)
1626 c
= readchar (timeout
);
1632 error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1633 memaddr
, i
, membuf
, c
);
1639 membuf
[i
] = '\000'; /* terminate the number */
1641 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1642 present), we will send TERM_CMD if that is present. In any case, we collect
1643 all of the output into buf, and then wait for the normal prompt. */
1645 if (current_monitor
->getmem
.term
)
1647 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1649 if (current_monitor
->getmem
.term_cmd
)
1651 monitor_printf (current_monitor
->getmem
.term_cmd
);
1652 monitor_expect_prompt (NULL
, 0);
1656 monitor_expect_prompt (NULL
, 0); /* get response */
1659 val
= strtoul (membuf
, &p
, 16);
1661 if (val
== 0 && membuf
== p
)
1662 error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
1665 /* supply register stores in target byte order, so swap here */
1667 store_unsigned_integer (myaddr
, len
, val
);
1672 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1673 memory at MEMADDR. Returns length moved. Currently, we do no more
1674 than 16 bytes at a time. */
1677 monitor_read_memory (memaddr
, myaddr
, len
)
1689 if (remote_debug
) printf("MON read block ta(%08x) ha(%08x) %d\n",
1690 (unsigned long) memaddr
, (unsigned long)myaddr
, len
);
1692 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1693 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1695 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1696 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1698 len
= min (len
, 16);
1700 /* Some dumpers align the first data with the preceeding 16
1701 byte boundary. Some print blanks and start at the
1702 requested boundary. EXACT_DUMPADDR
1705 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1706 ? memaddr
: memaddr
& ~ 0x0f ;
1708 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1709 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1710 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1712 /* send the memory examine command */
1714 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1715 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
- 1);
1716 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1717 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1719 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1721 /* If TERM is present, we wait for that to show up. Also, (if TERM
1722 is present), we will send TERM_CMD if that is present. In any
1723 case, we collect all of the output into buf, and then wait for
1724 the normal prompt. */
1726 if (current_monitor
->getmem
.term
)
1728 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1731 error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
1732 memaddr
, resp_len
, buf
);
1734 if (current_monitor
->getmem
.term_cmd
)
1736 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1737 strlen (current_monitor
->getmem
.term_cmd
));
1738 monitor_expect_prompt (NULL
, 0);
1742 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1746 /* If RESP_DELIM is specified, we search for that as a leading
1747 delimiter for the values. Otherwise, we just start searching
1748 from the start of the buf. */
1750 if (current_monitor
->getmem
.resp_delim
)
1753 struct re_registers resp_strings
;
1754 RDEBUG(("MON getmem.resp_delim %s\n",current_monitor
->getmem
.resp_delim
)) ;
1757 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1761 error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1762 memaddr
, resp_len
, buf
);
1764 p
+= resp_strings
.end
[0];
1766 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1768 error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1769 memaddr
, resp_len
, buf
);
1770 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1773 if (remote_debug
) printf("MON scanning %d ,%08x '%s'\n",len
,p
,p
) ;
1774 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1782 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1784 { if ((dumpaddr
>= memaddr
) && (i
> 0))
1785 { val
= fromhex (c
) * 16 + fromhex (*(p
+1));
1787 if (remote_debug
) printf("[%02x]",val
) ;
1794 ++p
; /* skip a blank or other non hex char */
1797 if (fetched
== 0) error("Failed to read via monitor") ;
1798 if (remote_debug
) printf("\n") ;
1799 return fetched
; /* Return the number of bytes actually read */
1801 RDEBUG(("MON scanning bytes\n")) ;
1803 for (i
= len
; i
> 0; i
--)
1805 /* Skip non-hex chars, but bomb on end of string and newlines */
1812 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1813 error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s", memaddr
, resp_len
, buf
);
1817 val
= strtoul (p
, &p1
, 16);
1819 if (val
== 0 && p
== p1
)
1820 error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.", memaddr
,
1834 /* This version supports very large reads by looping on multiline
1835 dump bytes outputs. Beware of buffering limits.
1837 static int monotor_read_memory_block(memaddr
,myaddr
,len
)
1845 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1850 struct target_ops
*target
; /* ignored */
1852 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, write
);
1858 return; /* ignore attempts to kill target system */
1861 /* All we actually do is set the PC to the start address of exec_bfd, and start
1862 the program at that point. */
1865 monitor_create_inferior (exec_file
, args
, env
)
1870 if (args
&& (*args
!= '\000'))
1871 error ("Args are not supported by the monitor.");
1874 clear_proceed_status ();
1875 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1878 /* Clean up when a program exits.
1879 The program actually lives on in the remote processor's RAM, and may be
1880 run again without a download. Don't leave it full of breakpoint
1884 monitor_mourn_inferior ()
1886 unpush_target (targ_ops
);
1887 generic_mourn_inferior (); /* Do all the proper things now */
1890 #define NUM_MONITOR_BREAKPOINTS 8
1892 static CORE_ADDR breakaddr
[NUM_MONITOR_BREAKPOINTS
] = {0};
1894 /* Tell the monitor to add a breakpoint. */
1897 monitor_insert_breakpoint (addr
, shadow
)
1905 RDEBUG(("MON inst bkpt %08x\n",addr
))
1906 if (current_monitor
->set_break
== NULL
)
1907 error ("No set_break defined for this monitor");
1909 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1910 addr
= ADDR_BITS_REMOVE (addr
);
1912 /* Determine appropriate breakpoint size for this address. */
1913 bp
= memory_breakpoint_from_pc (&addr
, &bplen
);
1915 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
1917 if (breakaddr
[i
] == 0)
1919 breakaddr
[i
] = addr
;
1920 monitor_read_memory (addr
, shadow
, bplen
);
1921 monitor_printf (current_monitor
->set_break
, addr
);
1922 monitor_expect_prompt (NULL
, 0);
1927 error ("Too many breakpoints (> %d) for monitor.", NUM_MONITOR_BREAKPOINTS
);
1930 /* Tell the monitor to remove a breakpoint. */
1933 monitor_remove_breakpoint (addr
, shadow
)
1939 RDEBUG(("MON rmbkpt %08x\n",addr
))
1940 if (current_monitor
->clr_break
== NULL
)
1941 error ("No clr_break defined for this monitor");
1943 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1944 addr
= ADDR_BITS_REMOVE (addr
);
1946 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
1948 if (breakaddr
[i
] == addr
)
1951 /* some monitors remove breakpoints based on the address */
1952 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
1953 monitor_printf (current_monitor
->clr_break
, addr
);
1954 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
1955 monitor_printf (current_monitor
->clr_break
, i
+ 1);
1957 monitor_printf (current_monitor
->clr_break
, i
);
1958 monitor_expect_prompt (NULL
, 0);
1962 fprintf_unfiltered (stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
1966 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
1967 an S-record. Return non-zero if the ACK is received properly. */
1970 monitor_wait_srec_ack ()
1974 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
1976 return (readchar (timeout
) == '+');
1978 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
1980 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
1981 if ((ch
= readchar (1)) < 0)
1983 if ((ch
= readchar (1)) < 0)
1985 if ((ch
= readchar (1)) < 0)
1987 if ((ch
= readchar (1)) < 0)
1993 /* monitor_load -- download a file. */
1996 monitor_load (file
, from_tty
)
2000 dcache_flush (remote_dcache
);
2001 RDEBUG(("MON load\n"))
2003 if (current_monitor
->load_routine
)
2004 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2006 { /* The default is ascii S-records */
2008 unsigned long load_offset
;
2011 /* enable user to specify address for downloading as 2nd arg to load */
2012 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2018 monitor_printf (current_monitor
->load
);
2019 if (current_monitor
->loadresp
)
2020 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2022 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2023 32, SREC_ALL
, hashmark
,
2024 current_monitor
->flags
& MO_SREC_ACK
?
2025 monitor_wait_srec_ack
: NULL
);
2027 monitor_expect_prompt (NULL
, 0);
2030 /* Finally, make the PC point at the start address */
2033 write_pc (bfd_get_start_address (exec_bfd
));
2035 inferior_pid
= 0; /* No process now */
2037 /* This is necessary because many things were based on the PC at the time that
2038 we attached to the monitor, which is no longer valid now that we have loaded
2039 new code (and just changed the PC). Another way to do this might be to call
2040 normal_stop, except that the stack may not be valid, and things would get
2041 horribly confused... */
2043 clear_symtab_users ();
2049 RDEBUG(("MON stop\n")) ;
2050 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2051 SERIAL_SEND_BREAK (monitor_desc
);
2052 if (current_monitor
->stop
)
2053 monitor_printf_noecho (current_monitor
->stop
);
2056 /* Put a command string, in args, out to MONITOR. Output from MONITOR
2057 is placed on the users terminal until the prompt is seen. FIXME: We
2058 read the characters ourseleves here cause of a nasty echo. */
2061 monitor_command (args
, from_tty
)
2069 if (monitor_desc
== NULL
)
2070 error ("monitor target not open.");
2072 p
= current_monitor
->prompt
;
2074 /* Send the command. Note that if no args were supplied, then we're
2075 just sending the monitor a newline, which is sometimes useful. */
2077 monitor_printf ("%s\r", (args
? args
: ""));
2079 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2081 fputs_unfiltered (buf
, gdb_stdout
); /* Output the response */
2084 /* Convert hex digit A to a number. */
2091 if (a
>= '0' && a
<= '9')
2093 if (a
>= 'a' && a
<= 'f')
2094 return a
- 'a' + 10;
2095 if (a
>= 'A' && a
<= 'F')
2096 return a
- 'A' + 10;
2098 error ("Reply contains invalid hex digit 0x%x", a
);
2103 monitor_get_dev_name ()
2108 static struct target_ops monitor_ops
;
2110 static void init_base_monitor_ops(void)
2112 monitor_ops
.to_shortname
= NULL
;
2113 monitor_ops
.to_longname
= NULL
;
2114 monitor_ops
.to_doc
= NULL
;
2115 monitor_ops
.to_open
= NULL
;
2116 monitor_ops
.to_close
= monitor_close
;
2117 monitor_ops
.to_attach
= NULL
;
2118 monitor_ops
.to_detach
= monitor_detach
;
2119 monitor_ops
.to_resume
= monitor_resume
;
2120 monitor_ops
.to_wait
= monitor_wait
;
2121 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2122 monitor_ops
.to_store_registers
= monitor_store_registers
;
2123 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2124 monitor_ops
.to_xfer_memory
= monitor_xfer_memory
;
2125 monitor_ops
.to_files_info
= monitor_files_info
;
2126 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2127 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2128 monitor_ops
.to_terminal_init
= 0;
2129 monitor_ops
.to_terminal_inferior
= 0;
2130 monitor_ops
.to_terminal_ours_for_output
= 0;
2131 monitor_ops
.to_terminal_ours
= 0;
2132 monitor_ops
.to_terminal_info
= 0;
2133 monitor_ops
.to_kill
= monitor_kill
;
2134 monitor_ops
.to_load
= monitor_load
;
2135 monitor_ops
.to_lookup_symbol
= 0;
2136 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2137 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2138 monitor_ops
.to_can_run
= 0;
2139 monitor_ops
.to_notice_signals
= 0;
2140 monitor_ops
.to_thread_alive
= 0;
2141 monitor_ops
.to_stop
= monitor_stop
;
2142 monitor_ops
.to_stratum
= process_stratum
;
2143 monitor_ops
.DONT_USE
= 0;
2144 monitor_ops
.to_has_all_memory
= 1;
2145 monitor_ops
.to_has_memory
= 1;
2146 monitor_ops
.to_has_stack
= 1;
2147 monitor_ops
.to_has_registers
= 1;
2148 monitor_ops
.to_has_execution
= 1;
2149 monitor_ops
.to_sections
= 0;
2150 monitor_ops
.to_sections_end
= 0;
2151 monitor_ops
.to_magic
= OPS_MAGIC
;
2152 } /* init_monitor_ops */
2154 /* Init the target_ops structure pointed at by OPS */
2157 init_monitor_ops (ops
)
2158 struct target_ops
*ops
;
2160 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2163 /* Define additional commands that are usually only used by monitors. */
2166 _initialize_remote_monitors ()
2168 init_base_monitor_ops() ;
2169 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
2171 "Set display of activity while downloading a file.\n\
2172 When enabled, a hashmark \'#\' is displayed.",
2176 add_com ("monitor", class_obscure
, monitor_command
,
2177 "Send a command to the debug monitor.");