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,
22 Boston, MA 02111-1307, USA. */
24 /* This file was derived from various remote-* modules. It is a collection
25 of generic support functions so GDB can talk directly to a ROM based
26 monitor. This saves use from having to hack an exception based handler
27 into existance, and makes for quick porting.
29 This module talks to a debug monitor called 'MONITOR', which
30 We communicate with MONITOR via either a direct serial line, or a TCP
31 (or possibly TELNET) stream to a terminal multiplexor,
32 which in turn talks to the target board. */
34 /* FIXME 32x64: This code assumes that registers and addresses are at
35 most 32 bits long. If they can be larger, you will need to declare
36 values as LONGEST and use %llx or some such to print values when
37 building commands to send to the monitor. Since we don't know of
38 any actual 64-bit targets with ROM monitors that use this code,
39 it's not an issue right now. -sts 4/18/96 */
47 #include "gdb_string.h"
48 #include <sys/types.h>
54 #include "gnu-regex.h"
58 static char *dev_name
;
59 static struct target_ops
*targ_ops
;
61 static void monitor_vsprintf
PARAMS ((char *sndbuf
, char *pattern
, va_list args
));
63 static int readchar
PARAMS ((int timeout
));
65 static void monitor_fetch_register
PARAMS ((int regno
));
66 static void monitor_store_register
PARAMS ((int regno
));
68 static void monitor_printable_string (char *newstr
, char *oldstr
, int len
);
69 static void monitor_error (char *function
, char *message
, CORE_ADDR memaddr
, int len
, char *string
, int final_char
);
70 static void monitor_detach
PARAMS ((char *args
, int from_tty
));
71 static void monitor_resume
PARAMS ((int pid
, int step
, enum target_signal sig
));
72 static void monitor_interrupt
PARAMS ((int signo
));
73 static void monitor_interrupt_twice
PARAMS ((int signo
));
74 static void monitor_interrupt_query
PARAMS ((void));
75 static void monitor_wait_cleanup
PARAMS ((void *old_timeout
));
77 static int monitor_wait
PARAMS ((int pid
, struct target_waitstatus
* status
));
78 static void monitor_fetch_registers
PARAMS ((int regno
));
79 static void monitor_store_registers
PARAMS ((int regno
));
80 static void monitor_prepare_to_store
PARAMS ((void));
81 static int monitor_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
, int len
, int write
, struct target_ops
* target
));
82 static void monitor_files_info
PARAMS ((struct target_ops
* ops
));
83 static int monitor_insert_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
84 static int monitor_remove_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
85 static void monitor_kill
PARAMS ((void));
86 static void monitor_load
PARAMS ((char *file
, int from_tty
));
87 static void monitor_mourn_inferior
PARAMS ((void));
88 static void monitor_stop
PARAMS ((void));
90 static int monitor_read_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
, int len
));
91 static int monitor_write_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
, int len
));
92 static int monitor_write_memory_bytes
PARAMS ((CORE_ADDR addr
,
93 char *myaddr
, int len
));
94 static int monitor_write_memory_block
PARAMS ((
98 static int monitor_expect_regexp
PARAMS ((struct re_pattern_buffer
* pat
,
99 char *buf
, int buflen
));
100 static void monitor_dump_regs
PARAMS ((void));
102 static int from_hex
PARAMS ((int a
));
103 static unsigned long get_hex_word
PARAMS ((void));
105 static void parse_register_dump
PARAMS ((char *, int));
107 static struct monitor_ops
*current_monitor
;
109 static int hashmark
; /* flag set by "set hash" */
111 static int timeout
= 30;
113 static int in_monitor_wait
= 0; /* Non-zero means we are in monitor_wait() */
115 static void (*ofunc
) (); /* Old SIGINT signal handler */
117 static CORE_ADDR
*breakaddr
;
119 /* Descriptor for I/O to remote machine. Initialize it to NULL so
120 that monitor_open knows that we don't have a file open when the
123 static serial_t monitor_desc
= NULL
;
125 /* Pointer to regexp pattern matching data */
127 static struct re_pattern_buffer register_pattern
;
128 static char register_fastmap
[256];
130 static struct re_pattern_buffer getmem_resp_delim_pattern
;
131 static char getmem_resp_delim_fastmap
[256];
133 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
134 monitor_wait wakes up. */
136 static DCACHE
*remote_dcache
;
137 static int first_time
= 0; /* is this the first time we're executing after
138 gaving created the child proccess? */
140 #define TARGET_BUF_SIZE 2048
142 /* Monitor specific debugging information. Typically only useful to
143 the developer of a new monitor interface. */
145 static void monitor_debug (const char *fmt
, ...) ATTR_FORMAT(printf
, 1, 2);
147 static int monitor_debug_p
= 0;
149 /* NOTE: This file alternates between monitor_debug_p and remote_debug
150 when determining if debug information is printed. Perhaphs this
151 could be simplified. */
154 monitor_debug (const char *fmt
, ...)
159 va_start (args
, fmt
);
160 vfprintf_filtered (gdb_stdlog
, fmt
, args
);
166 /* Convert a string into a printable representation, Return # byte in
167 the new string. When LEN is >0 it specifies the size of the
168 string. Otherwize strlen(oldstr) is used. */
171 monitor_printable_string (char *newstr
, char *oldstr
, int len
)
177 len
= strlen (oldstr
);
179 for (i
= 0; i
< len
; i
++)
190 sprintf (newstr
, "\\x%02x", ch
& 0xff);
229 /* Print monitor errors with a string, converting the string to printable
233 monitor_error (char *function
, char *message
,
234 CORE_ADDR memaddr
, int len
, char *string
, int final_char
)
236 int real_len
= (len
== 0 && string
!= (char *) 0) ? strlen (string
) : len
;
237 char *safe_string
= alloca ((real_len
* 4) + 1);
238 monitor_printable_string (safe_string
, string
, real_len
);
241 error ("%s (0x%s): %s: %s%c", function
, paddr_nz (memaddr
), message
, safe_string
, final_char
);
243 error ("%s (0x%s): %s: %s", function
, paddr_nz (memaddr
), message
, safe_string
);
246 /* Convert hex digit A to a number. */
252 if (a
>= '0' && a
<= '9')
254 else if (a
>= 'a' && a
<= 'f')
256 else if (a
>= 'A' && a
<= 'F')
259 error ("Invalid hex digit %d", a
);
262 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
264 This function exists to get around the problem that many host platforms
265 don't have a printf that can print 64-bit addresses. The %A format
266 specification is recognized as a special case, and causes the argument
267 to be printed as a 64-bit hexadecimal address.
269 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
270 If it is a '%s' format, the argument is a string; otherwise the
271 argument is assumed to be a long integer.
273 %% is also turned into a single %.
277 monitor_vsprintf (sndbuf
, pattern
, args
)
290 for (p
= pattern
; *p
; p
++)
294 /* Copy the format specifier to a separate buffer. */
296 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
299 format
[i
] = fmt
= *p
;
300 format
[i
+ 1] = '\0';
302 /* Fetch the next argument and print it. */
306 strcpy (sndbuf
, "%");
309 arg_addr
= va_arg (args
, CORE_ADDR
);
310 strcpy (sndbuf
, paddr_nz (arg_addr
));
313 arg_string
= va_arg (args
, char *);
314 sprintf (sndbuf
, format
, arg_string
);
317 arg_int
= va_arg (args
, long);
318 sprintf (sndbuf
, format
, arg_int
);
321 sndbuf
+= strlen (sndbuf
);
330 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
331 Works just like printf. */
334 monitor_printf_noecho (char *pattern
,...)
340 va_start (args
, pattern
);
342 monitor_vsprintf (sndbuf
, pattern
, args
);
344 len
= strlen (sndbuf
);
345 if (len
+ 1 > sizeof sndbuf
)
350 char *safe_string
= (char *) alloca ((strlen (sndbuf
) * 4) + 1);
351 monitor_printable_string (safe_string
, sndbuf
, 0);
352 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
355 monitor_write (sndbuf
, len
);
358 /* monitor_printf -- Send data to monitor and check the echo. Works just like
362 monitor_printf (char *pattern
,...)
368 va_start (args
, pattern
);
370 monitor_vsprintf (sndbuf
, pattern
, args
);
372 len
= strlen (sndbuf
);
373 if (len
+ 1 > sizeof sndbuf
)
378 char *safe_string
= (char *) alloca ((len
* 4) + 1);
379 monitor_printable_string (safe_string
, sndbuf
, 0);
380 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
383 monitor_write (sndbuf
, len
);
385 /* We used to expect that the next immediate output was the characters we
386 just output, but sometimes some extra junk appeared before the characters
387 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
388 So, just start searching for what we sent, and skip anything unknown. */
389 monitor_debug ("ExpectEcho\n");
390 monitor_expect (sndbuf
, (char *) 0, 0);
394 /* Write characters to the remote system. */
397 monitor_write (buf
, buflen
)
401 if (SERIAL_WRITE (monitor_desc
, buf
, buflen
))
402 fprintf_unfiltered (gdb_stderr
, "SERIAL_WRITE failed: %s\n",
403 safe_strerror (errno
));
407 /* Read a binary character from the remote system, doing all the fancy
408 timeout stuff, but without interpreting the character in any way,
409 and without printing remote debug information. */
420 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
423 c
&= 0xff; /* don't lose bit 7 */
430 if (c
== SERIAL_TIMEOUT
)
431 error ("Timeout reading from remote system.");
433 perror_with_name ("remote-monitor");
437 /* Read a character from the remote system, doing all the fancy
447 last_random
, last_nl
, last_cr
, last_crnl
455 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
460 /* This seems to interfere with proper function of the
462 if (monitor_debug_p
|| remote_debug
)
467 puts_debug ("read -->", buf
, "<--");
472 /* Canonicialize \n\r combinations into one \r */
473 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
475 if ((c
== '\r' && state
== last_nl
)
476 || (c
== '\n' && state
== last_cr
))
497 if (c
== SERIAL_TIMEOUT
)
499 /* I fail to see how detaching here can be useful */
500 if (in_monitor_wait
) /* Watchdog went off */
502 target_mourn_inferior ();
503 error ("GDB serial timeout has expired. Target detached.\n");
507 error ("Timeout reading from remote system.");
509 perror_with_name ("remote-monitor");
512 /* Scan input from the remote system, until STRING is found. If BUF is non-
513 zero, then collect input until we have collected either STRING or BUFLEN-1
514 chars. In either case we terminate BUF with a 0. If input overflows BUF
515 because STRING can't be found, return -1, else return number of chars in BUF
516 (minus the terminating NUL). Note that in the non-overflow case, STRING
517 will be at the end of BUF. */
520 monitor_expect (string
, buf
, buflen
)
526 int obuflen
= buflen
;
528 extern struct target_ops
*targ_ops
;
532 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
533 monitor_printable_string (safe_string
, string
, 0);
534 fprintf_unfiltered (gdb_stdlog
, "MON Expecting '%s'\n", safe_string
);
549 c
= readchar (timeout
);
556 c
= readchar (timeout
);
558 /* Don't expect any ^C sent to be echoed */
560 if (*p
== '\003' || c
== *p
)
570 return obuflen
- buflen
;
576 else if ((c
== '\021' || c
== '\023') &&
577 (STREQ (targ_ops
->to_shortname
, "m32r")
578 || STREQ (targ_ops
->to_shortname
, "mon2000")))
579 { /* m32r monitor emits random DC1/DC3 chars */
584 /* We got a character that doesn't match the string. We need to
585 back up p, but how far? If we're looking for "..howdy" and the
586 monitor sends "...howdy"? There's certainly a match in there,
587 but when we receive the third ".", we won't find it if we just
588 restart the matching at the beginning of the string.
590 This is a Boyer-Moore kind of situation. We want to reset P to
591 the end of the longest prefix of STRING that is a suffix of
592 what we've read so far. In the example above, that would be
593 ".." --- the longest prefix of "..howdy" that is a suffix of
594 "...". This longest prefix could be the empty string, if C
595 is nowhere to be found in STRING.
597 If this longest prefix is not the empty string, it must contain
598 C, so let's search from the end of STRING for instances of C,
599 and see if the portion of STRING before that is a suffix of
600 what we read before C. Actually, we can search backwards from
601 p, since we know no prefix can be longer than that.
603 Note that we can use STRING itself, along with C, as a record
604 of what we've received so far. :) */
607 for (i
= (p
- string
) - 1; i
>= 0; i
--)
610 /* Is this prefix a suffix of what we've read so far?
612 string[0 .. i-1] == string[p - i, p - 1]? */
613 if (! memcmp (string
, p
- i
, i
))
625 /* Search for a regexp. */
628 monitor_expect_regexp (pat
, buf
, buflen
)
629 struct re_pattern_buffer
*pat
;
635 monitor_debug ("MON Expecting regexp\n");
640 mybuf
= alloca (TARGET_BUF_SIZE
);
641 buflen
= TARGET_BUF_SIZE
;
649 if (p
- mybuf
>= buflen
)
650 { /* Buffer about to overflow */
652 /* On overflow, we copy the upper half of the buffer to the lower half. Not
653 great, but it usually works... */
655 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
656 p
= mybuf
+ buflen
/ 2;
659 *p
++ = readchar (timeout
);
661 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
667 /* Keep discarding input until we see the MONITOR prompt.
669 The convention for dealing with the prompt is that you
671 o *then* wait for the prompt.
673 Thus the last thing that a procedure does with the serial line will
674 be an monitor_expect_prompt(). Exception: monitor_resume does not
675 wait for the prompt, because the terminal is being handed over to
676 the inferior. However, the next thing which happens after that is
677 a monitor_wait which does wait for the prompt. Note that this
678 includes abnormal exit, e.g. error(). This is necessary to prevent
679 getting into states from which we can't recover. */
682 monitor_expect_prompt (buf
, buflen
)
686 monitor_debug ("MON Expecting prompt\n");
687 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
690 /* Get N 32-bit words from remote, each preceded by a space, and put
691 them in registers starting at REGNO. */
702 ch
= readchar (timeout
);
703 while (isspace (ch
));
707 for (i
= 7; i
>= 1; i
--)
709 ch
= readchar (timeout
);
712 val
= (val
<< 4) | from_hex (ch
);
720 compile_pattern (pattern
, compiled_pattern
, fastmap
)
722 struct re_pattern_buffer
*compiled_pattern
;
728 compiled_pattern
->fastmap
= fastmap
;
730 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
731 val
= re_compile_pattern (pattern
,
737 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern
, val
);
740 re_compile_fastmap (compiled_pattern
);
743 /* Open a connection to a remote debugger. NAME is the filename used
744 for communication. */
747 monitor_open (args
, mon_ops
, from_tty
)
749 struct monitor_ops
*mon_ops
;
755 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
756 error ("Magic number of monitor_ops struct wrong.");
758 targ_ops
= mon_ops
->target
;
759 name
= targ_ops
->to_shortname
;
762 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
763 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
765 target_preopen (from_tty
);
767 /* Setup pattern for register dump */
769 if (mon_ops
->register_pattern
)
770 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
773 if (mon_ops
->getmem
.resp_delim
)
774 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
775 getmem_resp_delim_fastmap
);
777 unpush_target (targ_ops
);
781 dev_name
= strsave (args
);
783 monitor_desc
= SERIAL_OPEN (dev_name
);
786 perror_with_name (dev_name
);
790 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
792 SERIAL_CLOSE (monitor_desc
);
793 perror_with_name (dev_name
);
797 SERIAL_RAW (monitor_desc
);
799 SERIAL_FLUSH_INPUT (monitor_desc
);
801 /* some systems only work with 2 stop bits */
803 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
805 current_monitor
= mon_ops
;
807 /* See if we can wake up the monitor. First, try sending a stop sequence,
808 then send the init strings. Last, remove all breakpoints. */
810 if (current_monitor
->stop
)
813 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
815 monitor_debug ("EXP Open echo\n");
816 monitor_expect_prompt (NULL
, 0);
820 /* wake up the monitor and see if it's alive */
821 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
823 /* Some of the characters we send may not be echoed,
824 but we hope to get a prompt at the end of it all. */
826 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
829 monitor_printf_noecho (*p
);
830 monitor_expect_prompt (NULL
, 0);
833 SERIAL_FLUSH_INPUT (monitor_desc
);
835 /* Alloc breakpoints */
836 if (mon_ops
->set_break
!= NULL
)
838 if (mon_ops
->num_breakpoints
== 0)
839 mon_ops
->num_breakpoints
= 8;
841 breakaddr
= (CORE_ADDR
*) xmalloc (mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
842 memset (breakaddr
, 0, mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
845 /* Remove all breakpoints */
847 if (mon_ops
->clr_all_break
)
849 monitor_printf (mon_ops
->clr_all_break
);
850 monitor_expect_prompt (NULL
, 0);
854 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
856 push_target (targ_ops
);
858 inferior_pid
= 42000; /* Make run command think we are busy... */
860 /* Give monitor_wait something to read */
862 monitor_printf (current_monitor
->line_term
);
864 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
865 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory_block
);
867 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory
);
871 /* Close out all files and local state before this target loses
875 monitor_close (quitting
)
879 SERIAL_CLOSE (monitor_desc
);
881 /* Free breakpoint memory */
882 if (breakaddr
!= NULL
)
891 /* Terminate the open connection to the remote debugger. Use this
892 when you want to detach and do something else with your gdb. */
895 monitor_detach (args
, from_tty
)
899 pop_target (); /* calls monitor_close to do the real work */
901 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
904 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
907 monitor_supply_register (regno
, valstr
)
912 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
917 while (p
&& *p
!= '\0')
919 if (*p
== '\r' || *p
== '\n')
930 if (!isxdigit (*p
) && *p
!= 'x')
936 val
+= fromhex (*p
++);
938 monitor_debug ("Supplying Register %d %s\n", regno
, valstr
);
941 error ("monitor_supply_register (%d): bad value from monitor: %s.",
944 /* supply register stores in target byte order, so swap here */
946 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
948 supply_register (regno
, regbuf
);
953 /* Tell the remote machine to resume. */
956 flush_monitor_dcache ()
958 dcache_flush (remote_dcache
);
962 monitor_resume (pid
, step
, sig
)
964 enum target_signal sig
;
966 /* Some monitors require a different command when starting a program */
967 monitor_debug ("MON resume\n");
968 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
971 monitor_printf ("run\r");
972 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
976 dcache_flush (remote_dcache
);
978 monitor_printf (current_monitor
->step
);
981 if (current_monitor
->continue_hook
)
982 (*current_monitor
->continue_hook
) ();
984 monitor_printf (current_monitor
->cont
);
985 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
990 /* Parse the output of a register dump command. A monitor specific
991 regexp is used to extract individual register descriptions of the
992 form REG=VAL. Each description is split up into a name and a value
993 string which are passed down to monitor specific code. */
996 parse_register_dump (buf
, len
)
1000 monitor_debug ("MON Parsing register dump\n");
1003 int regnamelen
, vallen
;
1004 char *regname
, *val
;
1005 /* Element 0 points to start of register name, and element 1
1006 points to the start of the register value. */
1007 struct re_registers register_strings
;
1009 memset (®ister_strings
, 0, sizeof (struct re_registers
));
1011 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
1012 ®ister_strings
) == -1)
1015 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
1016 regname
= buf
+ register_strings
.start
[1];
1017 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
1018 val
= buf
+ register_strings
.start
[2];
1020 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
1022 buf
+= register_strings
.end
[0];
1023 len
-= register_strings
.end
[0];
1027 /* Send ^C to target to halt it. Target will respond, and send us a
1031 monitor_interrupt (signo
)
1034 /* If this doesn't work, try more severe steps. */
1035 signal (signo
, monitor_interrupt_twice
);
1037 if (monitor_debug_p
|| remote_debug
)
1038 fprintf_unfiltered (gdb_stdlog
, "monitor_interrupt called\n");
1043 /* The user typed ^C twice. */
1046 monitor_interrupt_twice (signo
)
1049 signal (signo
, ofunc
);
1051 monitor_interrupt_query ();
1053 signal (signo
, monitor_interrupt
);
1056 /* Ask the user what to do when an interrupt is received. */
1059 monitor_interrupt_query ()
1061 target_terminal_ours ();
1063 if (query ("Interrupted while waiting for the program.\n\
1064 Give up (and stop debugging it)? "))
1066 target_mourn_inferior ();
1067 return_to_top_level (RETURN_QUIT
);
1070 target_terminal_inferior ();
1074 monitor_wait_cleanup (old_timeout
)
1077 timeout
= *(int *) old_timeout
;
1078 signal (SIGINT
, ofunc
);
1079 in_monitor_wait
= 0;
1085 monitor_wait_filter (char *buf
,
1088 struct target_waitstatus
*status
1094 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1095 *ext_resp_len
= resp_len
;
1098 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1100 while (resp_len
< 0);
1102 /* Print any output characters that were preceded by ^O. */
1103 /* FIXME - This would be great as a user settabgle flag */
1104 if (monitor_debug_p
|| remote_debug
1105 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1109 for (i
= 0; i
< resp_len
- 1; i
++)
1111 putchar_unfiltered (buf
[++i
]);
1117 /* Wait until the remote machine stops, then return, storing status in
1118 status just as `wait' would. */
1121 monitor_wait (pid
, status
)
1123 struct target_waitstatus
*status
;
1125 int old_timeout
= timeout
;
1126 char buf
[TARGET_BUF_SIZE
];
1128 struct cleanup
*old_chain
;
1130 status
->kind
= TARGET_WAITKIND_EXITED
;
1131 status
->value
.integer
= 0;
1133 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1134 monitor_debug ("MON wait\n");
1137 /* This is somthing other than a maintenance command */
1138 in_monitor_wait
= 1;
1139 timeout
= watchdog
> 0 ? watchdog
: -1;
1141 timeout
= -1; /* Don't time out -- user program is running. */
1144 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1146 if (current_monitor
->wait_filter
)
1147 (*current_monitor
->wait_filter
) (buf
, sizeof (buf
), &resp_len
, status
);
1149 monitor_wait_filter (buf
, sizeof (buf
), &resp_len
, status
);
1151 #if 0 /* Transferred to monitor wait filter */
1154 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1157 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1159 while (resp_len
< 0);
1161 /* Print any output characters that were preceded by ^O. */
1162 /* FIXME - This would be great as a user settabgle flag */
1163 if (monitor_debug_p
|| remote_debug
1164 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1168 for (i
= 0; i
< resp_len
- 1; i
++)
1170 putchar_unfiltered (buf
[++i
]);
1174 signal (SIGINT
, ofunc
);
1176 timeout
= old_timeout
;
1178 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1181 monitor_printf (current_monitor
->dump_registers
);
1182 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1185 if (current_monitor
->register_pattern
)
1186 parse_register_dump (buf
, resp_len
);
1188 monitor_debug ("Wait fetching registers after stop\n");
1189 monitor_dump_regs ();
1192 status
->kind
= TARGET_WAITKIND_STOPPED
;
1193 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1195 discard_cleanups (old_chain
);
1197 in_monitor_wait
= 0;
1199 return inferior_pid
;
1202 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1206 monitor_fetch_register (regno
)
1210 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] =
1212 char regbuf
[MAX_REGISTER_RAW_SIZE
* 2 + 1];
1215 name
= current_monitor
->regnames
[regno
];
1216 monitor_debug ("MON fetchreg %d '%s'\n", regno
, name
? name
: "(null name)");
1218 if (!name
|| (*name
== '\0'))
1220 monitor_debug ("No register known for %d\n", regno
);
1221 supply_register (regno
, zerobuf
);
1225 /* send the register examine command */
1227 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1229 /* If RESP_DELIM is specified, we search for that as a leading
1230 delimiter for the register value. Otherwise, we just start
1231 searching from the start of the buf. */
1233 if (current_monitor
->getreg
.resp_delim
)
1235 monitor_debug ("EXP getreg.resp_delim\n");
1236 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1237 /* Handle case of first 32 registers listed in pairs. */
1238 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1239 && (regno
& 1) != 0 && regno
< 32)
1241 monitor_debug ("EXP getreg.resp_delim\n");
1242 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1246 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1247 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1250 c
= readchar (timeout
);
1252 c
= readchar (timeout
);
1253 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1256 error ("Bad value returned from monitor while fetching register %x.",
1260 /* Read upto the maximum number of hex digits for this register, skipping
1261 spaces, but stop reading if something else is seen. Some monitors
1262 like to drop leading zeros. */
1264 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
1267 c
= readchar (timeout
);
1269 c
= readchar (timeout
);
1277 regbuf
[i
] = '\000'; /* terminate the number */
1278 monitor_debug ("REGVAL '%s'\n", regbuf
);
1280 /* If TERM is present, we wait for that to show up. Also, (if TERM
1281 is present), we will send TERM_CMD if that is present. In any
1282 case, we collect all of the output into buf, and then wait for
1283 the normal prompt. */
1285 if (current_monitor
->getreg
.term
)
1287 monitor_debug ("EXP getreg.term\n");
1288 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1291 if (current_monitor
->getreg
.term_cmd
)
1293 monitor_debug ("EMIT getreg.term.cmd\n");
1294 monitor_printf (current_monitor
->getreg
.term_cmd
);
1296 if (!current_monitor
->getreg
.term
|| /* Already expected or */
1297 current_monitor
->getreg
.term_cmd
) /* ack expected */
1298 monitor_expect_prompt (NULL
, 0); /* get response */
1300 monitor_supply_register (regno
, regbuf
);
1303 /* Sometimes, it takes several commands to dump the registers */
1304 /* This is a primitive for use by variations of monitor interfaces in
1305 case they need to compose the operation.
1308 monitor_dump_reg_block (char *block_cmd
)
1310 char buf
[TARGET_BUF_SIZE
];
1312 monitor_printf (block_cmd
);
1313 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1314 parse_register_dump (buf
, resp_len
);
1319 /* Read the remote registers into the block regs. */
1320 /* Call the specific function if it has been provided */
1323 monitor_dump_regs ()
1325 char buf
[TARGET_BUF_SIZE
];
1327 if (current_monitor
->dumpregs
)
1328 (*(current_monitor
->dumpregs
)) (); /* call supplied function */
1329 else if (current_monitor
->dump_registers
) /* default version */
1331 monitor_printf (current_monitor
->dump_registers
);
1332 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1333 parse_register_dump (buf
, resp_len
);
1336 abort (); /* Need some way to read registers */
1340 monitor_fetch_registers (regno
)
1343 monitor_debug ("MON fetchregs\n");
1344 if (current_monitor
->getreg
.cmd
)
1348 monitor_fetch_register (regno
);
1352 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1353 monitor_fetch_register (regno
);
1357 monitor_dump_regs ();
1361 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1364 monitor_store_register (regno
)
1370 name
= current_monitor
->regnames
[regno
];
1371 if (!name
|| (*name
== '\0'))
1373 monitor_debug ("MON Cannot store unknown register\n");
1377 val
= read_register (regno
);
1378 monitor_debug ("MON storeg %d %s\n", regno
, preg (val
));
1380 /* send the register deposit command */
1382 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1383 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1384 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1385 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1387 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1389 if (current_monitor
->setreg
.term
)
1391 monitor_debug ("EXP setreg.term\n");
1392 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1393 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1394 monitor_printf ("%s\r", paddr_nz (val
));
1395 monitor_expect_prompt (NULL
, 0);
1398 monitor_expect_prompt (NULL
, 0);
1399 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1401 monitor_debug ("EXP setreg_termcmd\n");
1402 monitor_printf ("%s", current_monitor
->setreg
.term_cmd
);
1403 monitor_expect_prompt (NULL
, 0);
1405 } /* monitor_store_register */
1407 /* Store the remote registers. */
1410 monitor_store_registers (regno
)
1415 monitor_store_register (regno
);
1419 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1420 monitor_store_register (regno
);
1423 /* Get ready to modify the registers array. On machines which store
1424 individual registers, this doesn't need to do anything. On machines
1425 which store all the registers in one fell swoop, this makes sure
1426 that registers contains all the registers from the program being
1430 monitor_prepare_to_store ()
1432 /* Do nothing, since we can store individual regs */
1436 monitor_files_info (ops
)
1437 struct target_ops
*ops
;
1439 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1443 monitor_write_memory (memaddr
, myaddr
, len
)
1448 unsigned int val
, hostval
;
1452 monitor_debug ("MON write %d %s\n", len
, paddr (memaddr
));
1454 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1455 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1457 /* Use memory fill command for leading 0 bytes. */
1459 if (current_monitor
->fill
)
1461 for (i
= 0; i
< len
; i
++)
1465 if (i
> 4) /* More than 4 zeros is worth doing */
1467 monitor_debug ("MON FILL %d\n", i
);
1468 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1469 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
) - 1, 0);
1471 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1473 monitor_expect_prompt (NULL
, 0);
1480 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1481 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1484 cmd
= current_monitor
->setmem
.cmdll
;
1488 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1491 cmd
= current_monitor
->setmem
.cmdl
;
1493 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1496 cmd
= current_monitor
->setmem
.cmdw
;
1501 cmd
= current_monitor
->setmem
.cmdb
;
1504 val
= extract_unsigned_integer (myaddr
, len
);
1508 hostval
= *(unsigned int *) myaddr
;
1509 monitor_debug ("Hostval(%08x) val(%08x)\n", hostval
, val
);
1513 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1514 monitor_printf_noecho (cmd
, memaddr
, val
);
1515 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1518 monitor_printf_noecho (cmd
, memaddr
);
1520 if (current_monitor
->setmem
.term
)
1522 monitor_debug ("EXP setmem.term");
1523 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1524 monitor_printf ("%x\r", val
);
1526 if (current_monitor
->setmem
.term_cmd
)
1527 { /* Emit this to get out of the memory editing state */
1528 monitor_printf ("%s", current_monitor
->setmem
.term_cmd
);
1529 /* Drop through to expecting a prompt */
1533 monitor_printf (cmd
, memaddr
, val
);
1535 monitor_expect_prompt (NULL
, 0);
1542 monitor_write_even_block (memaddr
, myaddr
, len
)
1549 /* Enter the sub mode */
1550 monitor_printf (current_monitor
->setmem
.cmdl
, memaddr
);
1551 monitor_expect_prompt (NULL
, 0);
1555 val
= extract_unsigned_integer (myaddr
, 4); /* REALLY */
1556 monitor_printf ("%x\r", val
);
1560 monitor_debug (" @ %s\n", paddr (memaddr
));
1561 /* If we wanted to, here we could validate the address */
1562 monitor_expect_prompt (NULL
, 0);
1564 /* Now exit the sub mode */
1565 monitor_printf (current_monitor
->getreg
.term_cmd
);
1566 monitor_expect_prompt (NULL
, 0);
1572 monitor_write_memory_bytes (memaddr
, myaddr
, len
)
1581 /* Enter the sub mode */
1582 monitor_printf (current_monitor
->setmem
.cmdb
, memaddr
);
1583 monitor_expect_prompt (NULL
, 0);
1587 monitor_printf ("%x\r", val
);
1591 /* If we wanted to, here we could validate the address */
1592 monitor_expect_prompt (NULL
, 0);
1595 /* Now exit the sub mode */
1596 monitor_printf (current_monitor
->getreg
.term_cmd
);
1597 monitor_expect_prompt (NULL
, 0);
1603 longlongendswap (unsigned char *a
)
1612 *(a
+ i
) = *(a
+ j
);
1617 /* Format 32 chars of long long value, advance the pointer */
1618 static char *hexlate
= "0123456789abcdef";
1620 longlong_hexchars (unsigned long long value
,
1630 static unsigned char disbuf
[8]; /* disassembly buffer */
1631 unsigned char *scan
, *limit
; /* loop controls */
1632 unsigned char c
, nib
;
1637 unsigned long long *dp
;
1638 dp
= (unsigned long long *) scan
;
1641 longlongendswap (disbuf
); /* FIXME: ONly on big endian hosts */
1642 while (scan
< limit
)
1644 c
= *scan
++; /* a byte of our long long value */
1650 leadzero
= 0; /* henceforth we print even zeroes */
1652 nib
= c
>> 4; /* high nibble bits */
1653 *outbuff
++ = hexlate
[nib
];
1654 nib
= c
& 0x0f; /* low nibble bits */
1655 *outbuff
++ = hexlate
[nib
];
1659 } /* longlong_hexchars */
1663 /* I am only going to call this when writing virtual byte streams.
1664 Which possably entails endian conversions
1667 monitor_write_memory_longlongs (memaddr
, myaddr
, len
)
1672 static char hexstage
[20]; /* At least 16 digits required, plus null */
1677 llptr
= (unsigned long long *) myaddr
;
1680 monitor_printf (current_monitor
->setmem
.cmdll
, memaddr
);
1681 monitor_expect_prompt (NULL
, 0);
1685 endstring
= longlong_hexchars (*llptr
, hexstage
);
1686 *endstring
= '\0'; /* NUll terminate for printf */
1687 monitor_printf ("%s\r", hexstage
);
1691 /* If we wanted to, here we could validate the address */
1692 monitor_expect_prompt (NULL
, 0);
1695 /* Now exit the sub mode */
1696 monitor_printf (current_monitor
->getreg
.term_cmd
);
1697 monitor_expect_prompt (NULL
, 0);
1703 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1704 /* This is for the large blocks of memory which may occur in downloading.
1705 And for monitors which use interactive entry,
1706 And for monitors which do not have other downloading methods.
1707 Without this, we will end up calling monitor_write_memory many times
1708 and do the entry and exit of the sub mode many times
1709 This currently assumes...
1710 MO_SETMEM_INTERACTIVE
1711 ! MO_NO_ECHO_ON_SETMEM
1712 To use this, the you have to patch the monitor_cmds block with
1713 this function. Otherwise, its not tuned up for use by all
1718 monitor_write_memory_block (memaddr
, myaddr
, len
)
1725 /* FIXME: This would be a good place to put the zero test */
1727 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1729 return monitor_write_memory_longlongs (memaddr
, myaddr
, len
);
1736 written
= monitor_write_even_block (memaddr
, myaddr
, len
);
1737 /* Adjust calling parameters by written amount */
1743 written
= monitor_write_memory_bytes (memaddr
, myaddr
, len
);
1747 /* This is an alternate form of monitor_read_memory which is used for monitors
1748 which can only read a single byte/word/etc. at a time. */
1751 monitor_read_memory_single (memaddr
, myaddr
, len
)
1757 char membuf
[sizeof (int) * 2 + 1];
1762 monitor_debug ("MON read single\n");
1764 /* Can't actually use long longs (nice idea, though). In fact, the
1765 call to strtoul below will fail if it tries to convert a value
1766 that's too big to fit in a long. */
1767 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1770 cmd
= current_monitor
->getmem
.cmdll
;
1774 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1777 cmd
= current_monitor
->getmem
.cmdl
;
1779 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1782 cmd
= current_monitor
->getmem
.cmdw
;
1787 cmd
= current_monitor
->getmem
.cmdb
;
1790 /* Send the examine command. */
1792 monitor_printf (cmd
, memaddr
);
1794 /* If RESP_DELIM is specified, we search for that as a leading
1795 delimiter for the memory value. Otherwise, we just start
1796 searching from the start of the buf. */
1798 if (current_monitor
->getmem
.resp_delim
)
1800 monitor_debug ("EXP getmem.resp_delim\n");
1801 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1804 /* Now, read the appropriate number of hex digits for this loc,
1807 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1808 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1812 c
= readchar (timeout
);
1814 c
= readchar (timeout
);
1815 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1818 monitor_error ("monitor_read_memory_single",
1819 "bad response from monitor",
1820 memaddr
, i
, membuf
, c
);
1822 for (i
= 0; i
< len
* 2; i
++)
1828 c
= readchar (timeout
);
1834 monitor_error ("monitor_read_memory_single",
1835 "bad response from monitor",
1836 memaddr
, i
, membuf
, c
);
1842 membuf
[i
] = '\000'; /* terminate the number */
1844 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1845 present), we will send TERM_CMD if that is present. In any case, we collect
1846 all of the output into buf, and then wait for the normal prompt. */
1848 if (current_monitor
->getmem
.term
)
1850 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1852 if (current_monitor
->getmem
.term_cmd
)
1854 monitor_printf (current_monitor
->getmem
.term_cmd
);
1855 monitor_expect_prompt (NULL
, 0);
1859 monitor_expect_prompt (NULL
, 0); /* get response */
1862 val
= strtoul (membuf
, &p
, 16);
1864 if (val
== 0 && membuf
== p
)
1865 monitor_error ("monitor_read_memory_single",
1866 "bad value from monitor",
1867 memaddr
, 0, membuf
, 0);
1869 /* supply register stores in target byte order, so swap here */
1871 store_unsigned_integer (myaddr
, len
, val
);
1876 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1877 memory at MEMADDR. Returns length moved. Currently, we do no more
1878 than 16 bytes at a time. */
1881 monitor_read_memory (memaddr
, myaddr
, len
)
1895 monitor_debug ("Zero length call to monitor_read_memory\n");
1899 monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
1900 paddr_nz (memaddr
), (long) myaddr
, len
);
1902 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1903 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1905 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1906 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1908 len
= min (len
, 16);
1910 /* Some dumpers align the first data with the preceeding 16
1911 byte boundary. Some print blanks and start at the
1912 requested boundary. EXACT_DUMPADDR
1915 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1916 ? memaddr
: memaddr
& ~0x0f;
1918 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1919 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1920 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1922 /* send the memory examine command */
1924 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1925 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
);
1926 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1927 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1929 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1931 /* If TERM is present, we wait for that to show up. Also, (if TERM
1932 is present), we will send TERM_CMD if that is present. In any
1933 case, we collect all of the output into buf, and then wait for
1934 the normal prompt. */
1936 if (current_monitor
->getmem
.term
)
1938 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1941 monitor_error ("monitor_read_memory",
1942 "excessive response from monitor",
1943 memaddr
, resp_len
, buf
, 0);
1945 if (current_monitor
->getmem
.term_cmd
)
1947 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1948 strlen (current_monitor
->getmem
.term_cmd
));
1949 monitor_expect_prompt (NULL
, 0);
1953 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1957 /* If RESP_DELIM is specified, we search for that as a leading
1958 delimiter for the values. Otherwise, we just start searching
1959 from the start of the buf. */
1961 if (current_monitor
->getmem
.resp_delim
)
1964 struct re_registers resp_strings
;
1965 monitor_debug ("MON getmem.resp_delim %s\n", current_monitor
->getmem
.resp_delim
);
1967 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1969 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1973 monitor_error ("monitor_read_memory",
1974 "bad response from monitor",
1975 memaddr
, resp_len
, buf
, 0);
1977 p
+= resp_strings
.end
[0];
1979 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1981 monitor_error ("monitor_read_memory",
1982 "bad response from monitor",
1983 memaddr
, resp_len
, buf
, 0);
1984 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1987 monitor_debug ("MON scanning %d ,%lx '%s'\n", len
, (long) p
, p
);
1988 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1996 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
2000 if ((dumpaddr
>= memaddr
) && (i
> 0))
2002 val
= fromhex (c
) * 16 + fromhex (*(p
+ 1));
2004 if (monitor_debug_p
|| remote_debug
)
2005 fprintf_unfiltered (gdb_stdlog
, "[%02x]", val
);
2012 ++p
; /* skip a blank or other non hex char */
2016 error ("Failed to read via monitor");
2017 if (monitor_debug_p
|| remote_debug
)
2018 fprintf_unfiltered (gdb_stdlog
, "\n");
2019 return fetched
; /* Return the number of bytes actually read */
2021 monitor_debug ("MON scanning bytes\n");
2023 for (i
= len
; i
> 0; i
--)
2025 /* Skip non-hex chars, but bomb on end of string and newlines */
2032 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
2033 monitor_error ("monitor_read_memory",
2034 "badly terminated response from monitor",
2035 memaddr
, resp_len
, buf
, 0);
2039 val
= strtoul (p
, &p1
, 16);
2041 if (val
== 0 && p
== p1
)
2042 monitor_error ("monitor_read_memory",
2043 "bad value from monitor",
2044 memaddr
, resp_len
, buf
, 0);
2058 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
2063 struct target_ops
*target
; /* ignored */
2065 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, write
);
2071 return; /* ignore attempts to kill target system */
2074 /* All we actually do is set the PC to the start address of exec_bfd, and start
2075 the program at that point. */
2078 monitor_create_inferior (exec_file
, args
, env
)
2083 if (args
&& (*args
!= '\000'))
2084 error ("Args are not supported by the monitor.");
2087 clear_proceed_status ();
2088 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
2091 /* Clean up when a program exits.
2092 The program actually lives on in the remote processor's RAM, and may be
2093 run again without a download. Don't leave it full of breakpoint
2097 monitor_mourn_inferior ()
2099 unpush_target (targ_ops
);
2100 generic_mourn_inferior (); /* Do all the proper things now */
2103 /* Tell the monitor to add a breakpoint. */
2106 monitor_insert_breakpoint (addr
, shadow
)
2114 monitor_debug ("MON inst bkpt %s\n", paddr (addr
));
2115 if (current_monitor
->set_break
== NULL
)
2116 error ("No set_break defined for this monitor");
2118 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2119 addr
= ADDR_BITS_REMOVE (addr
);
2121 /* Determine appropriate breakpoint size for this address. */
2122 bp
= memory_breakpoint_from_pc (&addr
, &bplen
);
2124 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2126 if (breakaddr
[i
] == 0)
2128 breakaddr
[i
] = addr
;
2129 monitor_read_memory (addr
, shadow
, bplen
);
2130 monitor_printf (current_monitor
->set_break
, addr
);
2131 monitor_expect_prompt (NULL
, 0);
2136 error ("Too many breakpoints (> %d) for monitor.", current_monitor
->num_breakpoints
);
2139 /* Tell the monitor to remove a breakpoint. */
2142 monitor_remove_breakpoint (addr
, shadow
)
2148 monitor_debug ("MON rmbkpt %s\n", paddr (addr
));
2149 if (current_monitor
->clr_break
== NULL
)
2150 error ("No clr_break defined for this monitor");
2152 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2153 addr
= ADDR_BITS_REMOVE (addr
);
2155 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2157 if (breakaddr
[i
] == addr
)
2160 /* some monitors remove breakpoints based on the address */
2161 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2162 monitor_printf (current_monitor
->clr_break
, addr
);
2163 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2164 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2166 monitor_printf (current_monitor
->clr_break
, i
);
2167 monitor_expect_prompt (NULL
, 0);
2171 fprintf_unfiltered (gdb_stderr
,
2172 "Can't find breakpoint associated with 0x%s\n",
2177 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2178 an S-record. Return non-zero if the ACK is received properly. */
2181 monitor_wait_srec_ack ()
2185 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2187 return (readchar (timeout
) == '+');
2189 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2191 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2192 if ((ch
= readchar (1)) < 0)
2194 if ((ch
= readchar (1)) < 0)
2196 if ((ch
= readchar (1)) < 0)
2198 if ((ch
= readchar (1)) < 0)
2204 /* monitor_load -- download a file. */
2207 monitor_load (file
, from_tty
)
2211 dcache_flush (remote_dcache
);
2212 monitor_debug ("MON load\n");
2214 if (current_monitor
->load_routine
)
2215 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2217 { /* The default is ascii S-records */
2219 unsigned long load_offset
;
2222 /* enable user to specify address for downloading as 2nd arg to load */
2223 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2229 monitor_printf (current_monitor
->load
);
2230 if (current_monitor
->loadresp
)
2231 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2233 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2234 32, SREC_ALL
, hashmark
,
2235 current_monitor
->flags
& MO_SREC_ACK
?
2236 monitor_wait_srec_ack
: NULL
);
2238 monitor_expect_prompt (NULL
, 0);
2241 /* Finally, make the PC point at the start address */
2244 write_pc (bfd_get_start_address (exec_bfd
));
2246 inferior_pid
= 0; /* No process now */
2248 /* This is necessary because many things were based on the PC at the time that
2249 we attached to the monitor, which is no longer valid now that we have loaded
2250 new code (and just changed the PC). Another way to do this might be to call
2251 normal_stop, except that the stack may not be valid, and things would get
2252 horribly confused... */
2254 clear_symtab_users ();
2260 monitor_debug ("MON stop\n");
2261 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2262 SERIAL_SEND_BREAK (monitor_desc
);
2263 if (current_monitor
->stop
)
2264 monitor_printf_noecho (current_monitor
->stop
);
2267 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2268 in OUTPUT until the prompt is seen. FIXME: We read the characters
2269 ourseleves here cause of a nasty echo. */
2272 monitor_rcmd (char *command
,
2273 struct gdb_file
*outbuf
)
2279 if (monitor_desc
== NULL
)
2280 error ("monitor target not open.");
2282 p
= current_monitor
->prompt
;
2284 /* Send the command. Note that if no args were supplied, then we're
2285 just sending the monitor a newline, which is sometimes useful. */
2287 monitor_printf ("%s\r", (command
? command
: ""));
2289 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2291 fputs_unfiltered (buf
, outbuf
); /* Output the response */
2294 /* Convert hex digit A to a number. */
2301 if (a
>= '0' && a
<= '9')
2303 if (a
>= 'a' && a
<= 'f')
2304 return a
- 'a' + 10;
2305 if (a
>= 'A' && a
<= 'F')
2306 return a
- 'A' + 10;
2308 error ("Reply contains invalid hex digit 0x%x", a
);
2313 monitor_get_dev_name ()
2318 static struct target_ops monitor_ops
;
2321 init_base_monitor_ops (void)
2323 monitor_ops
.to_shortname
= NULL
;
2324 monitor_ops
.to_longname
= NULL
;
2325 monitor_ops
.to_doc
= NULL
;
2326 monitor_ops
.to_open
= NULL
;
2327 monitor_ops
.to_close
= monitor_close
;
2328 monitor_ops
.to_attach
= NULL
;
2329 monitor_ops
.to_post_attach
= NULL
;
2330 monitor_ops
.to_require_attach
= NULL
;
2331 monitor_ops
.to_detach
= monitor_detach
;
2332 monitor_ops
.to_require_detach
= NULL
;
2333 monitor_ops
.to_resume
= monitor_resume
;
2334 monitor_ops
.to_wait
= monitor_wait
;
2335 monitor_ops
.to_post_wait
= NULL
;
2336 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2337 monitor_ops
.to_store_registers
= monitor_store_registers
;
2338 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2339 monitor_ops
.to_xfer_memory
= monitor_xfer_memory
;
2340 monitor_ops
.to_files_info
= monitor_files_info
;
2341 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2342 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2343 monitor_ops
.to_terminal_init
= 0;
2344 monitor_ops
.to_terminal_inferior
= 0;
2345 monitor_ops
.to_terminal_ours_for_output
= 0;
2346 monitor_ops
.to_terminal_ours
= 0;
2347 monitor_ops
.to_terminal_info
= 0;
2348 monitor_ops
.to_kill
= monitor_kill
;
2349 monitor_ops
.to_load
= monitor_load
;
2350 monitor_ops
.to_lookup_symbol
= 0;
2351 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2352 monitor_ops
.to_post_startup_inferior
= NULL
;
2353 monitor_ops
.to_acknowledge_created_inferior
= NULL
;
2354 monitor_ops
.to_clone_and_follow_inferior
= NULL
;
2355 monitor_ops
.to_post_follow_inferior_by_clone
= NULL
;
2356 monitor_ops
.to_insert_fork_catchpoint
= NULL
;
2357 monitor_ops
.to_remove_fork_catchpoint
= NULL
;
2358 monitor_ops
.to_insert_vfork_catchpoint
= NULL
;
2359 monitor_ops
.to_remove_vfork_catchpoint
= NULL
;
2360 monitor_ops
.to_has_forked
= NULL
;
2361 monitor_ops
.to_has_vforked
= NULL
;
2362 monitor_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2363 monitor_ops
.to_post_follow_vfork
= NULL
;
2364 monitor_ops
.to_insert_exec_catchpoint
= NULL
;
2365 monitor_ops
.to_remove_exec_catchpoint
= NULL
;
2366 monitor_ops
.to_has_execd
= NULL
;
2367 monitor_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2368 monitor_ops
.to_has_exited
= NULL
;
2369 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2370 monitor_ops
.to_can_run
= 0;
2371 monitor_ops
.to_notice_signals
= 0;
2372 monitor_ops
.to_thread_alive
= 0;
2373 monitor_ops
.to_stop
= monitor_stop
;
2374 monitor_ops
.to_rcmd
= monitor_rcmd
;
2375 monitor_ops
.to_pid_to_exec_file
= NULL
;
2376 monitor_ops
.to_core_file_to_sym_file
= NULL
;
2377 monitor_ops
.to_stratum
= process_stratum
;
2378 monitor_ops
.DONT_USE
= 0;
2379 monitor_ops
.to_has_all_memory
= 1;
2380 monitor_ops
.to_has_memory
= 1;
2381 monitor_ops
.to_has_stack
= 1;
2382 monitor_ops
.to_has_registers
= 1;
2383 monitor_ops
.to_has_execution
= 1;
2384 monitor_ops
.to_sections
= 0;
2385 monitor_ops
.to_sections_end
= 0;
2386 monitor_ops
.to_magic
= OPS_MAGIC
;
2387 } /* init_base_monitor_ops */
2389 /* Init the target_ops structure pointed at by OPS */
2392 init_monitor_ops (ops
)
2393 struct target_ops
*ops
;
2395 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2396 init_base_monitor_ops ();
2398 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2401 /* Define additional commands that are usually only used by monitors. */
2404 _initialize_remote_monitors ()
2406 init_base_monitor_ops ();
2407 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
2409 "Set display of activity while downloading a file.\n\
2410 When enabled, a hashmark \'#\' is displayed.",
2415 /* FIXME: cagney/1999-10-07: Wait until there is a generic ``set
2416 debug ...'' rather than another ``set ...debug'' command. */
2418 (add_set_cmd ("monitordebug", no_class
, var_zinteger
,
2419 (char *) &monitor_debug_p
,
2420 "Set debugging of remote monitor communication.\n\
2421 When enabled, communication between GDB and the remote monitor\n\
2422 is displayed.", &setlist
),