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. */
798 flush_monitor_dcache ()
800 dcache_flush (remote_dcache
);
804 monitor_resume (pid
, step
, sig
)
806 enum target_signal sig
;
808 /* Some monitors require a different command when starting a program */
809 RDEBUG(("MON resume\n")) ;
810 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
813 monitor_printf ("run\r");
814 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
818 dcache_flush (remote_dcache
);
820 monitor_printf (current_monitor
->step
);
823 if (current_monitor
->continue_hook
)
824 (*current_monitor
->continue_hook
)() ;
825 else monitor_printf (current_monitor
->cont
);
826 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
831 /* Parse the output of a register dump command. A monitor specific
832 regexp is used to extract individual register descriptions of the
833 form REG=VAL. Each description is split up into a name and a value
834 string which are passed down to monitor specific code. */
837 parse_register_dump (buf
, len
)
841 RDEBUG(("MON Parsing register dump\n"))
844 int regnamelen
, vallen
;
846 /* Element 0 points to start of register name, and element 1
847 points to the start of the register value. */
848 struct re_registers register_strings
;
850 memset (®ister_strings
, 0, sizeof (struct re_registers
));
852 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
853 ®ister_strings
) == -1)
856 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
857 regname
= buf
+ register_strings
.start
[1];
858 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
859 val
= buf
+ register_strings
.start
[2];
861 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
863 buf
+= register_strings
.end
[0];
864 len
-= register_strings
.end
[0];
868 /* Send ^C to target to halt it. Target will respond, and send us a
872 monitor_interrupt (signo
)
875 /* If this doesn't work, try more severe steps. */
876 signal (signo
, monitor_interrupt_twice
);
879 printf_unfiltered ("monitor_interrupt called\n");
884 /* The user typed ^C twice. */
887 monitor_interrupt_twice (signo
)
890 signal (signo
, ofunc
);
892 monitor_interrupt_query ();
894 signal (signo
, monitor_interrupt
);
897 /* Ask the user what to do when an interrupt is received. */
900 monitor_interrupt_query ()
902 target_terminal_ours ();
904 if (query ("Interrupted while waiting for the program.\n\
905 Give up (and stop debugging it)? "))
907 target_mourn_inferior ();
908 return_to_top_level (RETURN_QUIT
);
911 target_terminal_inferior ();
915 monitor_wait_cleanup (old_timeout
)
918 timeout
= *(int*)old_timeout
;
919 signal (SIGINT
, ofunc
);
925 void monitor_wait_filter(char * buf
,
928 struct target_waitstatus
* status
934 resp_len
= monitor_expect_prompt (buf
, bufmax
);
935 * ext_resp_len
=resp_len
;
938 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
940 while (resp_len
< 0);
942 /* Print any output characters that were preceded by ^O. */
943 /* FIXME - This would be great as a user settabgle flag */
945 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
949 for (i
= 0; i
< resp_len
- 1; i
++)
951 putchar_unfiltered (buf
[++i
]);
957 /* Wait until the remote machine stops, then return, storing status in
958 status just as `wait' would. */
961 monitor_wait (pid
, status
)
963 struct target_waitstatus
*status
;
965 int old_timeout
= timeout
;
968 struct cleanup
*old_chain
;
970 status
->kind
= TARGET_WAITKIND_EXITED
;
971 status
->value
.integer
= 0;
973 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
974 RDEBUG(("MON wait\n"))
976 #if 0 /* MAINTENANCE_CMDS */
977 /* This is somthing other than a maintenance command */
979 timeout
= watchdog
> 0 ? watchdog
: -1;
981 timeout
= -1; /* Don't time out -- user program is running. */
984 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
986 if (current_monitor
->wait_filter
)
987 (*current_monitor
->wait_filter
)(buf
,sizeof (buf
),&resp_len
,status
) ;
988 else monitor_wait_filter(buf
,sizeof (buf
),&resp_len
,status
) ;
990 #if 0 /* Transferred to monitor wait filter */
993 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
996 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
998 while (resp_len
< 0);
1000 /* Print any output characters that were preceded by ^O. */
1001 /* FIXME - This would be great as a user settabgle flag */
1003 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1007 for (i
= 0; i
< resp_len
- 1; i
++)
1009 putchar_unfiltered (buf
[++i
]);
1013 signal (SIGINT
, ofunc
);
1015 timeout
= old_timeout
;
1017 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1020 monitor_printf (current_monitor
->dump_registers
);
1021 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1024 if (current_monitor
->register_pattern
)
1025 parse_register_dump (buf
, resp_len
);
1027 RDEBUG(("Wait fetching registers after stop\n")) ;
1028 monitor_dump_regs() ;
1031 status
->kind
= TARGET_WAITKIND_STOPPED
;
1032 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1034 discard_cleanups (old_chain
);
1036 in_monitor_wait
= 0;
1038 return inferior_pid
;
1041 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1045 monitor_fetch_register (regno
)
1049 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] = {0};
1050 char regbuf
[MAX_REGISTER_RAW_SIZE
* 2 + 1];
1053 name
= current_monitor
->regnames
[regno
];
1054 RDEBUG(("MON fetchreg %d '%s'\n",regno
,name
))
1056 if (!name
|| (*name
== '\0'))
1057 { RDEBUG(("No register known for %d\n",regno
))
1058 supply_register (regno
, zerobuf
);
1062 /* send the register examine command */
1064 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1066 /* If RESP_DELIM is specified, we search for that as a leading
1067 delimiter for the register value. Otherwise, we just start
1068 searching from the start of the buf. */
1070 if (current_monitor
->getreg
.resp_delim
)
1072 RDEBUG(("EXP getreg.resp_delim\n"))
1073 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1074 /* Handle case of first 32 registers listed in pairs. */
1075 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1076 && regno
& 1 == 1 && regno
< 32)
1077 { RDEBUG(("EXP getreg.resp_delim\n")) ;
1078 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1082 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1083 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1086 c
= readchar (timeout
);
1088 c
= readchar (timeout
);
1089 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1092 error ("Bad value returned from monitor while fetching register %x.",
1096 /* Read upto the maximum number of hex digits for this register, skipping
1097 spaces, but stop reading if something else is seen. Some monitors
1098 like to drop leading zeros. */
1100 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
1103 c
= readchar (timeout
);
1105 c
= readchar (timeout
);
1113 regbuf
[i
] = '\000'; /* terminate the number */
1114 RDEBUG(("REGVAL '%s'\n",regbuf
)) ;
1116 /* If TERM is present, we wait for that to show up. Also, (if TERM
1117 is present), we will send TERM_CMD if that is present. In any
1118 case, we collect all of the output into buf, and then wait for
1119 the normal prompt. */
1121 if (current_monitor
->getreg
.term
)
1123 RDEBUG(("EXP getreg.term\n"))
1124 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1127 if (current_monitor
->getreg
.term_cmd
)
1128 { RDEBUG(("EMIT getreg.term.cmd\n"))
1129 monitor_printf (current_monitor
->getreg
.term_cmd
);
1131 if (! current_monitor
->getreg
.term
|| /* Already expected or */
1132 current_monitor
->getreg
.term_cmd
) /* ack expected */
1133 monitor_expect_prompt (NULL
, 0); /* get response */
1135 monitor_supply_register (regno
, regbuf
);
1138 /* Sometimes, it takes several commands to dump the registers */
1139 /* This is a primitive for use by variations of monitor interfaces in
1140 case they need to compose the operation.
1142 int monitor_dump_reg_block(char * block_cmd
)
1146 monitor_printf (block_cmd
);
1147 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1148 parse_register_dump (buf
, resp_len
);
1153 /* Read the remote registers into the block regs. */
1154 /* Call the specific function if it has been provided */
1157 monitor_dump_regs ()
1161 if (current_monitor
->dumpregs
)
1162 (*(current_monitor
->dumpregs
))() ; /* call supplied function */
1164 if (current_monitor
->dump_registers
) /* default version */
1165 { monitor_printf (current_monitor
->dump_registers
);
1166 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1167 parse_register_dump (buf
, resp_len
);
1170 abort(); /* Need some way to read registers */
1174 monitor_fetch_registers (regno
)
1177 RDEBUG(("MON fetchregs\n")) ;
1178 if (current_monitor
->getreg
.cmd
)
1182 monitor_fetch_register (regno
);
1186 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1187 monitor_fetch_register (regno
);
1190 monitor_dump_regs ();
1194 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1197 monitor_store_register (regno
)
1203 name
= current_monitor
->regnames
[regno
];
1204 if (!name
|| (*name
== '\0'))
1205 { RDEBUG(("MON Cannot store unknown register\n"))
1209 val
= read_register (regno
);
1210 RDEBUG(("MON storeg %d %08x\n",regno
,(unsigned int)val
))
1212 /* send the register deposit command */
1214 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1215 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1216 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1217 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1219 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1221 if (current_monitor
->setreg
.term
)
1222 { RDEBUG(("EXP setreg.term\n"))
1223 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1224 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1225 monitor_printf ("%x\r", val
);
1226 monitor_expect_prompt (NULL
, 0);
1229 monitor_expect_prompt (NULL
, 0);
1230 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1231 { RDEBUG(("EXP setreg_termcmd\n")) ;
1232 monitor_printf("%s",current_monitor
->setreg
.term_cmd
) ;
1233 monitor_expect_prompt(NULL
,0) ;
1235 } /* monitor_store_register */
1237 /* Store the remote registers. */
1240 monitor_store_registers (regno
)
1245 monitor_store_register (regno
);
1249 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1250 monitor_store_register (regno
);
1253 /* Get ready to modify the registers array. On machines which store
1254 individual registers, this doesn't need to do anything. On machines
1255 which store all the registers in one fell swoop, this makes sure
1256 that registers contains all the registers from the program being
1260 monitor_prepare_to_store ()
1262 /* Do nothing, since we can store individual regs */
1266 monitor_files_info (ops
)
1267 struct target_ops
*ops
;
1269 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1273 monitor_write_memory (memaddr
, myaddr
, len
)
1278 unsigned int val
, hostval
;
1282 RDEBUG(("MON write %d %08x\n",len
,(unsigned long)memaddr
))
1284 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1285 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1287 /* Use memory fill command for leading 0 bytes. */
1289 if (current_monitor
->fill
)
1291 for (i
= 0; i
< len
; i
++)
1295 if (i
> 4) /* More than 4 zeros is worth doing */
1297 RDEBUG(("MON FILL %d\n",i
))
1298 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1299 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
)-1, 0);
1301 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1303 monitor_expect_prompt (NULL
, 0);
1310 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1311 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1314 cmd
= current_monitor
->setmem
.cmdll
;
1318 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1321 cmd
= current_monitor
->setmem
.cmdl
;
1323 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1326 cmd
= current_monitor
->setmem
.cmdw
;
1331 cmd
= current_monitor
->setmem
.cmdb
;
1334 val
= extract_unsigned_integer (myaddr
, len
);
1337 { hostval
= * (unsigned int *) myaddr
;
1338 RDEBUG(("Hostval(%08x) val(%08x)\n",hostval
,val
)) ;
1342 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1343 monitor_printf_noecho (cmd
, memaddr
, val
);
1344 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1347 monitor_printf_noecho (cmd
, memaddr
);
1349 if (current_monitor
->setmem
.term
)
1350 { RDEBUG(("EXP setmem.term")) ;
1351 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1352 monitor_printf ("%x\r", val
);
1354 if (current_monitor
->setmem
.term_cmd
)
1355 { /* Emit this to get out of the memory editing state */
1356 monitor_printf("%s",current_monitor
->setmem
.term_cmd
) ;
1357 /* Drop through to expecting a prompt */
1361 monitor_printf (cmd
, memaddr
, val
);
1363 monitor_expect_prompt (NULL
, 0);
1370 monitor_write_even_block(memaddr
,myaddr
,len
)
1377 /* Enter the sub mode */
1378 monitor_printf(current_monitor
->setmem
.cmdl
,memaddr
) ;
1379 monitor_expect_prompt(NULL
,0) ;
1383 val
= extract_unsigned_integer(myaddr
,4) ; /* REALLY */
1384 monitor_printf("%x\r",val
) ;
1388 RDEBUG((" @ %08x\n",memaddr
))
1389 /* If we wanted to, here we could validate the address */
1390 monitor_expect_prompt(NULL
,0) ;
1392 /* Now exit the sub mode */
1393 monitor_printf (current_monitor
->getreg
.term_cmd
);
1394 monitor_expect_prompt(NULL
,0) ;
1399 static int monitor_write_memory_bytes(memaddr
,myaddr
,len
)
1406 if (len
== 0) return 0 ;
1407 /* Enter the sub mode */
1408 monitor_printf(current_monitor
->setmem
.cmdb
,memaddr
) ;
1409 monitor_expect_prompt(NULL
,0) ;
1413 monitor_printf("%x\r",val
) ;
1417 /* If we wanted to, here we could validate the address */
1418 monitor_expect_prompt(NULL
,0) ;
1421 /* Now exit the sub mode */
1422 monitor_printf (current_monitor
->getreg
.term_cmd
);
1423 monitor_expect_prompt(NULL
,0) ;
1429 longlongendswap (unsigned char * a
)
1441 /* Format 32 chars of long long value, advance the pointer */
1442 static char * hexlate
= "0123456789abcdef" ;
1443 static char * longlong_hexchars(unsigned long long value
,
1446 if (value
== 0) { *outbuff
++ = '0' ; return outbuff
; }
1448 { static unsigned char disbuf
[8] ; /* disassembly buffer */
1449 unsigned char * scan
, * limit
; /* loop controls */
1450 unsigned char c
, nib
;
1452 scan
= disbuf
; limit
= scan
+ 8 ;
1453 { unsigned long long * dp
;
1454 dp
= (unsigned long long *) scan
;
1457 longlongendswap(disbuf
) ; /* FIXME: ONly on big endian hosts */
1458 while (scan
< limit
)
1459 { c
= *scan
++ ; /* a byte of our long long value */
1461 if (c
== 0) continue ;
1462 else leadzero
= 0 ; /* henceforth we print even zeroes */
1463 nib
= c
>> 4 ; /* high nibble bits */
1464 *outbuff
++ = hexlate
[nib
] ;
1465 nib
= c
& 0x0f ; /* low nibble bits */
1466 *outbuff
++ = hexlate
[nib
] ;
1470 } /* longlong_hexchars */
1474 /* I am only going to call this when writing virtual byte streams.
1475 Which possably entails endian conversions
1477 static int monitor_write_memory_longlongs(memaddr
,myaddr
,len
)
1482 static char hexstage
[20] ; /* At least 16 digits required, plus null */
1487 llptr
= (unsigned long long *) myaddr
;
1488 if (len
== 0 ) return 0 ;
1489 monitor_printf(current_monitor
->setmem
.cmdll
,memaddr
) ;
1490 monitor_expect_prompt(NULL
,0) ;
1494 endstring
= longlong_hexchars(*llptr
,hexstage
) ;
1495 *endstring
= '\0' ; /* NUll terminate for printf */
1496 monitor_printf("%s\r",hexstage
) ;
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 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1513 /* This is for the large blocks of memory which may occur in downloading.
1514 And for monitors which use interactive entry,
1515 And for monitors which do not have other downloading methods.
1516 Without this, we will end up calling monitor_write_memory many times
1517 and do the entry and exit of the sub mode many times
1518 This currently assumes...
1519 MO_SETMEM_INTERACTIVE
1520 ! MO_NO_ECHO_ON_SETMEM
1521 To use this, the you have to patch the monitor_cmds block with
1522 this function. Otherwise, its not tuned up for use by all
1526 static int monitor_write_memory_block(memaddr
,myaddr
,len
)
1533 /* FIXME: This would be a good place to put the zero test */
1535 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1537 return monitor_write_memory_longlongs(memaddr
,myaddr
,len
) ;
1544 written
= monitor_write_even_block(memaddr
,myaddr
,len
) ;
1545 /* Adjust calling parameters by written amount */
1546 memaddr
+= written
;
1551 written
= monitor_write_memory_bytes(memaddr
,myaddr
,len
) ;
1555 /* This is an alternate form of monitor_read_memory which is used for monitors
1556 which can only read a single byte/word/etc. at a time. */
1559 monitor_read_memory_single (memaddr
, myaddr
, len
)
1565 char membuf
[sizeof(int) * 2 + 1];
1570 RDEBUG(("MON read single\n")) ;
1572 /* Can't actually use long longs (nice idea, though). In fact, the
1573 call to strtoul below will fail if it tries to convert a value
1574 that's too big to fit in a long. */
1575 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1578 cmd
= current_monitor
->getmem
.cmdll
;
1582 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1585 cmd
= current_monitor
->getmem
.cmdl
;
1587 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1590 cmd
= current_monitor
->getmem
.cmdw
;
1595 cmd
= current_monitor
->getmem
.cmdb
;
1598 /* Send the examine command. */
1600 monitor_printf (cmd
, memaddr
);
1602 /* If RESP_DELIM is specified, we search for that as a leading
1603 delimiter for the memory value. Otherwise, we just start
1604 searching from the start of the buf. */
1606 if (current_monitor
->getmem
.resp_delim
)
1607 { RDEBUG(("EXP getmem.resp_delim\n")) ;
1608 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1611 /* Now, read the appropriate number of hex digits for this loc,
1614 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1615 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1619 c
= readchar (timeout
);
1621 c
= readchar (timeout
);
1622 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1625 error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1626 memaddr
, i
, membuf
, c
);
1628 for (i
= 0; i
< len
* 2; i
++)
1634 c
= readchar (timeout
);
1640 error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1641 memaddr
, i
, membuf
, c
);
1647 membuf
[i
] = '\000'; /* terminate the number */
1649 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1650 present), we will send TERM_CMD if that is present. In any case, we collect
1651 all of the output into buf, and then wait for the normal prompt. */
1653 if (current_monitor
->getmem
.term
)
1655 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1657 if (current_monitor
->getmem
.term_cmd
)
1659 monitor_printf (current_monitor
->getmem
.term_cmd
);
1660 monitor_expect_prompt (NULL
, 0);
1664 monitor_expect_prompt (NULL
, 0); /* get response */
1667 val
= strtoul (membuf
, &p
, 16);
1669 if (val
== 0 && membuf
== p
)
1670 error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
1673 /* supply register stores in target byte order, so swap here */
1675 store_unsigned_integer (myaddr
, len
, val
);
1680 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1681 memory at MEMADDR. Returns length moved. Currently, we do no more
1682 than 16 bytes at a time. */
1685 monitor_read_memory (memaddr
, myaddr
, len
)
1697 if (remote_debug
) printf("MON read block ta(%08x) ha(%08x) %d\n",
1698 (unsigned long) memaddr
, (unsigned long)myaddr
, len
);
1700 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1701 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1703 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1704 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1706 len
= min (len
, 16);
1708 /* Some dumpers align the first data with the preceeding 16
1709 byte boundary. Some print blanks and start at the
1710 requested boundary. EXACT_DUMPADDR
1713 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1714 ? memaddr
: memaddr
& ~ 0x0f ;
1716 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1717 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1718 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1720 /* send the memory examine command */
1722 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1723 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
- 1);
1724 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1725 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1727 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1729 /* If TERM is present, we wait for that to show up. Also, (if TERM
1730 is present), we will send TERM_CMD if that is present. In any
1731 case, we collect all of the output into buf, and then wait for
1732 the normal prompt. */
1734 if (current_monitor
->getmem
.term
)
1736 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1739 error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
1740 memaddr
, resp_len
, buf
);
1742 if (current_monitor
->getmem
.term_cmd
)
1744 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1745 strlen (current_monitor
->getmem
.term_cmd
));
1746 monitor_expect_prompt (NULL
, 0);
1750 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1754 /* If RESP_DELIM is specified, we search for that as a leading
1755 delimiter for the values. Otherwise, we just start searching
1756 from the start of the buf. */
1758 if (current_monitor
->getmem
.resp_delim
)
1761 struct re_registers resp_strings
;
1762 RDEBUG(("MON getmem.resp_delim %s\n",current_monitor
->getmem
.resp_delim
)) ;
1764 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1766 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1770 error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1771 memaddr
, resp_len
, buf
);
1773 p
+= resp_strings
.end
[0];
1775 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1777 error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1778 memaddr
, resp_len
, buf
);
1779 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1782 if (remote_debug
) printf("MON scanning %d ,%08x '%s'\n",len
,p
,p
) ;
1783 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1791 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1793 { if ((dumpaddr
>= memaddr
) && (i
> 0))
1794 { val
= fromhex (c
) * 16 + fromhex (*(p
+1));
1796 if (remote_debug
) printf("[%02x]",val
) ;
1803 ++p
; /* skip a blank or other non hex char */
1806 if (fetched
== 0) error("Failed to read via monitor") ;
1807 if (remote_debug
) printf("\n") ;
1808 return fetched
; /* Return the number of bytes actually read */
1810 RDEBUG(("MON scanning bytes\n")) ;
1812 for (i
= len
; i
> 0; i
--)
1814 /* Skip non-hex chars, but bomb on end of string and newlines */
1821 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1822 error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s", memaddr
, resp_len
, buf
);
1826 val
= strtoul (p
, &p1
, 16);
1828 if (val
== 0 && p
== p1
)
1829 error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.", memaddr
,
1844 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1849 struct target_ops
*target
; /* ignored */
1851 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, write
);
1857 return; /* ignore attempts to kill target system */
1860 /* All we actually do is set the PC to the start address of exec_bfd, and start
1861 the program at that point. */
1864 monitor_create_inferior (exec_file
, args
, env
)
1869 if (args
&& (*args
!= '\000'))
1870 error ("Args are not supported by the monitor.");
1873 clear_proceed_status ();
1874 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1877 /* Clean up when a program exits.
1878 The program actually lives on in the remote processor's RAM, and may be
1879 run again without a download. Don't leave it full of breakpoint
1883 monitor_mourn_inferior ()
1885 unpush_target (targ_ops
);
1886 generic_mourn_inferior (); /* Do all the proper things now */
1889 #define NUM_MONITOR_BREAKPOINTS 8
1891 static CORE_ADDR breakaddr
[NUM_MONITOR_BREAKPOINTS
] = {0};
1893 /* Tell the monitor to add a breakpoint. */
1896 monitor_insert_breakpoint (addr
, shadow
)
1904 RDEBUG(("MON inst bkpt %08x\n",addr
))
1905 if (current_monitor
->set_break
== NULL
)
1906 error ("No set_break defined for this monitor");
1908 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1909 addr
= ADDR_BITS_REMOVE (addr
);
1911 /* Determine appropriate breakpoint size for this address. */
1912 bp
= memory_breakpoint_from_pc (&addr
, &bplen
);
1914 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
1916 if (breakaddr
[i
] == 0)
1918 breakaddr
[i
] = addr
;
1919 monitor_read_memory (addr
, shadow
, bplen
);
1920 monitor_printf (current_monitor
->set_break
, addr
);
1921 monitor_expect_prompt (NULL
, 0);
1926 error ("Too many breakpoints (> %d) for monitor.", NUM_MONITOR_BREAKPOINTS
);
1929 /* Tell the monitor to remove a breakpoint. */
1932 monitor_remove_breakpoint (addr
, shadow
)
1938 RDEBUG(("MON rmbkpt %08x\n",addr
))
1939 if (current_monitor
->clr_break
== NULL
)
1940 error ("No clr_break defined for this monitor");
1942 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1943 addr
= ADDR_BITS_REMOVE (addr
);
1945 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
1947 if (breakaddr
[i
] == addr
)
1950 /* some monitors remove breakpoints based on the address */
1951 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
1952 monitor_printf (current_monitor
->clr_break
, addr
);
1953 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
1954 monitor_printf (current_monitor
->clr_break
, i
+ 1);
1956 monitor_printf (current_monitor
->clr_break
, i
);
1957 monitor_expect_prompt (NULL
, 0);
1961 fprintf_unfiltered (stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
1965 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
1966 an S-record. Return non-zero if the ACK is received properly. */
1969 monitor_wait_srec_ack ()
1973 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
1975 return (readchar (timeout
) == '+');
1977 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
1979 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
1980 if ((ch
= readchar (1)) < 0)
1982 if ((ch
= readchar (1)) < 0)
1984 if ((ch
= readchar (1)) < 0)
1986 if ((ch
= readchar (1)) < 0)
1992 /* monitor_load -- download a file. */
1995 monitor_load (file
, from_tty
)
1999 dcache_flush (remote_dcache
);
2000 RDEBUG(("MON load\n"))
2002 if (current_monitor
->load_routine
)
2003 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2005 { /* The default is ascii S-records */
2007 unsigned long load_offset
;
2010 /* enable user to specify address for downloading as 2nd arg to load */
2011 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2017 monitor_printf (current_monitor
->load
);
2018 if (current_monitor
->loadresp
)
2019 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2021 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2022 32, SREC_ALL
, hashmark
,
2023 current_monitor
->flags
& MO_SREC_ACK
?
2024 monitor_wait_srec_ack
: NULL
);
2026 monitor_expect_prompt (NULL
, 0);
2029 /* Finally, make the PC point at the start address */
2032 write_pc (bfd_get_start_address (exec_bfd
));
2034 inferior_pid
= 0; /* No process now */
2036 /* This is necessary because many things were based on the PC at the time that
2037 we attached to the monitor, which is no longer valid now that we have loaded
2038 new code (and just changed the PC). Another way to do this might be to call
2039 normal_stop, except that the stack may not be valid, and things would get
2040 horribly confused... */
2042 clear_symtab_users ();
2048 RDEBUG(("MON stop\n")) ;
2049 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2050 SERIAL_SEND_BREAK (monitor_desc
);
2051 if (current_monitor
->stop
)
2052 monitor_printf_noecho (current_monitor
->stop
);
2055 /* Put a command string, in args, out to MONITOR. Output from MONITOR
2056 is placed on the users terminal until the prompt is seen. FIXME: We
2057 read the characters ourseleves here cause of a nasty echo. */
2060 monitor_command (args
, from_tty
)
2068 if (monitor_desc
== NULL
)
2069 error ("monitor target not open.");
2071 p
= current_monitor
->prompt
;
2073 /* Send the command. Note that if no args were supplied, then we're
2074 just sending the monitor a newline, which is sometimes useful. */
2076 monitor_printf ("%s\r", (args
? args
: ""));
2078 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2080 fputs_unfiltered (buf
, gdb_stdout
); /* Output the response */
2083 /* Convert hex digit A to a number. */
2090 if (a
>= '0' && a
<= '9')
2092 if (a
>= 'a' && a
<= 'f')
2093 return a
- 'a' + 10;
2094 if (a
>= 'A' && a
<= 'F')
2095 return a
- 'A' + 10;
2097 error ("Reply contains invalid hex digit 0x%x", a
);
2102 monitor_get_dev_name ()
2107 static struct target_ops monitor_ops
;
2109 static void init_base_monitor_ops(void)
2111 monitor_ops
.to_shortname
= NULL
;
2112 monitor_ops
.to_longname
= NULL
;
2113 monitor_ops
.to_doc
= NULL
;
2114 monitor_ops
.to_open
= NULL
;
2115 monitor_ops
.to_close
= monitor_close
;
2116 monitor_ops
.to_attach
= NULL
;
2117 monitor_ops
.to_detach
= monitor_detach
;
2118 monitor_ops
.to_resume
= monitor_resume
;
2119 monitor_ops
.to_wait
= monitor_wait
;
2120 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2121 monitor_ops
.to_store_registers
= monitor_store_registers
;
2122 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2123 monitor_ops
.to_xfer_memory
= monitor_xfer_memory
;
2124 monitor_ops
.to_files_info
= monitor_files_info
;
2125 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2126 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2127 monitor_ops
.to_terminal_init
= 0;
2128 monitor_ops
.to_terminal_inferior
= 0;
2129 monitor_ops
.to_terminal_ours_for_output
= 0;
2130 monitor_ops
.to_terminal_ours
= 0;
2131 monitor_ops
.to_terminal_info
= 0;
2132 monitor_ops
.to_kill
= monitor_kill
;
2133 monitor_ops
.to_load
= monitor_load
;
2134 monitor_ops
.to_lookup_symbol
= 0;
2135 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2136 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2137 monitor_ops
.to_can_run
= 0;
2138 monitor_ops
.to_notice_signals
= 0;
2139 monitor_ops
.to_thread_alive
= 0;
2140 monitor_ops
.to_stop
= monitor_stop
;
2141 monitor_ops
.to_stratum
= process_stratum
;
2142 monitor_ops
.DONT_USE
= 0;
2143 monitor_ops
.to_has_all_memory
= 1;
2144 monitor_ops
.to_has_memory
= 1;
2145 monitor_ops
.to_has_stack
= 1;
2146 monitor_ops
.to_has_registers
= 1;
2147 monitor_ops
.to_has_execution
= 1;
2148 monitor_ops
.to_sections
= 0;
2149 monitor_ops
.to_sections_end
= 0;
2150 monitor_ops
.to_magic
= OPS_MAGIC
;
2151 } /* init_monitor_ops */
2153 /* Init the target_ops structure pointed at by OPS */
2156 init_monitor_ops (ops
)
2157 struct target_ops
*ops
;
2159 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2162 /* Define additional commands that are usually only used by monitors. */
2165 _initialize_remote_monitors ()
2167 init_base_monitor_ops() ;
2168 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
2170 "Set display of activity while downloading a file.\n\
2171 When enabled, a hashmark \'#\' is displayed.",
2175 add_com ("monitor", class_obscure
, monitor_command
,
2176 "Send a command to the debug monitor.");