1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990, 1991, 1992, 1993, 1995, 1996, 1997, 1999
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
5 Resurrected from the ashes by Stu Grossman.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 /* This file was derived from various remote-* modules. It is a collection
24 of generic support functions so GDB can talk directly to a ROM based
25 monitor. This saves use from having to hack an exception based handler
26 into existance, and makes for quick porting.
28 This module talks to a debug monitor called 'MONITOR', which
29 We communicate with MONITOR via either a direct serial line, or a TCP
30 (or possibly TELNET) stream to a terminal multiplexor,
31 which in turn talks to the target board. */
33 /* FIXME 32x64: This code assumes that registers and addresses are at
34 most 32 bits long. If they can be larger, you will need to declare
35 values as LONGEST and use %llx or some such to print values when
36 building commands to send to the monitor. Since we don't know of
37 any actual 64-bit targets with ROM monitors that use this code,
38 it's not an issue right now. -sts 4/18/96 */
44 #ifdef ANSI_PROTOTYPES
51 #include "gdb_string.h"
52 #include <sys/types.h>
58 #include "gnu-regex.h"
62 static char *dev_name
;
63 static struct target_ops
*targ_ops
;
65 static void monitor_vsprintf
PARAMS ((char *sndbuf
, char *pattern
, va_list args
));
67 static int readchar
PARAMS ((int timeout
));
69 static void monitor_command
PARAMS ((char *args
, int fromtty
));
71 static void monitor_fetch_register
PARAMS ((int regno
));
72 static void monitor_store_register
PARAMS ((int regno
));
74 static int monitor_printable_string
PARAMS ((char *newstr
, char *oldstr
));
75 static void monitor_error
PARAMS ((char *format
, CORE_ADDR memaddr
, int len
, char *string
, int final_char
));
76 static void monitor_detach
PARAMS ((char *args
, int from_tty
));
77 static void monitor_resume
PARAMS ((int pid
, int step
, enum target_signal sig
));
78 static void monitor_interrupt
PARAMS ((int signo
));
79 static void monitor_interrupt_twice
PARAMS ((int signo
));
80 static void monitor_interrupt_query
PARAMS ((void));
81 static void monitor_wait_cleanup
PARAMS ((void *old_timeout
));
83 static int monitor_wait
PARAMS ((int pid
, struct target_waitstatus
*status
));
84 static void monitor_fetch_registers
PARAMS ((int regno
));
85 static void monitor_store_registers
PARAMS ((int regno
));
86 static void monitor_prepare_to_store
PARAMS ((void));
87 static int monitor_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
, int len
, int write
, struct target_ops
*target
));
88 static void monitor_files_info
PARAMS ((struct target_ops
*ops
));
89 static int monitor_insert_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
90 static int monitor_remove_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
91 static void monitor_kill
PARAMS ((void));
92 static void monitor_load
PARAMS ((char *file
, int from_tty
));
93 static void monitor_mourn_inferior
PARAMS ((void));
94 static void monitor_stop
PARAMS ((void));
96 static int monitor_read_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
,int len
));
97 static int monitor_write_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
,int len
));
98 static int monitor_write_memory_bytes
PARAMS ((CORE_ADDR addr
,
99 char *myaddr
,int len
));
100 static int monitor_write_memory_block
PARAMS((
104 static int monitor_expect_regexp
PARAMS ((struct re_pattern_buffer
*pat
,
105 char *buf
, int buflen
));
106 static void monitor_dump_regs
PARAMS((void)) ;
108 static int from_hex
PARAMS ((int a
));
109 static unsigned long get_hex_word
PARAMS ((void));
111 static void parse_register_dump
PARAMS ((char *, int));
113 static struct monitor_ops
*current_monitor
;
115 static int hashmark
; /* flag set by "set hash" */
117 static int timeout
= 30;
119 static int in_monitor_wait
= 0; /* Non-zero means we are in monitor_wait() */
121 static void (*ofunc
)(); /* Old SIGINT signal handler */
123 /* Extra remote debugging for developing a new rom monitor variation */
124 #if ! defined(EXTRA_RDEBUG)
125 #define EXTRA_RDEBUG 0
127 #define RDEBUG(stuff) { if (EXTRA_RDEBUG && remote_debug) printf stuff ; }
129 /* Descriptor for I/O to remote machine. Initialize it to NULL so
130 that monitor_open knows that we don't have a file open when the
133 static serial_t monitor_desc
= NULL
;
135 /* Pointer to regexp pattern matching data */
137 static struct re_pattern_buffer register_pattern
;
138 static char register_fastmap
[256];
140 static struct re_pattern_buffer getmem_resp_delim_pattern
;
141 static char getmem_resp_delim_fastmap
[256];
143 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
144 monitor_wait wakes up. */
146 static DCACHE
*remote_dcache
;
147 static int first_time
=0; /* is this the first time we're executing after
148 gaving created the child proccess? */
150 /* Convert a string into a printable representation, Return # byte in the
154 monitor_printable_string (newstr
, oldstr
)
161 while ((ch
= *oldstr
++) != '\0')
171 sprintf (newstr
, "\\x%02x", ch
& 0xff);
176 case '\\': *newstr
++ = '\\'; *newstr
++ = '\\'; break;
177 case '\b': *newstr
++ = '\\'; *newstr
++ = 'b'; break;
178 case '\f': *newstr
++ = '\\'; *newstr
++ = 't'; break;
179 case '\n': *newstr
++ = '\\'; *newstr
++ = 'n'; break;
180 case '\r': *newstr
++ = '\\'; *newstr
++ = 'r'; break;
181 case '\t': *newstr
++ = '\\'; *newstr
++ = 't'; break;
182 case '\v': *newstr
++ = '\\'; *newstr
++ = 'v'; break;
187 return newstr
- save
;
190 /* Print monitor errors with a string, converting the string to printable
194 monitor_error (format
, memaddr
, len
, string
, final_char
)
201 int real_len
= (len
== 0 && string
!= (char *)0) ? strlen (string
) : len
;
202 char *safe_string
= alloca ((real_len
* 4) + 1);
205 int safe_len
= monitor_printable_string (safe_string
, string
);
208 error (format
, (int)memaddr
, p
- safe_string
, safe_string
, final_char
);
210 error (format
, (int)memaddr
, p
- safe_string
, safe_string
);
213 /* Convert hex digit A to a number. */
219 if (a
>= '0' && a
<= '9')
221 else if (a
>= 'a' && a
<= 'f')
224 if (a
>= 'A' && a
<= 'F')
225 return a
- 'A' + 10 ;
226 else error ("Invalid hex digit %d", a
);
229 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
231 This function exists to get around the problem that many host platforms
232 don't have a printf that can print 64-bit addresses. The %A format
233 specification is recognized as a special case, and causes the argument
234 to be printed as a 64-bit hexadecimal address.
236 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
237 If it is a '%s' format, the argument is a string; otherwise the
238 argument is assumed to be a long integer.
240 %% is also turned into a single %.
244 monitor_vsprintf (sndbuf
, pattern
, args
)
257 for (p
= pattern
; *p
; p
++)
261 /* Copy the format specifier to a separate buffer. */
263 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
266 format
[i
] = fmt
= *p
;
269 /* Fetch the next argument and print it. */
273 strcpy (sndbuf
, "%");
276 arg_addr
= va_arg (args
, CORE_ADDR
);
277 strcpy (sndbuf
, paddr_nz (arg_addr
));
280 arg_string
= va_arg (args
, char *);
281 sprintf (sndbuf
, format
, arg_string
);
284 arg_int
= va_arg (args
, long);
285 sprintf (sndbuf
, format
, arg_int
);
288 sndbuf
+= strlen (sndbuf
);
297 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
298 Works just like printf. */
301 #ifdef ANSI_PROTOTYPES
302 monitor_printf_noecho (char *pattern
, ...)
304 monitor_printf_noecho (va_alist
)
313 va_start (args
, pattern
);
317 pattern
= va_arg (args
, char *);
320 monitor_vsprintf (sndbuf
, pattern
, args
);
322 len
= strlen (sndbuf
);
323 if (len
+ 1 > sizeof sndbuf
)
327 if (remote_debug
> 0)
328 puts_debug ("sent -->", sndbuf
, "<--");
333 char *safe_string
= (char *) alloca ((strlen (sndbuf
) * 4) + 1);
334 monitor_printable_string (safe_string
, sndbuf
);
335 printf ("sent[%s]\n", safe_string
);
338 monitor_write (sndbuf
, len
);
341 /* monitor_printf -- Send data to monitor and check the echo. Works just like
345 #ifdef ANSI_PROTOTYPES
346 monitor_printf (char *pattern
, ...)
348 monitor_printf (va_alist
)
356 #ifdef ANSI_PROTOTYPES
357 va_start (args
, pattern
);
361 pattern
= va_arg (args
, char *);
364 monitor_vsprintf (sndbuf
, pattern
, args
);
366 len
= strlen (sndbuf
);
367 if (len
+ 1 > sizeof sndbuf
)
371 if (remote_debug
> 0)
372 puts_debug ("sent -->", sndbuf
, "<--");
377 char *safe_string
= (char *) alloca ((len
* 4) + 1);
378 monitor_printable_string (safe_string
, sndbuf
);
379 printf ("sent[%s]\n", safe_string
);
382 monitor_write (sndbuf
, len
);
384 /* We used to expect that the next immediate output was the characters we
385 just output, but sometimes some extra junk appeared before the characters
386 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
387 So, just start searching for what we sent, and skip anything unknown. */
388 RDEBUG(("ExpectEcho\n"))
389 monitor_expect (sndbuf
, (char *)0, 0);
393 /* Write characters to the remote system. */
396 monitor_write (buf
, buflen
)
400 if (SERIAL_WRITE(monitor_desc
, buf
, buflen
))
401 fprintf_unfiltered (gdb_stderr
, "SERIAL_WRITE failed: %s\n",
402 safe_strerror (errno
));
406 /* Read a binary character from the remote system, doing all the fancy
407 timeout stuff, but without interpreting the character in any way,
408 and without printing remote debug information. */
419 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
422 c
&= 0xff; /* don't lose bit 7 */
429 if (c
== SERIAL_TIMEOUT
)
430 error ("Timeout reading from remote system.");
432 perror_with_name ("remote-monitor");
436 /* Read a character from the remote system, doing all the fancy
444 static enum { last_random
, last_nl
, last_cr
, last_crnl
} state
= last_random
;
450 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
456 /* This seems to interfere with proper function of the
458 if (remote_debug
> 0)
463 puts_debug ("read -->", buf
, "<--");
469 /* Canonicialize \n\r combinations into one \r */
470 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
472 if ((c
== '\r' && state
== last_nl
)
473 || (c
== '\n' && state
== last_cr
))
494 if (c
== SERIAL_TIMEOUT
)
495 #if 0 /* MAINTENANCE_CMDS */
496 /* I fail to see how detaching here can be useful */
497 if (in_monitor_wait
) /* Watchdog went off */
499 target_mourn_inferior ();
500 error ("GDB serial timeout has expired. Target detached.\n");
504 error ("Timeout reading from remote system.");
506 perror_with_name ("remote-monitor");
509 /* Scan input from the remote system, until STRING is found. If BUF is non-
510 zero, then collect input until we have collected either STRING or BUFLEN-1
511 chars. In either case we terminate BUF with a 0. If input overflows BUF
512 because STRING can't be found, return -1, else return number of chars in BUF
513 (minus the terminating NUL). Note that in the non-overflow case, STRING
514 will be at the end of BUF. */
517 monitor_expect (string
, buf
, buflen
)
523 int obuflen
= buflen
;
525 extern struct target_ops
*targ_ops
;
530 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
531 monitor_printable_string (safe_string
, string
);
532 printf ("MON Expecting '%s'\n", safe_string
);
547 c
= readchar (timeout
);
554 c
= readchar (timeout
);
556 /* Don't expect any ^C sent to be echoed */
558 if (*p
== '\003' || c
== *p
)
568 return obuflen
- buflen
;
574 else if ((c
== '\021' || c
== '\023') &&
575 (STREQ (targ_ops
->to_shortname
, "m32r")
576 || STREQ (targ_ops
->to_shortname
, "mon2000")))
577 { /* m32r monitor emits random DC1/DC3 chars */
589 /* Search for a regexp. */
592 monitor_expect_regexp (pat
, buf
, buflen
)
593 struct re_pattern_buffer
*pat
;
599 RDEBUG(("MON Expecting regexp\n")) ;
604 mybuf
= alloca (1024);
613 if (p
- mybuf
>= buflen
)
614 { /* Buffer about to overflow */
616 /* On overflow, we copy the upper half of the buffer to the lower half. Not
617 great, but it usually works... */
619 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
620 p
= mybuf
+ buflen
/ 2;
623 *p
++ = readchar (timeout
);
625 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
631 /* Keep discarding input until we see the MONITOR prompt.
633 The convention for dealing with the prompt is that you
635 o *then* wait for the prompt.
637 Thus the last thing that a procedure does with the serial line will
638 be an monitor_expect_prompt(). Exception: monitor_resume does not
639 wait for the prompt, because the terminal is being handed over to
640 the inferior. However, the next thing which happens after that is
641 a monitor_wait which does wait for the prompt. Note that this
642 includes abnormal exit, e.g. error(). This is necessary to prevent
643 getting into states from which we can't recover. */
646 monitor_expect_prompt (buf
, buflen
)
650 RDEBUG(("MON Expecting prompt\n"))
651 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
654 /* Get N 32-bit words from remote, each preceded by a space, and put
655 them in registers starting at REGNO. */
666 ch
= readchar (timeout
);
671 for (i
= 7; i
>= 1; i
--)
673 ch
= readchar (timeout
);
676 val
= (val
<< 4) | from_hex (ch
);
684 compile_pattern (pattern
, compiled_pattern
, fastmap
)
686 struct re_pattern_buffer
*compiled_pattern
;
692 compiled_pattern
->fastmap
= fastmap
;
694 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
695 val
= re_compile_pattern (pattern
,
701 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern
, val
);
704 re_compile_fastmap (compiled_pattern
);
707 /* Open a connection to a remote debugger. NAME is the filename used
708 for communication. */
711 monitor_open (args
, mon_ops
, from_tty
)
713 struct monitor_ops
*mon_ops
;
719 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
720 error ("Magic number of monitor_ops struct wrong.");
722 targ_ops
= mon_ops
->target
;
723 name
= targ_ops
->to_shortname
;
726 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
727 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
729 target_preopen (from_tty
);
731 /* Setup pattern for register dump */
733 if (mon_ops
->register_pattern
)
734 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
737 if (mon_ops
->getmem
.resp_delim
)
738 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
739 getmem_resp_delim_fastmap
);
741 unpush_target (targ_ops
);
745 dev_name
= strsave (args
);
747 monitor_desc
= SERIAL_OPEN (dev_name
);
750 perror_with_name (dev_name
);
754 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
756 SERIAL_CLOSE (monitor_desc
);
757 perror_with_name (dev_name
);
761 SERIAL_RAW (monitor_desc
);
763 SERIAL_FLUSH_INPUT (monitor_desc
);
765 /* some systems only work with 2 stop bits */
767 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
769 current_monitor
= mon_ops
;
771 /* See if we can wake up the monitor. First, try sending a stop sequence,
772 then send the init strings. Last, remove all breakpoints. */
774 if (current_monitor
->stop
)
777 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
779 RDEBUG(("EXP Open echo\n")) ;
780 monitor_expect_prompt (NULL
, 0);
784 /* wake up the monitor and see if it's alive */
785 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
787 /* Some of the characters we send may not be echoed,
788 but we hope to get a prompt at the end of it all. */
790 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
793 monitor_printf_noecho (*p
);
794 monitor_expect_prompt (NULL
, 0);
797 SERIAL_FLUSH_INPUT (monitor_desc
);
799 /* Remove all breakpoints */
801 if (mon_ops
->clr_all_break
)
803 monitor_printf (mon_ops
->clr_all_break
);
804 monitor_expect_prompt (NULL
, 0);
808 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
810 push_target (targ_ops
);
812 inferior_pid
= 42000; /* Make run command think we are busy... */
814 /* Give monitor_wait something to read */
816 monitor_printf (current_monitor
->line_term
);
818 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
819 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory_block
);
821 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory
);
825 /* Close out all files and local state before this target loses
829 monitor_close (quitting
)
833 SERIAL_CLOSE (monitor_desc
);
837 /* Terminate the open connection to the remote debugger. Use this
838 when you want to detach and do something else with your gdb. */
841 monitor_detach (args
, from_tty
)
845 pop_target (); /* calls monitor_close to do the real work */
847 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
850 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
853 monitor_supply_register (regno
, valstr
)
858 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
861 val
= strtoul (valstr
, &p
, 16);
862 RDEBUG(("Supplying Register %d %s\n",regno
,valstr
)) ;
864 if (val
== 0 && valstr
== p
)
865 error ("monitor_supply_register (%d): bad value from monitor: %s.",
868 /* supply register stores in target byte order, so swap here */
870 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
872 supply_register (regno
, regbuf
);
877 /* Tell the remote machine to resume. */
880 flush_monitor_dcache ()
882 dcache_flush (remote_dcache
);
886 monitor_resume (pid
, step
, sig
)
888 enum target_signal sig
;
890 /* Some monitors require a different command when starting a program */
891 RDEBUG(("MON resume\n")) ;
892 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
895 monitor_printf ("run\r");
896 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
900 dcache_flush (remote_dcache
);
902 monitor_printf (current_monitor
->step
);
905 if (current_monitor
->continue_hook
)
906 (*current_monitor
->continue_hook
)() ;
907 else monitor_printf (current_monitor
->cont
);
908 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
913 /* Parse the output of a register dump command. A monitor specific
914 regexp is used to extract individual register descriptions of the
915 form REG=VAL. Each description is split up into a name and a value
916 string which are passed down to monitor specific code. */
919 parse_register_dump (buf
, len
)
923 RDEBUG(("MON Parsing register dump\n"))
926 int regnamelen
, vallen
;
928 /* Element 0 points to start of register name, and element 1
929 points to the start of the register value. */
930 struct re_registers register_strings
;
932 memset (®ister_strings
, 0, sizeof (struct re_registers
));
934 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
935 ®ister_strings
) == -1)
938 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
939 regname
= buf
+ register_strings
.start
[1];
940 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
941 val
= buf
+ register_strings
.start
[2];
943 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
945 buf
+= register_strings
.end
[0];
946 len
-= register_strings
.end
[0];
950 /* Send ^C to target to halt it. Target will respond, and send us a
954 monitor_interrupt (signo
)
957 /* If this doesn't work, try more severe steps. */
958 signal (signo
, monitor_interrupt_twice
);
961 printf_unfiltered ("monitor_interrupt called\n");
966 /* The user typed ^C twice. */
969 monitor_interrupt_twice (signo
)
972 signal (signo
, ofunc
);
974 monitor_interrupt_query ();
976 signal (signo
, monitor_interrupt
);
979 /* Ask the user what to do when an interrupt is received. */
982 monitor_interrupt_query ()
984 target_terminal_ours ();
986 if (query ("Interrupted while waiting for the program.\n\
987 Give up (and stop debugging it)? "))
989 target_mourn_inferior ();
990 return_to_top_level (RETURN_QUIT
);
993 target_terminal_inferior ();
997 monitor_wait_cleanup (old_timeout
)
1000 timeout
= *(int*)old_timeout
;
1001 signal (SIGINT
, ofunc
);
1002 in_monitor_wait
= 0;
1007 void monitor_wait_filter(char * buf
,
1010 struct target_waitstatus
* status
1016 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1017 * ext_resp_len
=resp_len
;
1020 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1022 while (resp_len
< 0);
1024 /* Print any output characters that were preceded by ^O. */
1025 /* FIXME - This would be great as a user settabgle flag */
1027 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1031 for (i
= 0; i
< resp_len
- 1; i
++)
1033 putchar_unfiltered (buf
[++i
]);
1039 /* Wait until the remote machine stops, then return, storing status in
1040 status just as `wait' would. */
1043 monitor_wait (pid
, status
)
1045 struct target_waitstatus
*status
;
1047 int old_timeout
= timeout
;
1050 struct cleanup
*old_chain
;
1052 status
->kind
= TARGET_WAITKIND_EXITED
;
1053 status
->value
.integer
= 0;
1055 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1056 RDEBUG(("MON wait\n"))
1058 #if 0 /* MAINTENANCE_CMDS */
1059 /* This is somthing other than a maintenance command */
1060 in_monitor_wait
= 1;
1061 timeout
= watchdog
> 0 ? watchdog
: -1;
1063 timeout
= -1; /* Don't time out -- user program is running. */
1066 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1068 if (current_monitor
->wait_filter
)
1069 (*current_monitor
->wait_filter
)(buf
,sizeof (buf
),&resp_len
,status
) ;
1070 else monitor_wait_filter(buf
,sizeof (buf
),&resp_len
,status
) ;
1072 #if 0 /* Transferred to monitor wait filter */
1075 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1078 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1080 while (resp_len
< 0);
1082 /* Print any output characters that were preceded by ^O. */
1083 /* FIXME - This would be great as a user settabgle flag */
1085 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1089 for (i
= 0; i
< resp_len
- 1; i
++)
1091 putchar_unfiltered (buf
[++i
]);
1095 signal (SIGINT
, ofunc
);
1097 timeout
= old_timeout
;
1099 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1102 monitor_printf (current_monitor
->dump_registers
);
1103 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1106 if (current_monitor
->register_pattern
)
1107 parse_register_dump (buf
, resp_len
);
1109 RDEBUG(("Wait fetching registers after stop\n")) ;
1110 monitor_dump_regs() ;
1113 status
->kind
= TARGET_WAITKIND_STOPPED
;
1114 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1116 discard_cleanups (old_chain
);
1118 in_monitor_wait
= 0;
1120 return inferior_pid
;
1123 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1127 monitor_fetch_register (regno
)
1131 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] = {0};
1132 char regbuf
[MAX_REGISTER_RAW_SIZE
* 2 + 1];
1135 name
= current_monitor
->regnames
[regno
];
1136 RDEBUG(("MON fetchreg %d '%s'\n",regno
,name
))
1138 if (!name
|| (*name
== '\0'))
1139 { RDEBUG(("No register known for %d\n",regno
))
1140 supply_register (regno
, zerobuf
);
1144 /* send the register examine command */
1146 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1148 /* If RESP_DELIM is specified, we search for that as a leading
1149 delimiter for the register value. Otherwise, we just start
1150 searching from the start of the buf. */
1152 if (current_monitor
->getreg
.resp_delim
)
1154 RDEBUG(("EXP getreg.resp_delim\n"))
1155 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1156 /* Handle case of first 32 registers listed in pairs. */
1157 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1158 && regno
& 1 == 1 && regno
< 32)
1159 { RDEBUG(("EXP getreg.resp_delim\n")) ;
1160 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1164 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1165 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1168 c
= readchar (timeout
);
1170 c
= readchar (timeout
);
1171 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1174 error ("Bad value returned from monitor while fetching register %x.",
1178 /* Read upto the maximum number of hex digits for this register, skipping
1179 spaces, but stop reading if something else is seen. Some monitors
1180 like to drop leading zeros. */
1182 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
1185 c
= readchar (timeout
);
1187 c
= readchar (timeout
);
1195 regbuf
[i
] = '\000'; /* terminate the number */
1196 RDEBUG(("REGVAL '%s'\n",regbuf
)) ;
1198 /* If TERM is present, we wait for that to show up. Also, (if TERM
1199 is present), we will send TERM_CMD if that is present. In any
1200 case, we collect all of the output into buf, and then wait for
1201 the normal prompt. */
1203 if (current_monitor
->getreg
.term
)
1205 RDEBUG(("EXP getreg.term\n"))
1206 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1209 if (current_monitor
->getreg
.term_cmd
)
1210 { RDEBUG(("EMIT getreg.term.cmd\n"))
1211 monitor_printf (current_monitor
->getreg
.term_cmd
);
1213 if (! current_monitor
->getreg
.term
|| /* Already expected or */
1214 current_monitor
->getreg
.term_cmd
) /* ack expected */
1215 monitor_expect_prompt (NULL
, 0); /* get response */
1217 monitor_supply_register (regno
, regbuf
);
1220 /* Sometimes, it takes several commands to dump the registers */
1221 /* This is a primitive for use by variations of monitor interfaces in
1222 case they need to compose the operation.
1224 int monitor_dump_reg_block(char * block_cmd
)
1228 monitor_printf (block_cmd
);
1229 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1230 parse_register_dump (buf
, resp_len
);
1235 /* Read the remote registers into the block regs. */
1236 /* Call the specific function if it has been provided */
1239 monitor_dump_regs ()
1243 if (current_monitor
->dumpregs
)
1244 (*(current_monitor
->dumpregs
))() ; /* call supplied function */
1246 if (current_monitor
->dump_registers
) /* default version */
1247 { monitor_printf (current_monitor
->dump_registers
);
1248 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1249 parse_register_dump (buf
, resp_len
);
1252 abort(); /* Need some way to read registers */
1256 monitor_fetch_registers (regno
)
1259 RDEBUG(("MON fetchregs\n")) ;
1260 if (current_monitor
->getreg
.cmd
)
1264 monitor_fetch_register (regno
);
1268 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1269 monitor_fetch_register (regno
);
1272 monitor_dump_regs ();
1276 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1279 monitor_store_register (regno
)
1285 name
= current_monitor
->regnames
[regno
];
1286 if (!name
|| (*name
== '\0'))
1287 { RDEBUG(("MON Cannot store unknown register\n"))
1291 val
= read_register (regno
);
1292 RDEBUG(("MON storeg %d %08x\n",regno
,(unsigned int)val
))
1294 /* send the register deposit command */
1296 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1297 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1298 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1299 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1301 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1303 if (current_monitor
->setreg
.term
)
1304 { RDEBUG(("EXP setreg.term\n"))
1305 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1306 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1307 monitor_printf ("%x\r", val
);
1308 monitor_expect_prompt (NULL
, 0);
1311 monitor_expect_prompt (NULL
, 0);
1312 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1313 { RDEBUG(("EXP setreg_termcmd\n")) ;
1314 monitor_printf("%s",current_monitor
->setreg
.term_cmd
) ;
1315 monitor_expect_prompt(NULL
,0) ;
1317 } /* monitor_store_register */
1319 /* Store the remote registers. */
1322 monitor_store_registers (regno
)
1327 monitor_store_register (regno
);
1331 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1332 monitor_store_register (regno
);
1335 /* Get ready to modify the registers array. On machines which store
1336 individual registers, this doesn't need to do anything. On machines
1337 which store all the registers in one fell swoop, this makes sure
1338 that registers contains all the registers from the program being
1342 monitor_prepare_to_store ()
1344 /* Do nothing, since we can store individual regs */
1348 monitor_files_info (ops
)
1349 struct target_ops
*ops
;
1351 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1355 monitor_write_memory (memaddr
, myaddr
, len
)
1360 unsigned int val
, hostval
;
1364 RDEBUG(("MON write %d %08x\n",len
,(unsigned long)memaddr
))
1366 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1367 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1369 /* Use memory fill command for leading 0 bytes. */
1371 if (current_monitor
->fill
)
1373 for (i
= 0; i
< len
; i
++)
1377 if (i
> 4) /* More than 4 zeros is worth doing */
1379 RDEBUG(("MON FILL %d\n",i
))
1380 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1381 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
)-1, 0);
1383 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1385 monitor_expect_prompt (NULL
, 0);
1392 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1393 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1396 cmd
= current_monitor
->setmem
.cmdll
;
1400 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1403 cmd
= current_monitor
->setmem
.cmdl
;
1405 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1408 cmd
= current_monitor
->setmem
.cmdw
;
1413 cmd
= current_monitor
->setmem
.cmdb
;
1416 val
= extract_unsigned_integer (myaddr
, len
);
1419 { hostval
= * (unsigned int *) myaddr
;
1420 RDEBUG(("Hostval(%08x) val(%08x)\n",hostval
,val
)) ;
1424 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1425 monitor_printf_noecho (cmd
, memaddr
, val
);
1426 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1429 monitor_printf_noecho (cmd
, memaddr
);
1431 if (current_monitor
->setmem
.term
)
1432 { RDEBUG(("EXP setmem.term")) ;
1433 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1434 monitor_printf ("%x\r", val
);
1436 if (current_monitor
->setmem
.term_cmd
)
1437 { /* Emit this to get out of the memory editing state */
1438 monitor_printf("%s",current_monitor
->setmem
.term_cmd
) ;
1439 /* Drop through to expecting a prompt */
1443 monitor_printf (cmd
, memaddr
, val
);
1445 monitor_expect_prompt (NULL
, 0);
1452 monitor_write_even_block(memaddr
,myaddr
,len
)
1459 /* Enter the sub mode */
1460 monitor_printf(current_monitor
->setmem
.cmdl
,memaddr
) ;
1461 monitor_expect_prompt(NULL
,0) ;
1465 val
= extract_unsigned_integer(myaddr
,4) ; /* REALLY */
1466 monitor_printf("%x\r",val
) ;
1470 RDEBUG((" @ %08x\n",memaddr
))
1471 /* If we wanted to, here we could validate the address */
1472 monitor_expect_prompt(NULL
,0) ;
1474 /* Now exit the sub mode */
1475 monitor_printf (current_monitor
->getreg
.term_cmd
);
1476 monitor_expect_prompt(NULL
,0) ;
1481 static int monitor_write_memory_bytes(memaddr
,myaddr
,len
)
1488 if (len
== 0) return 0 ;
1489 /* Enter the sub mode */
1490 monitor_printf(current_monitor
->setmem
.cmdb
,memaddr
) ;
1491 monitor_expect_prompt(NULL
,0) ;
1495 monitor_printf("%x\r",val
) ;
1499 /* If we wanted to, here we could validate the address */
1500 monitor_expect_prompt(NULL
,0) ;
1503 /* Now exit the sub mode */
1504 monitor_printf (current_monitor
->getreg
.term_cmd
);
1505 monitor_expect_prompt(NULL
,0) ;
1511 longlongendswap (unsigned char * a
)
1523 /* Format 32 chars of long long value, advance the pointer */
1524 static char * hexlate
= "0123456789abcdef" ;
1525 static char * longlong_hexchars(unsigned long long value
,
1528 if (value
== 0) { *outbuff
++ = '0' ; return outbuff
; }
1530 { static unsigned char disbuf
[8] ; /* disassembly buffer */
1531 unsigned char * scan
, * limit
; /* loop controls */
1532 unsigned char c
, nib
;
1534 scan
= disbuf
; limit
= scan
+ 8 ;
1535 { unsigned long long * dp
;
1536 dp
= (unsigned long long *) scan
;
1539 longlongendswap(disbuf
) ; /* FIXME: ONly on big endian hosts */
1540 while (scan
< limit
)
1541 { c
= *scan
++ ; /* a byte of our long long value */
1543 if (c
== 0) continue ;
1544 else leadzero
= 0 ; /* henceforth we print even zeroes */
1545 nib
= c
>> 4 ; /* high nibble bits */
1546 *outbuff
++ = hexlate
[nib
] ;
1547 nib
= c
& 0x0f ; /* low nibble bits */
1548 *outbuff
++ = hexlate
[nib
] ;
1552 } /* longlong_hexchars */
1556 /* I am only going to call this when writing virtual byte streams.
1557 Which possably entails endian conversions
1559 static int monitor_write_memory_longlongs(memaddr
,myaddr
,len
)
1564 static char hexstage
[20] ; /* At least 16 digits required, plus null */
1569 llptr
= (unsigned long long *) myaddr
;
1570 if (len
== 0 ) return 0 ;
1571 monitor_printf(current_monitor
->setmem
.cmdll
,memaddr
) ;
1572 monitor_expect_prompt(NULL
,0) ;
1576 endstring
= longlong_hexchars(*llptr
,hexstage
) ;
1577 *endstring
= '\0' ; /* NUll terminate for printf */
1578 monitor_printf("%s\r",hexstage
) ;
1582 /* If we wanted to, here we could validate the address */
1583 monitor_expect_prompt(NULL
,0) ;
1586 /* Now exit the sub mode */
1587 monitor_printf (current_monitor
->getreg
.term_cmd
);
1588 monitor_expect_prompt(NULL
,0) ;
1594 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1595 /* This is for the large blocks of memory which may occur in downloading.
1596 And for monitors which use interactive entry,
1597 And for monitors which do not have other downloading methods.
1598 Without this, we will end up calling monitor_write_memory many times
1599 and do the entry and exit of the sub mode many times
1600 This currently assumes...
1601 MO_SETMEM_INTERACTIVE
1602 ! MO_NO_ECHO_ON_SETMEM
1603 To use this, the you have to patch the monitor_cmds block with
1604 this function. Otherwise, its not tuned up for use by all
1608 static int monitor_write_memory_block(memaddr
,myaddr
,len
)
1615 /* FIXME: This would be a good place to put the zero test */
1617 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1619 return monitor_write_memory_longlongs(memaddr
,myaddr
,len
) ;
1626 written
= monitor_write_even_block(memaddr
,myaddr
,len
) ;
1627 /* Adjust calling parameters by written amount */
1628 memaddr
+= written
;
1633 written
= monitor_write_memory_bytes(memaddr
,myaddr
,len
) ;
1637 /* This is an alternate form of monitor_read_memory which is used for monitors
1638 which can only read a single byte/word/etc. at a time. */
1641 monitor_read_memory_single (memaddr
, myaddr
, len
)
1647 char membuf
[sizeof(int) * 2 + 1];
1652 RDEBUG(("MON read single\n")) ;
1654 /* Can't actually use long longs (nice idea, though). In fact, the
1655 call to strtoul below will fail if it tries to convert a value
1656 that's too big to fit in a long. */
1657 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1660 cmd
= current_monitor
->getmem
.cmdll
;
1664 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1667 cmd
= current_monitor
->getmem
.cmdl
;
1669 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1672 cmd
= current_monitor
->getmem
.cmdw
;
1677 cmd
= current_monitor
->getmem
.cmdb
;
1680 /* Send the examine command. */
1682 monitor_printf (cmd
, memaddr
);
1684 /* If RESP_DELIM is specified, we search for that as a leading
1685 delimiter for the memory value. Otherwise, we just start
1686 searching from the start of the buf. */
1688 if (current_monitor
->getmem
.resp_delim
)
1689 { RDEBUG(("EXP getmem.resp_delim\n")) ;
1690 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1693 /* Now, read the appropriate number of hex digits for this loc,
1696 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1697 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1701 c
= readchar (timeout
);
1703 c
= readchar (timeout
);
1704 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1707 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1708 memaddr
, i
, membuf
, c
);
1710 for (i
= 0; i
< len
* 2; i
++)
1716 c
= readchar (timeout
);
1722 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1723 memaddr
, i
, membuf
, c
);
1729 membuf
[i
] = '\000'; /* terminate the number */
1731 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1732 present), we will send TERM_CMD if that is present. In any case, we collect
1733 all of the output into buf, and then wait for the normal prompt. */
1735 if (current_monitor
->getmem
.term
)
1737 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1739 if (current_monitor
->getmem
.term_cmd
)
1741 monitor_printf (current_monitor
->getmem
.term_cmd
);
1742 monitor_expect_prompt (NULL
, 0);
1746 monitor_expect_prompt (NULL
, 0); /* get response */
1749 val
= strtoul (membuf
, &p
, 16);
1751 if (val
== 0 && membuf
== p
)
1752 monitor_error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
1753 memaddr
, 0, membuf
, 0);
1755 /* supply register stores in target byte order, so swap here */
1757 store_unsigned_integer (myaddr
, len
, val
);
1762 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1763 memory at MEMADDR. Returns length moved. Currently, we do no more
1764 than 16 bytes at a time. */
1767 monitor_read_memory (memaddr
, myaddr
, len
)
1781 RDEBUG (("Zero length call to monitor_read_memory\n"));
1785 if (remote_debug
) printf("MON read block ta(%08x) ha(%08x) %d\n",
1786 (unsigned long) memaddr
, (unsigned long)myaddr
, len
);
1788 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1789 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1791 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1792 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1794 len
= min (len
, 16);
1796 /* Some dumpers align the first data with the preceeding 16
1797 byte boundary. Some print blanks and start at the
1798 requested boundary. EXACT_DUMPADDR
1801 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1802 ? memaddr
: memaddr
& ~ 0x0f ;
1804 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1805 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1806 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1808 /* send the memory examine command */
1810 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1811 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
- 1);
1812 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1813 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1815 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1817 /* If TERM is present, we wait for that to show up. Also, (if TERM
1818 is present), we will send TERM_CMD if that is present. In any
1819 case, we collect all of the output into buf, and then wait for
1820 the normal prompt. */
1822 if (current_monitor
->getmem
.term
)
1824 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1827 monitor_error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
1828 memaddr
, resp_len
, buf
, 0);
1830 if (current_monitor
->getmem
.term_cmd
)
1832 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1833 strlen (current_monitor
->getmem
.term_cmd
));
1834 monitor_expect_prompt (NULL
, 0);
1838 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1842 /* If RESP_DELIM is specified, we search for that as a leading
1843 delimiter for the values. Otherwise, we just start searching
1844 from the start of the buf. */
1846 if (current_monitor
->getmem
.resp_delim
)
1849 struct re_registers resp_strings
;
1850 RDEBUG(("MON getmem.resp_delim %s\n",current_monitor
->getmem
.resp_delim
)) ;
1852 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1854 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1858 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1859 memaddr
, resp_len
, buf
, 0);
1861 p
+= resp_strings
.end
[0];
1863 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1865 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1866 memaddr
, resp_len
, buf
, 0);
1867 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1870 if (remote_debug
) printf("MON scanning %d ,%08x '%s'\n",len
,p
,p
) ;
1871 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1879 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1881 { if ((dumpaddr
>= memaddr
) && (i
> 0))
1882 { val
= fromhex (c
) * 16 + fromhex (*(p
+1));
1884 if (remote_debug
) printf("[%02x]",val
) ;
1891 ++p
; /* skip a blank or other non hex char */
1894 if (fetched
== 0) error("Failed to read via monitor") ;
1895 if (remote_debug
) printf("\n") ;
1896 return fetched
; /* Return the number of bytes actually read */
1898 RDEBUG(("MON scanning bytes\n")) ;
1900 for (i
= len
; i
> 0; i
--)
1902 /* Skip non-hex chars, but bomb on end of string and newlines */
1909 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1910 monitor_error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s",
1911 memaddr
, resp_len
, buf
, 0);
1915 val
= strtoul (p
, &p1
, 16);
1917 if (val
== 0 && p
== p1
)
1918 monitor_error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.",
1919 memaddr
, resp_len
, buf
, 0);
1933 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1938 struct target_ops
*target
; /* ignored */
1940 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, write
);
1946 return; /* ignore attempts to kill target system */
1949 /* All we actually do is set the PC to the start address of exec_bfd, and start
1950 the program at that point. */
1953 monitor_create_inferior (exec_file
, args
, env
)
1958 if (args
&& (*args
!= '\000'))
1959 error ("Args are not supported by the monitor.");
1962 clear_proceed_status ();
1963 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1966 /* Clean up when a program exits.
1967 The program actually lives on in the remote processor's RAM, and may be
1968 run again without a download. Don't leave it full of breakpoint
1972 monitor_mourn_inferior ()
1974 unpush_target (targ_ops
);
1975 generic_mourn_inferior (); /* Do all the proper things now */
1978 #define NUM_MONITOR_BREAKPOINTS 8
1980 static CORE_ADDR breakaddr
[NUM_MONITOR_BREAKPOINTS
] = {0};
1982 /* Tell the monitor to add a breakpoint. */
1985 monitor_insert_breakpoint (addr
, shadow
)
1993 RDEBUG(("MON inst bkpt %08x\n",addr
))
1994 if (current_monitor
->set_break
== NULL
)
1995 error ("No set_break defined for this monitor");
1997 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1998 addr
= ADDR_BITS_REMOVE (addr
);
2000 /* Determine appropriate breakpoint size for this address. */
2001 bp
= memory_breakpoint_from_pc (&addr
, &bplen
);
2003 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
2005 if (breakaddr
[i
] == 0)
2007 breakaddr
[i
] = addr
;
2008 monitor_read_memory (addr
, shadow
, bplen
);
2009 monitor_printf (current_monitor
->set_break
, addr
);
2010 monitor_expect_prompt (NULL
, 0);
2015 error ("Too many breakpoints (> %d) for monitor.", NUM_MONITOR_BREAKPOINTS
);
2018 /* Tell the monitor to remove a breakpoint. */
2021 monitor_remove_breakpoint (addr
, shadow
)
2027 RDEBUG(("MON rmbkpt %08x\n",addr
))
2028 if (current_monitor
->clr_break
== NULL
)
2029 error ("No clr_break defined for this monitor");
2031 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2032 addr
= ADDR_BITS_REMOVE (addr
);
2034 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
2036 if (breakaddr
[i
] == addr
)
2039 /* some monitors remove breakpoints based on the address */
2040 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2041 monitor_printf (current_monitor
->clr_break
, addr
);
2042 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2043 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2045 monitor_printf (current_monitor
->clr_break
, i
);
2046 monitor_expect_prompt (NULL
, 0);
2050 fprintf_unfiltered (gdb_stderr
,
2051 "Can't find breakpoint associated with 0x%x\n", addr
);
2055 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2056 an S-record. Return non-zero if the ACK is received properly. */
2059 monitor_wait_srec_ack ()
2063 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2065 return (readchar (timeout
) == '+');
2067 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2069 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2070 if ((ch
= readchar (1)) < 0)
2072 if ((ch
= readchar (1)) < 0)
2074 if ((ch
= readchar (1)) < 0)
2076 if ((ch
= readchar (1)) < 0)
2082 /* monitor_load -- download a file. */
2085 monitor_load (file
, from_tty
)
2089 dcache_flush (remote_dcache
);
2090 RDEBUG(("MON load\n"))
2092 if (current_monitor
->load_routine
)
2093 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2095 { /* The default is ascii S-records */
2097 unsigned long load_offset
;
2100 /* enable user to specify address for downloading as 2nd arg to load */
2101 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2107 monitor_printf (current_monitor
->load
);
2108 if (current_monitor
->loadresp
)
2109 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2111 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2112 32, SREC_ALL
, hashmark
,
2113 current_monitor
->flags
& MO_SREC_ACK
?
2114 monitor_wait_srec_ack
: NULL
);
2116 monitor_expect_prompt (NULL
, 0);
2119 /* Finally, make the PC point at the start address */
2122 write_pc (bfd_get_start_address (exec_bfd
));
2124 inferior_pid
= 0; /* No process now */
2126 /* This is necessary because many things were based on the PC at the time that
2127 we attached to the monitor, which is no longer valid now that we have loaded
2128 new code (and just changed the PC). Another way to do this might be to call
2129 normal_stop, except that the stack may not be valid, and things would get
2130 horribly confused... */
2132 clear_symtab_users ();
2138 RDEBUG(("MON stop\n")) ;
2139 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2140 SERIAL_SEND_BREAK (monitor_desc
);
2141 if (current_monitor
->stop
)
2142 monitor_printf_noecho (current_monitor
->stop
);
2145 /* Put a command string, in args, out to MONITOR. Output from MONITOR
2146 is placed on the users terminal until the prompt is seen. FIXME: We
2147 read the characters ourseleves here cause of a nasty echo. */
2150 monitor_command (args
, from_tty
)
2158 if (monitor_desc
== NULL
)
2159 error ("monitor target not open.");
2161 p
= current_monitor
->prompt
;
2163 /* Send the command. Note that if no args were supplied, then we're
2164 just sending the monitor a newline, which is sometimes useful. */
2166 monitor_printf ("%s\r", (args
? args
: ""));
2168 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2170 fputs_unfiltered (buf
, gdb_stdout
); /* Output the response */
2173 /* Convert hex digit A to a number. */
2180 if (a
>= '0' && a
<= '9')
2182 if (a
>= 'a' && a
<= 'f')
2183 return a
- 'a' + 10;
2184 if (a
>= 'A' && a
<= 'F')
2185 return a
- 'A' + 10;
2187 error ("Reply contains invalid hex digit 0x%x", a
);
2192 monitor_get_dev_name ()
2197 static struct target_ops monitor_ops
;
2200 init_base_monitor_ops (void)
2202 monitor_ops
.to_shortname
= NULL
;
2203 monitor_ops
.to_longname
= NULL
;
2204 monitor_ops
.to_doc
= NULL
;
2205 monitor_ops
.to_open
= NULL
;
2206 monitor_ops
.to_close
= monitor_close
;
2207 monitor_ops
.to_attach
= NULL
;
2208 monitor_ops
.to_post_attach
= NULL
;
2209 monitor_ops
.to_require_attach
= NULL
;
2210 monitor_ops
.to_detach
= monitor_detach
;
2211 monitor_ops
.to_require_detach
= NULL
;
2212 monitor_ops
.to_resume
= monitor_resume
;
2213 monitor_ops
.to_wait
= monitor_wait
;
2214 monitor_ops
.to_post_wait
= NULL
;
2215 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2216 monitor_ops
.to_store_registers
= monitor_store_registers
;
2217 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2218 monitor_ops
.to_xfer_memory
= monitor_xfer_memory
;
2219 monitor_ops
.to_files_info
= monitor_files_info
;
2220 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2221 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2222 monitor_ops
.to_terminal_init
= 0;
2223 monitor_ops
.to_terminal_inferior
= 0;
2224 monitor_ops
.to_terminal_ours_for_output
= 0;
2225 monitor_ops
.to_terminal_ours
= 0;
2226 monitor_ops
.to_terminal_info
= 0;
2227 monitor_ops
.to_kill
= monitor_kill
;
2228 monitor_ops
.to_load
= monitor_load
;
2229 monitor_ops
.to_lookup_symbol
= 0;
2230 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2231 monitor_ops
.to_post_startup_inferior
= NULL
;
2232 monitor_ops
.to_acknowledge_created_inferior
= NULL
;
2233 monitor_ops
.to_clone_and_follow_inferior
= NULL
;
2234 monitor_ops
.to_post_follow_inferior_by_clone
= NULL
;
2235 monitor_ops
.to_insert_fork_catchpoint
= NULL
;
2236 monitor_ops
.to_remove_fork_catchpoint
= NULL
;
2237 monitor_ops
.to_insert_vfork_catchpoint
= NULL
;
2238 monitor_ops
.to_remove_vfork_catchpoint
= NULL
;
2239 monitor_ops
.to_has_forked
= NULL
;
2240 monitor_ops
.to_has_vforked
= NULL
;
2241 monitor_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2242 monitor_ops
.to_post_follow_vfork
= NULL
;
2243 monitor_ops
.to_insert_exec_catchpoint
= NULL
;
2244 monitor_ops
.to_remove_exec_catchpoint
= NULL
;
2245 monitor_ops
.to_has_execd
= NULL
;
2246 monitor_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2247 monitor_ops
.to_has_exited
= NULL
;
2248 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2249 monitor_ops
.to_can_run
= 0;
2250 monitor_ops
.to_notice_signals
= 0;
2251 monitor_ops
.to_thread_alive
= 0;
2252 monitor_ops
.to_stop
= monitor_stop
;
2253 monitor_ops
.to_pid_to_exec_file
= NULL
;
2254 monitor_ops
.to_core_file_to_sym_file
= NULL
;
2255 monitor_ops
.to_stratum
= process_stratum
;
2256 monitor_ops
.DONT_USE
= 0;
2257 monitor_ops
.to_has_all_memory
= 1;
2258 monitor_ops
.to_has_memory
= 1;
2259 monitor_ops
.to_has_stack
= 1;
2260 monitor_ops
.to_has_registers
= 1;
2261 monitor_ops
.to_has_execution
= 1;
2262 monitor_ops
.to_sections
= 0;
2263 monitor_ops
.to_sections_end
= 0;
2264 monitor_ops
.to_magic
= OPS_MAGIC
;
2265 } /* init_base_monitor_ops */
2267 /* Init the target_ops structure pointed at by OPS */
2270 init_monitor_ops (ops
)
2271 struct target_ops
*ops
;
2273 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2274 init_base_monitor_ops ();
2276 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2279 /* Define additional commands that are usually only used by monitors. */
2282 _initialize_remote_monitors ()
2284 init_base_monitor_ops ();
2285 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
2287 "Set display of activity while downloading a file.\n\
2288 When enabled, a hashmark \'#\' is displayed.",
2292 add_com ("monitor", class_obscure
, monitor_command
,
2293 "Send a command to the debug monitor.");